# Visualization Integration — Charting and Mapping Across the Soapbox Stack

*Where interactive charts and census-scale maps can actually live across Shakespeare, Ditto, Blossom/nsite, and Nostr long-form content — and the reference pattern for building an Atlas-class dashboard on top of it, with zero origin servers.*

**Verified: 2026-07-09**

Confidence: High for the landscape survey, licensing, and the Shakespeare/MKStack embedding answer (a live dependency-manifest fetch is primary evidence). Medium-High for the static/Blossom-hosting and Nostr long-form answers (protocol specs are primary and quoted verbatim, but real-world server behavior varies). Medium for Ditto's embedding ceiling (no widget/plugin doc was found across two source sweeps — an absence, not a documented "no"). Medium for the Atlas reference architecture itself: every component is independently well-sourced, but no live Nostr-stack census/civic-data project was found to validate the combination end-to-end — this pattern is this chapter's synthesis, not a Soapbox playbook.

## 1. The 2026 Landscape

| Tool | Category | License | 2026 status | Fit note |
|---|---|---|---|---|
| **Observable Framework + Plot** | Static-site generator + grammar-of-graphics charting | ISC (D3 family) | Active; data loaders run at build time in *any* language and can shell out to binaries like DuckDB or ffmpeg [1][2][3] | Best match for a build-time, zero-server report/dashboard |
| **D3** | Low-level rendering primitives | ISC | Foundational substrate — Plot, Vega, Nivo, and visx all sit on it [4] | Rarely hand-written now; used as a base layer |
| **Apache ECharts** | Full chart + geo + 3D framework | Apache 2.0 | Highest adoption of any JS-native chart lib by a wide margin; weekly npm downloads in the millions vs. Vega-Lite's low hundreds of thousands [5] | Broadest single-library feature set, including a native geo/map chart type |
| **Vega-Lite** | Declarative JSON chart grammar | BSD-3 | Active; strongest in Jupyter/Python (Altair) exploratory workflows [6] | Good AI-generation target (compact spec), weaker as a production UI polish layer |
| **deck.gl + MapLibre GL JS** | WebGL geo layers + vector-tile map engine | MIT (deck.gl) / BSD-3 (MapLibre) | deck.gl v9 lives under the OpenJS Foundation's Open Visualization space [7][9]; MapLibre is the Linux-Foundation-incubated fork of Mapbox GL JS from its Dec-2020 license change [10] | The map-heavy pairing; deck.gl's `MapboxOverlay` syncs its WebGL layers to MapLibre's camera exactly [7] |
| **React layer — Recharts / visx / Nivo / Tremor** | Chart components | All MIT | Recharts v3 is current; Tremor was fully open-sourced (incl. its paid "Blocks") when Vercel acquired it in Jan 2025 [11][12][13][41] | Recharts is also shadcn/ui's own official chart primitive [14] |
| **Svelte — LayerChart / unovis** | Chart components | MIT | Both confirmed Svelte-5-compatible [15][16] | Smaller ecosystem/training-data footprint than the React equivalents |
| **evidence.dev** | SQL + Markdown → static BI site | MIT | Active, DuckDB-powered, now ships its own in-browser AI dev agent [17] | Closest single-tool match to "Atlas as a reproducible, versioned report" |
| **AI-assisted generation** | Practice, not a library | n/a | LLMs default to Recharts or Chart.js when asked for a React chart [21]; Microsoft's Data Formulator 0.7 (2026) adds an iterative AI chart-authoring workspace [20]; MapLibre ships a dedicated agent-skills repo for AI coding tools [22][23] | Prompted generation is a first-class path now, not a novelty — see §5 |

Confidence: High — every cell above traces to a primary repo/license file or a 2026-dated comparison source.

## 2. Embedding in the Stack

