semiotic 3.0.0 → 3.1.0

package/CLAUDE.md

@@ -2,25 +2,39 @@
 
 ## Quick Start
 - Install: `npm install semiotic`
-- Import: `semiotic`, `semiotic/xy`, `semiotic/ordinal`, `semiotic/network`, `semiotic/realtime`, `semiotic/ai`, `semiotic/data`
+- Import: `semiotic`, `semiotic/xy`, `semiotic/ordinal`, `semiotic/network`, `semiotic/geo`, `semiotic/realtime`, `semiotic/ai`, `semiotic/data`, `semiotic/server`
 - CLI: `npx semiotic-ai [--schema|--compact|--examples|--doctor]`
 - MCP: `npx semiotic-mcp`
 - Every HOC has a built-in error boundary (never blanks the page) and dev-mode validation warnings
 
 ## Architecture
 - **HOC Charts**: Simple props, sensible defaults. **Stream Frames**: Full control.
+- **Always use HOC charts** (`ForceDirectedGraph`, `SankeyDiagram`, `LineChart`, `RealtimeLineChart`, `ChoroplethMap`, etc.) unless you need sophisticated control they don't expose. Stream Frames (`StreamNetworkFrame`, `StreamXYFrame`, `StreamOrdinalFrame`, `StreamGeoFrame`) are low-level escape hatches — they accept raw `RealtimeNode`/`RealtimeEdge` wrappers in callbacks, not your data objects directly.
 - Every HOC accepts `frameProps` to pass through. TypeScript `strict: true`.
 
 ## Common Props (all HOCs)
-`title`, `width` (600), `height` (400), `responsiveWidth`, `responsiveHeight`, `margin`, `className`, `enableHover` (true), `tooltip`, `showLegend`, `showGrid` (false), `frameProps`, `onObservation`, `chartId`
+`title`, `width` (600), `height` (400), `responsiveWidth`, `responsiveHeight`, `margin`, `className`, `enableHover` (true), `tooltip` (boolean | `(datum) => ReactNode` | config object), `showLegend`, `showGrid` (false), `frameProps`, `onObservation` (callback, see below), `chartId`, `loading` (false), `emptyContent`, `legendInteraction` ("none"|"highlight"|"isolate"), `legendPosition` ("right"|"left"|"top"|"bottom", default "right"), `emphasis` ("primary"|"secondary")
+
+### tooltip
+`tooltip` accepts: `true` (default tooltip), `false` (disabled), a **function** `(datum: Record<string, any>) => ReactNode`, or a config `{ fields?: string[], title?: accessor, format?: fn, style?: CSSProperties }`. The function form receives your raw data object directly.
+
+### onObservation
+`onObservation` receives a `ChartObservation` with `type` and event-specific fields:
+- **hover**: `{ type: "hover", datum: <your data>, x, y, timestamp, chartType, chartId }`
+- **hover-end**: `{ type: "hover-end", timestamp, chartType, chartId }`
+- **click**: `{ type: "click", datum: <your data>, x, y, timestamp, chartType, chartId }`
+- **brush**: `{ type: "brush", extent: { x: [min, max], y: [min, max] }, timestamp, chartType }`
+- **selection**: `{ type: "selection", selection: { name, fields }, timestamp, chartType }`
+
+The `datum` field contains your original data object (not a wrapper).
 
 ## XY Charts (`semiotic/xy`)
 
-**LineChart** — `data`, `xAccessor` ("x"), `yAccessor` ("y"), `lineBy`, `lineDataAccessor` ("coordinates"), `colorBy`, `colorScheme`, `curve`, `lineWidth` (2), `showPoints`, `pointRadius` (3), `fillArea`, `areaOpacity` (0.3), `anomaly` (AnomalyConfig), `forecast` (ForecastConfig)
+**LineChart** — `data`, `xAccessor` ("x"), `yAccessor` ("y"), `lineBy`, `lineDataAccessor` ("coordinates"), `colorBy`, `colorScheme`, `curve`, `lineWidth` (2), `showPoints`, `pointRadius` (3), `fillArea`, `areaOpacity` (0.3), `anomaly` (AnomalyConfig), `forecast` (ForecastConfig), `directLabel` (boolean|{position,fontSize}), `gapStrategy` ("break"|"interpolate"|"zero"), `xScaleType` ("linear"|"log"), `yScaleType` ("linear"|"log")
 
 **AreaChart** — LineChart props + `areaBy`, `y0Accessor` (band/ribbon), `gradientFill` (boolean|{topOpacity,bottomOpacity}), `areaOpacity` (0.7), `showLine` (true)
 
-**StackedAreaChart** — AreaChart + `normalize` (false)
+**StackedAreaChart** — flat array data + `areaBy` (required, groups into stacked areas), `colorBy`, `normalize` (false). Do NOT use `lineBy` or `lineDataAccessor` — those are LineChart props.
 
 **Scatterplot** — `data`, `xAccessor`, `yAccessor`, `colorBy`, `sizeBy`, `sizeRange`, `pointRadius` (5), `pointOpacity` (0.8), `marginalGraphics`
 
@@ -28,64 +42,188 @@
 
 **ConnectedScatterplot** — `data`, `xAccessor`, `yAccessor`, `orderAccessor` (number|Date field for sequencing), `pointRadius` (4). Viridis colored start→end, line width = point radius, white halo under lines when <100 points.
 
-**Heatmap** — `data`, `xAccessor`, `yAccessor`, `valueAccessor`, `colorScheme`, `showValues`, `cellBorderColor`
+**QuadrantChart** — Scatterplot divided into four labeled, colored quadrants. `data`, `xAccessor`, `yAccessor`, `quadrants` (required: `{ topRight, topLeft, bottomRight, bottomLeft }` each with `label`, `color`, optional `opacity`), `xCenter` (vertical center line in data units), `yCenter` (horizontal center line), `centerlineStyle` (`{ stroke, strokeWidth, strokeDasharray }`), `showQuadrantLabels` (true), `quadrantLabelSize` (12), `colorBy`, `sizeBy`, `sizeRange`, `pointRadius` (5), `pointOpacity` (0.8). Supports push API. Quadrant fills and labels drawn via `canvasPreRenderers`.
+
+**Heatmap** — `data`, `xAccessor`, `yAccessor`, `valueAccessor`, `colorScheme` ("blues"|"reds"|"greens"|"viridis" or custom), `showValues`, `cellBorderColor`. Accessors can be string field names (including string/categorical fields) or functions.
 
 ## Ordinal Charts (`semiotic/ordinal`)
 
