@jarenjs/charts 0.34.0

package/dist/types/core/domain.d.ts

@@ -0,0 +1,96 @@
+/**
+ * @file Domain-stability policies for the streaming chart types. A
+ * unit-space AST stores every position as a fraction of its domain, so
+ * a tick that moves the domain legitimately changes every mark — a
+ * wholesale re-render is then correct. These policies exist so that
+ * most streaming ticks do NOT move the domain, which is what makes
+ * incremental re-render (the chart session) possible:
+ *
+ * - `x: { window, slide? }` — sliding x window of fixed span `window`,
+ *   whose END is quantized to multiples of `slide` (default a quarter
+ *   window). The domain therefore moves once per `slide` of x
+ *   progress, not once per sample; samples older than the window are
+ *   dropped from the plot.
+ * - `y: { min?, max? }` — pinned value bounds; samples beyond them
+ *   clamp to the plot edge (the render's clamp01 already does this).
+ * - `y: 'step'` — hysteresis by quantization: the value domain snaps
+ *   outward to nice-number multiples (decades under a log axis), so it
+ *   changes only when a sample crosses a step boundary.
+ *
+ * All resolution is pure — policies are declared in the config and
+ * resolved from the data extremes on every build; stability comes from
+ * quantization, not hidden state.
+ */
+export type DomainPolicy = {
+    /**
+     * sliding x span (null = none)
+     */
+    window: number | null;
+    /**
+     * window end quantum (null = window/4)
+     */
+    slide: number | null;
+    /**
+     * pinned y bounds
+     */
+    pin: {
+        min: number | null;
+        max: number | null;
+    } | null;
+    /**
+     * quantized y domain
+     */
+    step: boolean;
+};
+/**
+ * @typedef {object} DomainPolicy
+ * @property {number|null} window sliding x span (null = none)
+ * @property {number|null} slide window end quantum (null = window/4)
+ * @property {{min: number|null, max: number|null}|null} pin pinned y bounds
+ * @property {boolean} step quantized y domain
+ */
+/**
+ * Normalize a config `domain` member into a policy object; hostile or
+ * absent input yields the all-null policy (today's behavior).
+ * @param {any} domain the config `domain` member
+ * @returns {DomainPolicy}
+ */
+export declare function normalizeDomainPolicy(domain: any): DomainPolicy;
+/**
+ * Resolve the windowed x domain `[end - window, end]`: the end is the
+ * smallest multiple of the slide quantum at or above the newest sample,
+ * so it moves once per quantum, not once per sample.
+ * @param {number} xMax newest x in the data (non-finite = empty data)
+ * @param {number} window the window span (> 0)
+ * @param {number|null} slide the end quantum (null = window / 4)
+ * @returns {[number, number]}
+ */
+export declare function resolveWindowX(xMax: number, window: number, slide: number | null): [number, number];
+/**
+ * Resolve the quantized (`'step'`) y domain: extremes snapped outward
+ * to multiples of a nice step of the span, so small new extremes
+ * usually land inside the current domain.
+ * @param {number} yMin @param {number} yMax data extremes (finite)
+ * @returns {[number, number]}
+ */
+export declare function resolveStepY(yMin: number, yMax: number): [number, number];
+/**
+ * Resolve the quantized y domain under a log axis: decade bounds
+ * (`10^floor` / `10^ceil`), the log counterpart of {@link resolveStepY}.
+ * @param {number} yMin @param {number} yMax data extremes (> 0)
+ * @returns {[number, number]}
+ */
+export declare function resolveStepYLog(yMin: number, yMax: number): [number, number];
+/**
+ * Resolve pinned y bounds over the data extremes. Under a log axis a
+ * non-positive pin is ignored (a hostile pin never breaks the scale);
+ * a pin pair that closes the domain falls back to the data extremes.
+ * @param {number} yMin @param {number} yMax data extremes
+ * @param {{min: number|null, max: number|null}} pin
+ * @param {boolean} log
+ * @returns {[number, number]}
+ */
+export declare function resolvePinnedY(yMin: number, yMax: number, pin: {
+    min: number | null;
+    max: number | null;
+}, log: boolean): [number, number];