The one fact that resolves most of this section: **the MKStack template that Shakespeare scaffolds already depends on Recharts.** A live fetch of its `package.json` shows React 19.2.5, Vite 8.0.10, Tailwind CSS v4.2.4, and **Recharts v3.8.1** as a first-class dependency, alongside Radix UI, TanStack Query, and Nostrify [18]. A secondary write-up describes MKStack as "React 18.x... TailwindCSS 3.x" [43] — that's stale against the live manifest; treat any secondary MKStack description as provisional and re-fetch before quoting a client.

| Surface | Interactive charts/maps? | Mechanism | Ceiling |
|---|---|---|---|
| **(a) Shakespeare-generated sites** | **Yes** | Recharts is already in the dependency tree — prompt Shakespeare directly for a chart or dashboard page and it composes from an installed library, not a cold start [18] | Full client-side React chart; a live database view needs an external API wired in by prompt, same as any Shakespeare funnel gap (see this manual's Shakespeare chapter) |
| **(b) Static/Blossom/nsite hosting** | **Yes, client-side only** | Any JS chart/map library runs fine as static assets; maps need PMTiles (below) | No server-side rendering, no live query API, no request-time database — everything must be precomputed at build time or fetched from a *separate* hosted service |
| **(c) Ditto communities** | **No native widget/embed surface found** *(inferred — absence across two doc sweeps, not a stated "no")* | Ditto's own customization docs describe only theme CSS tokens (9 presets, 19 tokens) and "add new features... completely redesign the UI to fit your wants and dreams" via forking the React source with Shakespeare [28][29] | Getting a chart into Ditto means editing Ditto's own React+Vite frontend directly — not a drop-in widget slot |
| **(d) Nostr long-form (kind 30023)** | **No** | NIP-23 is explicit: **"MUST NOT support adding HTML to Markdown"** [24]. The only visual hook is the optional `image` tag, "a URL pointing to an image to be shown along with the title" [24][25] | A chart in a 30023 article can only be a static exported image, or prose linking out to a hosted interactive page — never an inline embed |

**On (b), the fine print that matters for the Atlas pattern:** nsite maps file paths to content via Nostr **kind 34128** events (`d` tag = path, `sha256` tag = content hash), storing raw bytes on Blossom servers; the spec is explicit that this is for "a simple application that doesn't use a backend" [26]. Blossom's own BUD-01 spec **requires** CORS — "Servers MUST set the `Access-Control-Allow-Origin: *` header on all responses" — but only *recommends* byte-range support: "servers **should** support range requests (RFC 7233 section 3)" [27]. That word "should" is load-bearing: PMTiles depends on range requests to work at all, so a given Blossom server may or may not serve a census-scale map efficiently — verify per-server before committing production tiles to nsite (see Open Questions).

Confidence: High for (a) and (d) — primary manifest and primary spec text. Medium-High for (b) — primary specs, but real-server range-support behavior is untested here. Medium for (c) — a documented absence, not a documented limit.

## 3. The Atlas Pattern — Reference Architecture

A census/ACS dashboard (Equity Atlas-class: county→tract drill-down, choropleth fill, bilingual labels) fits this stack **only** as a build-time-baked, fully static app. No component in the pipeline below needs an origin server at request time.

```mermaid
flowchart TD
    A["Census Bureau\nTIGER/Line geometry + ACS 5-Year API"] --> B["Build-time pipeline\n(tidycensus/tigris or cenpy, ogr2ogr)"]
    B --> C1["Attribute Parquet\n(ACS variables, no geometry)"]
    B --> C2["GeoJSON -> Tippecanoe\n-> PMTiles (county/tract geometry)"]
    C1 --> D["Static host\nCloudflare R2/Pages, GitHub Pages,\nor nsite + Blossom"]
    C2 --> D
    D --> E["MapLibre GL JS\n+ pmtiles protocol handler\n(choropleth fill layer)"]
    D --> F["DuckDB-WASM query\nover hosted Parquet,\nor pre-aggregated static JSON"]
    E --> G["Drill-down UI\nstate -> county -> tract\n(client-side view state)"]
    F --> G
    G --> H["Bilingual label layer\n(i18n hook point --\nsee parallel i18n chapter)"]
    H --> I["Shipped static build\nReact/Shakespeare-MKStack\nor standalone Svelte 5"]
```

**Build runbook:**

1. Pull ACS 5-year variables and TIGER/Line geometry (county, tract) via the Census API, `tidycensus`/`tigris` (R), or `cenpy` (Python).
2. Join ACS attributes to geometry; export the **attribute table only** (no geometry) to Parquet for the DuckDB-WASM/pre-aggregation path.
3. Convert geometry to GeoJSON, then to PMTiles with Tippecanoe (v2.17+ writes PMTiles directly) — e.g. `tippecanoe -zg -o tracts.pmtiles -l tracts tracts.geojson` — tuning min/max zoom for the state→county→tract drill-down [30]. A documented precedent exists at this exact scale: a 650,000-plus-feature Texas census-block PMTiles build via Tippecanoe [31].
4. Precompute heavy rollups (state/county summaries) as static JSON at build time — an Observable Framework data loader or a plain build script both work [1][2].
5. Host PMTiles + JSON + Parquet as static assets. **Cloudflare R2/Pages is the verified-safe default**: Protomaps documents a direct Cloudflare integration [35], though a stock Cloudflare CDN path has been reported to corrupt PMTiles' byte-range responses unless served through a Worker or R2 directly [37] — configure CORS to allow the `range` and `if-match` headers explicitly [36]. nsite+Blossom is *reachable* but its range-request support is a spec-level "should," not a guarantee (§2) — pilot it, don't default to it for production tiles.
6. Render with MapLibre GL JS plus the `pmtiles://` protocol handler; add a choropleth fill layer keyed to the joined ACS variable.
7. Wire drill-down as client-side view state: zoom/tap swaps the active PMTiles zoom range and re-queries either the in-browser DuckDB-WASM Parquet or the pre-aggregated JSON for the side panel.
8. Hook the bilingual layer at two boundaries only — the component string table, and the `Intl.NumberFormat`/`Intl.DateTimeFormat` call for chart ticks and tooltips — full locale-file strategy is the parallel i18n chapter's job, not this one's.
9. Ship the frontend as a static build — React via Shakespeare/MKStack, or a standalone Svelte 5 app — to Cloudflare Pages, GitHub Pages, or nsite. No origin server exists anywhere in this stack.
10. Before first paint in production, `curl -I` the tile host and confirm `accept-ranges: bytes` and `access-control-allow-origin` are actually present — MapLibre degrades silently (slow, not broken) when range requests aren't honored.

Confidence: High on each individual component (Tippecanoe, PMTiles, MapLibre, DuckDB-WASM are all independently well-documented). Medium on the architecture as a *combination* — no Nostr-stack precedent for census/civic-data work was found in this pass; TresPies would be first-of-kind here.

## 4. Framework Tension — React vs. Svelte 5

| Surface | Framework | Why |
|---|---|---|
| Shakespeare/MKStack-generated funnel or community site | **React** (follow the stack) | MKStack's scaffolding is React 19 + Vite + Recharts already installed [18]; hand-rewriting it in Svelte defeats the reason to use Shakespeare at all |
| Ditto community customization | **React** (follow the stack) | Ditto's own frontend is React 18+Vite (per this manual's Community Ops chapter); "beyond themes" customization means editing that codebase directly |
| Standalone dashboards (dash.trespies.dev, an Equity Atlas build) | **Svelte 5** (house standard) | No Soapbox/MKStack dependency exists here — it's the maintainers' own infra and build, so their house Svelte 5 convention (documented in their own project-instructions file) applies without conflict |
| Shared spec layer across both | **Framework-agnostic libraries** | ECharts, Vega-Lite, Observable Plot, and MapLibre GL JS all render from a plain JS/JSON call, not a component tree — the *same* chart option object or map style can be wrapped by a thin React shell in a Shakespeare output and a thin Svelte shell in a standalone build |