-**BarChart** — `data`, `categoryAccessor`, `valueAccessor`, `orientation`, `colorBy`, `sort`, `barPadding`
-**StackedBarChart** — + `stackBy` (required), `normalize`
-**GroupedBarChart** — + `groupBy` (required)
+**BarChart** — `data`, `categoryAccessor`, `valueAccessor`, `orientation`, `colorBy`, `sort`, `barPadding` (40)
+**StackedBarChart** — + `stackBy` (required), `normalize`, `barPadding` (40)
+**GroupedBarChart** — + `groupBy` (required), `barPadding` (60)
 **SwarmPlot** — `data`, `categoryAccessor`, `valueAccessor`, `colorBy`, `sizeBy`, `pointRadius`, `pointOpacity`
 **BoxPlot** — + `showOutliers`, `outlierRadius`
-**Histogram** — + `bins` (25), `relative`. Always horizontal.
+**Histogram** — + `bins` (25), `relative`. Always horizontal. `categoryAccessor` is optional (defaults to `"category"`) — for a single-group histogram, either omit it or ensure your data has a `category` field with a single value.
 **ViolinPlot** — + `bins`, `curve`, `showIQR`
 **DotPlot** — + `sort` (true), `dotRadius`, `showGrid` default true
 **PieChart** — `data`, `categoryAccessor`, `valueAccessor`, `colorBy`, `startAngle`, `slicePadding`
-**DonutChart** — PieChart + `innerRadius` (60), `centerContent`
+**DonutChart** — PieChart + `innerRadius` (60), `centerContent` (ReactNode — any React element, e.g. `<div>50%</div>`)
 
 ## Network Charts (`semiotic/network`)
 
-**ForceDirectedGraph** — `nodes`, `edges`, `nodeIDAccessor`, `sourceAccessor`, `targetAccessor`, `colorBy`, `nodeSize`, `edgeWidth`, `iterations`, `showLabels`
+**ForceDirectedGraph** — `nodes`, `edges`, `nodeIDAccessor`, `sourceAccessor`, `targetAccessor`, `colorBy`, `colorScheme`, `nodeSize` (number|string|fn), `nodeSizeRange`, `edgeWidth`, `edgeColor`, `edgeOpacity`, `iterations` (300), `forceStrength` (0.1), `showLabels`, `nodeLabel`, `tooltip`, `showLegend`, `legendInteraction`
 **SankeyDiagram** — `edges`, `nodes`, `valueAccessor`, `edgeColorBy`, `orientation`, `nodeAlign`, `nodeWidth`, `showLabels`, `edgeOpacity`
 **ChordDiagram** — `edges`, `nodes`, `valueAccessor`, `edgeColorBy`, `padAngle`, `groupWidth`, `showLabels`
 **TreeDiagram** — `data` (root), `layout`, `orientation`, `childrenAccessor`, `colorBy`, `colorByDepth`, `edgeStyle`
 **Treemap** — `data` (root), `childrenAccessor`, `valueAccessor`, `colorBy`, `colorByDepth`, `showLabels`, `labelMode`
 **CirclePack** — `data` (root), `childrenAccessor`, `valueAccessor`, `colorBy`, `colorByDepth`, `circleOpacity`