package/dist/types/core/marks.d.ts

@@ -0,0 +1,86 @@
+/**
+ * @file Value marks — the two things every value-carrying mark carries.
+ *
+ * 1. A `<title>` child holding the mark's hover text. Native SSR-safe
+ *    hover: it works in a static `toSvgString()` document with no
+ *    script, no CSS and no app, which is why it is unconditional.
+ * 2. Opt-in pointer **bindings** (`on`, VIEW-FORMAT §4) for a host that
+ *    wants a positioned floating tooltip instead. Bindings are plain
+ *    JSON built at render time, so the engine stays pure — it names an
+ *    action, it never calls one — and `renderToString` drops `on`
+ *    entirely, so the SSR bytes are the same either way.
+ *
+ * The binding's `with` payload is the mark descriptor: its `text` (the
+ * same string the `<title>` carries, so a host needs nothing else to
+ * draw a box) plus whatever identifies the mark for a richer host.
+ */
+export type ChartTooltipSpec = {
+    /**
+     * action dispatched when the pointer enters a mark
+     */
+    action: string;
+    /**
+     * action dispatched when it leaves
+     */
+    leaveAction?: string;
+    /**
+     * enter event name (default `'pointerenter'`)
+     */
+    enter?: string;
+    /**
+     * leave event name (default `'pointerleave'`)
+     */
+    leave?: string;
+    /**
+     * `$event` fields to request (default
+     * `['clientX', 'clientY']` — what a floating box needs to position itself)
+     */
+    event?: string[];
+};
+export type ChartTooltip = {
+    action: string;
+    leaveAction: string | null;
+    enter: string;
+    leave: string;
+    event: string[];
+};
+/**
+ * Resolve a tooltip spec. Anything that does not name an action
+ * resolves to `null` — bindings off, `<title>` hover only — so a
+ * hostile or half-written spec degrades to the static rendering rather
+ * than emitting a binding no action answers.
+ * @param {ChartTooltipSpec|null|undefined|any} spec
+ * @returns {ChartTooltip|null}
+ */
+export declare function normalizeTooltip(spec: ChartTooltipSpec | null | undefined | any): ChartTooltip | null;
+/**
+ * The `on` binding object for one mark, or `undefined` when tooltips
+ * are off (so callers can keep passing their props object through
+ * untouched — an unbound chart allocates nothing extra).
+ * @param {ChartTooltip|null} tooltip
+ * @param {string} text the mark's hover text
+ * @param {Record<string, any>} [descriptor] extra `with` members
+ * @returns {Record<string, any>|undefined}
+ */
+export declare function markBinding(tooltip: ChartTooltip | null, text: string, descriptor?: Record<string, any>): Record<string, any> | undefined;
+/**
+ * Mark props with the tooltip bindings folded in — for a mark whose
+ * `<title>` sits among other children (a series or candle `<g>`).
+ * @param {Record<string, any>} props
+ * @param {ChartTooltip|null} tooltip
+ * @param {string} text
+ * @param {Record<string, any>} [descriptor]
+ * @returns {Record<string, any>}
+ */
+export declare function markProps(props: Record<string, any>, tooltip: ChartTooltip | null, text: string, descriptor?: Record<string, any>): Record<string, any>;
+/**
+ * A leaf value mark: its element, its hover `<title>`, and the tooltip
+ * bindings when a host asked for them.
+ * @param {string} tag
+ * @param {Record<string, any>} props
+ * @param {ChartTooltip|null} tooltip
+ * @param {string} text hover text
+ * @param {Record<string, any>} [descriptor] extra `with` members
+ * @returns {any} the mark vnode
+ */
+export declare function valueMark(tag: string, props: Record<string, any>, tooltip: ChartTooltip | null, text: string, descriptor?: Record<string, any>): any;

package/dist/types/core/palette.d.ts