**Recommendation:** treat ECharts (general charts) and MapLibre GL JS (maps) as the portable spec layer — write the chart option / map style once, wrap it twice. Use Recharts/shadcn charts *only* inside Shakespeare-generated React surfaces, where it's already a zero-cost dependency [14][18]. Use LayerChart/unovis *only* inside standalone Svelte 5 builds. Never hand-port Recharts JSX into Svelte or vice versa — re-point the same underlying option object instead; that's the actual reuse boundary, not the component code.

Confidence: High — grounded directly in the fetched MKStack manifest, this manual's own prior Ditto/Agora architecture findings, and the maintainers' own standing Svelte 5 convention.

## 5. Recommendation

| Option | Map-heavy equity-data fit | Static-host compatible | Bilingual labeling | AI/agent generatable | Bundle weight | License |
|---|---|---|---|---|---|---|
| **MapLibre GL JS + PMTiles** | High — purpose-built vector-tile map engine | High — confirmed GitHub Pages/R2 patterns [30][35] | Medium — labels are app strings, not lib-native | High — dedicated agent-skills repo exists [22][23] | Medium (~200KB core + separate tile files) | BSD-3 [10] |
| **deck.gl** | High — WebGL layers for large point/polygon counts | High — client-only, syncs to MapLibre's camera [7] | Medium — same as above | Medium — general WebGL/React knowledge, no dedicated skill repo found | Heavy (full WebGL2 stack) | MIT, OpenJS/vis.gl [9] |
| **Apache ECharts** | Medium-High — native geo/map chart type, less GIS-purpose-built than MapLibre | High — pure client JS, no build step required | Medium — locale config exists, set manually | High — huge training corpus, framework-agnostic | Medium (~1MB full; tree-shakeable) | Apache 2.0 [5] |
| **Observable Plot / Framework** | Medium — has a `geo` mark [32][33], not a full interactive map engine | High — Framework *is* a static-site generator [1] | Medium — build-time loaders can bake per-locale files | Medium-High — concise grammar is a good LLM target | Light (Plot) / build-tool (Framework) | ISC |
| **Recharts (via shadcn/ui)** | Low — no native geo support | High — pure client bundle | Medium — standard React i18n patterns apply | **High — MKStack ships it by default; Claude/LLMs default to it for React asks** [18][21] | Light (~150–290KB) | MIT |
| **LayerChart / unovis (Svelte)** | Low (LayerChart) / Medium (unovis has map primitives) | High — pure client bundle | Medium | Medium — smaller training-data footprint than React libs | Light | MIT |
| **evidence.dev** | Medium — SQL-first framework, not GIS-first | High for *output*; build step needs Node + a real DB connection | Low — not a localization-focused tool | Medium — ships its own AI dev agent in-IDE [17] | N/A (full framework, not a component) | MIT |
| **DuckDB-WASM** *(data layer, not a chart lib)* | Enabling — pairs with any option above | High — the mechanism that makes "static yet queryable" possible [38] | N/A | Medium | Heavy (~33MB wasm binary) [39] | MIT [40] |