+**OrbitDiagram** — animated radial/orbital hierarchy. Use this (not TreeDiagram) when you want animated orbiting nodes. `data` (root), `childrenAccessor`, `nodeIdAccessor`, `orbitMode` ("flat"|"solar"|"atomic"|number[]), `speed` (0.25), `revolution`, `eccentricity`, `orbitSize`, `nodeRadius`, `showRings`, `showLabels`, `animated` (true), `colorBy`, `colorByDepth`, `annotations` (widget annotations anchor by nodeId). For static radial trees, use `TreeDiagram layout="radial"` instead.
+
+## Geo Charts (`semiotic/geo`)
+
+Geographic visualization with d3-geo projections. Canvas-rendered via `StreamGeoFrame`. Import from `semiotic/geo` to avoid adding d3-geo to non-geo bundles.
+
+**ChoroplethMap** — `areas` (GeoJSON Feature[] or reference string like "world-110m"), `valueAccessor`, `colorScheme` ("blues"|"reds"|"greens"|"viridis"), `areaOpacity` (1), `projection` ("equalEarth"), `graticule`, `tooltip`, `showLegend`
+**ProportionalSymbolMap** — `points`, `xAccessor` ("lon"), `yAccessor` ("lat"), `sizeBy`, `sizeRange` ([3,30]), `colorBy`, `areas` (optional background), `projection`
+**FlowMap** — `flows` ({source, target, value}), `nodes`, `xAccessor`, `yAccessor`, `nodeIdAccessor` ("id"), `valueAccessor` ("value"), `edgeColorBy`, `edgeOpacity` (0.6), `edgeWidthRange` ([1,8]), `edgeLinecap` ("round"), `lineType` ("geo"|"line"), `areas` (optional background), `showParticles`, `particleStyle` ({ radius, color, opacity, speedMultiplier, maxPerLine, spawnRate }). Particle `color` accepts a string, `"source"` (inherit line stroke), or `(datum) => string`.
+**DistanceCartogram** — `points`, `center` (id of center node), `costAccessor`, `strength` (0-1), `lineMode` ("straight"|"fractional"), `nodeIdAccessor` ("id"), `lines`, `projection`, `showRings` (true|false|number[]), `ringStyle` ({ stroke, strokeWidth, ... }), `showNorth` (true), `costLabel` (string for ring labels), `transition` (ms for smooth animation), `pointRadius`
+
+All geo HOCs support: `selection`, `linkedHover`, `onObservation`, `showLegend`, `legendInteraction`, `tooltip`, `loading`, `emptyContent`, `frameProps`, `fitPadding` (0–1 fraction, insets auto-fit projection from edges), `zoomable` (defaults true with tileURL, false otherwise), `zoomExtent`, `onZoom`, `dragRotate`, `graticule`, `tileURL`, `tileAttribution`, `tileCacheSize`
+
+**Zoom/Pan**: All geo charts accept `zoomable` (boolean), `zoomExtent` ([minZoom, maxZoom], default [1, 8]), and `onZoom` (callback with `{ projection, zoom }`). Re-renders projection directly on every zoom tick (no CSS transform). Imperative API: `ref.current.getZoom()`, `ref.current.resetZoom()`.
+
+**Geo Particles**: `FlowMap` and `StreamGeoFrame` support `showParticles` (boolean) and `particleStyle` to animate dots flowing along line paths. Uses `GeoParticlePool` — an object-pool polyline particle system. Particle `color` accepts: `"source"` (inherit line stroke), a CSS string, or `(datum) => string` for per-line color.
+
+**Drag Rotate (Globe Spinning)**: `dragRotate` (boolean) — when true, drag gestures rotate the projection (globe spinning) instead of panning. **Defaults to true for orthographic projection.** Scroll-wheel zoom still works normally. Explicitly set `dragRotate={false}` on orthographic to get standard pan behavior, or `dragRotate={true}` on other projections to enable rotation. Latitude rotation is clamped to [-90, 90] to prevent flipping.
+
+**Tile Maps**: All geo charts accept `tileURL` (string template like `"https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png"` or `(z, x, y, dpr) => string`), `tileAttribution` (e.g., `"© OpenStreetMap contributors"`), `tileCacheSize` (default 256). Tiles render on a background canvas behind data layers. **Mercator projection only** — a dev warning is emitted for non-Mercator projections. Tiles update on zoom/pan. Retina support via `{r}` placeholder or DPR parameter. **Production**: OpenStreetMap tiles are for development/demo only. For production, use a commercial tile provider (Mapbox, MapTiler, Stadia Maps) with your own API key passed via environment variable (never hard-code keys in client code). Example: `tileURL={\`https://api.mapbox.com/styles/v1/mapbox/light-v11/tiles/{z}/{x}/{y}?access_token=\${process.env.MAPBOX_TOKEN}\`}`.
+
+**StreamGeoFrame** — low-level frame with full control. Props: `projection`, `areas`, `points`, `lines`, `xAccessor`, `yAccessor`, `areaStyle`, `pointStyle`, `lineStyle`, `graticule`, `projectionTransform` (distance cartogram config), `projectionExtent`, `enableHover`, `tooltipContent`, `zoomable`, `zoomExtent`, `onZoom`, `tileURL`, `tileAttribution`, `tileCacheSize`, `decay`, `pulse`, `transition`. Push API: `ref.current.push(datum)`, `ref.current.pushMany(data)`, `ref.current.clear()`.
+
+**Reference geography**: `resolveReferenceGeography("world-110m")` returns GeoJSON features from Natural Earth data (world-atlas). Supported: `"world-110m"`, `"world-50m"`, `"land-110m"`, `"land-50m"`. All geo HOCs accept `areas` as `GeoJSON.Feature[]` or a reference string.
+
+**mergeData(features, data, { featureKey, dataKey })** — join external data into GeoJSON features by key field. Supports nested paths (e.g., `"properties.iso_a3"`). World-atlas uses ISO 3166-1 numeric codes as the `id` field. Also available from `semiotic/data` as a general join-by-key utility.
+
+```jsx
+// World choropleth with reference geography + data joining
+import { ChoroplethMap, resolveReferenceGeography, mergeData } from "semiotic/geo"
+const world = await resolveReferenceGeography("world-110m")
+const areas = mergeData(world, gdpData, { featureKey: "id", dataKey: "id" })
+<ChoroplethMap areas={areas} valueAccessor="gdpPerCapita" colorScheme="viridis"
+  projection="equalEarth" zoomable tooltip />
+
+// Distance cartogram (ORBIS-style) with concentric rings overlay
+import { DistanceCartogram } from "semiotic/geo"
+<DistanceCartogram
+  points={cities} center="rome" costAccessor="travelDays"
+  strength={0.8} lines={routes} showLegend zoomable
+  showRings costLabel="days" showNorth
+  ringStyle={{ stroke: "#999", strokeWidth: 0.5 }}
+/>
+
+// Tile map basemap with proportional symbols
+<ProportionalSymbolMap
+  points={earthquakes} xAccessor="lon" yAccessor="lat"
+  sizeBy="magnitude" sizeRange={[2, 20]}
+  projection="mercator" zoomable
+  tileURL="https://tile.openstreetmap.org/{z}/{x}/{y}.png"
+  tileAttribution="© OpenStreetMap contributors"
+/>
+
+// Streaming geo points with zoom
+const geoRef = useRef()
+geoRef.current.push({ lon: -122.4, lat: 37.8, value: 42 })
+<StreamGeoFrame ref={geoRef} projection="mercator" xAccessor="lon" yAccessor="lat"
+  runtimeMode="streaming" decay={{ type: "linear", minOpacity: 0.1 }}
+  zoomable zoomExtent={[1, 12]} onZoom={({ zoom }) => console.log(zoom)} />
+```
 
 ## Realtime Charts (`semiotic/realtime`)
 
 Push API: `chartRef.current.push({ time, value })`
 