@@ -0,0 +1,72 @@
+/**
+ * @file Colors: the categorical palette and the theme token tables.
+ *
+ * The categorical palette is a concrete constant, not a set of theme
+ * tokens (docs/DESIGN.md §8), in the suite's anchor order — blue first,
+ * amber second, teal third, then green/red/navy/olive/slate — with no
+ * pink and no purple anywhere. It is the same palette the mermaid pie
+ * used before it delegated here, so a pie renders byte-identically
+ * through either package.
+ *
+ * The semantic tokens (text/grid/axis, the win/loss pair) resolve
+ * through the shared `resolveTheme` kernel with the `chart` prefix; the
+ * `'host'` theme links them to the site token vocabulary (docs/DESIGN.md §2,
+ * §7) so charts follow the host's light/dark flip live with no
+ * re-render. Sync invariant: the `default`/`dark` values below must
+ * match the `--chart-*` fallbacks in `styles/charts.css`.
+ */
+import { inkFor } from '@jarenjs/core/color';
+export { inkFor };
+/**
+ * The categorical series palette (docs/DESIGN.md §8 anchor order).
+ * @type {readonly string[]}
+ */
+export declare const CATEGORICAL: readonly string[];
+/**
+ * Ordinal color assignment: series `i` gets the `i`-th palette entry,
+ * wrapping.
+ * @param {number} i - Series index
+ * @param {readonly string[]} [palette] - Palette to draw from
+ * @returns {string}
+ */
+export declare function seriesColor(i: number, palette?: readonly string[]): string;
+/**
+ * The sequential magnitude ramp: one hue (the brand blue family),
+ * light→dark, for value-carrying fills (heatmap cells). A concrete
+ * constant like {@link CATEGORICAL}, not a theme token. The stops keep
+ * monotone perceptual lightness with visible step gaps, and both ends
+ * stay legible against the light and the dark site surface (the ramp
+ * does not flip with the theme).
+ * @type {readonly string[]}
+ */
+export declare const SEQUENTIAL: readonly string[];
+/**
+ * Continuous color for a normalized magnitude: `t` in [0,1] maps onto
+ * the ramp by piecewise-linear interpolation between its stops
+ * (clamped; non-finite `t` reads as 0).
+ * @param {number} t - Normalized magnitude (0 = low, 1 = high)
+ * @param {readonly string[]} [ramp] - Ramp stops, light→dark
+ * @returns {string} a `#rrggbb` color
+ */
+export declare function sequentialColor(t: number, ramp?: readonly string[]): string;
+/** @type {Record<string, Record<string, string>>} */
+declare const THEMES: Record<string, Record<string, string>>;
+/**
+ * Host custom-property links for the `'host'` theme: token key → the
+ * site token it follows (docs/DESIGN.md §2). Concrete defaults remain as
+ * `var()` fallbacks, so the same SVG stays standalone-valid.
+ * @type {Record<string, string>}
+ */
+export declare const HOST_VARS: Record<string, string>;
+/**
+ * Resolve a chart theme. The name `'host'` resolves the default tokens
+ * linked to the host token vocabulary via {@link HOST_VARS}.
+ * @param {string | Record<string, any>} [nameOrOverrides]
+ * @returns {{ name: string, tokens: Record<string, string>, cssVars: Record<string, string> }}
+ */
+export declare function createTheme(nameOrOverrides?: string | Record<string, any>): {
+    name: string;
+    tokens: Record<string, string>;
+    cssVars: Record<string, string>;
+};
+export { THEMES };

package/dist/types/core/scale.d.ts