**Ranked pick:**

1. **MapLibre GL JS + PMTiles** — the map layer, non-negotiable for anything Atlas-shaped.
2. **Apache ECharts** — the general chart layer: framework-agnostic, highest-adoption, one spec reusable across the React and Svelte shells in §4.
3. **Recharts (shadcn) inside Shakespeare/MKStack surfaces; LayerChart/unovis inside standalone Svelte 5** — not a single winner, a routing rule per §4.

**Gap list — what still needs an external service:**
- Address/geocoding lookups need the Census Geocoder API (or similar) called at request time — the one piece that can't be fully baked static.
- Range+CORS-verified tile hosting *on Blossom/nsite specifically* is unverified end-to-end (§2, §3) — Cloudflare R2/Pages is the proven fallback.
- The bilingual string/number pipeline itself is intentionally out of scope here — hook points only (§3, step 8); full design lives in the parallel i18n chapter.
- Any query workload that outgrows what DuckDB-WASM can hold client-side (multi-GB full-resolution microdata, not summary tables) needs a real backend or a hosted DuckDB/MotherDuck endpoint — the static pattern has a ceiling.

Confidence: Medium-High — license/adoption facts are High confidence; the equity-data-fit *scoring* is this chapter's judgment call, not a third-party benchmark.

## Open Questions