-**RealtimeLineChart** — `size`, `timeAccessor`, `valueAccessor`, `windowSize` (200), `windowMode`, `stroke`, `strokeWidth`
-**RealtimeHistogram** — + `binSize` (required), `categoryAccessor`, `colors`
-**RealtimeSwarmChart** — + `categoryAccessor`, `radius`, `opacity`
-**RealtimeWaterfallChart** — + `positiveColor`, `negativeColor`
-**RealtimeHeatmap** — + `heatmapXBins`, `heatmapYBins`, `aggregation`
-**Streaming Sankey** — `StreamNetworkFrame` with `chartType="sankey"`, `showParticles`, `particleStyle`, `tensionConfig`, `thresholds`
+**IMPORTANT**: All pushed data must include a time field (default: `"time"`). If your data uses a different field name, set `timeAccessor` explicitly. Without a valid time field, charts render blank with no error.
+
+Sizing: all Realtime HOCs accept both `size={[600, 400]}` (tuple) and `width={600} height={400}`. Either works.
+
+**RealtimeLineChart** — `size`|`width`+`height`, **`timeAccessor`** ("time"), **`valueAccessor`** ("value"), `windowSize` (200), `windowMode`, `stroke`, `strokeWidth`
+**RealtimeHistogram** — **`binSize`** (required), **`timeAccessor`** ("time"), **`valueAccessor`** ("value"), `categoryAccessor`, `colors`. Time field is required even though this shows a distribution — it's used for windowing.
+**RealtimeSwarmChart** — **`timeAccessor`** ("time"), **`valueAccessor`** ("value"), `categoryAccessor`, `radius`, `opacity`
+**RealtimeWaterfallChart** — **`timeAccessor`** ("time"), **`valueAccessor`** ("value"), `positiveColor`, `negativeColor`
+**RealtimeHeatmap** — **`timeAccessor`** ("time"), **`valueAccessor`** ("value"), `heatmapXBins`, `heatmapYBins`, `aggregation`. Both accessors must match your data fields or the chart renders blank.
+**Streaming Sankey** — `StreamNetworkFrame` with `chartType="sankey"`, `showParticles` (boolean), `particleStyle` (`{ radius, opacity, speedMultiplier, maxPerEdge, colorBy }`), `tensionConfig`, `thresholds`. Push **individual edges**: `ref.current.push({ source: "A", target: "B", value: 42 })`. Use `ref.current.pushMany([...edges])` for batches.
 
 Realtime encoding: `decay`, `pulse`, `transition`, `staleness` — compose freely on all streaming charts.
 
+### Realtime data shape
+```jsx
+// Every pushed datum should have a time field
+ref.current.push({ time: Date.now(), value: 42 })              // line, waterfall
+ref.current.push({ time: Date.now(), value: 42, category: "A" }) // histogram, swarm
+ref.current.push({ time: Date.now(), value: 42 })              // heatmap (time=x, value=y)
+```
+
+### Push API on HOC charts
+Many HOC charts support the push API via `forwardRef`. Omit the `data` prop and push data imperatively:
+```jsx
+const chartRef = useRef()
+chartRef.current.push({ x: 1, y: 2 })          // single point
+chartRef.current.pushMany([...points])           // batch
+chartRef.current.clear()                          // reset
+chartRef.current.getData()                        // read current data
+<Scatterplot ref={chartRef} xAccessor="x" yAccessor="y" />
+```
+**IMPORTANT**: When using the push API, **omit** the `data`/`nodes`/`edges` prop entirely — do NOT pass `data={[]}`, which clears pushed data on every render. Streaming-specific props (`windowSize`, `decay`, `pulse`) go in `frameProps`.
+
+Supported: all XY charts (LineChart, AreaChart, Scatterplot, etc.), all ordinal charts (BarChart, Histogram, etc.), network charts (ForceDirectedGraph, SankeyDiagram, ChordDiagram), and geo point charts (ProportionalSymbolMap, DistanceCartogram). **Not supported**: hierarchy charts (TreeDiagram, Treemap, CirclePack, OrbitDiagram) — their root-object data shape is incompatible with flat push. ChoroplethMap (area-based, not point-based), FlowMap (line-based), and ScatterplotMatrix also do not support push.
+
+## Stream Frame Callbacks (advanced — prefer HOCs)
+Stream Frame callbacks (`nodeStyle`, `edgeStyle`, `nodeSize` as function, `colorBy` as function, `nodeLabel` as function) receive **`RealtimeNode`/`RealtimeEdge`** wrappers, NOT your raw data. Access your original data via `.data`:
+```jsx
+// WRONG: nodeSize={(d) => d.weight}         — d is RealtimeNode, d.weight is undefined
+// RIGHT: nodeSize={(d) => d.data?.weight}   — d.data is your original node object
+// RIGHT: nodeSize="weight"                  — string accessor handles this automatically
+// WRONG: nodeStyle={(d) => ({ fill: d.datum.color })}  — .datum does not exist
+// RIGHT: nodeStyle={(d) => ({ fill: d.data?.color })}  — use .data
+```
+`customHoverBehavior` and `customClickBehavior` receive `{ type: "node"|"edge", data: <your raw object>, x, y } | null`.
+`tooltipContent` receives `{ type: "node"|"edge", data: <your raw object> }`.
+
 ## Coordinated Views
 
-**LinkedCharts** — wraps charts. Props: `selections` (resolution: "union"|"intersect"|"crossfilter")
+**LinkedCharts** — wraps charts. Props: `selections` (resolution: "union"|"intersect"|"crossfilter"), `showLegend` (auto when CategoryColorProvider present), `legendPosition` ("top"|"bottom"), `legendInteraction` ("highlight"|"isolate"|"none"), `legendSelectionName` (selection name for legend-driven cross-highlighting), `legendField` (data field for legend selections)
 **CategoryColorProvider** — stable category→color mapping. Props: `colors` (map) or `categories` + `colorScheme`
 Chart props: `selection`, `linkedHover`, `linkedBrush`. Hooks: `useSelection`, `useLinkedHover`, `useBrushSelection`, `useFilteredData`
 **ScatterplotMatrix** — `data`, `fields`, `colorBy`, `cellSize`, `hoverMode`, `brushMode`
 
+## ChartContainer
+
+**ChartContainer** — wrapper with title, subtitle, status indicator, toolbar actions. Props: `title`, `subtitle`, `height` (default **400** — set this to match your chart's height or you'll get extra whitespace), `width` (default "100%"), `status` ("live"|"stale"|"error"), `loading`, `error`, `errorBoundary`, `actions` (`{ export, fullscreen, copyConfig }`), `controls`, `style`, `className`
+
+When using `ChartContainer` with a chart that has `size={[w, h]}`, always set `height={h}` on the container to avoid a mismatch.
+
 ## Layout & Composition
 