@@ -0,0 +1,59 @@
+/**
+ * @file Scales: pure `domain -> (value) => [0,1]` closures. All pixel
+ * mapping happens in the render pass; the AST and these scales stay in
+ * abstract unit space (the geometry-free contract). Construction may
+ * allocate (lookup maps); the returned functions never do.
+ *
+ * Out-of-domain inputs map outside [0,1] (linear/log/time) or to `NaN`
+ * (unknown ordinal/band categories); `polylinePath` and `num` in
+ * `@jarenjs/view/helpers` are the render-side guards that keep a NaN
+ * from ever reaching an emitted string.
+ */
+export type UnitScale = (value: number) => number;
+/**
+ * @typedef {(value: number) => number} UnitScale
+ */
+/**
+ * Linear scale. A zero-span domain maps every value to 0.5.
+ * @param {number} min - Domain minimum
+ * @param {number} max - Domain maximum
+ * @returns {UnitScale}
+ */
+export declare function scaleLinear(min: number, max: number): UnitScale;
+/**
+ * Logarithmic scale (base 10). The domain must be strictly positive —
+ * that is checked once here, not per call; a non-positive *value* maps
+ * to NaN (log of a non-positive number), which the render guards drop.
+ * @param {number} min - Domain minimum (> 0)
+ * @param {number} max - Domain maximum (> 0)
+ * @returns {UnitScale}
+ */
+export declare function scaleLog(min: number, max: number): UnitScale;
+/**
+ * Ordinal scale: each category maps to the center of its equal slot,
+ * `(i + 0.5) / n`. Unknown categories map to NaN.
+ * @param {readonly string[]} categories - Domain, in display order
+ * @returns {(category: string) => number}
+ */
+export declare function scaleOrdinal(categories: readonly string[]): (category: string) => number;
+/**
+ * Band scale: each category owns an equal band with inner padding. The
+ * returned function gives the band's start; `bandwidth` and `step` are
+ * exposed as properties. Unknown categories map to NaN.
+ * @param {readonly string[]} categories - Domain, in display order
+ * @param {number} [padding] - Fraction of each step left empty (0..1)
+ * @returns {((category: string) => number) & {bandwidth: number, step: number}}
+ */
+export declare function scaleBand(categories: readonly string[], padding?: number): ((category: string) => number) & {
+    bandwidth: number;
+    step: number;
+};
+/**
+ * Time scale: a linear scale over epoch milliseconds that also accepts
+ * `Date` instances (converted once per call via `getTime`, no
+ * allocation).
+ * @param {number|Date} min - Domain minimum
+ * @param {number|Date} max - Domain maximum
+ * @returns {(value: number|Date) => number}
+ */
+export declare function scaleTime(min: number | Date, max: number | Date): (value: number | Date) => number;

package/dist/types/core/session.d.ts

