graphein 0.3.0

package/dist/index.d.ts

@@ -0,0 +1,2392 @@
+/**
+ * Shared primitive types used across Graphein core.
+ *
+ * These are intentionally tiny and dependency-free so every module
+ * (scales, shapes, layout, charts, tables) can share a common vocabulary.
+ */
+/** A 2D point in pixel space. */
+interface Point {
+    x: number;
+    y: number;
+}
+/** Width/height in pixels. */
+interface Size {
+    width: number;
+    height: number;
+}
+/** An axis-aligned rectangle in pixel space (top-left origin). */
+interface Rect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/** Padding/margins around a box. */
+interface Insets {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+}
+/** A single data record (row). Agent-supplied data is an array of these. */
+type Datum = Record<string, unknown>;
+/** Primitive field value types Graphein understands. */
+type FieldValue = number | string | boolean | Date | null | undefined;
+/**
+ * Encoding channel data types (Vega-Lite-like):
+ * - quantitative: continuous numbers (linear/log scales)
+ * - temporal: dates/times (time scale)
+ * - ordinal: ordered categories
+ * - nominal: unordered categories
+ */
+type FieldType = 'quantitative' | 'temporal' | 'ordinal' | 'nominal';
+/** Normalized RGBA color, channels in [0,255], alpha in [0,1]. */
+interface RGBA {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+}
+/** A [min, max] numeric interval. */
+type Extent = [number, number];
+/** Anything with a numeric-or-categorical comparable value. */
+type Comparable = number | string | Date;
+
+interface ContinuousScale {
+    map(value: number): number;
+    invert(pixel: number): number;
+    ticks(count?: number): number[];
+    tickFormat(count?: number): (v: number) => string;
+    nice(count?: number): ContinuousScale;
+    copy(): ContinuousScale;
+    readonly domain: readonly [number, number];
+    readonly range: readonly [number, number];
+}
+interface BandScale {
+    map(value: string): number | undefined;
+    readonly bandwidth: number;
+    readonly step: number;
+    readonly domain: readonly string[];
+    readonly range: readonly [number, number];
+}
+interface PointScale {
+    map(value: string): number | undefined;
+    readonly step: number;
+    readonly domain: readonly string[];
+    readonly range: readonly [number, number];
+}
+
+interface BandScaleOptions {
+    domain: string[];
+    range: [number, number];
+    paddingInner?: number;
+    paddingOuter?: number;
+    align?: number;
+}
+interface PointScaleOptions {
+    domain: string[];
+    range: [number, number];
+    padding?: number;
+    align?: number;
+}
+declare function bandScale(opts: BandScaleOptions): BandScale;
+declare function pointScale(opts: PointScaleOptions): PointScale;
+
+interface LinearScaleOptions {
+    domain: [number, number];
+    range: [number, number];
+    clamp?: boolean;
+}
+declare function linearScale(opts: LinearScaleOptions): ContinuousScale;
+
+interface LogScaleOptions {
+    domain: [number, number];
+    range: [number, number];
+    base?: number;
+    clamp?: boolean;
+}
+declare function logScale(opts: LogScaleOptions): ContinuousScale;
+
+interface TimeScaleOptions {
+    domain: [number, number] | [Date, Date];
+    range: [number, number];
+    clamp?: boolean;
+}
+declare function timeScale(opts: TimeScaleOptions): ContinuousScale;
+
+declare function tickStep(start: number, stop: number, count: number): number;
+declare function tickIncrement(start: number, stop: number, count: number): number;
+declare function niceDomain(start: number, stop: number, count: number): [number, number];
+declare function ticks(start: number, stop: number, count: number): number[];
+
+declare function timeTicks(start: number, stop: number, count: number): number[];
+declare function timeTickFormat(values: number[]): (t: number) => string;
+
+/** Color-space conversions: sRGB <-> linear <-> OKLab <-> OKLCH. */
+declare const clamp01: (x: number) => number;
+declare const clamp255: (x: number) => number;
+/** sRGB channel (0..1) -> linear-light (0..1). */
+declare function srgbToLinear(c: number): number;
+/** linear-light (0..1) -> sRGB channel (0..1). */
+declare function linearToSrgb(c: number): number;
+interface OKLab {
+    L: number;
+    a: number;
+    b: number;
+}
+interface OKLCH {
+    L: number;
+    C: number;
+    /** Hue in radians. */
+    h: number;
+}
+/** RGBA (0..255) -> OKLab. */
+declare function rgbToOklab(color: RGBA): OKLab;
+/** OKLab -> RGBA (0..255), gamut-clamped. Alpha defaults to 1. */
+declare function oklabToRgb(lab: OKLab, alpha?: number): RGBA;
+declare function oklabToOklch(lab: OKLab): OKLCH;
+declare function oklchToOklab(lch: OKLCH): OKLab;
+
+/**
+ * Parse a CSS color string into RGBA (r,g,b in 0..255, a in 0..1).
+ * Supports hex (#rgb/#rgba/#rrggbb/#rrggbbaa), rgb()/rgba(), hsl()/hsla(),
+ * and a small set of named colors. Returns null when unparseable.
+ */
+declare function parseColor(input: string): RGBA | null;
+
+/** Format an RGBA as a CSS rgb()/rgba() string. */
+declare function rgbaToCss(c: RGBA): string;
+/**
+ * Return `color` as a CSS rgba() string at the given alpha (0..1). Accepts any
+ * parseable CSS color; falls back to the input string when unparseable.
+ */
+declare function withAlpha(color: string, alpha: number): string;
+/** Format an RGBA as a hex string (#rrggbb, or #rrggbbaa when includeAlpha). */
+declare function toHex(c: RGBA, includeAlpha?: boolean): string;
+
+type Interpolator = (t: number) => RGBA;
+/** Interpolate two colors in sRGB space. Endpoints are exact. */
+declare function interpolateRgb(a: RGBA, b: RGBA): Interpolator;
+/**
+ * Interpolate two colors through OKLab for perceptually smooth ramps.
+ * Endpoints are returned exactly (no round-trip drift).
+ */
+declare function interpolateOklab(a: RGBA, b: RGBA): Interpolator;
+
+/** Get a categorical palette by name (defaults to the 'graphein' palette). */
+declare function categorical(name?: string): string[];
+/**
+ * Build a continuous ramp from ordered color stops, interpolating each segment
+ * in OKLab. Endpoints (t=0,1) return the first/last stop exactly.
+ */
+declare function rampFromStops(stops: string[]): Interpolator;
+/** A named sequential interpolator (blues, teal, viridis, magma, greys). */
+declare function sequential(name: string): Interpolator;
+/** A named diverging interpolator (redBlue, spectral, blueRed). */
+declare function diverging(name: string): Interpolator;
+declare const sequentialSchemes: string[];
+declare const divergingSchemes: string[];
+
+interface ColorScale<T> {
+    map(value: T): RGBA;
+}
+/** Map a continuous numeric domain through a sequential interpolator. */
+declare function sequentialColorScale(opts: {
+    domain: [number, number];
+    interpolator: Interpolator;
+    clamp?: boolean;
+}): ColorScale<number>;
+/** Map a [min, mid, max] domain symmetrically through a diverging interpolator. */
+declare function divergingColorScale(opts: {
+    domain: [number, number, number];
+    interpolator: Interpolator;
+    clamp?: boolean;
+}): ColorScale<number>;
+/** Map categorical keys to palette colors (cycled by first-seen index). */
+declare function ordinalColorScale(opts: {
+    domain?: string[];
+    palette?: string[];
+}): ColorScale<string>;
+
+/** WCAG relative luminance of a color. */
+declare function relativeLuminance(c: RGBA): number;
+/** WCAG contrast ratio between two colors (1..21). */
+declare function contrastRatio(a: RGBA, b: RGBA): number;
+/**
+ * Pick whichever of two candidate text colors (default white/black) has the
+ * higher contrast against the given background — for legible labels on marks.
+ */
+declare function readableTextColor(bg: RGBA, options?: {
+    light?: RGBA;
+    dark?: RGBA;
+}): RGBA;
+
+interface PathSink {
+    moveTo(x: number, y: number): void;
+    lineTo(x: number, y: number): void;
+    bezierCurveTo(cp1x: number, cp1y: number, cp2x: number, cp2y: number, x: number, y: number): void;
+    quadraticCurveTo(cpx: number, cpy: number, x: number, y: number): void;
+    arc(x: number, y: number, radius: number, startAngle: number, endAngle: number, counterclockwise?: boolean): void;
+    closePath(): void;
+}
+
+type Curve = (points: Point[], sink: PathSink) => void;
+declare function curveLinear(points: Point[], sink: PathSink): void;
+declare function curveStepAfter(points: Point[], sink: PathSink): void;
+declare function curveStepBefore(points: Point[], sink: PathSink): void;
+declare const curveStep: Curve;
+declare function monotoneXTangents(points: Point[]): number[];
+declare function curveMonotoneX(points: Point[], sink: PathSink): void;
+declare function curveCatmullRom(points: Point[], sink: PathSink): void;
+
+interface LineOptions {
+    curve?: Curve;
+}
+declare function line(opts?: LineOptions): (points: Point[], sink: PathSink) => void;
+
+interface AreaPoint {
+    x: number;
+    y0: number;
+    y1: number;
+}
+interface AreaOptions {
+    curve?: Curve;
+}
+declare function area(opts?: AreaOptions): (points: AreaPoint[], sink: PathSink) => void;
+
+interface ArcOptions {
+    innerRadius: number;
+    outerRadius: number;
+    startAngle: number;
+    endAngle: number;
+    cornerRadius?: number;
+    padAngle?: number;
+}
+/**
+ * Creates a pie/donut path generator.
+ *
+ * Angles are radians with 0 at 12 o'clock and positive angles moving clockwise.
+ * `padAngle` symmetrically trims the angular span. `cornerRadius` is accepted for
+ * API compatibility and clamped, but corners remain circular arc/radial joins.
+ */
+declare function arc(opts: ArcOptions): (sink: PathSink, cx: number, cy: number) => void;
+
+declare function roundedRect(sink: PathSink, x: number, y: number, w: number, h: number, radii: number | [number, number, number, number]): void;
+
+/**
+ * Type vocabulary for the rough (hand-drawn) drawing engine.
+ *
+ * `RoughStyle` is the resolved set of knobs that controls how sketchy a chart
+ * looks; it is produced once per chart (see `resolveSketch`) and handed to a
+ * `RoughPen`. `MarkOptions` carries the per-mark colors plus any local overrides.
+ */
+/** How closed shapes are filled. */
+type FillStyle = 'hachure' | 'solid' | 'cross-hatch';
+/** Resolved, fully-defaulted sketch knobs shared by every mark in a chart. */
+interface RoughStyle {
+    /** Magnitude of the random wobble. 0 ≈ clean, 1 = default, >1 = wilder. */
+    roughness: number;
+    /** How much straight lines bow/curve between endpoints. */
+    bowing: number;
+    /** Fill treatment for closed shapes. */
+    fillStyle: FillStyle;
+    /** Spacing (px) between hachure lines. <= 0 derives from stroke width. */
+    hachureGap: number;
+    /** Hachure line angle in degrees. */
+    hachureAngle: number;
+    /** Outline width in px. */
+    strokeWidth: number;
+    /** PRNG seed — the source of all deterministic jitter. */
+    seed: number;
+}
+/** Per-mark drawing options (colors + optional local style overrides). */
+interface MarkOptions extends Partial<RoughStyle> {
+    /** Outline color. Omit to skip the outline. */
+    stroke?: string;
+    /** Fill color. Omit to skip the fill. */
+    fill?: string;
+    /** Hachure line width (defaults to a thin fraction of strokeWidth). */
+    fillWeight?: number;
+    /** Opacity applied to the fill only (0..1). */
+    fillAlpha?: number;
+    /** Opacity applied to the outline only (0..1). */
+    strokeAlpha?: number;
+}
+declare const DEFAULT_ROUGH_STYLE: RoughStyle;
+
+/**
+ * The rough (hand-drawn) drawing engine.
+ *
+ * A `RoughPen` wraps a Canvas2D-like context and a single seeded PRNG, exposing
+ * the handful of primitives charts need — polylines, polygons, rects, circles,
+ * and pie wedges — rendered as wobbly multi-pass strokes with hachure / solid /
+ * cross-hatch fills. The shared PRNG means marks differ from one another yet the
+ * whole chart is deterministic given its seed (call order is stable).
+ *
+ * The line model is a faithful port of rough.js's: each segment is a cubic with
+ * two randomly displaced control points, drawn twice for the sketched, doubled
+ * look; `bowing` bends the midpoint, `roughness` scales the jitter.
+ */
+
+/** The minimal Canvas2D surface the engine draws onto (CRC2D satisfies it). */
+interface RoughContext {
+    save(): void;
+    restore(): void;
+    beginPath(): void;
+    closePath(): void;
+    moveTo(x: number, y: number): void;
+    lineTo(x: number, y: number): void;
+    bezierCurveTo(cp1x: number, cp1y: number, cp2x: number, cp2y: number, x: number, y: number): void;
+    quadraticCurveTo(cpx: number, cpy: number, x: number, y: number): void;
+    stroke(): void;
+    fill(): void;
+    lineWidth: number;
+    lineCap: CanvasLineCap;
+    lineJoin: CanvasLineJoin;
+    strokeStyle: string | CanvasGradient | CanvasPattern;
+    fillStyle: string | CanvasGradient | CanvasPattern;
+    globalAlpha: number;
+}
+declare class RoughPen {
+    private readonly ctx;
+    private readonly base;
+    private readonly rng;
+    constructor(ctx: RoughContext, style?: Partial<RoughStyle>);
+    private resolve;
+    /** A symmetric random offset in [-x, x], scaled by a length-based gain. */
+    private off;
+    /**
+     * Append one hand-drawn cubic from (x1,y1) to (x2,y2) to the current path.
+     * `overlay` is the second, tighter pass that creates the doubled-stroke look.
+     */
+    private emitLine;
+    /** Build a doubled hand-drawn stroke through `points` into the current path. */
+    private tracePolyline;
+    /**
+     * Trace a smooth *closed* loop through `points` (quadratic spline through the
+     * segment midpoints, with each point as a control). Used for circles so they
+     * read as round hand-drawn blobs rather than angular polygons.
+     */
+    private traceSmoothClosed;
+    private applyStroke;
+    /** Fill a closed polygon with hachure / cross-hatch / solid. */
+    private fillPolygon;
+    /** Hand-drawn open polyline (axis rules, box-plot whiskers, short features). */
+    polyline(points: readonly Point[], opts?: MarkOptions): void;
+    /**
+     * Hand-drawn open stroke for data *trend* lines — line/area tops and KPI
+     * sparklines. A trend line is many short segments, and both the bowing
+     * (length-scaled) and the per-segment endpoint jitter stay tiny on short
+     * segments, so a plain {@link polyline} reads almost ruler-straight — out of
+     * keeping with the confidently wobbly bars/wedges. This amplifies the wobble
+     * so trend lines read as clearly hand-drawn. Axis rules and box-plot features
+     * keep the subtler {@link polyline} (a long axis rule would over-bow here).
+     */
+    trendStroke(points: readonly Point[], opts?: MarkOptions): void;
+    /** Hand-drawn closed polygon with optional fill (drawn behind the outline). */
+    polygon(points: readonly Point[], opts?: MarkOptions): void;
+    /** Hand-drawn rectangle (bars, cells, table chips). */
+    rect(x: number, y: number, w: number, h: number, opts?: MarkOptions): void;
+    /** Hand-drawn circle (scatter points, line markers). Filled solid for clarity. */
+    circle(cx: number, cy: number, r: number, opts?: MarkOptions): void;
+    /**
+     * Hand-drawn pie/donut wedge. Angles match `shape/arc`: 0 at 12 o'clock,
+     * positive clockwise. `innerRadius` 0 draws a full pie slice to the center.
+     */
+    wedge(cx: number, cy: number, innerRadius: number, outerRadius: number, startAngle: number, endAngle: number, opts?: MarkOptions): void;
+}
+/** Convenience factory mirroring the class constructor. */
+declare function createRoughPen(ctx: RoughContext, style?: Partial<RoughStyle>): RoughPen;
+
+/**
+ * Deterministic randomness for the hand-drawn ("sketch") renderer.
+ *
+ * Every wobble in a sketched chart comes from this PRNG, seeded from the spec so
+ * a given chart renders pixel-identically on every paint — a hard requirement
+ * for the screenshot harness (which waits on a stable `data-graphein-ready`).
+ */
+/** A seeded pseudo-random source returning floats in [0, 1). */
+type Rng = () => number;
+/**
+ * mulberry32 — a tiny, fast, well-distributed 32-bit PRNG. Same seed ⇒ same
+ * stream, which is exactly what deterministic sketching needs.
+ */
+declare function mulberry32(seed: number): Rng;
+/**
+ * FNV-1a string hash → 32-bit unsigned int. Used to derive a stable seed from a
+ * spec's identity (type/title/data size) when the author doesn't pass one.
+ */
+declare function hashString(input: string): number;
+
+/**
+ * Geometry helpers for the rough engine: polygon hachure (parallel fill lines)
+ * and the rotation math it needs. Kept pure and allocation-light so fills stay
+ * cheap even on dense charts (heatmaps, stacked bars).
+ */
+
+/** Rotate `p` by `angle` radians around `center`. */
+declare function rotatePoint(p: Point, center: Point, angle: number): Point;
+/** A filled hachure stroke: a single straight segment from a to b. */
+type HachureSegment = [Point, Point];
+/**
+ * Generate parallel scan-line segments that fill `polygon`, angled at
+ * `angleDeg`. The classic rough.js fill: rotate the polygon flat, sweep
+ * horizontal scan lines spaced `gap` apart, intersect each with the edges, pair
+ * the crossings, then rotate the resulting segments back.
+ *
+ * `maxLines` caps density so a huge/under-spaced shape can't explode the segment
+ * count (it widens the step instead) — important for performance on dense charts.
+ */
+declare function polygonHachureLines(polygon: readonly Point[], gap: number, angleDeg: number, maxLines?: number): HachureSegment[];
+/**
+ * Sample a circular arc into a polyline. Angles use the same convention as
+ * `shape/arc`: 0 at 12 o'clock, positive clockwise. Inclusive of both ends.
+ */
+declare function sampleArc(cx: number, cy: number, radius: number, startAngle: number, endAngle: number, segments: number): Point[];
+
+/**
+ * Largest-Triangle-Three-Buckets (LTTB) downsampling.
+ *
+ * LTTB reduces a dense series to a target point count while preserving the
+ * visual shape far better than naive every-Nth sampling — it keeps peaks,
+ * troughs, and the first/last points. We run it draw-side on pixel-projected
+ * points so a 100k-point line still strokes in ~plot-width segments.
+ *
+ * The decimator is generic over the point type (line uses {x,y}; area uses
+ * {x,y0,y1}) via x/y accessors, and is gap-aware: runs separated by a
+ * non-finite point are decimated independently and rejoined with a gap, so
+ * missing-value breaks survive downsampling.
+ */
+/** Core LTTB over a fully-finite run. Returns at most `threshold` points. */
+declare function lttbRun<T>(run: readonly T[], threshold: number, getX: (p: T) => number, getY: (p: T) => number): T[];
+interface DecimateOptions<T> {
+    getX: (p: T) => number;
+    getY: (p: T) => number;
+    /** Produce a gap marker placed between decimated runs. */
+    gap: () => T;
+}
+/**
+ * Gap-aware LTTB. Splits `points` on non-finite (x or y) markers, decimates each
+ * finite run to a share of `threshold` proportional to its length, and rejoins
+ * the runs with a single gap marker. When the finite total already fits within
+ * `threshold`, the input is returned unchanged (gaps preserved).
+ */
+declare function decimate<T>(points: readonly T[], threshold: number, opts: DecimateOptions<T>): T[];
+
+interface AnimateOptions {
+    duration: number;
+    easing?: (t: number) => number;
+    onUpdate: (t: number) => void;
+    onComplete?: () => void;
+    now?: () => number;
+    raf?: (cb: (t: number) => void) => number;
+    cancelRaf?: (handle: number) => void;
+}
+interface AnimationHandle {
+    cancel(): void;
+}
+declare function animate(opts: AnimateOptions): AnimationHandle;
+
+type EasingFunction = (t: number) => number;
+declare function linear(t: number): number;
+declare function quadIn(t: number): number;
+declare function quadOut(t: number): number;
+declare function quadInOut(t: number): number;
+declare function cubicIn(t: number): number;
+declare function cubicOut(t: number): number;
+declare function cubicInOut(t: number): number;
+declare function expoOut(t: number): number;
+declare function expoInOut(t: number): number;
+declare function sinInOut(t: number): number;
+declare function backOut(t: number): number;
+declare function bounceOut(t: number): number;
+declare function elasticOut(t: number): number;
+declare const easings: Record<string, EasingFunction>;
+
+type AggOp = 'sum' | 'mean' | 'avg' | 'min' | 'max' | 'count' | 'countDistinct' | 'median' | 'first' | 'last';
+interface PivotValueDef {
+    field: string;
+    op: AggOp;
+    label?: string;
+}
+interface PivotOptions {
+    rows?: string[];
+    columns?: string[];
+    values: PivotValueDef[];
+    includeRowSubtotals?: boolean;
+    includeColumnSubtotals?: boolean;
+    includeGrandTotals?: boolean;
+    sort?: 'asc' | 'desc' | 'none';
+}
+interface PivotHeaderNode {
+    key: string;
+    path: string[];
+    depth: number;
+    children: PivotHeaderNode[];
+    isSubtotal?: boolean;
+    isGrandTotal?: boolean;
+    span: number;
+}
+interface PivotCell {
+    values: (number | null)[];
+}
+interface PivotFlatRow {
+    path: string[];
+    depth: number;
+    isSubtotal?: boolean;
+    isGrandTotal?: boolean;
+    label: string;
+    cellsByColumnKey: Map<string, PivotCell>;
+}
+interface PivotResult {
+    rowTree: PivotHeaderNode[];
+    columnTree: PivotHeaderNode[];
+    columnLeaves: PivotHeaderNode[];
+    rows: PivotFlatRow[];
+    values: PivotValueDef[];
+    valueAt(rowPath: string[], colPath: string[], valueIndex: number): number | null;
+}
+type GroupedMap<T> = Map<string, GroupedMap<T> | T[]>;
+declare function aggregateValues(values: unknown[], op: AggOp): number | null;
+declare function groupBy<T extends Record<string, unknown>>(rows: T[], keyFields: string[]): GroupedMap<T>;
+declare function pivot(data: Datum[], options: PivotOptions): PivotResult;
+
+/**
+ * Graphein design tokens.
+ *
+ * Flat, modern aesthetic: solid fills, minimal shadows, restrained radii, and a
+ * teal accent. Two built-in themes (light/dark). Token values are literals so
+ * this module stays dependency-free; charts combine these with the color module
+ * for derived ramps and contrast.
+ */
+interface ThemeColors {
+    /** Page/plot background. */
+    background: string;
+    /** Cards / elevated surfaces (KPI cards, tooltips, table headers). */
+    surface: string;
+    /** Primary text. */
+    text: string;
+    /** Secondary / muted text (axis labels, captions). */
+    textMuted: string;
+    /** Axis baseline color. */
+    axis: string;
+    /** Gridline color (lighter than the axis). */
+    grid: string;
+    /** Hairline borders. */
+    border: string;
+    /** Brand accent (selection, focus, primary series). */
+    accent: string;
+    /** Categorical series palette. */
+    palette: string[];
+    /** Positive / up semantics. */
+    positive: string;
+    /** Negative / down semantics. */
+    negative: string;
+}
+interface ThemeFont {
+    family: string;
+    size: {
+        tiny: number;
+        small: number;
+        base: number;
+        large: number;
+        title: number;
+    };
+    weight: {
+        normal: number;
+        medium: number;
+        bold: number;
+    };
+}
+interface ThemeTokens {
+    name: string;
+    dark: boolean;
+    color: ThemeColors;
+    font: ThemeFont;
+    spacing: {
+        xs: number;
+        sm: number;
+        md: number;
+        lg: number;
+        xl: number;
+    };
+    radius: {
+        sm: number;
+        md: number;
+        lg: number;
+    };
+    stroke: {
+        thin: number;
+        base: number;
+        thick: number;
+    };
+}
+declare const lightTheme: ThemeTokens;
+declare const darkTheme: ThemeTokens;
+declare const themes: Record<string, ThemeTokens>;
+type ThemeInput = string | (Partial<ThemeTokens> & {
+    base?: string;
+});
+/**
+ * Resolve a theme reference into concrete tokens.
+ * - a name ('light' | 'dark') selects a built-in theme
+ * - an object deep-merges onto a base theme (override.base or override.dark picks it)
+ */
+declare function resolveTheme(theme?: ThemeInput): ThemeTokens;
+
+/**
+ * Theme-side support for the hand-drawn ("sketch") style.
+ *
+ * Two responsibilities:
+ *  1. `ensureSketchFont()` lazily loads the bundled handwriting font (Patrick
+ *     Hand, SIL OFL) as a data URL — no network, works offline. The base64 blob
+ *     lives in its own module that we `import()` dynamically so it is code-split
+ *     out of the main bundle and only fetched when a chart actually sketches.
+ *  2. `withSketchFont()` swaps a theme's font family to the handwriting stack so
+ *     every bit of text (titles, axes, legends, KPI/table/matrix) reads as drawn.
+ */
+
+/** The font-family name the injected `@font-face` registers. */
+declare const SKETCH_FONT_NAME = "Patrick Hand";
+/** Handwriting stack with graceful fallbacks for SSR / pre-load / odd hosts. */
+declare const SKETCH_FONT_FAMILY = "'Patrick Hand', 'Segoe Print', 'Bradley Hand', 'Comic Sans MS', ui-rounded, cursive";
+/**
+ * Ensure the handwriting font is available. Resolves `true` only when it was
+ * newly loaded this call (so the caller can trigger a single corrective redraw
+ * once real glyph metrics exist); resolves `false` if already present or if the
+ * environment can't load fonts (Node/SSR).
+ */
+declare function ensureSketchFont(): Promise<boolean>;
+/** Return a copy of `tokens` whose text uses the handwriting font. */
+declare function withSketchFont(tokens: ThemeTokens): ThemeTokens;
+
+/**
+ * Selection model — the declarative vocabulary for interactivity.
+ *
+ * A *selection* is the unit of interactivity: a named, JSON-serializable value
+ * that a visual publishes (by clicking marks, brushing, or changing a slicer)
+ * and that other visuals consume as either a **highlight** (emphasize matches,
+ * dim the rest) or a **filter** (subset the rows). Selections are plain data —
+ * no functions — so specs still round-trip through `JSON.stringify`.
+ *
+ * Inspired by Vega-Lite params/selections, but pared down to what coding agents
+ * need to wire dashboards: a `point`/`interval` definition, and four concrete
+ * resolved value shapes (point, set, range, text).
+ */
+/** How a selection is captured from user interaction. */
+interface SelectionDef {
+    /**
+     * - `point`: discrete picks (click marks, choose categories). Toggling builds
+     *   a set of selected tuples.
+     * - `interval`: a continuous range (brush on an axis, a min/max slider, a date
+     *   range).
+     */
+    type: 'point' | 'interval';
+    /** Pointer event that updates the selection. Default `'click'`. */
+    on?: 'click' | 'hover';
+    /**
+     * Data fields that identify the selection. Defaults to the chart's key channel
+     * (e.g. the `x`/`series` field for cartesian charts, the `field` of a slicer).
+     */
+    fields?: string[];
+    /**
+     * Click an already-selected mark to deselect, and accumulate multiple picks.
+     * Default `true` for `on:'click'`.
+     */
+    toggle?: boolean;
+    /**
+     * What an *empty* selection means for consumers: `'all'` (the default) treats
+     * "nothing selected" as "match everything" (no dimming / no filtering);
+     * `'none'` treats it as "match nothing".
+     */
+    empty?: 'all' | 'none';
+}
+/** A named selection a visual defines. */
+interface SelectionParam {
+    /** Unique name within a chart or dashboard. */
+    name: string;
+    select: SelectionDef;
+    /** Optional initial value. */
+    value?: SelectionValue;
+}
+/** Discrete picks: rows whose `fields` equal one of the selected `tuples`. */
+interface PointSelection {
+    kind: 'point';
+    fields: string[];
+    /** Each tuple is one selected combination, aligned to `fields`. */
+    tuples: unknown[][];
+}
+/** Membership: rows whose `field` value is one of `values` (dropdown / list). */
+interface SetSelection {
+    kind: 'set';
+    field: string;
+    values: unknown[];
+}
+/** A continuous span over `field` (numeric or temporal). Bounds are inclusive. */
+interface RangeSelection {
+    kind: 'range';
+    field: string;
+    min?: number | string;
+    max?: number | string;
+}
+/** A case-insensitive substring match over `field` (search box). */
+interface TextSelection {
+    kind: 'text';
+    field: string;
+    query: string;
+}
+/** The resolved value of a selection — what lives in the store. */
+type SelectionValue = PointSelection | SetSelection | RangeSelection | TextSelection;
+/** Reference a named selection for highlighting. */
+interface HighlightConfig {
+    /** The param whose current value drives the emphasis. */
+    param: string;
+}
+/**
+ * A literal, param-free predicate usable directly in `filter`. Each form maps to
+ * a {@link SelectionValue}, so the same matcher handles params and literals.
+ */
+type LiteralPredicate = {
+    field: string;
+    equals: unknown;
+} | {
+    field: string;
+    oneOf: unknown[];
+} | {
+    field: string;
+    range: [number | string, number | string];
+} | {
+    field: string;
+    contains: string;
+};
+/** One clause of a `filter`: a named param or a literal predicate. */
+type FilterClause = {
+    param: string;
+} | LiteralPredicate;
+
+/**
+ * Graphein declarative chart specs.
+ *
+ * One chart = one JSON-serializable `ChartSpec`. The shape is intentionally
+ * Vega-Lite-flavored (data + encoding channels) so coding agents can generate
+ * charts reliably. Every field is plain JSON (no functions) so specs round-trip
+ * through `JSON.stringify`.
+ */
+/** How a data field maps onto a visual channel. */
+interface FieldDef {
+    /** Column name in each datum. */
+    field: string;
+    /** Data type; inferred from the data when omitted. */
+    type?: FieldType;
+    /** Optional aggregation applied when grouping (e.g. sum of sales). */
+    aggregate?: AggOp;
+    /** Axis/legend title override. */
+    title?: string;
+    /** Number/date format hint (see format module), e.g. ',.0f' or '%b %Y'. */
+    format?: string;
+    /** Per-channel scale overrides. */
+    scale?: ScaleConfig;
+}
+type ScaleType = 'linear' | 'log' | 'time' | 'band' | 'point';
+interface ScaleConfig {
+    type?: ScaleType;
+    /** Explicit domain; numbers for continuous, strings for categorical. */
+    domain?: [number, number] | string[];
+    /** Round the domain to nice values (continuous only). */
+    nice?: boolean;
+    /** Force the domain to include zero (continuous only). */
+    zero?: boolean;
+    /** Clamp out-of-domain values into range. */
+    clamp?: boolean;
+    /** Band/point padding (0..1). */
+    padding?: number;
+    /** Log base. */
+    base?: number;
+    /** Reverse the range. */
+    reverse?: boolean;
+}
+/** Visual encoding channels. Not every chart uses every channel. */
+interface Encoding {
+    x?: FieldDef;
+    y?: FieldDef;
+    /** Upper bound for ranged area / band marks. */
+    y2?: FieldDef;
+    /** Color channel (series color or continuous color). */
+    color?: FieldDef;
+    /** Size channel (bubble radius). */
+    size?: FieldDef;
+    /** Splits data into multiple series (multi-line, grouped/stacked bars). */
+    series?: FieldDef;
+    /** Pie/donut angular measure. */
+    theta?: FieldDef;
+    /** Text/label channel. */
+    label?: FieldDef;
+    /** Sankey link source node. */
+    source?: FieldDef;
+    /** Sankey link target node. */
+    target?: FieldDef;
+    /** Magnitude channel (Sankey link value / generic measure). */
+    value?: FieldDef;
+    /** Geographic key matching a GeoJSON feature (choropleth). */
+    key?: FieldDef;
+    /** Funnel stage (ordered category, one bar per stage). */
+    stage?: FieldDef;
+}
+interface Dimensions {
+    /** Fixed width in px. Omit for responsive (fills container). */
+    width?: number;
+    /** Fixed height in px. Omit for responsive (fills container). */
+    height?: number;
+    /** Re-render on container resize (default true when width/height omitted). */
+    autoResize?: boolean;
+}
+interface AxisConfig {
+    show?: boolean;
+    title?: string;
+    grid?: boolean;
+    /** Approximate tick count. */
+    ticks?: number;
+    /** Explicit tick values. */
+    tickValues?: number[];
+    format?: string;
+    /** Show tick labels. */
+    labels?: boolean;
+}
+interface AxesConfig {
+    x?: AxisConfig;
+    y?: AxisConfig;
+}
+type LegendPosition = 'top' | 'right' | 'bottom' | 'left';
+interface LegendConfig {
+    show?: boolean;
+    position?: LegendPosition;
+    title?: string;
+}
+interface TooltipConfig {
+    show?: boolean;
+}
+interface TitleConfig {
+    text?: string;
+    subtitle?: string;
+    align?: 'left' | 'center' | 'right';
+}
+interface AnimationConfig {
+    enabled?: boolean;
+    duration?: number;
+    easing?: string;
+}
+/**
+ * Hand-drawn ("sketch") rendering options. Set `sketch: true` on any spec for
+ * the defaults, or pass this object to tune the look. All fields are plain JSON
+ * so specs still round-trip through `JSON.stringify`.
+ */
+interface SketchConfig {
+    /** Wobble magnitude. 0 ≈ clean, 1 = default, >1 = wilder. */
+    roughness?: number;
+    /** How much straight strokes bow between their endpoints. */
+    bowing?: number;
+    /** Fill treatment for closed marks (bars, wedges, cells). Default 'hachure'. */
+    fillStyle?: FillStyle;
+    /** Spacing (px) between hachure lines. Omit to derive from stroke width. */
+    hachureGap?: number;
+    /** Hachure angle in degrees (default -41). */
+    hachureAngle?: number;
+    /** Outline width multiplier (default 1). */
+    strokeWidth?: number;
+    /** Explicit PRNG seed; omit to derive a stable one from the spec. */
+    seed?: number;
+    /** Apply the hand-drawn font to titles/labels/axes (default true). */
+    font?: boolean;
+}
+/** Fields shared by all spec types. */
+interface BaseSpec {
+    /** Row-oriented (tidy) data. Required for all charts/tables. */
+    data?: Datum[];
+    /** Theme name ('light' | 'dark') or a partial override object. */
+    theme?: ThemeInput;
+    dimensions?: Dimensions;
+    title?: string | TitleConfig;
+    /**
+     * Accessible description (alt text) for the chart. Used verbatim as the
+     * chart's `aria-label`; when omitted, a concise label is synthesized from the
+     * type, title, and data. Agents should set this to convey the chart's intent.
+     */
+    description?: string;
+    legend?: LegendConfig | boolean;
+    tooltip?: TooltipConfig | boolean;
+    axes?: AxesConfig;
+    animation?: AnimationConfig | boolean;
+    /** Extra padding around the plot area. */
+    padding?: Partial<Insets>;
+    /** Background override (defaults to the theme background). */
+    background?: string;
+    /**
+     * Render the chart in a hand-drawn ("sketch") style — wobbly outlines, hachure
+     * fills, and a handwriting font. `true` uses the defaults; pass a `SketchConfig`
+     * to tune it. Omit (or `false`) for the default clean rendering.
+     */
+    sketch?: boolean | SketchConfig;
+    /**
+     * Named selections this visual publishes. Clicking marks, brushing, or
+     * changing a slicer updates the param's value on the shared selection store,
+     * which other visuals can consume via {@link BaseSpec.highlight} or
+     * {@link BaseSpec.filter}. Pure data — no callbacks.
+     */
+    params?: SelectionParam[];
+    /**
+     * Emphasize rows matching a selection and dim the rest. References a param by
+     * name (typically published by another visual for cross-highlighting). An array
+     * unions several sources: a row is emphasized if it matches *any* active one.
+     */
+    highlight?: HighlightConfig | HighlightConfig[];
+    /**
+     * Subset this visual's rows to those matching every clause (logical AND).
+     * Each clause is a named param (cross-filter) or a literal predicate.
+     */
+    filter?: FilterClause[];
+}
+type CurveType = 'linear' | 'monotone' | 'step' | 'stepBefore' | 'stepAfter' | 'catmullRom';
+interface LineSpec extends BaseSpec {
+    type: 'line';
+    encoding: Encoding & {
+        x: FieldDef;
+        y: FieldDef;
+    };
+    curve?: CurveType;
+    /** Show point markers on the line. */
+    points?: boolean;
+    /** Fill the area under the line. */
+    area?: boolean;
+}
+interface AreaSpec extends BaseSpec {
+    type: 'area';
+    encoding: Encoding & {
+        x: FieldDef;
+        y: FieldDef;
+    };
+    curve?: CurveType;
+    /** Stack multiple series. */
+    stack?: boolean;
+}
+interface BarSpec extends BaseSpec {
+    type: 'bar';
+    encoding: Encoding & {
+        x: FieldDef;
+        y: FieldDef;
+    };
+    orientation?: 'vertical' | 'horizontal';
+    /** Stack series (default false). */
+    stack?: boolean;
+    /** Group series side-by-side (default when `series` present and not stacked). */
+    group?: boolean;
+    cornerRadius?: number;
+}
+interface ScatterSpec extends BaseSpec {
+    type: 'scatter';
+    encoding: Encoding & {
+        x: FieldDef;
+        y: FieldDef;
+    };
+}
+interface PieSpec extends BaseSpec {
+    type: 'pie';
+    encoding: Encoding & {
+        theta: FieldDef;
+        color: FieldDef;
+    };
+    /** true for a default donut, or a 0..1 inner-radius ratio. */
+    donut?: boolean | number;
+    /**
+     * Value/percent labels. `true` (default) / `false` toggles them; pass a
+     * {@link PieLabels} object to control placement (inside vs. outside callouts),
+     * what each label says, and the connector style.
+     */
+    labels?: boolean | PieLabels;
+}
+/** Fine-grained control over pie/donut slice labels. */
+interface PieLabels {
+    /** Master toggle (default true). */
+    show?: boolean;
+    /**
+     * Where labels sit:
+     * - 'auto' (default): inside the slice when the text fits, otherwise an
+     *   outside callout with a leader line.
+     * - 'inside': always inside (small slices are dropped if they don't fit).
+     * - 'outside': always an outside callout with a leader line.
+     */
+    placement?: 'inside' | 'outside' | 'auto';
+    /**
+     * What each label says (default: 'percent' inside, 'category-percent' for
+     * outside callouts).
+     */
+    content?: 'percent' | 'value' | 'category' | 'category-percent' | 'category-value';
+    /** Hide labels for slices below this share of the total (0..1, default 0.01). */
+    minShare?: number;
+    /** Leader-line colour for outside callouts: the slice colour or a muted grey. */
+    connector?: 'slice' | 'muted';
+}
+interface HeatmapSpec extends BaseSpec {
+    type: 'heatmap';
+    encoding: Encoding & {
+        x: FieldDef;
+        y: FieldDef;
+        color: FieldDef;
+    };
+    /** Sequential/diverging ramp name. */
+    scheme?: string;
+}
+/**
+ * A funnel chart: ordered `stage`s drawn as stacked, centered trapezoids whose
+ * width encodes `value`. Ideal for conversion / drop-off across a pipeline. Each
+ * stage shows its value and the share retained relative to the first (or the
+ * previous) stage.
+ */
+interface FunnelSpec extends BaseSpec {
+    type: 'funnel';
+    encoding: Encoding & {
+        stage: FieldDef;
+        value: FieldDef;
+    };
+    /** Show stage labels + value/percent inside the funnel (default true). */
+    labels?: boolean;
+    /**
+     * What the per-stage percentage is measured against:
+     * - 'first' (default): share retained vs. the top of the funnel.
+     * - 'previous': step conversion vs. the stage above.
+     */
+    percent?: 'first' | 'previous';
+}
+type ValueRef = number | {
+    field: string;
+    aggregate?: AggOp;
+};
+interface KpiSpec extends BaseSpec {
+    type: 'kpi';
+    /** Literal value or a field (optionally aggregated over data). */
+    value: ValueRef;
+    label?: string;
+    /** Delta vs. a comparison, drives the up/down indicator. */
+    delta?: ValueRef;
+    format?: string;
+    /** Inline sparkline from a numeric field. */
+    sparkline?: boolean | {
+        field: string;
+    };
+}
+type ConditionalFormat = {
+    type: 'colorScale';
+    scheme?: string;
+    domain?: [number, number];
+    midpoint?: number;
+    diverging?: boolean;
+    target?: 'background' | 'text';
+} | {
+    type: 'bar';
+    color?: string;
+    negativeColor?: string;
+    domain?: [number, number];
+    baseline?: 'zero' | 'min';
+    showValue?: boolean;
+} | {
+    type: 'icon';
+    set?: 'arrows' | 'triangles' | 'dots' | 'trafficLights';
+    rules?: IconRule[];
+    position?: 'left' | 'right';
+} | {
+    type: 'rules';
+    rules: ValueRule[];
+};
+interface ValueRule {
+    when: 'gt' | 'gte' | 'lt' | 'lte' | 'eq' | 'ne' | 'between';
+    value: number | string;
+    to?: number;
+    background?: string;
+    color?: string;
+    weight?: 'bold' | 'normal';
+    icon?: string;
+}
+interface IconRule {
+    when: ValueRule['when'];
+    value: number;
+    to?: number;
+    icon?: string;
+    color?: string;
+}
+interface TableColumn {
+    field: string;
+    title?: string;
+    type?: FieldType;
+    format?: string;
+    align?: 'left' | 'center' | 'right';
+    width?: number;
+    conditionalFormat?: ConditionalFormat;
+    prefix?: string;
+    suffix?: string;
+    negativeStyle?: 'sign' | 'parens' | 'red' | 'parens-red';
+    hidden?: boolean;
+    sortable?: boolean;
+    wrap?: boolean;
+    group?: string;
+    total?: AggOp | false;
+}
+interface TableSpec extends BaseSpec {
+    type: 'table';
+    /** Explicit columns; inferred from data keys when omitted. */
+    columns?: TableColumn[];
+    sort?: {
+        field: string;
+        order?: 'asc' | 'desc';
+    };
+    density?: 'comfortable' | 'standard' | 'compact';
+    totals?: boolean | {
+        label?: string;
+    };
+    /** Zebra striping (off by default — flat aesthetic). */
+    striped?: boolean;
+    /** Sticky header (default true). */
+    stickyHeader?: boolean;
+}
+interface MatrixValueDef {
+    field: string;
+    op: AggOp;
+    label?: string;
+    format?: string;
+    conditionalFormat?: ConditionalFormat;
+    prefix?: string;
+    suffix?: string;
+    negativeStyle?: TableColumn['negativeStyle'];
+    showAs?: 'value' | 'percentOfRow' | 'percentOfColumn' | 'percentOfTotal';
+}
+interface MatrixSpec extends BaseSpec {
+    type: 'matrix';
+    /** Row grouping fields (hierarchical). */
+    rows: string[];
+    /** Column grouping fields (hierarchical). */
+    columns?: string[];
+    values: MatrixValueDef[];
+    subtotals?: boolean;
+    grandTotals?: boolean;
+    density?: 'comfortable' | 'standard' | 'compact';
+    columnSort?: {
+        by: 'value' | 'label';
+        valueIndex?: number;
+        order?: 'asc' | 'desc';
+    };
+}
+interface BoxSpec extends BaseSpec {
+    type: 'box';
+    /**
+     * `x` is the category axis (one box per category); `y` holds the raw
+     * observations that are summarized into quartiles. Add `series` to draw
+     * grouped boxes side-by-side within each category.
+     */
+    encoding: Encoding & {
+        x: FieldDef;
+        y: FieldDef;
+    };
+    /**
+     * Whisker rule:
+     * - 'tukey' (default): whiskers reach the furthest points within 1.5×IQR of
+     *   the quartiles; points beyond are drawn as outliers.
+     * - 'minMax': whiskers span the full data range (no outliers).
+     */
+    whisker?: 'tukey' | 'minMax';
+    /** Draw outlier points beyond the whiskers (tukey only; default true). */
+    outliers?: boolean;
+}
+interface SankeySpec extends BaseSpec {
+    type: 'sankey';
+    /**
+     * Each data row is one link. Nodes are derived from the distinct `source`
+     * and `target` values; `value` is the flow magnitude (link/node thickness).
+     */
+    encoding: Encoding & {
+        source: FieldDef;
+        target: FieldDef;
+        value: FieldDef;
+    };
+    /** Node block width in px (default 16). */
+    nodeWidth?: number;
+    /** Vertical gap between stacked nodes in px (default 14). */
+    nodePadding?: number;
+    /** Show the node total alongside its label (default true). */
+    nodeValues?: boolean;
+}
+/** A GeoJSON position: [longitude, latitude] (or projected [x, y]). */
+type GeoPosition = [number, number];
+interface GeoPolygon {
+    type: 'Polygon';
+    /** Rings: the first is the exterior, the rest are holes. */
+    coordinates: GeoPosition[][];
+}
+interface GeoMultiPolygon {
+    type: 'MultiPolygon';
+    coordinates: GeoPosition[][][];
+}
+type GeoGeometry = GeoPolygon | GeoMultiPolygon;
+interface GeoFeature {
+    type: 'Feature';
+    id?: string | number;
+    properties?: Record<string, unknown> | null;
+    geometry: GeoGeometry | null;
+}
+interface GeoFeatureCollection {
+    type: 'FeatureCollection';
+    features: GeoFeature[];
+}
+/**
+ * How feature coordinates are mapped to the screen:
+ * - 'mercator' / 'equirectangular': geographic [lon, lat] projections.
+ * - 'identity': coordinates are already planar [x, y] in screen orientation
+ *   (y increases downward), e.g. data pre-projected with Albers USA. Useful for
+ *   composite projections or non-geographic polygon maps.
+ */
+type MapProjection = 'mercator' | 'equirectangular' | 'identity';
+interface ChoroplethSpec extends BaseSpec {
+    type: 'choropleth';
+    /** Map geometry: a GeoJSON FeatureCollection of Polygon/MultiPolygon features. */
+    geo: GeoFeatureCollection;
+    /**
+     * `key` joins each data row to a feature; `color` is the numeric value that
+     * drives the fill via a sequential color scale.
+     */
+    encoding: Encoding & {
+        key: FieldDef;
+        color: FieldDef;
+    };
+    /**
+     * Where to read a feature's join id: a property name (e.g. 'name' for
+     * `feature.properties.name'), or 'id' for the top-level `feature.id`.
+     * Defaults to trying `feature.id`, then `properties.id`, then `properties.name`.
+     */
+    featureId?: string;
+    /** Geographic projection (default 'mercator'). */
+    projection?: MapProjection;
+    /** Sequential color scheme name (e.g. 'teal', 'blues', 'viridis'). */
+    scheme?: string;
+}
+/**
+ * Slicer visuals — interactive controls that *publish* a selection (rather than
+ * plotting marks). A slicer cross-filters (or cross-highlights) every visual that
+ * consumes its param. They are ordinary DOM widgets, so they validate and render
+ * standalone, and slot into a dashboard like any other view.
+ *
+ * Every slicer reads a single `field` and writes to a named param (defaulting to
+ * the field name, so a chart's `filter: [{ param: 'region' }]` auto-connects to a
+ * `field: 'region'` slicer). Options/bounds are derived from the *unfiltered*
+ * data so a slicer never hides its own choices.
+ */
+interface BaseSlicerSpec extends BaseSpec {
+    /** The data field this slicer reads its options/bounds from and filters on. */
+    field: string;
+    /**
+     * The param name this slicer publishes to. Defaults to `field`, which makes a
+     * slicer auto-wire to any visual filtering/highlighting on that param name.
+     */
+    param?: string;
+    /** Label shown above the control. Defaults to `title` or the field name. */
+    label?: string;
+    /** How consumers should react: emphasize matches or subset rows. Default 'filter'. */
+    as?: 'filter' | 'highlight';
+}
+/** Choose one (single) or several (multi) of a field's distinct values. */
+interface DropdownSlicerSpec extends BaseSlicerSpec {
+    type: 'dropdown';
+    /** Allow choosing multiple values (emits a set). Default false (single-select). */
+    multiple?: boolean;
+    /** Placeholder shown when nothing is selected. */
+    placeholder?: string;
+}
+/** A debounced case-insensitive substring filter over a text field. */
+interface SearchSlicerSpec extends BaseSlicerSpec {
+    type: 'search';
+    placeholder?: string;
+    /** Debounce in ms before publishing the query (default 200). */
+    debounce?: number;
+}
+/** A scrollable checkbox list of a field's distinct values (multi-select). */
+interface ListSlicerSpec extends BaseSlicerSpec {
+    type: 'list';
+    /** Show a search-within box once options exceed this count (default 8). */
+    searchThreshold?: number;
+    /** Show the "Select all" / "Clear" row (default true). */
+    selectAll?: boolean;
+}
+/** A numeric min/max range over a quantitative field (dual-thumb slider). */
+interface RangeSlicerSpec extends BaseSlicerSpec {
+    type: 'range';
+    /** Lower bound; defaults to the data minimum of `field`. */
+    min?: number;
+    /** Upper bound; defaults to the data maximum of `field`. */
+    max?: number;
+    /** Thumb step; defaults to a sensible fraction of the range. */
+    step?: number;
+    /** Number format hint for the value labels (e.g. ',.0f'). */
+    format?: string;
+}
+/** A temporal min/max range over a date field, with relative presets. */
+interface DateRangeSlicerSpec extends BaseSlicerSpec {
+    type: 'dateRange';
+    /** Show relative presets (last 7 / 30 / 90 days, all). Default true. */
+    presets?: boolean;
+    /** Date format hint for the value labels (e.g. '%b %e, %Y'). */
+    format?: string;
+}
+type SlicerSpec = DropdownSlicerSpec | SearchSlicerSpec | ListSlicerSpec | RangeSlicerSpec | DateRangeSlicerSpec;
+type SlicerType = SlicerSpec['type'];
+declare const SLICER_TYPES: readonly SlicerType[];
+type ChartSpec = LineSpec | AreaSpec | BarSpec | ScatterSpec | PieSpec | HeatmapSpec | FunnelSpec | KpiSpec | TableSpec | MatrixSpec | BoxSpec | SankeySpec | ChoroplethSpec | DropdownSlicerSpec | SearchSlicerSpec | ListSlicerSpec | RangeSlicerSpec | DateRangeSlicerSpec;
+type ChartType = ChartSpec['type'];
+declare const CHART_TYPES: readonly ChartType[];
+
+/**
+ * Entrance-animation resolution.
+ *
+ * Pure policy that turns a spec's `animation` field (plus environment signals:
+ * `prefers-reduced-motion` and a global screenshot kill-switch) into concrete
+ * `{ enabled, duration, easing }`. Kept DOM-free so it's trivially unit-tested;
+ * the runtime drives the actual frames.
+ */
+
+interface ResolvedEntrance {
+    enabled: boolean;
+    /** Milliseconds. */
+    duration: number;
+    easing: EasingFunction;
+}
+/** Default entrance duration (ms) when a spec enables animation without one. */
+declare const DEFAULT_ENTRANCE_DURATION = 480;
+interface EntranceContext {
+    /** Honor the OS "reduce motion" setting (disables animation). */
+    reducedMotion?: boolean;
+    /** Global kill-switch (e.g. screenshot/automation harnesses). */
+    disabled?: boolean;
+}
+/**
+ * Resolve the effective entrance animation. Motion is suppressed when reduced
+ * motion is requested, when globally disabled, or when the spec opts out
+ * (`animation: false` / `{ enabled: false }` / non-positive duration).
+ */
+declare function resolveEntrance(animation: AnimationConfig | boolean | undefined, ctx?: EntranceContext): ResolvedEntrance;
+
+declare function prefersReducedMotion(): boolean;
+
+declare function interpolateNumber(a: number, b: number): (t: number) => number;
+declare function interpolateArray(a: number[], b: number[]): (t: number) => number[];
+declare function interpolateObject<T extends Record<string, number>>(a: T, b: T): (t: number) => T;
+declare function interpolateNumberArray(a: ArrayLike<number>, b: ArrayLike<number>): (t: number) => number[];
+
+/**
+ * Update-transition resolution.
+ *
+ * Pure policy (mirrors {@link resolveEntrance}) that turns a spec's `animation`
+ * field — plus environment signals (`prefers-reduced-motion` and the global
+ * screenshot kill-switch) — into concrete `{ enabled, duration, easing }` for the
+ * cross-fade played when a chart's data/config changes via `update()`. Kept
+ * DOM-free so it's trivially unit-tested; the runtime drives the actual frames.
+ */
+
+/** Default update cross-fade duration (ms). Snappier than the entrance. */
+declare const DEFAULT_UPDATE_DURATION = 360;
+interface UpdateContext {
+    /** Honor the OS "reduce motion" setting (disables animation). */
+    reducedMotion?: boolean;
+    /** Global kill-switch (e.g. screenshot/automation harnesses). */
+    disabled?: boolean;
+}
+/**
+ * Resolve the effective update transition. Motion is suppressed when reduced
+ * motion is requested, when globally disabled, or when the spec opts out
+ * (`animation: false` / `{ enabled: false }` / non-positive duration). A custom
+ * `easing` defaults to `cubicInOut` (symmetric — reads well for a cross-fade).
+ */
+declare function resolveUpdate(animation: AnimationConfig | boolean | undefined, ctx?: UpdateContext): ResolvedEntrance;
+
+/**
+ * Accessible descriptions for charts.
+ *
+ * Canvas marks are invisible to assistive technology, so every chart needs a
+ * concise accessible *name* (what it is) plus, for canvas-drawn charts, a
+ * visually-hidden data table (the numbers behind it — see `./table`). This
+ * module owns the pure, DOM-free summarization logic.
+ */
+
+/** Human-readable label for a chart type (e.g. `'bar'` → `'Bar chart'`). */
+declare function chartTypeLabel(type: string): string;
+/** Extract the chart's title text from a `string | TitleConfig` title field. */
+declare function chartTitleText(spec: ChartSpec): string | undefined;
+interface ChartSummary {
+    /** Concise accessible name for the chart root (used as `aria-label`). */
+    label: string;
+    /** Number of data rows backing the chart. */
+    rowCount: number;
+}
+/**
+ * Build a concise accessible name for a chart. An explicit `spec.description`
+ * always wins (agents can supply precise alt text); otherwise we synthesize
+ * `"<Type>: <title>. <n> data points."` from the spec.
+ */
+declare function summarizeChart(spec: ChartSpec): ChartSummary;
+
+/**
+ * Visually-hidden data-table fallback.
+ *
+ * For canvas-drawn charts (line/area/bar/scatter/pie/heatmap) the values live
+ * only in pixels, so we mirror the chart's `data` into an off-screen semantic
+ * `<table>`. Screen-reader users get the real numbers; sighted users see
+ * nothing. Charts that already render real DOM text (table/matrix/kpi) don't
+ * need this.
+ */
+
+/** Canonical "visually hidden" style — present to AT, invisible on screen. */
+declare const SR_ONLY_STYLE: string;
+/**
+ * Build a visually-hidden `<table>` mirroring the chart's data. Returns `null`
+ * when there is nothing useful to tabulate (no rows or no columns).
+ */
+declare function buildDataTableFallback(spec: ChartSpec): HTMLTableElement | null;
+
+/**
+ * A single hi-DPI Canvas2D layer. Drawing is done in CSS pixels — the context
+ * transform is scaled by the device pixel ratio so output stays crisp.
+ */
+declare class CanvasLayer {
+    readonly canvas: HTMLCanvasElement;
+    readonly ctx: CanvasRenderingContext2D;
+    /** Logical (CSS px) width. */
+    width: number;
+    /** Logical (CSS px) height. */
+    height: number;
+    dpr: number;
+    constructor(canvas?: HTMLCanvasElement);
+    /** Resize the layer to a CSS size; updates the backing store + DPR transform. */
+    resize(width: number, height: number, dpr?: number): void;
+    /** Clear the entire backing store regardless of the current transform. */
+    clear(): void;
+}
+
+/**
+ * A rendering Surface mounted inside a user-provided container. It owns a stack
+ * of layers:
+ *   - `marks`        : static Canvas2D layer for data marks + gridlines
+ *   - `interaction`  : Canvas2D layer for hover/crosshair (redrawn cheaply)
+ *   - `overlay`      : HTML layer for crisp text (axis labels, legend, tooltip)
+ *
+ * The Surface creates a single wrapper element it fully owns, so it never
+ * clobbers other content in the container.
+ */
+declare class Surface {
+    readonly container: HTMLElement;
+    readonly root: HTMLDivElement;
+    readonly marks: CanvasLayer;
+    readonly interaction: CanvasLayer;
+    readonly overlay: HTMLDivElement;
+    /** Visually-hidden container for the screen-reader data-table fallback. */
+    readonly a11y: HTMLDivElement;
+    width: number;
+    height: number;
+    dpr: number;
+    constructor(container: HTMLElement);
+    resize(width: number, height: number, dpr?: number): void;
+    /** Clear both canvas layers and empty the HTML overlay. */
+    clear(): void;
+    /** Remove all DOM created by this Surface. */
+    destroy(): void;
+}
+
+/**
+ * Apply accessibility semantics to a rendered chart Surface.
+ *
+ * Called by the runtime after each draw. Idempotent: safe to re-run on every
+ * update/resize.
+ */
+
+declare function applyA11y(surface: Surface, spec: ChartSpec): void;
+
+/** Environment helpers — safe in both browser and Node (SSR/test). */
+declare const isBrowser: boolean;
+/** Current device pixel ratio (defaults to 1 outside the browser). */
+declare function getDevicePixelRatio(): number;
+
+/**
+ * Pure sizing math for hi-DPI canvases (no DOM — unit testable).
+ */
+interface BackingSize {
+    /** Logical CSS pixel width. */
+    cssWidth: number;
+    /** Logical CSS pixel height. */
+    cssHeight: number;
+    /** Backing-store (device) pixel width. */
+    pixelWidth: number;
+    /** Backing-store (device) pixel height. */
+    pixelHeight: number;
+    /** Effective device pixel ratio used. */
+    dpr: number;
+}
+/**
+ * Compute the backing-store pixel size for a canvas of the given CSS size at a
+ * device pixel ratio. Backing dimensions are at least 1px so the canvas stays valid.
+ */
+declare function computeBackingSize(width: number, height: number, dpr: number): BackingSize;
+
+/** Tiny DOM helpers (browser-only). */
+declare function setStyle(el: HTMLElement, style: Partial<CSSStyleDeclaration>): void;
+declare function createDiv(className?: string, style?: Partial<CSSStyleDeclaration>): HTMLDivElement;
+/** Absolute-position a layer to fill its positioned parent. */
+declare const fillParentStyle: Partial<CSSStyleDeclaration>;
+
+/**
+ * Text measurement using a shared offscreen canvas context. Falls back to a
+ * rough heuristic when no canvas is available (SSR/test).
+ */
+interface TextMetricsLite {
+    width: number;
+}
+/** Measure the advance width of `text` rendered with the given CSS `font`. */
+declare function measureText(text: string, font: string): TextMetricsLite;
+/** Build a CSS font shorthand string. */
+declare function fontString(size: number, family: string, weight?: number | string, style?: string): string;
+
+/**
+ * Dashboard spec — the single-JSON, agent-facing layer that composes several
+ * charts and slicers into one cross-interacting page.
+ *
+ * A dashboard owns a shared dataset and a shared selection store, lays its views
+ * out on a responsive grid, and *auto-wires* cross-interaction: slicers filter
+ * the charts, and clicking a chart cross-highlights the other charts that share
+ * the selected field. Everything is plain JSON — no callbacks — so a dashboard
+ * round-trips through `JSON.stringify` just like a chart.
+ */
+
+interface DashboardResponsiveSpan {
+    /** Dashboard/section width threshold in px. Smallest matching maxWidth wins. */
+    maxWidth: number;
+    /** Override column span at this width. */
+    w?: number;
+    /** Override row span at this width. */
+    h?: number;
+    /** Hide the view at this width. */
+    hidden?: boolean;
+}
+/** One placed view in a dashboard: a chart or slicer spec plus grid placement. */
+interface DashboardView {
+    /** Unique id within the dashboard (used for layout + link references). */
+    id: string;
+    /** The chart or slicer to render. Inherits the dashboard's `data` when omitted. */
+    spec: ChartSpec;
+    /** Grid column start (1-based). Omit for auto-flow placement. */
+    x?: number;
+    /** Grid row start (1-based). Omit for auto-flow placement. */
+    y?: number;
+    /** Column span (in grid columns). Defaults by view type. */
+    w?: number;
+    /** Row span (in grid rows). Defaults by view type. */
+    h?: number;
+    /** Optional card title drawn by the dashboard chrome. */
+    title?: string;
+    /** Optional card subtitle drawn below the dashboard card title. */
+    subtitle?: string;
+    /** Whether to draw the card frame. Defaults to true. */
+    frame?: boolean;
+    /** Card background override. */
+    background?: string;
+    /** Solid accent bar color for the card. */
+    accent?: string;
+    /** Card content padding. Defaults to 'standard'. */
+    padding?: 'none' | 'standard';
+    /** Per-view responsive span overrides; smallest matching maxWidth wins. */
+    responsive?: DashboardResponsiveSpan[];
+}
+/** Explicit cross-interaction from one view to others (overrides auto-wiring). */
+interface InteractionLink {
+    /** Source view id (the visual whose selection drives the interaction). */
+    source: string;
+    /** Target view id(s), or '*' for every other view. */
+    target: string | string[] | '*';
+    /** How targets react. Default: 'filter' for slicers, 'highlight' for charts. */
+    as?: 'highlight' | 'filter' | 'none';
+    /** Identity fields to match on. Defaults to the source's key field(s). */
+    fields?: string[];
+}
+interface DashboardLayout {
+    /** Number of grid columns at full width (default 12). */
+    cols?: number;
+    /** Height of one grid row in px (default 96). */
+    rowHeight?: number;
+    /** Gap between cells in px (default 14). */
+    gap?: number;
+    /**
+     * Responsive column counts. When the dashboard is narrower than a breakpoint's
+     * `maxWidth`, the grid switches to that breakpoint's `cols` and tiles reflow
+     * (DataZen-style). The smallest matching breakpoint wins. Defaults to
+     * `[{ maxWidth: 600, cols: 1 }, { maxWidth: 960, cols: 6 }]`.
+     */
+    breakpoints?: {
+        maxWidth: number;
+        cols: number;
+    }[];
+    /**
+     * Where unplaced slicers are laid out:
+     * - 'top' (default): compact slicers (dropdown/search/range/dateRange) form a
+     *   navigator strip above the grid, like a BI filter bar.
+     * - 'inline': every slicer is laid out in the grid like a chart.
+     */
+    navigators?: 'top' | 'inline';
+    /** Optional section bands; unlisted views render in an implicit trailing section. */
+    sections?: DashboardSection[];
+    /** Placement preset for unplaced views. Defaults to 'auto'. */
+    preset?: 'auto' | 'kpi-first' | 'sidebar';
+    /** Constrain and center the dashboard page. */
+    maxWidth?: number;
+    /** Spacing preset applied before explicit gap/rowHeight overrides. */
+    density?: 'compact' | 'standard' | 'comfortable';
+    /** Page padding in px. Defaults to a value derived from gap. */
+    padding?: number;
+}
+interface DashboardSection {
+    /** Optional stable id for the section band. */
+    id?: string;
+    /** Section title shown above the grid. */
+    title?: string;
+    /** Muted line shown under the section title. */
+    subtitle?: string;
+    /** View ids included in this section. */
+    views: string[];
+    /** Section-specific column count override. */
+    cols?: number;
+    /** Section-specific row height override. */
+    rowHeight?: number;
+    /** Header band background tint. */
+    background?: string;
+    /** Initial collapsed state; click the header to expand/collapse. */
+    collapsed?: boolean;
+}
+interface DashboardSpec {
+    type: 'dashboard';
+    /** Shared dataset; views without their own `data` inherit this. */
+    data?: Datum[];
+    theme?: ThemeInput;
+    title?: string | TitleConfig;
+    /** Optional muted subtitle shown under the title in the dashboard header. */
+    subtitle?: string;
+    background?: string;
+    dimensions?: Dimensions;
+    /** Dashboard-level named selections (e.g. seeded initial values). */
+    params?: SelectionParam[];
+    layout?: DashboardLayout;
+    /** The placed views. */
+    views: DashboardView[];
+    /**
+     * Cross-interaction policy:
+     * - 'auto' (default): slicers filter charts; chart clicks cross-highlight
+     *   charts sharing the selected field.
+     * - 'none': views are laid out but not linked.
+     * - an array of {@link InteractionLink}: explicit wiring (replaces auto).
+     */
+    interactions?: 'auto' | 'none' | InteractionLink[];
+}
+
+/** Infer the channel type of a single value. */
+declare function inferValueType(value: unknown): FieldType | undefined;
+/**
+ * Infer the type of a field across a dataset by sampling non-null values.
+ * Falls back to 'nominal' when ambiguous.
+ */
+declare function inferFieldType(data: Datum[], field: string, sample?: number): FieldType;
+/** Infer types for every field present in the first rows of the dataset. */
+declare function inferFieldTypes(data: Datum[]): Record<string, FieldType>;
+
+interface ValidationError {
+    /** JSON-path-ish location, e.g. "encoding.x.field". */
+    path: string;
+    message: string;
+}
+interface ValidationResult {
+    valid: boolean;
+    errors: ValidationError[];
+    warnings: ValidationError[];
+}
+/**
+ * Validate a chart spec, returning friendly, path-pointed errors and warnings.
+ * Designed so an agent can read the messages and fix its spec without guessing.
+ */
+declare function validateSpec(spec: unknown): ValidationResult;
+/**
+ * Validate a {@link DashboardSpec}: view-id uniqueness, grid placement, each
+ * view's nested spec (recursively, inheriting the dashboard's data so a view
+ * doesn't error on "missing data"), the cross-interaction surface, and explicit
+ * link references. Messages are path-pointed (e.g. `views[2].spec.encoding.x`).
+ */
+declare function validateDashboard(spec: Record<string, unknown>): ValidationResult;
+declare function assertValidSpec(spec: unknown): ChartSpec;
+
+/**
+ * Resolve a spec's `sketch` option into concrete, fully-defaulted knobs for the
+ * rough engine. Returns `null` when sketching is off, which lets every chart
+ * keep its pixel-identical clean path with a single early check.
+ *
+ * The seed is derived deterministically from the spec's identity when the author
+ * doesn't pass one, so the same chart always wobbles the same way (required for
+ * the screenshot harness).
+ */
+
+/** Fully-resolved sketch settings handed to charts / the rough pen. */
+interface ResolvedSketch extends RoughStyle {
+    /** Whether text should use the hand-drawn font. */
+    font: boolean;
+}
+/**
+ * Map `spec.sketch` to a `ResolvedSketch`, or `null` when disabled.
+ * `sketch: true` uses all defaults; an object overrides individual knobs.
+ */
+declare function resolveSketch(spec: ChartSpec): ResolvedSketch | null;
+
+/**
+ * Number formatting — a pragmatic subset of the d3-format mini-language, enough
+ * for agent-authored specs without a runtime dependency.
+ *
+ * Grammar:  [$][,][.precision][type]
+ *   $            prefix a currency symbol
+ *   ,            group thousands
+ *   .N           precision (digits after the decimal, or significant digits)
+ *   type:
+ *     f  fixed-point            (.2f  → 3.14)
+ *     %  percent (×100)         (.0%  → 42%)
+ *     s  SI suffix              (.1s  → 1.2k, 3.4M)
+ *     d  integer (rounded)      (,d   → 1,234)
+ *     e  exponential            (.2e  → 1.23e+4)
+ *     g  significant digits     (.3g  → 12300)
+ *     (none) → smart default: trims trailing zeros, optional grouping
+ */
+interface NumberFormatSpec {
+    currency?: string;
+    group?: boolean;
+    precision?: number;
+    type?: 'f' | '%' | 's' | 'd' | 'e' | 'g' | '';
+}
+declare function parseNumberFormat(spec: string): NumberFormatSpec;
+/** Format a number according to a parsed or string spec. */
+declare function formatNumber(value: number, spec?: string | NumberFormatSpec): string;
+
+/**
+ * Date formatting — strftime-style tokens, plus a "smart" formatter that picks
+ * a sensible representation from the time span being shown (used by time axes).
+ */
+/** Format a date with a strftime-like pattern, e.g. `%b %Y` → "Jan 2024". */
+declare function formatDate(value: Date | number, pattern: string): string;
+/**
+ * Smart, span-aware label for a tick on a time axis. Picks granularity from the
+ * distance between adjacent ticks so labels stay compact and legible.
+ */
+declare function smartDate(value: Date | number, stepMs: number): string;
+/** A standalone, context-free pretty date used by tooltips. */
+declare function prettyDate(value: Date | number): string;
+
+/**
+ * Format any field value for display. Routes by value type and an optional
+ * format hint:
+ *   - a hint containing `%` → strftime date pattern
+ *   - otherwise → number format mini-language (when the value is numeric)
+ *   - Dates without a hint use a friendly default; everything else stringifies.
+ *
+ * Because JSON has no Date type, agent-authored specs pass dates as ISO-ish
+ * strings. When a `%` (date) hint is supplied for such a string we parse it and
+ * format as a date, so e.g. a table column `{ format: '%b %e, %Y' }` over
+ * `"2024-05-02"` renders `May 2, 2024` rather than the raw string.
+ */
+declare function formatValue(value: unknown, hint?: string): string;
+
+/**
+ * Layout engine.
+ *
+ * Given the surface size, theme typography, and what the chart needs to show
+ * (title, legend, axis tick labels), `computeFrame` reserves space for each
+ * region and returns the plot rectangle where marks are drawn. It is pure (text
+ * widths come from an injected measurer) so it unit-tests in node.
+ */
+
+interface LegendItem {
+    label: string;
+    color: string;
+    /** Marker style; defaults to a filled swatch. */
+    symbol?: 'square' | 'line' | 'circle';
+}
+interface PositionedLegendItem extends LegendItem {
+    x: number;
+    y: number;
+    /** Total item width (swatch + gap + label). */
+    width: number;
+}
+interface TitleInput {
+    text?: string;
+    subtitle?: string;
+    align?: 'left' | 'center' | 'right';
+}
+interface AxisInput {
+    show: boolean;
+    /** Formatted tick labels used to measure the gutter. */
+    labels: string[];
+    title?: string;
+    /**
+     * True when the first/last ticks sit exactly on the plot's horizontal edges
+     * (linear/time scales), so half of each edge label overflows the plot and the
+     * layout must reserve room for it. Band scales inset their labels, so this is
+     * false/omitted for them.
+     */
+    edgeAnchored?: boolean;
+}
+interface FrameInput {
+    width: number;
+    height: number;
+    padding: Insets;
+    font: ThemeFont;
+    title?: TitleInput;
+    legend?: {
+        items: LegendItem[];
+        position: LegendPosition;
+    };
+    /** Cartesian charts pass both axes; non-cartesian omit them. */
+    xAxis?: AxisInput;
+    yAxis?: AxisInput;
+}
+interface Frame {
+    width: number;
+    height: number;
+    plot: Rect;
+    titleRect?: Rect;
+    subtitleRect?: Rect;
+    legendRect?: Rect;
+    legendItems?: PositionedLegendItem[];
+    legendPosition?: LegendPosition;
+}
+declare const TICK_SIZE = 6;
+/** Reserve space for every region and return the plot rect + positioned chrome. */
+declare function computeFrame(input: FrameInput): Frame;
+
+/**
+ * Interaction model contracts.
+ *
+ * A chart (cartesian or custom) can expose an `InteractionModel` describing how
+ * to hit-test the cursor and what to show. The shared `InteractionController`
+ * owns the DOM listeners, the rAF throttle, the interaction-canvas highlight,
+ * and the HTML tooltip — so individual charts only describe *what* to surface,
+ * never *how* to wire events.
+ */
+
+/** One line in a tooltip card. */
+interface TooltipRow {
+    /** CSS color for the leading swatch chip. Omit for no chip. */
+    swatch?: string;
+    /** Left-aligned label (e.g. a series name). */
+    label: string;
+    /** Right-aligned, pre-formatted value. */
+    value: string;
+    /** Render muted (secondary measure / metadata). */
+    muted?: boolean;
+    /** Emphasise (e.g. the focused series under the cursor). */
+    strong?: boolean;
+}
+/** Structured tooltip content; the controller renders it as a flat card. */
+interface TooltipContent {
+    /** Bold header line (typically the shared x value or the category). */
+    title?: string;
+    rows: TooltipRow[];
+}
+/** The resolved hover under the cursor. */
+interface Hover {
+    /**
+     * Stable identity for the focused datum. While this is unchanged between
+     * pointer moves the controller skips re-rendering — keeping hover cheap.
+     */
+    key: string;
+    /** Tooltip anchor in CSS px (where the crosshair/marker focuses). */
+    anchorX: number;
+    anchorY: number;
+    content: TooltipContent;
+    /**
+     * Draw the highlight (crosshair, focus markers, cell outline…) onto the
+     * already-cleared interaction context. Coordinates are CSS px.
+     */
+    draw?(ctx: CanvasRenderingContext2D): void;
+}
+/** A chart's hit-testable description for the current frame. */
+interface InteractionModel {
+    /** Hit region in CSS px. Moves outside it clear the hover. */
+    region: Rect;
+    /** Resolve the datum under a CSS-px point, or `null` for none. */
+    hitTest(px: number, py: number): Hover | null;
+    /**
+     * Resolve the *selection* under a CSS-px point (for click/tap), or `null` when
+     * the point hits no mark (which clears the selection). Optional: charts without
+     * a `pick` are hover-only.
+     */
+    pick?(px: number, py: number): SelectionValue | null;
+}
+/**
+ * Resolved emphasis for the current frame: which rows are "in" the active
+ * selection, and how strongly to fade the rest. Renderers dim non-matching marks
+ * to `dim` (a 0..1 alpha multiplier) and keep matching marks at full strength.
+ */
+interface Emphasis {
+    /** True when a row is part of the active selection (drawn at full strength). */
+    match(row: Datum): boolean;
+    /** Alpha multiplier applied to non-matching marks (e.g. 0.22). */
+    dim: number;
+}
+
+/**
+ * Cartesian model builder.
+ *
+ * Turns a line / area / bar / scatter spec + resolved theme + pixel size into a
+ * fully-resolved drawing model: x/y scales, the plot rect, series split, color
+ * mapping, and positioned axis ticks. Charts consume this model and only worry
+ * about drawing marks. Heatmap, pie, kpi, table, and matrix are non-cartesian
+ * and build their own models.
+ */
+
+type CartesianChartSpec = LineSpec | AreaSpec | BarSpec | ScatterSpec | BoxSpec;
+type XKind = 'linear' | 'time' | 'band' | 'point';
+interface Tick {
+    value: number | string;
+    /** Pixel position along the axis. */
+    pos: number;
+    label: string;
+}
+interface XModel {
+    kind: XKind;
+    field: string;
+    type: FieldType;
+    /** Band/point category domain. */
+    categories?: string[];
+    band?: BandScale;
+    point?: PointScale;
+    /** Continuous (linear/time) scale; domain in numbers or epoch ms. */
+    continuous?: ContinuousScale;
+    /** Category width for band scales (0 otherwise). */
+    bandwidth: number;
+    /** Project a data value to its center pixel, or undefined if unmappable. */
+    pixel(value: unknown): number | undefined;
+}
+interface YModel {
+    field?: string;
+    scale: ContinuousScale;
+    /** Pixel of the zero baseline, clamped into the plot. */
+    baseline: number;
+    pixel(value: unknown): number;
+}
+interface ResolvedSeries {
+    key: string;
+    label: string;
+    color: string;
+    value: unknown;
+    rows: Datum[];
+}
+interface CartesianModel {
+    spec: CartesianChartSpec;
+    tokens: ThemeTokens;
+    frame: Frame;
+    plot: Rect;
+    x: XModel;
+    y: YModel;
+    series: ResolvedSeries[];
+    seriesField?: string;
+    stacked: boolean;
+    xTicks: Tick[];
+    yTicks: Tick[];
+    colorOf(key: string): string;
+    /** Hand-drawn render settings, or null for the default clean rendering. */
+    sketch: ResolvedSketch | null;
+    /**
+     * Active highlight for this frame (matching rows full strength, the rest dimmed),
+     * or null when nothing is selected. Set externally by the runtime from the spec's
+     * `highlight` param + the shared store; `buildCartesianModel` leaves it null.
+     */
+    emphasis?: Emphasis | null;
+}
+declare function resolveCurve(curve?: CurveType): Curve;
+interface BuildOptions {
+    width: number;
+    height: number;
+}
+declare function buildCartesianModel(spec: CartesianChartSpec, tokens: ThemeTokens, opts: BuildOptions): CartesianModel;
+
+/**
+ * Axis, gridline, legend, and title rendering for cartesian charts.
+ *
+ * Marks (gridlines, tick marks, axis baselines) are drawn on the canvas; text
+ * (tick labels, axis titles, chart title, legend) lives in the HTML overlay for
+ * crisp, accessible, selectable typography. Geometry comes from the already
+ * computed `CartesianModel` / `Frame`, so this module is pure presentation.
+ */
+
+/** Draw gridlines + axis baselines + tick marks on the marks canvas (behind marks). */
+declare function drawAxesUnderlay(surface: Surface, model: CartesianModel): void;
+/** Draw all overlay text: tick labels, axis titles, chart title, legend. */
+declare function drawOverlay(surface: Surface, model: CartesianModel): void;
+
+/**
+ * SelectionStore — the dependency-free bus that links interactive visuals.
+ *
+ * It holds the current {@link SelectionValue} for every named param and notifies
+ * subscribers when one changes. Visuals **publish** to params they define (click,
+ * brush, slicer change) and **subscribe** to params they consume (re-resolve
+ * highlight/filter, redraw). A single store shared across `render()` calls links
+ * independently-mounted charts; a `DashboardSpec` owns one internally.
+ *
+ * The store is deliberately "dumb": toggle/accumulate logic lives in the visual
+ * that computes the next value. Change detection uses a structural compare so a
+ * no-op `set` doesn't trigger redundant redraws.
+ */
+
+/** Notified after a param's value changes. */
+type SelectionListener = (name: string, value: SelectionValue | null) => void;
+interface SelectionStore {
+    /** Current value for `name`, or `null` if unset/empty. */
+    get(name: string): SelectionValue | null;
+    /** Replace `name`'s value; no-ops (and skips notifying) if unchanged. */
+    set(name: string, value: SelectionValue | null): void;
+    /** Clear one param, or all params when `name` is omitted. */
+    clear(name?: string): void;
+    /** A snapshot of every param's current value. */
+    all(): Record<string, SelectionValue | null>;
+    /** Subscribe to changes; returns an unsubscribe function. */
+    subscribe(listener: SelectionListener): () => void;
+}
+declare function createSelectionStore(initial?: Record<string, SelectionValue | null>): SelectionStore;
+
+/**
+ * Chart registry.
+ *
+ * Cartesian charts (line/area/bar/scatter) consume a prebuilt `CartesianModel`
+ * and only draw marks. Custom charts (heatmap/pie/kpi/table/matrix) own their
+ * full layout and draw directly onto the surface. The runtime dispatches here.
+ */
+
+type CartesianRenderer = (surface: Surface, model: CartesianModel) => void;
+type CartesianInteractionBuilder = (model: CartesianModel) => InteractionModel | void;
+/**
+ * Optional per-frame interactivity context handed to custom renderers. Lets a
+ * chart dim non-selected marks (`emphasis`), publish its own selection to the
+ * shared bus (`store` + `param`/`def`), and request a redraw when its internal
+ * state changes (slicers). All fields are optional — a renderer that ignores the
+ * context behaves exactly as before.
+ */
+interface RenderContext {
+    /** Active highlight for this frame, or null when nothing is selected. */
+    emphasis?: Emphasis | null;
+    /** Shared selection bus when this chart is linked to others. */
+    store?: SelectionStore;
+    /** The param this chart publishes selections to (usually `spec.params[0]`). */
+    param?: string;
+    /** The selection definition backing `param`. */
+    def?: SelectionDef;
+    /**
+     * The visual's *unfiltered* source rows. Slicers derive their option lists from
+     * this (so a slicer never hides its own choices by filtering itself), while the
+     * `spec.data` handed to the renderer may already be cross-filtered.
+     */
+    sourceData?: Datum[];
+    /**
+     * The host already provides card chrome (e.g. a dashboard cell), so renderers
+     * that normally draw their own card (KPI) should render flat to avoid doubling
+     * the border/background.
+     */
+    framed?: boolean;
+    /** Ask the runtime to redraw the marks layer (used by DOM slicers). */
+    requestRedraw?: () => void;
+}
+type CustomRenderer = (surface: Surface, spec: ChartSpec, tokens: ThemeTokens, size: Size, context?: RenderContext) => InteractionModel | void;
+declare const CARTESIAN_TYPES: ReadonlySet<ChartType>;
+declare const cartesianRenderers: Partial<Record<ChartType, CartesianRenderer>>;
+/**
+ * Cartesian charts whose hover semantics differ from the generic nearest-point
+ * model (e.g. box plots surface quartile stats). When present, the runtime uses
+ * this builder instead of `buildCartesianInteraction`.
+ */
+declare const cartesianInteractionBuilders: Partial<Record<ChartType, CartesianInteractionBuilder>>;
+declare const customRenderers: Partial<Record<ChartType, CustomRenderer>>;
+
+/**
+ * InteractionController — the single owner of pointer events for a Surface.
+ *
+ * Created once per chart instance; handed a fresh `InteractionModel` on every
+ * redraw. It throttles pointer moves to one rAF, hit-tests against the current
+ * model, paints the highlight onto the interaction canvas, and drives the HTML
+ * tooltip. Hover never touches the marks layer.
+ */
+
+/** How the controller publishes a click/tap selection from the current model. */
+interface ControllerSelect {
+    /** Called with the picked value (or `null` when empty space is clicked). */
+    onPick(value: SelectionValue | null): void;
+}
+declare class InteractionController {
+    private readonly surface;
+    private model;
+    private tokens;
+    private readonly tooltip;
+    private raf;
+    private pending;
+    private activeKey;
+    private selectCfg;
+    private pickable;
+    constructor(surface: Surface, tokens: ThemeTokens);
+    /** Install the model for the current frame (or `null` to disable hover). */
+    setModel(model: InteractionModel | null, tokens: ThemeTokens): void;
+    /** Wire click/tap selection for this chart (or `null` to disable it). */
+    setSelect(cfg: ControllerSelect | null): void;
+    private readonly onMove;
+    private readonly onLeave;
+    private readonly onClick;
+    private readonly flush;
+    private render;
+    private paintHighlight;
+    private clearHover;
+    destroy(): void;
+}
+
+/**
+ * The hover tooltip — a flat, themed HTML card the controller positions next to
+ * the cursor. It lives as a direct child of the Surface root (a sibling of the
+ * overlay layer) so the per-frame `surface.clear()` never wipes it; the
+ * controller owns its full lifecycle.
+ */
+
+declare class Tooltip {
+    private readonly root;
+    private readonly el;
+    private tokens;
+    private visible;
+    constructor(root: HTMLElement, tokens: ThemeTokens);
+    setTokens(tokens: ThemeTokens): void;
+    private applyShell;
+    /** Replace the card contents from structured data. */
+    setContent(content: TooltipContent): void;
+    /**
+     * Position the card near (anchorX, anchorY) in CSS px, flipping away from the
+     * surface edges so it never clips. `surfaceW/H` bound the placement.
+     */
+    place(anchorX: number, anchorY: number, surfaceW: number, surfaceH: number): void;
+    hide(): void;
+    destroy(): void;
+}
+
+/**
+ * Cartesian hit-testing.
+ *
+ * Builds an `InteractionModel` from a resolved `CartesianModel`:
+ *   - line / area / bar / point-x  → shared-x "index" hover (crosshair + one
+ *     tooltip row per series at the focused x).
+ *   - scatter (quantitative x)      → nearest-point hover (focus ring).
+ *
+ * All highlight drawing targets the interaction canvas in CSS px; nothing here
+ * mutates the marks layer, so hover never triggers a full redraw.
+ */
+
+declare function tooltipEnabled(spec: CartesianModel['spec']): boolean;
+declare function buildCartesianInteraction(model: CartesianModel): InteractionModel | null;
+
+/**
+ * Predicate engine — pure, dependency-free matching of data rows against a
+ * resolved {@link SelectionValue}.
+ *
+ * Used by both consumers of a selection: **filter** (keep matching rows) and
+ * **highlight** (test each mark to decide emphasis vs. dim). Kept side-effect
+ * free so it unit-tests in node and runs cheaply per mark.
+ */
+
+/** A selection with no constraint (null, empty set/point/text) matches all. */
+declare function isEmptyValue(value: SelectionValue | null | undefined): boolean;
+/**
+ * Compile a row → boolean tester for a selection value, hoisting accessors and
+ * lookup sets out of the per-row path so it's cheap to call across many marks.
+ * An empty/null constraint compiles to a constant `true`.
+ */
+declare function makeMatcher(value: SelectionValue | null | undefined): (row: Datum) => boolean;
+/** Does `row` satisfy `value`? An empty/null constraint always matches. */
+declare function matchesValue(row: Datum, value: SelectionValue | null | undefined): boolean;
+/** Keep only the rows matching *every* provided selection (logical AND). */
+declare function filterRows(rows: readonly Datum[], values: ReadonlyArray<SelectionValue | null | undefined>): Datum[];
+/** Convert a literal `filter` predicate into a {@link SelectionValue}. */
+declare function literalToValue(pred: LiteralPredicate): SelectionValue;
+/** True when a filter clause is a named-param reference (vs. a literal). */
+declare function isParamClause(clause: FilterClause): clause is {
+    param: string;
+};
+
+/**
+ * Selection wiring — turn a single "pick" into a published selection value, and
+ * resolve a spec's `highlight`/`filter` against the store.
+ *
+ * The interaction models describe *what* a click picks (a {@link SelectionValue}
+ * for one mark); this module applies the param's toggle/accumulate semantics and
+ * publishes the result. It also resolves the consuming side: the emphasis a chart
+ * draws (from `highlight`) and the row predicates it filters by (from `filter`).
+ */
+
+/** Default dim alpha applied to non-matching marks during highlight. */
+declare const DIM_ALPHA = 0.22;
+/** What a selectable visual needs to publish picks to the store. */
+interface SelectConfig {
+    store: SelectionStore;
+    param: string;
+    def: SelectionDef;
+}
+/**
+ * Publish a pick to the store, applying the param's semantics:
+ * - a `null` pick (clicked empty space) clears the selection;
+ * - `point` params with `toggle` (the default) accumulate / deselect;
+ * - everything else replaces the value (single-select, brush, slicer).
+ */
+declare function applyPick(cfg: SelectConfig, pick: SelectionValue | null): void;
+/** Resolve a `highlight` reference (one param or a union of several) into the
+ * emphasis to draw this frame. With multiple params a row is emphasized if it
+ * matches *any* active selection; emphasis is null when none are active. */
+declare function resolveEmphasis(highlight: HighlightConfig | HighlightConfig[] | undefined, store: SelectionStore | undefined, dim?: number): Emphasis | null;
+/** Resolve a `filter` list into concrete selection values (params + literals). */
+declare function resolveFilterValues(filter: FilterClause[] | undefined, store: SelectionStore | undefined): SelectionValue[];
+/** The set of param names a spec reacts to (for change-driven redraws). */
+declare function dependentParams(highlight: HighlightConfig | HighlightConfig[] | undefined, filter: FilterClause[] | undefined, ownParams?: readonly string[]): Set<string>;
+
+/**
+ * Chart runtime: the public `render(container, spec)` entry point.
+ *
+ * Mounts a hybrid canvas + HTML `Surface`, resolves the theme, dispatches to the
+ * right chart renderer, and manages the lifecycle (update / resize / destroy)
+ * plus a deterministic "ready" signal for screenshot harnesses.
+ */
+
+/** A change to a named selection: the param name and its new value (or null). */
+type SelectionChangeListener = (name: string, value: SelectionValue | null) => void;
+/** Options for {@link render}. */
+interface RenderOptions {
+    /**
+     * A shared selection bus. Pass the same store to multiple `render()` calls to
+     * link them (cross-highlight / cross-filter). Omit to give the chart its own
+     * private store.
+     */
+    store?: SelectionStore;
+    /**
+     * The chart is mounted inside a host that already provides card chrome (e.g. a
+     * dashboard cell). Renderers that normally draw their own card (KPI) render
+     * flat so the chrome isn't doubled. Optional; defaults to false.
+     */
+    frame?: boolean;
+}
+interface ChartInstance {
+    /** Re-render with a new spec (data or config changes). */
+    update(spec: ChartSpec): void;
+    /** Re-measure the container (or use explicit dims) and redraw. */
+    resize(width?: number, height?: number): void;
+    /** Tear down DOM, observers, and listeners. */
+    destroy(): void;
+    /** The currently rendered spec. */
+    readonly spec: ChartSpec;
+    /** The mounted surface (advanced/imperative use). */
+    readonly surface: Surface;
+    /** The selection bus this chart is bound to (advanced/linking use). */
+    readonly store: SelectionStore;
+    /** Read a param's current value, or a snapshot of all params when omitted. */
+    getSelection(name?: string): SelectionValue | null | Record<string, SelectionValue | null>;
+    /** Set a param's value (drives highlight/filter across linked visuals). */
+    setSelection(name: string, value: SelectionValue | null): void;
+    /** Clear one param, or every param when `name` is omitted. */
+    clearSelection(name?: string): void;
+    /** Subscribe to selection changes; returns an unsubscribe function. */
+    on(event: 'selectionchange', listener: SelectionChangeListener): () => void;
+    /** Remove a previously-registered selection listener. */
+    off(event: 'selectionchange', listener: SelectionChangeListener): void;
+}
+declare global {
+    var __GRAPHEIN_READY: number | undefined;
+    var __GRAPHEIN_DISABLE_ANIM: boolean | undefined;
+}
+declare function render(target: HTMLElement | string, spec: ChartSpec, options?: RenderOptions): ChartInstance;
+
+/**
+ * Dashboard auto-wiring — pure spec rewriting that turns a set of views into
+ * cross-interacting ones by injecting `params` (sources), `highlight`, and
+ * `filter` (consumers) onto each view's spec. Kept side-effect free (no DOM, no
+ * store) so it unit-tests in node and the runtime stays a thin shell.
+ *
+ * Rules (interactions: 'auto'):
+ * - A **slicer** publishes a value on its field/param; every chart that *uses*
+ *   that field gets a `filter` clause for it (cross-filter).
+ * - A **chart** click publishes a point selection on its key field(s); every
+ *   chart that uses *all* those fields (including itself) gets that param added
+ *   to its `highlight` union (cross-highlight). Matching on shared fields means
+ *   emphasis is always well-defined — a chart never dims itself to nothing.
+ */
+
+declare function isSlicerType(type: ChartSpec['type']): boolean;
+/** Every data field a chart's encoding references (used to test "uses field"). */
+declare function specFields(spec: ChartSpec): Set<string>;
+/** The field(s) a click on this chart selects (mirror of each model's `pick`). */
+declare function keyFields(spec: ChartSpec): string[];
+/** The param a slicer publishes to (explicit `param`, else its field). */
+declare function slicerParamName(spec: BaseSlicerSpec): string;
+/**
+ * Rewrite a dashboard's views, injecting the params/highlight/filter that
+ * implement the requested cross-interaction. Returns new view objects with new
+ * specs; inputs are not mutated.
+ */
+declare function wireViews(views: DashboardView[], interactions: 'auto' | 'none' | InteractionLink[] | undefined): DashboardView[];
+
+/**
+ * Dashboard runtime — `renderDashboard(container, spec)`.
+ *
+ * Lays views out on responsive CSS grids, shares one {@link SelectionStore}
+ * across them, and auto-wires cross-interaction (slicers filter charts; chart
+ * clicks cross-highlight charts that share the field). Each view is mounted with
+ * the same `render()` used for standalone charts — the dashboard is mostly a
+ * spec rewriter (see {@link wireViews}) plus layout and a shared bus, so all of
+ * Phase 1's filter/highlight machinery is reused unchanged.
+ */
+
+interface RenderDashboardOptions {
+    /** Share a bus with charts/dashboards outside this one. */
+    store?: SelectionStore;
+}
+interface DashboardInstance {
+    /** Re-render with a new dashboard spec (keeps the shared store/selection). */
+    update(spec: DashboardSpec): void;
+    /** Re-measure every view. */
+    resize(): void;
+    /** Tear down all views, observers, and listeners. */
+    destroy(): void;
+    /** The currently rendered dashboard spec. */
+    readonly spec: DashboardSpec;
+    /** The shared selection bus driving cross-interaction. */
+    readonly store: SelectionStore;
+    /** The mounted chart instances, in view order. */
+    readonly views: ChartInstance[];
+    getSelection(name?: string): SelectionValue | null | Record<string, SelectionValue | null>;
+    setSelection(name: string, value: SelectionValue | null): void;
+    clearSelection(name?: string): void;
+    on(event: 'selectionchange', listener: SelectionChangeListener): () => void;
+    off(event: 'selectionchange', listener: SelectionChangeListener): void;
+}
+type ResolvedLayout = Required<Pick<DashboardLayout, 'cols' | 'rowHeight' | 'gap'>> & Pick<DashboardLayout, 'breakpoints' | 'navigators' | 'sections' | 'preset' | 'maxWidth' | 'density' | 'padding'>;
+type WiredView = DashboardView & {
+    spec: ChartSpec;
+};
+type SectionPlan = {
+    section?: DashboardSection;
+    views: WiredView[];
+    cols: number;
+    rowHeight: number;
+    collapsed: boolean;
+    explicit: boolean;
+};
+declare function resolveDashboardLayout(layout?: DashboardLayout): ResolvedLayout;
+declare function resolveDashboardSections(views: WiredView[], layout: Pick<ResolvedLayout, 'cols' | 'rowHeight' | 'sections'>): SectionPlan[];
+declare function renderDashboard(target: HTMLElement | string, spec: DashboardSpec, options?: RenderDashboardOptions): DashboardInstance;
+
+/**
+ * graphein — public entry point.
+ *
+ * The barrel grows as modules land. Keep exports explicit and tree-shakeable.
+ */
+declare const VERSION = "0.1.0";
+
+export { type AggOp, type AnimateOptions, type AnimationConfig, type AnimationHandle, type ArcOptions, type AreaOptions, type AreaPoint, type AreaSpec, type AxesConfig, type AxisConfig, type AxisInput, type BackingSize, type BandScale, type BandScaleOptions, type BarSpec, type BaseSlicerSpec, type BaseSpec, type BoxSpec, type BuildOptions, CARTESIAN_TYPES, CHART_TYPES, CanvasLayer, type CartesianChartSpec, type CartesianInteractionBuilder, type CartesianModel, type CartesianRenderer, type ChartInstance, type ChartSpec, type ChartSummary, type ChartType, type ChoroplethSpec, type ColorScale, type Comparable, type ConditionalFormat, type ContinuousScale, type ControllerSelect, type Curve, type CurveType, type CustomRenderer, DEFAULT_ENTRANCE_DURATION, DEFAULT_ROUGH_STYLE, DEFAULT_UPDATE_DURATION, DIM_ALPHA, type DashboardInstance, type DashboardLayout, type DashboardResponsiveSpan, type DashboardSection, type DashboardSpec, type DashboardView, type DateRangeSlicerSpec, type Datum, type DecimateOptions, type Dimensions, type DropdownSlicerSpec, type EasingFunction, type Emphasis, type Encoding, type EntranceContext, type Extent, type FieldDef, type FieldType, type FieldValue, type FillStyle, type FilterClause, type Frame, type FrameInput, type FunnelSpec, type GeoFeature, type GeoFeatureCollection, type GeoGeometry, type GeoMultiPolygon, type GeoPolygon, type GeoPosition, type GroupedMap, type HachureSegment, type HeatmapSpec, type HighlightConfig, type Hover, type IconRule, type Insets, InteractionController, type InteractionLink, type InteractionModel, type Interpolator, type KpiSpec, type LegendConfig, type LegendItem, type LegendPosition, type LineOptions, type LineSpec, type LinearScaleOptions, type ListSlicerSpec, type LiteralPredicate, type LogScaleOptions, type MapProjection, type MarkOptions, type MatrixSpec, type MatrixValueDef, type NumberFormatSpec, type OKLCH, type OKLab, type PathSink, type PieLabels, type PieSpec, type PivotCell, type PivotFlatRow, type PivotHeaderNode, type PivotOptions, type PivotResult, type PivotValueDef, type Point, type PointScale, type PointScaleOptions, type PointSelection, type PositionedLegendItem, type RGBA, type RangeSelection, type RangeSlicerSpec, type Rect, type RenderContext, type RenderDashboardOptions, type RenderOptions, type ResolvedEntrance, type ResolvedSeries, type ResolvedSketch, type Rng, type RoughContext, RoughPen, type RoughStyle, SKETCH_FONT_FAMILY, SKETCH_FONT_NAME, SLICER_TYPES, SR_ONLY_STYLE, type SankeySpec, type ScaleConfig, type ScaleType, type ScatterSpec, type SearchSlicerSpec, type SelectConfig, type SelectionChangeListener, type SelectionDef, type SelectionListener, type SelectionParam, type SelectionStore, type SelectionValue, type SetSelection, type Size, type SketchConfig, type SlicerSpec, type SlicerType, Surface, TICK_SIZE, type TableColumn, type TableSpec, type TextMetricsLite, type TextSelection, type ThemeColors, type ThemeFont, type ThemeInput, type ThemeTokens, type Tick, type TimeScaleOptions, type TitleConfig, type TitleInput, Tooltip, type TooltipConfig, type TooltipContent, type TooltipRow, type UpdateContext, VERSION, type ValidationError, type ValidationResult, type ValueRef, type ValueRule, type XKind, type XModel, type YModel, aggregateValues, animate, applyA11y, applyPick, arc, area, assertValidSpec, backOut, bandScale, bounceOut, buildCartesianInteraction, buildCartesianModel, buildDataTableFallback, cartesianInteractionBuilders, cartesianRenderers, categorical, chartTitleText, chartTypeLabel, clamp01, clamp255, computeBackingSize, computeFrame, contrastRatio, createDiv, createRoughPen, createSelectionStore, cubicIn, cubicInOut, cubicOut, curveCatmullRom, curveLinear, curveMonotoneX, curveStep, curveStepAfter, curveStepBefore, customRenderers, darkTheme, decimate, dependentParams, diverging, divergingColorScale, divergingSchemes, drawAxesUnderlay, drawOverlay, easings, elasticOut, ensureSketchFont, expoInOut, expoOut, fillParentStyle, filterRows, fontString, formatDate, formatNumber, formatValue, getDevicePixelRatio, groupBy, hashString, inferFieldType, inferFieldTypes, inferValueType, interpolateArray, interpolateNumber, interpolateNumberArray, interpolateObject, interpolateOklab, interpolateRgb, isBrowser, isEmptyValue, isParamClause, isSlicerType, keyFields, lightTheme, line, linear, linearScale, linearToSrgb, literalToValue, logScale, lttbRun, makeMatcher, matchesValue, measureText, monotoneXTangents, mulberry32, niceDomain, oklabToOklch, oklabToRgb, oklchToOklab, ordinalColorScale, parseColor, parseNumberFormat, pivot, pointScale, polygonHachureLines, prefersReducedMotion, prettyDate, quadIn, quadInOut, quadOut, rampFromStops, readableTextColor, relativeLuminance, render, renderDashboard, resolveCurve, resolveDashboardLayout, resolveDashboardSections, resolveEmphasis, resolveEntrance, resolveFilterValues, resolveSketch, resolveTheme, resolveUpdate, rgbToOklab, rgbaToCss, rotatePoint, roundedRect, sampleArc, sequential, sequentialColorScale, sequentialSchemes, setStyle, sinInOut, slicerParamName, smartDate, specFields, srgbToLinear, summarizeChart, themes, tickIncrement, tickStep, ticks, timeScale, timeTickFormat, timeTicks, toHex, tooltipEnabled, validateDashboard, validateSpec, wireViews, withAlpha, withSketchFont };