-**ChartGrid** — CSS Grid layout. `columns` (number|"auto"), `minCellWidth` (300), `gap` (16)
+**ChartGrid** — CSS Grid layout. `columns` (number|"auto"), `minCellWidth` (300), `gap` (16). Children with `emphasis="primary"` span two columns.
 **ContextLayout** — primary + context panel. `context` (ReactNode), `position`, `contextSize` (250)
 
 ## Key Patterns
 
 ```jsx
-// Cross-highlighting dashboard
+// Force-directed graph with custom sizing and hover
+<ForceDirectedGraph
+  nodes={[{ id: "A", group: "eng", weight: 10 }, { id: "B", group: "design", weight: 5 }]}
+  edges={[{ source: "A", target: "B" }]}
+  colorBy="group"
+  nodeSize="weight"           // string accessor → reads node.weight, scales to nodeSizeRange
+  nodeSizeRange={[5, 25]}
+  showLabels
+  showLegend
+  tooltip={(d) => <div>{d.data.id}: {d.data.weight}</div>}
+  frameProps={{
+    customClickBehavior: (d) => { if (d?.type === "node") console.log(d.data) },
+    background: "#f5f5f5",
+  }}
+/>
+
+// Cross-highlighting dashboard with column spanning
+// emphasis="primary" makes a chart span 2 columns in ChartGrid
 <CategoryColorProvider categories={["North", "South", "East"]}>
 <LinkedCharts>
   <ChartGrid columns={2}>
-    <LineChart data={d} colorBy="region" linkedHover={{ name: "hl", fields: ["region"] }} selection={{ name: "hl" }} responsiveWidth />
+    <LineChart data={d} colorBy="region" linkedHover={{ name: "hl", fields: ["region"] }} selection={{ name: "hl" }} emphasis="primary" responsiveWidth />
     <BarChart data={d} colorBy="region" linkedHover={{ name: "hl", fields: ["region"] }} selection={{ name: "hl" }} responsiveWidth />
+    <Scatterplot data={d} colorBy="region" linkedHover={{ name: "hl", fields: ["region"] }} selection={{ name: "hl" }} responsiveWidth />
   </ChartGrid>
 </LinkedCharts>
 </CategoryColorProvider>
@@ -99,25 +237,100 @@ Chart props: `selection`, `linkedHover`, `linkedBrush`. Hooks: `useSelection`, `
 <LineChart data={ml} xAccessor="time" yAccessor="value"
   forecast={{ isTraining: "isTraining", isForecast: "isForecast", isAnomaly: "isAnomaly", upperBounds: "upper", lowerBounds: "lower" }} />
 
-// Gradient area + percentile band
-<AreaChart data={d} xAccessor="x" yAccessor="p95" y0Accessor="p5" gradientFill />
+// Stacked area (flat array + areaBy, NOT lineBy)
+<StackedAreaChart data={flatData} xAccessor="month" yAccessor="value"
+  areaBy="category" colorBy="category" />
 
-// Realtime
+// Percentile band (p5–p95) with main line (p50) — MUST layer two charts
+// AreaChart with y0Accessor renders the band; showLine only draws the TOP edge (p95), not p50
+// To show a separate main line, add a LineChart on top:
+<>
+  <AreaChart data={d} xAccessor="x" yAccessor="p95" y0Accessor="p5"
+    showLine={false} areaOpacity={0.3} gradientFill />
+  <LineChart data={d} xAccessor="x" yAccessor="p50" lineWidth={2} />
+</>
+// Simple gradient area (no band):
+<AreaChart data={d} xAccessor="x" yAccessor="y" gradientFill />
+
+// Realtime — always include time field in pushed data
 const ref = useRef()
 ref.current.push({ time: Date.now(), value: 42 })
 <RealtimeLineChart ref={ref} timeAccessor="time" valueAccessor="value" />