@@ -0,0 +1,85 @@
+/**
+ * @file The incremental chart session: a stateful compile pipeline for
+ * the streaming chart types that consumes a change-reporting source
+ * (`createStreamAdapter` with `{ changes: true }`, or anything with
+ * the same `takeChanges()`/`getData()` pair) and produces the next
+ * vnode tree in O(changed marks) work — WHEN the frame is "still".
+ *
+ * The stillness test is exact, not heuristic: the session re-resolves
+ * the scale domains from the updated extremes with the SAME exported
+ * helpers the wholesale build uses, and compares against the AST's
+ * recorded domain. Equal domains ⇒ every existing mark's position is
+ * unchanged, so only touched series re-render (untouched children
+ * keep their references — the view patcher skips them in O(1)).
+ * Anything else — a moved domain, a new series, a reset — falls back
+ * to a wholesale rebuild, which is the correct rendering of a frame
+ * whose scales moved, not a failure mode. Domain-stability policies
+ * (`config.domain`, `core/domain.js`) exist to make most ticks still.
+ *
+ * The correctness contract is byte equality: after every `tick()`,
+ * serializing the session's vnode equals serializing a wholesale
+ * `compileChart(config, source.getData())` of the same data —
+ * property-tested, never assumed.
+ */
+export type ChartSessionSource = {
+    takeChanges: () => {
+        op: string;
+        path: string;
+        value?: any;
+    }[];
+    getData: () => any;
+};
+export type ChartSessionResult = {
+    /**
+     * the current svg vnode (reference-stable when unchanged)
+     */
+    vnode: any;
+    /**
+     * which path produced it
+     */
+    mode: 'unchanged' | 'incremental' | 'rebuilt';
+};
+export type ChartSession = {
+    /**
+     * drain the source and produce the next frame
+     */
+    tick: () => ChartSessionResult;
+};
+/**
+ * @typedef {object} ChartSessionSource
+ * @property {() => {op: string, path: string, value?: any}[]} takeChanges
+ * @property {() => any} getData
+ */
+/**
+ * @typedef {object} ChartSessionResult
+ * @property {any} vnode the current svg vnode (reference-stable when unchanged)
+ * @property {'unchanged'|'incremental'|'rebuilt'} mode which path produced it
+ */
+/**
+ * @typedef {object} ChartSession
+ * @property {() => ChartSessionResult} tick drain the source and produce the next frame
+ */
+/**
+ * Create an incremental session for a streaming chart. Supported
+ * `config.type`: `'line'` (append/evict traffic), `'bar'` (live counts
+ * and sums) and `'candlestick'` (keyed kline upserts). The config is
+ * treated as immutable for the session's lifetime.
+ * @param {{type: string, [k: string]: any}} config
+ * @param {ChartSessionSource} source
+ * @param {{theme?: any, palette?: readonly string[], width?: number,
+ *   rootClass?: string, keyPrefix?: string,
+ *   tooltip?: import('./marks.js').ChartTooltipSpec}} [options]
+ * @returns {ChartSession}
+ * @throws {TypeError} On an unsupported chart type
+ */
+export declare function createChartSession(config: {
+    type: string;
+    [k: string]: any;
+}, source: ChartSessionSource, options?: {
+    theme?: any;
+    palette?: readonly string[];
+    width?: number;
+    rootClass?: string;
+    keyPrefix?: string;
+    tooltip?: import('./marks.js').ChartTooltipSpec;
+}): ChartSession;

package/dist/types/core/stream-adapter.d.ts