- Whether any production Blossom server in the wild actually serves `Accept-Ranges: bytes` on blob GETs — BUD-01 only recommends it [27]; untested against a real nsite deployment this pass.
- Whether Ditto has any embed/widget surface beyond CSS theme tokens that simply isn't publicly documented yet — two independent doc sweeps found none, which is evidence of absence, not proof of it.
- Exact current version numbers for Vega-Lite and Observable Framework's newest release notes beyond the ~1.13.x line observed on npm — worth a fresh check before a client-facing commitment.
- Whether MKStack's dependency set (React 19.2.5, Vite 8.0.10, Tailwind v4.2.4, Recharts v3.8.1, observed live 2026-07-09) has moved again by the time this is read — re-fetch `package.json` from the GitLab repo rather than trusting this snapshot or any secondary blog description [18][43].
- No live example of a Nostr-stack census/civic-data dashboard was found — TresPies would be building the reference case, not following one.

## Sources

1. [observablehq/framework — GitHub](https://github.com/observablehq/framework) — static-site generator description, data-loader language support. Accessed 2026-07-09.
2. [Data loaders — Observable Framework](https://observablehq.com/framework/data-loaders) — build-time data loaders, multi-language + binary invocation (DuckDB, ffmpeg). Accessed 2026-07-09.
3. [@observablehq/framework — npm](https://www.npmjs.com/package/@observablehq/framework) — current release line (~1.13.x, ~2026-03). Accessed 2026-07-09.
4. [d3/d3 LICENSE — GitHub](https://github.com/d3/d3/blob/main/LICENSE) — ISC license confirmation. Accessed 2026-07-09.
5. [Best Apache ECharts Alternative In 2026 — LightningChart](https://lightningchart.com/blog/best-apache-echarts-alternative-in-2026/) and [echarts vs vega-lite — npm trends](https://npmtrends.com/echarts-vs-vega-lite) — Apache 2.0 license, relative weekly-download adoption. Accessed 2026-07-09.
6. [Vega and D3 — Vega docs](https://vega.github.io/vega/about/vega-and-d3/) — Vega-Lite BSD-3 license, relationship to D3. Accessed 2026-07-09.
7. [deck.gl homepage](https://deck.gl/) and [Using with MapLibre — deck.gl docs](https://deck.gl/docs/developer-guide/base-maps/using-with-maplibre) — MapView/MapboxOverlay camera sync with MapLibre. Accessed 2026-07-09.
8. [Choropleths, Four Ways — Parker Ziegler](https://parkerziegler.com/thoughts/choropleths-four-ways) — worked example of deck.gl choropleths on ACS 5-year California tract data. Accessed 2026-07-09.
9. [Open Source Data Visualization Project deck.gl v9 Released — OpenJS Foundation](https://openjsf.org/blog/deckgl-v9) and [visgl/deck.gl LICENSE](https://github.com/visgl/deck.gl/blob/master/LICENSE) — MIT license, OpenJS/vis.gl governance. Accessed 2026-07-09.
10. [maplibre/maplibre-gl-js — GitHub](https://github.com/maplibre/maplibre-gl-js) and LICENSE.txt — BSD-3 license, Linux Foundation incubation, fork lineage from Mapbox GL JS pre-Dec-2020. Accessed 2026-07-09.
11. [Recharts v3 vs Tremor vs Nivo: React Charts 2026 — PkgPulse](https://www.pkgpulse.com/guides/recharts-v3-vs-tremor-vs-nivo-react-charting-2026) — bundle-size and positioning comparison. Accessed 2026-07-09.
12. [Best React chart libraries in 2026 — LogRocket](https://blog.logrocket.com/best-react-chart-libraries-2026/) — bundle sizes, use-case framing for Recharts/Tremor/Nivo/visx. Accessed 2026-07-09.
13. [airbnb/visx — GitHub](https://github.com/airbnb/visx) — MIT license, low-level D3+React primitives, adoption figures. Accessed 2026-07-09.
14. [Chart — shadcn/ui](https://ui.shadcn.com/docs/components/radix/chart) and [Beautiful Charts & Graphs — shadcn/ui](https://ui.shadcn.com/charts/area) — official shadcn/ui chart components built directly on Recharts. Accessed 2026-07-09.
15. [techniq/layerchart — GitHub](https://github.com/techniq/layerchart) — Svelte 4/5-compatible composable chart components, MIT. Accessed 2026-07-09.
16. [f5/unovis — GitHub](https://github.com/f5/unovis) — multi-framework (incl. Svelte) viz framework, CSS-variable theming, MIT. Accessed 2026-07-09.
17. [evidence-dev/evidence — GitHub](https://github.com/evidence-dev/evidence) and [Evidence Docs](https://docs.evidence.dev/) — MIT license, SQL+Markdown static BI site, DuckDB-powered, in-app AI agent. Accessed 2026-07-09.
18. [gitlab.com/soapbox-pub/mkstack — package.json (raw)](https://gitlab.com/soapbox-pub/mkstack/-/raw/main/package.json) — primary dependency manifest: React 19.2.5, Vite 8.0.10, Tailwind v4.2.4, Recharts v3.8.1, Radix UI, TanStack Query, Nostrify. Accessed 2026-07-09.
19. [MKStack — Soapbox](https://soapbox.pub/mkstack/) — product framing, "AI-Powered Nostr App Framework." Accessed 2026-07-09.
20. [microsoft/data-formulator — GitHub](https://github.com/microsoft/data-formulator) and [Data Formulator 0.7 — Microsoft Research](https://www.microsoft.com/en-us/research/blog/data-formulator-0-7-ai-powered-data-analytics-for-enterprise-data/) — 2026 AI-native iterative chart-authoring tool. Accessed 2026-07-09.
21. [I Vibe-Coded a Complex Data Visualization Dashboard — Generative AI in the Newsroom](https://generative-ai-newsroom.com/i-vibe-coded-a-complex-data-visualization-and-analysis-dashboard-heres-what-i-learned-146398657149) — LLM default to Recharts/Chart.js when generating React chart code. Accessed 2026-07-09.
22. [maplibre/maplibre-agent-skills — GitHub](https://github.com/maplibre/maplibre-agent-skills) — MIT-licensed, community-maintained AI coding-assistant skills for MapLibre. Accessed 2026-07-09.
23. [maplibre-pmtiles-patterns SKILL.md — GitHub](https://github.com/maplibre/maplibre-agent-skills/blob/main/skills/maplibre-pmtiles-patterns/SKILL.md) — PMTiles generation/hosting/connection patterns for AI agents. Accessed 2026-07-09.
24. [NIP-23 — nostr-protocol/nips (raw)](https://raw.githubusercontent.com/nostr-protocol/nips/master/23.md) — primary spec text: HTML prohibition, optional `image` tag definition. Accessed 2026-07-09.
25. [Kind 30023: Long-form Content — Nostrbook](https://nostrbook.dev/kinds/30023) — secondary confirmation of kind 30023 structure. Accessed 2026-07-09.
26. [lez/nsite — GitHub README](https://github.com/lez/nsite) — kind 34128 path/hash mapping, "a simple application that doesn't use a backend," redundant frontend/relay/Blossom architecture. Accessed 2026-07-09.
27. [Blossom BUD-01 — hzrd149/blossom (raw)](https://raw.githubusercontent.com/hzrd149/blossom/master/buds/01.md) — primary spec text: range-request "should" language, CORS "MUST" requirement. Accessed 2026-07-09.
28. [soapbox-pub/ditto — GitHub](https://github.com/soapbox-pub/ditto) — 9 theme presets, 19 CSS token properties, 100+ UI components. Accessed 2026-07-09.
29. [about.ditto.pub](https://about.ditto.pub) — customization docs: theme/profile personalization, Shakespeare-based deep customization framing ("completely redesign the UI"), no widget/embed architecture found. Accessed 2026-07-09.
30. [Creating PMTiles — Tippecanoe / Protomaps Docs](https://docs.protomaps.com/pmtiles/create) — Tippecanoe v2.17+ direct PMTiles output, CLI workflow. Accessed 2026-07-09.
31. [Mapping 650,000+ Texas Census blocks with PMTiles — Walker Data](https://walker-data.com/posts/pmtiles-texas-blocks/) — tigris + Tippecanoe pipeline at census-block scale, hosting notes. Accessed 2026-07-09.
32. [Geo mark — Observable Plot](https://observablehq.com/plot/marks/geo) — GeoJSON/TopoJSON-based choropleth mark, Albers-USA projection example. Accessed 2026-07-09.
33. [Build your first choropleth map with Observable Plot](https://observablehq.com/@observablehq/build-your-first-choropleth-map-with-observable-plot) — worked county-level choropleth tutorial. Accessed 2026-07-09.
34. [protomaps/basemaps — GitHub](https://github.com/protomaps/basemaps) and LICENSE_DATA.md — BSD-3 code license, CC0 cartographic styling, OpenStreetMap ODbL data license ("Produced Works of the OpenStreetMap dataset under the Open Database License"). Accessed 2026-07-09.
35. [Cloudflare Integration — Protomaps Docs](https://docs.protomaps.com/deploy/cloudflare) — documented PMTiles-on-Cloudflare hosting pattern. Accessed 2026-07-09.
36. [Cloudflare Community — R2 CORS for PMTiles](https://community.cloudflare.com/t/stuck-at-cors-header-access-control-allow-origin-missing-when-using-cloudflare-workers-to-access-resources-at-r2-storage/610073) — practical CORS/range header configuration for R2-hosted tiles. Accessed 2026-07-09.
37. [maplibre/demotiles Issue #35](https://github.com/maplibre/demotiles/issues/35) — reported case of Cloudflare's CDN corrupting PMTiles range responses; Worker/R2-direct as the fix. Accessed 2026-07-09.
38. [Query — DuckDB Wasm docs](https://duckdb.org/docs/lts/clients/wasm/query) — client-side SQL over remote Parquet via HTTP range requests. Accessed 2026-07-09.
39. [DuckDB Wasm: Analytical SQL Database in Your Browser — MotherDuck](https://motherduck.com/blog/duckdb-wasm-in-browser/) — in-browser analytics benefits, ~33MB wasm binary size note. Accessed 2026-07-09.
40. [Is DuckDB Open Source? Yes — the MIT License, Explained — Definite](https://www.definite.app/blog/duckdb-open-source) — MIT license, DuckDB Foundation perpetuity statute. Accessed 2026-07-09.
41. [Vercel acquires Tremor — Vercel Blog](https://vercel.com/blog/vercel-acquires-tremor) — Jan 2025 acquisition, Tremor Blocks made free/MIT. Accessed 2026-07-09.
42. [react-i18next / i18next Issue #1201](https://github.com/i18next/i18next/issues/1201) — confirms i18next has no built-in number/date formatting; Intl API or a date library is required alongside it — the i18n hook-point boundary referenced in §3. Accessed 2026-07-09.
43. [Using MKStack to Build Nostr Apps — PayPerQ Blog](https://ppq.ai/blog/using-mkstacks-with-payperq) — secondary source describing MKStack as "React 18.x... TailwindCSS 3.x"; superseded by the primary manifest fetch [18] and flagged in Open Questions as a live-verify caution.