+
+// Realtime histogram — time field required even for distribution charts
+const histRef = useRef()
+histRef.current.push({ time: Date.now(), value: Math.abs(delta) })
+<RealtimeHistogram ref={histRef} timeAccessor="time" valueAccessor="value" binSize={100} />
+
+// Streaming sankey with particles — push individual edges, NOT full snapshots
+const sankeyRef = useRef()
+sankeyRef.current.push({ source: "Web", target: "API", value: 1 })    // one edge at a time
+sankeyRef.current.pushMany([                                            // or batch
+  { source: "Web", target: "API", value: 3 },
+  { source: "API", target: "DB", value: 2 },
+])
+<StreamNetworkFrame
+  ref={sankeyRef}
+  chartType="sankey"
+  showParticles={true}
+  particleStyle={{ radius: 2, colorBy: "source", speedMultiplier: 1.5 }}
+  width={600} height={400}
+/>
+
+// SSR — renderToStaticSVG takes frame type string, not component name
+import { renderOrdinalToStaticSVG } from "semiotic/server"
+const svg = renderOrdinalToStaticSVG({
+  data, categoryAccessor: "category", valueAccessor: "value", width: 600, height: 400
+})
+```
+
+## Annotations
+- `type: "widget"` — place any React element at data coordinates. Works on all frame types. XY/ordinal use data coordinates (`x`/`y` or field names). Network/orbit use `nodeId`. Default: info emoji. Renders as HTML overlay (not SVG) so popups/threads overflow freely.
+```jsx
+annotations={[{ type: "widget", month: 4, revenue: 32, dy: -4, content: <MyAlertButton /> }]}
+// OrbitDiagram: annotations={[{ type: "widget", nodeId: "Pipeline", content: <Alert /> }]}
 ```
 
+## Server-Side Rendering
+- All HOC charts and Stream Frames render SVG automatically in server environments (no window/document)
+- `renderToStaticSVG(frameType, props)` — standalone SVG string from `semiotic/server`. `frameType` is `"xy"` | `"ordinal"` | `"network"` | `"geo"` (NOT a component name like "BarChart")
+- Type-specific shortcuts: `renderXYToStaticSVG(props)`, `renderOrdinalToStaticSVG(props)`, `renderNetworkToStaticSVG(props)`, `renderGeoToStaticSVG(props)`
+- For a bar chart: `renderOrdinalToStaticSVG({ data, categoryAccessor: "cat", valueAccessor: "val", width: 600, height: 400 })`
+- Works with Next.js App Router, Remix, Astro — same component on server and client
+- **Geo SSR requires pre-resolved features**: `renderGeoToStaticSVG` is synchronous — pass GeoJSON features directly, not reference strings like `"world-110m"`. Call `await resolveReferenceGeography("world-110m")` first and pass the result as `areas`.
+
 ## AI Features
 - `onObservation` — structured events (hover, click, brush, selection) on all HOCs
 - `useChartObserver` — aggregates observations across LinkedCharts
 - `toConfig`/`fromConfig`/`toURL`/`fromURL`/`copyConfig`/`configToJSX` — chart state serialization
 - `DetailsPanel` — click-driven detail panel inside `ChartContainer`
-- `validateProps(componentName, props)` — prop validation
+- `validateProps(componentName, props)` — prop validation with Levenshtein typo suggestions
+- `diagnoseConfig(componentName, props)` — anti-pattern detector (12 checks: empty data, bad dimensions, missing accessors, margin overflow, etc.)
 - `ChartErrorBoundary` — error boundary
-- `exportChart(el, { format: "png"|"svg" })` — browser export
-- `renderToStaticSVG()` — server-side SVG (from `semiotic/server`)
-- `npx semiotic-ai --doctor` — validate component + props JSON from CLI
+- `exportChart(containerDiv, { format: "png"|"svg" })` — pass the **wrapper div** (not the SVG element); it finds canvas + SVG internally. Default: PNG, composites canvas + SVG layers
+- `npx semiotic-ai --doctor` — validate component + props JSON from CLI (uses both validateProps and diagnoseConfig)
+
+## Known Pitfalls
+
+**Tooltip datum shape**: HOC tooltip functions receive your raw data object. When using `frameProps.tooltipContent` on Stream Frames, the datum may be wrapped — access your data via `d.data`. HOC `tooltip` functions don't need this.
+
+**Legend positioning**: `legendPosition` controls where the legend renders. When set to "bottom", the chart automatically expands the bottom margin to ~80px to clear axis labels. For "top", margin expands to ~50px. If you need more space, override `margin` explicitly. For charts narrower than ~400px, prefer `legendPosition="bottom"` or `"top"` (bottom is more common) to avoid squeezing the chart area. Similarly, for short charts (~250px or less), a side legend may compress the chart too much — use top or bottom instead.
+
+**Log scale and zero**: `xScaleType="log"` / `yScaleType="log"` clamp domain minimums to 1e-6 because log(0) is undefined. Data with zero or negative values will be clamped.
+
+**Heatmap with string axes**: Heatmap supports string/categorical x and y values (e.g., weekday names, hour labels). The `colorScheme` prop accepts d3-scale-chromatic names: "blues", "reds", "greens", "viridis".
+
+**barPadding is in pixels**: `barPadding` on ordinal charts is an absolute pixel value divided by the chart width to compute a band scale padding ratio. The defaults (40 for bar/stacked, 60 for grouped) work well at 600px width. For very small charts, you may need to reduce it.
+
+**Horizontal bar charts need wider left margins**: When using `orientation="horizontal"` with long category labels, increase the left margin manually: `margin={{ left: 120 }}`. There is no auto-measurement of label width.
+
+**LinkedCharts suppresses child legends**: When a `CategoryColorProvider` wraps `LinkedCharts`, individual chart legends are suppressed in favor of a unified legend. To force a child chart to show its own legend, set `showLegend={true}` explicitly.
+
+**Geo bundle isolation**: `semiotic/geo` is a separate entry point. Do NOT import geo components from `semiotic` — use `import { ChoroplethMap } from "semiotic/geo"` to avoid pulling d3-geo (~30KB) into non-geo bundles.
+
+**Push API: omit data, don't pass empty array**: When using `ref.current.push()` on HOCs, **omit** the `data`/`nodes`/`edges` prop entirely. Passing `data={[]}` clears pushed data on every render because the HOC forwards it to the Stream Frame's `setBoundedData([])`. Similarly, `data={undefined}` is fine (prop not present), but `data={null}` is treated the same as omitted.
+
+**`diagnoseConfig` catches common mistakes**: Run `diagnoseConfig("BarChart", props)` to check for empty data, bad dimensions, missing accessors, margin overflow, invisible bar padding, and more. Use `npx semiotic-ai --doctor` from CLI.
 
 ## Differentiators
-Network viz, streaming canvas, realtime encoding, coordinated views, statistical summaries, AI hooks, chart serialization, global theming, keyboard navigation
+Network viz, geographic viz (choropleth, flow maps, distance cartograms), streaming canvas, realtime encoding, coordinated views, statistical summaries, AI hooks, chart serialization, global theming, keyboard navigation, interactive legends (highlight/isolate), direct labeling, gap handling, empty/loading states, landmark tick labels, LinkedCharts unified legend

package/README.md

@@ -4,10 +4,11 @@
 [![npm version](https://img.shields.io/npm/v/semiotic.svg)](https://www.npmjs.com/package/semiotic)
 [![TypeScript](https://img.shields.io/badge/TypeScript-built--in-blue.svg)](https://www.typescriptlang.org/)
 
-A React data visualization library for charts, networks, and beyond.
+A React data visualization library designed for AI-assisted development.
 
-Simple charts in 5 lines. Force-directed graphs, Sankey diagrams, treemaps,
-and chord diagrams when you need them. Full D3-level control when you want it.
+Simple charts in 5 lines. Network graphs, streaming data, and coordinated
+dashboards when you need them. Structured schemas and an MCP server so
+AI coding assistants generate correct chart code on the first try.
 
 ```jsx
 import { LineChart } from "semiotic"
@@ -21,31 +22,52 @@ import { LineChart } from "semiotic"
 
 ## Why Semiotic
 