@@ -0,0 +1,187 @@
+/**
+ * @file The streaming adapter: unified reader events in, chart data
+ * out. Source-agnostic by design — it consumes the `pair` event shape
+ * that the JOSL reader (`createStreamReader`) and the JSONX/strict-JSON
+ * reader (`createJsonxStreamReader`) both emit, so one adapter serves
+ * every syntax and this package never depends on a parser (it sees
+ * events, never a reader; pair it with `@jarenjs/josl` at the call
+ * site).
+ *
+ * Two record-boundary modes cover the two streaming shapes:
+ *
+ * - `recordBoundary: 'path'` — one large document arriving in chunks;
+ *   a record is the subtree at `recordPath + [index]` (a JOSL `[[run]]`
+ *   array-of-tables and a JSON `{"run": […]}` array produce the same
+ *   pair paths — that is the point of the unified events), and closes
+ *   when the event path leaves it.
+ * - `recordBoundary: 'document'` — many small complete documents over
+ *   time (e.g. one WebSocket message each); every document IS one
+ *   record — the fields directly under `recordPath` (default: the
+ *   document root) — closed by an `endDocument()` call after the
+ *   reader's `end()`. A message that fails mid-parse is discarded with
+ *   `abortDocument()`, leaving the accumulated snapshot untouched.
+ *
+ * Accumulators: `line` (records → per-series points, ring-buffer
+ * eviction), `bar` (live category counts or sums), `heatmap` (the same
+ * counts or sums under TWO grouping keys — the column is `xField`, the
+ * row `seriesField`), `gauge` (the latest reading, nothing kept),
+ * `candlestick` (records keyed by open time; a re-delivered key
+ * REPLACES its candle, which is exactly how exchange kline updates
+ * behave), and `map` (whole GeoJSON Features, projected and simplified
+ * on arrival — see below).
+ *
+ * The `map` accumulator is the odd one out in two ways. Its record is
+ * not flat pair fields but a complete Feature, so it consumes the
+ * reader's `object-end` events at `recordPath + [index]` (default
+ * `['features']`) — pair the reader with `detach: ['features', '*']` so
+ * the document root keeps nothing and the accumulator is the only
+ * retention. And what it keeps is *reduced*: each feature's geometry is
+ * simplified on arrival to the vertices a drawing of the current extent
+ * could distinguish, so memory is bounded by the drawn detail, not the
+ * source detail. The projection cannot be fitted before the last
+ * feature has been seen, so the design is refit-on-growth: the running
+ * bbox sets the simplification tolerance, and when it grows enough to
+ * double the tolerance, the kept features are re-simplified against the
+ * new extent (a coarsening of already-kept vertices — never a re-read
+ * of dropped ones, which is why early features can only ever be finer
+ * than needed, not wrong).
+ *
+ * A record is emitted into the snapshot only when its required fields
+ * are present; `getData()` returns a FRESH object shaped for
+ * `compileChart(config, adapter.getData())`, so identity-keyed memos
+ * re-render per snapshot.
+ *
+ * Change reporting (`{ changes: true }`): every snapshot mutation is
+ * also buffered as an RFC 6902 operation against the `getData()`
+ * shape, collected with `takeChanges()` — the feed the incremental
+ * chart session consumes. The contract is replay equivalence: applying
+ * a `takeChanges()` batch to the previous snapshot yields exactly the
+ * next one (`reset()` buffers a whole-document replace). The ops are
+ * plain data; this module never imports a patch applier.
+ */
+export type StreamAdapterConfig = {
+    /**
+     * path prefix owning the
+     * records: in path mode, e.g. `['run']` for `{"run": […]}` / `[[run]]`;
+     * in document mode, the object whose direct fields form the record
+     * (e.g. `['data', 'k']` for a combined-stream kline payload)
+     */
+    recordPath?: (string | number)[];
+    /**
+     * default 'path'
+     */
+    recordBoundary?: 'path' | 'document';
+    /**
+     * record field for x (line/candlestick) or
+     * the category (bar) / column (heatmap)
+     */
+    xField?: string;
+    /**
+     * record field for y (line), the summed
+     * value (bar/heatmap; omitted = count records), or the reading (gauge)
+     */
+    yField?: string;
+    /**
+     * record field naming the series
+     * (line) or the row (heatmap)
+     */
+    seriesField?: string;
+    /**
+     * candlestick fields (defaults
+     * 'open'/'high'/'low'/'close')
+     */
+    openField?: string;
+    highField?: string;
+    lowField?: string;
+    closeField?: string;
+    /**
+     * ring-buffer size (line: per series;
+     * candlestick: total candles)
+     */
+    maxPoints?: number;
+    /**
+     * buffer RFC 6902 ops per snapshot
+     * mutation for {@link StreamAdapter#takeChanges}
+     */
+    changes?: boolean;
+    /**
+     * map: the feature property naming a
+     * feature (default 'name')
+     */
+    labelField?: string;
+    /**
+     * map: the feature property to shade by
+     */
+    valueField?: string;
+    /**
+     * map: simplification tolerance as a
+     * fraction of the frame's width (default the map chart's own; `false`
+     * keeps every vertex, which unbounds memory)
+     */
+    simplify?: number | false;
+    /**
+     * map: frame width:height ratio the drawing
+     * will use (default 1.6, the map chart's own)
+     */
+    aspect?: number;
+};
+export type StreamAdapter = {
+    /**
+     * the reader event sink
+     */
+    onEvent: (event: any) => void;
+    /**
+     * close the current record
+     * (document mode: call once per completed document; path mode: call
+     * once at end of stream)
+     */
+    endDocument: () => void;
+    /**
+     * discard the record in progress
+     * (a message that failed to parse)
+     */
+    abortDocument: () => void;
+    /**
+     * a fresh chart-data snapshot
+     */
+    getData: () => any;
+    /**
+     *  drain the buffered ops since the last call (requires
+     *  `{ changes: true }`; throws a TypeError otherwise)
+     */
+    takeChanges: () => {
+        op: string;
+        path: string;
+        value?: any;
+    }[];
+    /**
+     * drop all accumulated state
+     */
+    reset: () => void;
+};
+/**
+ * Create a streaming accumulator for a chart type.
+ * @param {'line'|'bar'|'heatmap'|'gauge'|'candlestick'|'map'} chartType
+ * @param {StreamAdapterConfig} [config]
+ * @returns {StreamAdapter}
+ */
+export declare function createStreamAdapter(chartType: 'line' | 'bar' | 'heatmap' | 'gauge' | 'candlestick' | 'map', config?: StreamAdapterConfig): StreamAdapter;
+/**
+ * Lift a temporal coordinate to its epoch-millisecond number, passing every
+ * other value through untouched so a downstream `Number.isFinite` still
+ * decides what is plottable.
+ *
+ * A `Date` and an **RFC 3339 string** both lift, because both say
+ * unambiguously that they are an instant — which is what a time axis asked
+ * for, and JSON has no other way to spell one. A *numeric* string still does
+ * not: unlike `numish`, this refuses to accept `"5"` where the config asked
+ * for a number, because that is a type confusion rather than a date.
+ *
+ * A date with no time (`2026-07-27`) reads as UTC midnight, and a value
+ * carrying an offset is shifted to its instant, so points spelled in
+ * different zones land in the right order on one axis.
+ *
+ * @param {any} v
+ * @returns {any}
+ */
+export declare function numOf(v: any): any;