-Most React charting libraries give you bar charts, line charts, and pie charts.
-Semiotic gives you those too — but it's built for the projects where those
-aren't enough.
+Semiotic is a data visualization library for React that combines broad chart
+coverage with first-class AI tooling. It handles the chart types that most
+libraries skip — network graphs, streaming data, statistical distributions,
+coordinated views — and ships with machine-readable schemas so LLMs can
+generate correct code without examples.
 
-### When you need more than standard charts
+### Built for AI-assisted development
 
-**Network visualization.** Show how things connect — org charts,
-dependency graphs, budget flows, taxonomies. Semiotic has force-directed
-graphs, Sankey diagrams, chord diagrams, tree layouts, treemaps, and circle
-packing as React components with the same prop API as LineChart.
+Semiotic ships with everything an AI coding assistant needs to generate
+correct visualizations without trial and error:
 
-**Streaming data.** Monitor live systems — server metrics, sensor feeds,
-financial tickers. Semiotic's realtime charts render on canvas at 60fps with
-a ref-based push API. Old data fades out (decay), new data flashes in
-(pulse), and stale feeds are flagged automatically.
+- **`semiotic/ai`** — a single import with all 37 chart components, optimized for LLM code generation
+- **`ai/schema.json`** — machine-readable prop schemas for every component
+- **`npx semiotic-mcp`** — an MCP server for tool-based chart rendering in any MCP client
+- **`npx semiotic-ai --doctor`** — validate component + props JSON from the command line with typo suggestions and anti-pattern detection
+- **`diagnoseConfig(component, props)`** — programmatic anti-pattern detector with 12 checks and actionable fixes
+- **`CLAUDE.md`** — instruction files auto-synced for Claude, Cursor, Copilot, Windsurf, and Cline
+- **`llms.txt`** — machine-readable documentation following the emerging standard
 
-**Coordinated dashboards.** Hover one chart, highlight matching data in
-others. Brush a scatterplot, filter a bar chart. Semiotic's `LinkedCharts`
-and `ScatterplotMatrix` provide crossfilter coordination that other libraries
-leave you to build from scratch.
+Every chart includes a built-in error boundary, dev-mode validation
+warnings with typo suggestions, and accessibility features (canvas
+`aria-label`, keyboard-navigable legends, `aria-live` tooltips, SVG
+`<title>`/`<desc>`) so AI-generated code fails gracefully with
+actionable diagnostics instead of a blank screen.
 
-**Statistical summaries.** Box plots, violin plots, swarm plots, ridgeline
-plots, histograms — the distribution charts that data scientists need and
-most charting libraries skip. Add marginal distribution graphics (histogram,
-violin, ridgeline, boxplot) to scatterplot margins with a single prop.
+### Beyond standard charts
+
+**Network visualization.** Force-directed graphs, Sankey diagrams, chord
+diagrams, tree layouts, treemaps, circle packing, and orbit diagrams — all
+as React components with the same prop API as LineChart.
+
+**Streaming data.** Realtime charts render on canvas at 60fps with a
+ref-based push API. Built-in decay, pulse, and staleness encoding for
+monitoring dashboards.
+
+**Coordinated views.** `LinkedCharts` provides hover cross-highlighting,
+brush cross-filtering, and selection synchronization across any combination
+of chart types — zero wiring.
+
+**Geographic visualization.** Choropleth maps, proportional symbol maps, flow
+maps with animated particles, and distance cartograms — all canvas-rendered
+with d3-geo projections, zoom/pan, tile basemaps, and drag-rotate globe spinning.
+
+**Statistical summaries.** Box plots, violin plots, swarm plots, histograms,
+LOESS smoothing, forecast with confidence envelopes, and anomaly detection.
+Marginal distribution graphics on scatterplot axes with a single prop.
 
 ### Start simple, go deep
 
@@ -57,6 +79,13 @@ violin, ridgeline, boxplot) to scatterplot margins with a single prop.
 Every Chart component accepts a `frameProps` prop to access the underlying
 Frame API without leaving the simpler interface.
 
+### Serialization and interop
+
+Charts serialize to JSON and back: `toConfig`, `fromConfig`, `toURL`,
+`copyConfig`, `configToJSX`. Have Vega-Lite specs? `fromVegaLite(spec)`
+translates them to Semiotic configs — works with `configToJSX()` for
+full round-trip from notebooks and AI-generated specs.
+
 ### When to use something else
 
 Need a standard bar or line chart for a dashboard you'll never need to
@@ -69,40 +98,10 @@ Semiotic is for projects that outgrow those libraries — when you need
 network graphs alongside time series, streaming data alongside static
 snapshots, or coordinated views across chart types.
 
-### Bundle size comparison
-
-| Library | Packed | Unpacked | What you get |
-|---|---|---|---|
-| Victory | 393 KB | 2.3 MB | Charts only |
-| Lightweight Charts | 586 KB | 3.0 MB | Financial charts only |
-| **Semiotic** | **668 KB** | **2.5 MB** | **Charts + networks + streaming + coordination** |
-| Recharts | 1.4 MB | 6.4 MB | Charts only |
-| Chart.js | 1.6 MB | 6.2 MB | Charts only, no React |
-| ApexCharts | 1.8 MB | 8.4 MB | Charts only |
-| ECharts | 11.4 MB | 57.6 MB | Everything, no React |
-
-**AI-ready.** Semiotic ships with structured schemas (`ai/schema.json`), an
-`import from "semiotic/ai"` entry point, and an MCP server — all designed for
-LLM code generation. AI coding assistants can generate correct Semiotic code on
-the first try. Run `npx semiotic-ai --help` for CLI options, `npx semiotic-ai --doctor`
-to validate props from the command line, or add `semiotic-mcp` to your MCP client
-config for tool-based chart rendering. Every HOC chart includes a built-in error
-boundary and dev-mode validation warnings with actionable fix suggestions.
-
-**Vega-Lite compatible.** Have existing Vega-Lite specs? `fromVegaLite(spec)`
-translates them to Semiotic chart configs — instant onboarding from notebooks,
-dashboards, or AI-generated specs. Composes with `configToJSX()`,
-`copyConfig()`, and `toURL()` for full round-trip interop.
-
-**Streaming system models.** Turn a streaming Sankey into a live system monitor:
-click-to-inspect `DetailsPanel`, particle speed proportional to edge throughput,
-threshold alerting with animated glow, and automatic topology diffing that
-highlights new services as they appear. Visualization as product navigation.
-
 ## Install
 
 ```bash
-npm install semiotic@3.0.0
+npm install semiotic
 ```
 
 Requires React 18.1+ or React 19.