package/dist/types/index.d.ts

@@ -0,0 +1,35 @@
+/**
+ * @file `@jarenjs/charts` — headless charts. This is the **engine**:
+ * pure functions over data — definition + data ⇄ geometry-free AST ⇄
+ * pure-vnode SVG — that know only the `@jarenjs/view` vnode shape. It
+ * imports nothing from the component layer, `@jarenjs/app`, or the DOM
+ * (the two-layer component rule).
+ *
+ * The pipeline mirrors `@jarenjs/mermaid`:
+ *
+ *   {config, data} ──build{Type}AST──▶ geometry-free AST (abstract
+ *                                       fractions/angles, no pixels)
+ *                      │
+ *                      ▼
+ *                render{Type}AST ──▶ pure-vnode SVG (toVnode /
+ *                                     toSvgString via compileChart)
+ */
+export { compileChart, chartTypes } from './core/chart.js';
+export { scaleLinear, scaleLog, scaleOrdinal, scaleBand, scaleTime } from './core/scale.js';
+export { niceStep, axisTicksLinear, axisTicksLog, axisTicksOrdinal, formatTickValue, formatTimeTick, axisTicksTime, niceTimeStep, } from './core/axis.js';
+export { CATEGORICAL, SEQUENTIAL, seriesColor, sequentialColor, inkFor, createTheme, THEMES, HOST_VARS } from './core/palette.js';
+export { buildPieAST, renderPieAST } from './types/pie.js';
+export { buildBarAST, renderBarAST } from './types/bar.js';
+export { buildLineAST, renderLineAST } from './types/line.js';
+export { buildScatterAST, renderScatterAST } from './types/scatter.js';
+export { buildCandlestickAST, renderCandlestickAST } from './types/candlestick.js';
+export { buildRadarAST, renderRadarAST } from './types/radar.js';
+export { buildGaugeAST, renderGaugeAST } from './types/gauge.js';
+export { buildBoxplotAST, renderBoxplotAST, quantileSorted } from './types/boxplot.js';
+export { buildHeatmapAST, renderHeatmapAST } from './types/heatmap.js';
+export { buildTreemapAST, renderTreemapAST } from './types/treemap.js';
+export { buildStreamgraphAST, renderStreamgraphAST } from './types/streamgraph.js';
+export { buildSankeyAST, renderSankeyAST } from './types/sankey.js';
+export { buildMapAST, renderMapAST } from './types/map.js';
+export { createStreamAdapter } from './core/stream-adapter.js';
+export { createChartSession } from './core/session.js';