@@ -166,6 +165,30 @@ import { ForceDirectedGraph, SankeyDiagram } from "semiotic"
 />
 ```
 
+### Geographic Visualization
+
+Choropleth maps, flow maps, and distance cartograms with canvas rendering,
+zoom/pan, tile basemaps, and animated particles:
+
+```jsx
+import { ChoroplethMap, FlowMap, DistanceCartogram } from "semiotic/geo"
+
+<ChoroplethMap
+  areas={geoJsonFeatures} valueAccessor="gdp"
+  colorScheme="viridis" projection="equalEarth" zoomable tooltip
+/>
+
+<FlowMap
+  nodes={airports} flows={routes} valueAccessor="passengers"
+  showParticles particleStyle={{ color: "source", speedMultiplier: 1.5 }}
+/>
+
+<DistanceCartogram
+  points={cities} center="rome" costAccessor="travelDays"
+  showRings costLabel="days" lines={routes}
+/>
+```
+
 ### Streaming System Monitor
 
 Live service topology with threshold alerting and click-to-inspect:
@@ -215,13 +238,14 @@ import { LineChart, BarChart } from "semiotic"
 
 | Category | Components |
 |---|---|
-| **XY** | `LineChart` `AreaChart` `StackedAreaChart` `Scatterplot` `BubbleChart` `Heatmap` |
-| **Categorical** | `BarChart` `StackedBarChart` `GroupedBarChart` `SwarmPlot` `BoxPlot` `Histogram` `ViolinPlot` `DotPlot` `PieChart` `DonutChart` |
-| **Network** | `ForceDirectedGraph` `ChordDiagram` `SankeyDiagram` `TreeDiagram` `Treemap` `CirclePack` |
+| **XY** | `LineChart` `AreaChart` `StackedAreaChart` `Scatterplot` `ConnectedScatterplot` `BubbleChart` `Heatmap` `QuadrantChart` `MinimapChart` |
+| **Categorical** | `BarChart` `StackedBarChart` `GroupedBarChart` `SwarmPlot` `BoxPlot` `Histogram` `ViolinPlot` `RidgelinePlot` `DotPlot` `PieChart` `DonutChart` |
+| **Network** | `ForceDirectedGraph` `ChordDiagram` `SankeyDiagram` `TreeDiagram` `Treemap` `CirclePack` `OrbitDiagram` |
+| **Geo** | `ChoroplethMap` `ProportionalSymbolMap` `FlowMap` `DistanceCartogram` |
 | **Realtime** | `RealtimeLineChart` `RealtimeHistogram` `RealtimeSwarmChart` `RealtimeWaterfallChart` `RealtimeHeatmap` |
 | **Coordination** | `LinkedCharts` `ScatterplotMatrix` |
 | **Layout** | `ChartGrid` `ContextLayout` `CategoryColorProvider` |
-| **Frames** | `StreamXYFrame` `StreamOrdinalFrame` `StreamNetworkFrame` |
+| **Frames** | `StreamXYFrame` `StreamOrdinalFrame` `StreamNetworkFrame` `StreamGeoFrame` |
 
 ### Vega-Lite Translation
 
@@ -257,10 +281,11 @@ for color, size, aggregation, and binning.
 Import only what you need:
 
 ```jsx
-import { LineChart } from "semiotic/xy"                 // 123 KB
-import { BarChart } from "semiotic/ordinal"              // 118 KB
-import { ForceDirectedGraph } from "semiotic/network"    // 127 KB
-import { LineChart } from "semiotic/ai"                  // HOC-only surface for AI generation
+import { LineChart } from "semiotic/xy"                 // ~156 KB
+import { BarChart } from "semiotic/ordinal"              // ~124 KB
+import { ForceDirectedGraph } from "semiotic/network"    // ~123 KB
+import { ChoroplethMap } from "semiotic/geo"             // ~102 KB (+ d3-geo peer)
+import { LineChart } from "semiotic/ai"                  // ~397 KB (all HOCs)
 ```
 
 Granular entry points export only v3 Stream Frames and HOC charts — no legacy
@@ -283,7 +308,19 @@ interface Sale { month: number; revenue: number }
 
 ## Server-Side Rendering
 
-Static SVG generation for Node.js (email, OG images, PDF):
+All chart components render SVG automatically in server environments — no
+special imports or configuration needed:
+
+```jsx
+// Works in Next.js App Router, Remix, Astro — same component, same props
+import { LineChart } from "semiotic"
+
+// Server: renders <svg> with path/circle/rect elements
+// Client: renders <canvas> with SVG overlay for axes
+<LineChart data={data} xAccessor="date" yAccessor="value" />
+```
+
+For standalone SVG generation (email, OG images, PDF), use the server entry point:
 
 ```js
 import { renderToStaticSVG } from "semiotic/server"
@@ -296,14 +333,12 @@ const svg = renderToStaticSVG("xy", {
 })
 ```
 
-Works with Next.js App Router, Remix, and Astro via `"use client"` directives.
-
 ## Documentation
 
 [Interactive docs and examples](https://semiotic.nteract.io)
 
 - [Getting Started](https://semiotic.nteract.io/getting-started)
-- [Charts](https://semiotic.nteract.io/charts) — all 27 chart types with live examples
+- [Charts](https://semiotic.nteract.io/charts) — all 37 chart types with live examples
 - [Frames](https://semiotic.nteract.io/frames) — full Frame API reference
 - [Features](https://semiotic.nteract.io/features) — axes, annotations, tooltips, styling, Vega-Lite translator
 - [Cookbook](https://semiotic.nteract.io/cookbook) — advanced patterns and recipes