@perspective-dev/viewer-charts 4.3.0

package/dist/esm/charts/common/tree-chart.d.ts

@@ -0,0 +1,48 @@
+import { AbstractChart } from "../chart-base";
+import { NodeStore } from "./node-store";
+import { LazyTooltip } from "../../interaction/lazy-tooltip";
+/**
+ * Shared state for hierarchical charts (treemap, sunburst). Holds the
+ * tree store + streaming-insert scaffolding + per-row tooltip data
+ * buffers. Concrete chart classes extend this and add their own
+ * layout / render / interact state.
+ *
+ * Fields are `public` so the `tree-data.ts` helpers and per-chart
+ * layout modules can read/write them without friction.
+ */
+export declare abstract class TreeChartBase extends AbstractChart {
+    _sizeName: string;
+    _colorName: string;
+    /**
+     * Color-slot semantics.
+     * - `"empty"`: no Color slot → single palette[0], legend suppressed.
+     * - `"numeric"`: Color column is float / integer / date / datetime →
+     *   continuous gradient via `colorValueToT`.
+     * - `"series"`: Color column is any other type → discrete series
+     *   palette keyed by the composite of group_by level values.
+     */
+    _colorMode: "empty" | "numeric" | "series";
+    _nodeStore: NodeStore;
+    _rootId: number;
+    _currentRootId: number;
+    _breadcrumbIds: number[];
+    /**
+     * Per-parent `Map<childName, childId>` for O(1) find-or-create
+     * during streaming tree insertion. Rebuilt on each dataset reset.
+     */
+    _childLookup: Map<number, Map<string, number>>;
+    _rowCount: number;
+    _colorMin: number;
+    _colorMax: number;
+    _uniqueColorLabels: Map<string, number>;
+    _visibleNodeIds: Int32Array | null;
+    _visibleNodeCount: number;
+    /**
+     * Lazy-tooltip cache. `lines` is `null` until the async row fetch
+     * resolves; the controller's serial dance drops stale results so
+     * rapid mouse motion doesn't paint out-of-date text. The render
+     * path consults `hoveredTarget` to verify cached lines belong to
+     * the currently hovered node before painting.
+     */
+    _lazyTooltip: LazyTooltip<number>;
+}

package/dist/esm/charts/common/tree-chrome.d.ts

@@ -0,0 +1,31 @@
+import type { Context2D } from "../canvas-types";
+import type { TreeChartBase } from "./tree-chart";
+/**
+ * Click target for one breadcrumb segment. Tree-chart hit-testing
+ * checks `_breadcrumbRegions` first so a click on the trail re-roots
+ * the view to that ancestor.
+ */
+export interface BreadcrumbRegion {
+    nodeId: number;
+    x0: number;
+    y0: number;
+    x1: number;
+    y1: number;
+}
+/**
+ * Paint the ancestor-path strip across the top of a tree chart and
+ * record per-crumb hit regions on `chart._breadcrumbRegions`. Mirrors
+ * the structure used by both treemap and sunburst — they only differ
+ * in their hover-highlight geometry, so this strip is shared verbatim.
+ */
+export declare function renderBreadcrumbs(chart: TreeChartBase & {
+    _breadcrumbRegions: BreadcrumbRegion[];
+}, ctx: Context2D, cssWidth: number, fontFamily: string, textColor: string): void;
+/**
+ * Paint the lazy-tooltip box for a tree-chart node, anchored at
+ * `(cx, cy)`. Returns early when no lines are cached for `nodeId`
+ * (the lazy lookup hasn't resolved yet, or `nodeId` doesn't match the
+ * currently-hovered target). Both treemap (rect-center) and sunburst
+ * (arc-mid) charts only differ in how they compute the anchor.
+ */
+export declare function renderTreeTooltip(chart: TreeChartBase, ctx: Context2D, nodeId: number, cx: number, cy: number, cssWidth: number, cssHeight: number, fontFamily: string): void;

package/dist/esm/charts/common/tree-data.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Streaming tree pipeline shared by treemap and sunburst. Rows arrive
+ * incrementally; each chunk inserts its rows directly into the SOA
+ * tree. Per-leaf tooltip columns are fetched lazily on pin via the
+ * chart's `_lazyRows`; the tree only retains `leafRowIdx` per leaf
+ * (small, O(leaves)) as the handle back to the source view row.
+ * After a chunk is processed, `finalizeTree` recomputes `value`
+ * bottom-up.
+ *
+ * Color mode:
+ *   - `"numeric"` — `readColor` reads the row's numeric value; the
+ *     render path maps it through the continuous gradient.
+ *   - `"series"` — `readColor` reads the row's string value from the
+ *     color column's dictionary, and `seedColorLabels` pre-populates
+ *     `_uniqueColorLabels` in dictionary-index order. Render picks
+ *     `palette[dictIdx % paletteSize]`.
+ *   - `"empty"` — no color column; every leaf gets `palette[0]`.
+ *
+ * When `_splitBy` is populated, every row is duplicated — one insertion
+ * per split prefix, with that prefix pushed as the top-level path
+ * segment so the top-level children of the synthetic root become
+ * facet roots. The per-prefix `size` / `color` columns (named
+ * `${prefix}|${base}`) feed the facet's values. `seedColorLabels`
+ * runs once per split so every split's dictionary contributes to the
+ * shared legend.
+ */
+import type { ColumnDataMap } from "../../data/view-reader";
+import type { TreeChartBase } from "./tree-chart";
+/**
+ * Reset the shared tree state. Called on the first chunk
+ * (`startRow === 0`) of each dataset load.
+ */
+export declare function resetTreeState(chart: TreeChartBase): void;
+/**
+ * Process one incoming chunk: grow row-data buffers, walk every row,
+ * capture column values, and insert into the tree.
+ */
+export declare function processTreeChunk(chart: TreeChartBase, columns: ColumnDataMap): void;
+/**
+ * Post-chunk finalization.
+ *   1. Recompute `value` bottom-up from `size` via an iterative
+ *      post-order walk.
+ *   2. Re-resolve `_currentRootId` from the breadcrumb name-path so
+ *      drill state survives incremental chunk arrivals.
+ *
+ * `colorLabel` is set at insert time (`readColor`) and needs no
+ * post-pass: in `"series"` mode it comes from the color column's
+ * dictionary, and in `"numeric"` / `"empty"` modes it's unused.
+ */
+export declare function finalizeTree(chart: TreeChartBase): void;
+/**
+ * Rebuild `chart._breadcrumbIds` by walking up from `nodeId`.
+ */
+export declare function rebuildBreadcrumbs(chart: TreeChartBase, nodeId: number): void;

package/dist/esm/charts/common/visible-extent.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Generic "find the value-axis extent among records whose category
+ * position falls inside a visible window" helper. Used by Y Bar,
+ * X Bar, Candlestick, and any future categorical-axis chart that
+ * wants an auto-fit value axis on zoom.
+ *
+ * Takes a pre-extracted numeric tuple per record via the `extract`
+ * callback instead of reading fields directly, so the same code path
+ * handles both Bar's `{ catIdx, y0, y1, axis, seriesId }` shape and
+ * Candlestick's `{ xCenter, low, high }` shape.
+ *
+ * TODO(perf): linear scan. Callers that order records by category
+ * index could pre-sort once and binary-search the slice to reduce
+ * this to O(log N + K_visible). Deferred until profiling shows the
+ * scan in the hot path.
+ */
+export interface VisibleExtent {
+    min: number;
+    max: number;
+    hasFit: boolean;
+}
+export interface VisibleExtentRecord {
+    /**
+     * Position on the categorical axis — compared to the visible window.
+     */
+    cat: number;
+    /**
+     * Low bound of the value-axis extent for this record.
+     */
+    lo: number;
+    /**
+     * High bound of the value-axis extent for this record.
+     */
+    hi: number;
+    /**
+     * True to skip this record (hidden series / wrong axis / etc.).
+     */
+    skip: boolean;
+}
+/**
+ * Walk `items`, filter by `visCatMin <= cat <= visCatMax` (and the
+ * caller-supplied `skip` flag), and return min/max over `lo`/`hi`.
+ *
+ * Returns `hasFit: false` when the window matches no records, so
+ * callers can fall back to the base domain.
+ *
+ * Zero-range guard: if every visible record shares a single value
+ * (flat run), pad by `±|value|` so the axis doesn't collapse to a
+ * single pixel.
+ */
+export declare function computeVisibleExtent<T>(items: readonly T[], visCatMin: number, visCatMax: number, extract: (item: T, out: VisibleExtentRecord) => void, out: VisibleExtent): VisibleExtent;

package/dist/esm/charts/heatmap/heatmap-build.d.ts

@@ -0,0 +1,86 @@
+import type { ColumnDataMap } from "../../data/view-reader";
+import type { CategoricalLevel } from "../../axis/categorical-axis";
+import { type AxisMode, type NumericCategoryDomain } from "../common/category-axis-resolver";
+export interface HeatmapCell {
+    xIdx: number;
+    yIdx: number;
+    value: number;
+}
+export interface HeatmapPipelineInput {
+    columns: ColumnDataMap;
+    numRows: number;
+    groupBy: string[];
+    splitBy: string[];
+    /**
+     * Source-column types keyed by column name (table.schema() merged
+     * with view.expression_schema()). Drives both the X-axis level-type
+     * lookup (for non-string row-paths) and the Y-axis numeric-mode
+     * decision when there's a single split_by.
+     */
+    groupByTypes: Record<string, string>;
+}
+export interface HeatmapPipelineResult {
+    /**
+     * Hierarchical row_path levels driving the X axis (outermost-first).
+     */
+    xLevels: CategoricalLevel[];
+    /**
+     * Arrow column names in iteration order; `yIdx === index in this list`.
+     */
+    yColumnNames: string[];
+    /**
+     * Hierarchical Y levels derived by splitting each name on `|`.
+     */
+    yLevels: CategoricalLevel[];
+    numX: number;
+    numY: number;
+    rowOffset: number;
+    cells: HeatmapCell[];
+    /**
+     * O(1) lookup by `yIdx * numX + xIdx`; `null` means no-data.
+     */
+    cells2D: (HeatmapCell | null)[];
+    colorMin: number;
+    colorMax: number;
+    /**
+     * X-axis mode. `numeric` fires when the single group_by is
+     * date/datetime/integer/float; positions live in `xPositions`
+     * and the domain in `xNumericDomain`.
+     */
+    xAxisMode: AxisMode;
+    yAxisMode: AxisMode;
+    xPositions: Float64Array | null;
+    yPositions: Float64Array | null;
+    xNumericDomain: NumericCategoryDomain | null;
+    yNumericDomain: NumericCategoryDomain | null;
+}
+/**
+ * Pure heatmap pipeline. Y indexing maps 1:1 to the arrow column iteration
+ * order — `yIdx` is the position of a value column in the ordered
+ * `ColumnDataMap` (after skipping `__ROW_PATH_N__` metadata). No
+ * aggregate/split reconstruction; the column name *is* the Y label.
+ *
+ * Externally enforced: only one entry sits in the `Color` slot, so every
+ * non-metadata column is a splitwise expansion of that single aggregate.
+ *
+ * Numeric-axis mode (matching bar/candlestick): when there's exactly one
+ * non-string group_by, the X axis switches to a real numeric/date axis
+ * with `xPositions[xIdx]` carrying the data-space center. Y mirrors this
+ * for a single non-string split_by, parsed best-effort out of the column
+ * name leaf segment; on parse failure it falls back to category mode.
+ */
+export declare function buildHeatmapPipeline(input: HeatmapPipelineInput): HeatmapPipelineResult;
+/**
+ * Partition a `ColumnDataMap` into one sub-map per user column. Every
+ * arrow value column is assigned to the partition whose user column name
+ * matches its terminal segment (everything after the last `|`, which
+ * equals the whole name when there's no `split_by`). `__ROW_PATH_N__`
+ * and `__GROUPING_ID__` metadata columns are copied into every partition
+ * since they describe the shared X axis.
+ *
+ * Used to render one heatmap per user column in a facet grid.
+ */
+export declare function partitionColumnsPerFacet(columns: ColumnDataMap, userColumns: string[]): Array<{
+    label: string;
+    columns: ColumnDataMap;
+}>;

package/dist/esm/charts/heatmap/heatmap-interact.d.ts

@@ -0,0 +1,19 @@
+import type { HeatmapChart } from "./heatmap";
+import type { CategoricalLevel } from "../../axis/categorical-axis";
+/**
+ * Find the heatmap cell under `(mx, my)`. O(1) via the prebuilt `cells2D`
+ * index. Sets `chart._hoveredCell` and schedules a re-render when the
+ * hovered cell changes.
+ *
+ * In multi-facet mode, iterates facets to find the one whose plot rect
+ * contains the cursor, then hit-tests against that facet's pipeline.
+ */
+export declare function handleHeatmapHover(chart: HeatmapChart, mx: number, my: number): void;
+/**
+ * Format a hierarchical path from a precomputed-label `CategoricalLevel` array.
+ */
+export declare function formatHierarchicalPath(levels: CategoricalLevel[], idx: number): string;
+/**
+ * Render a tooltip for the currently hovered cell.
+ */
+export declare function renderHeatmapTooltip(chart: HeatmapChart): void;

package/dist/esm/charts/heatmap/heatmap-render.d.ts

@@ -0,0 +1,19 @@
+import type { WebGLContextManager } from "../../webgl/context-manager";
+import type { HeatmapChart } from "./heatmap";
+export interface HeatmapLocations {
+    u_projection: WebGLUniformLocation | null;
+    u_cell_inset: WebGLUniformLocation | null;
+    u_cell_size: WebGLUniformLocation | null;
+    u_gradient_lut: WebGLUniformLocation | null;
+    a_corner: number;
+    a_cell: number;
+    a_color_t: number;
+}
+/**
+ * Full-frame render: WebGL cells → chrome overlay.
+ */
+export declare function renderHeatmapFrame(chart: HeatmapChart, glManager: WebGLContextManager): void;
+/**
+ * Chrome overlay: X axis + Y axis + color legend + (optional) tooltip.
+ */
+export declare function renderHeatmapChromeOverlay(chart: HeatmapChart): void;

package/dist/esm/charts/heatmap/heatmap-y-axis.d.ts

@@ -0,0 +1,46 @@
+import type { Context2D } from "../canvas-types";
+import { PlotLayout } from "../../layout/plot-layout";
+import type { Theme } from "../../theme/theme";
+import type { CategoricalDomain } from "../../axis/categorical-axis";
+interface LevelTickLayout {
+    size: number;
+}
+export interface CategoricalYAxisOptions {
+    /**
+     * Drop the innermost level of the domain before rendering, promoting
+     * the second-to-last level into the leaf position. Used by the
+     * heatmap, whose column names encode `split…|aggregate` — with a
+     * single aggregate the leaf level is a redundant constant column,
+     * and showing the last split as the leaf reads more naturally.
+     *
+     * No-op when `levels.length <= 1` (there's nothing left to promote);
+     * the axis renders nothing in that case.
+     */
+    skipLeafLevel?: boolean;
+}
+/**
+ * Map a Y category index to a pixel y-coordinate. Matches the convention
+ * chosen for the heatmap plot: yIdx=0 sits at the *bottom* (math Y-up),
+ * so a higher yIdx maps to a lower pixel value via `dataToPixel`'s
+ * standard (1 - t) flip.
+ */
+export declare function categoryIndexToPixelY(layout: PlotLayout, index: number): number;
+/**
+ * Per-level widths for a vertical categorical axis. Leaf width is
+ * derived from the longest label in that level's dictionary; outer
+ * levels get a fixed narrow column for the bracket + short text.
+ */
+export declare function measureCategoricalYLevels(domain: CategoricalDomain, opts?: CategoricalYAxisOptions): LevelTickLayout[];
+/**
+ * Total CSS-pixel width required for the categorical tick band (levels),
+ * NOT including the per-axis-label allowance. Caller feeds this to
+ * `PlotLayout` as `leftExtra`; the axis label is added via `hasYLabel`.
+ */
+export declare function measureCategoricalAxisWidth(domain: CategoricalDomain, opts?: CategoricalYAxisOptions): number;
+/**
+ * Render hierarchical Y-axis tick marks, leaf labels, and outer-level
+ * bracket labels on the chrome canvas. The axis line is drawn by the
+ * caller alongside the X axis.
+ */
+export declare function renderCategoricalYTicks(ctx: Context2D, layout: PlotLayout, domain: CategoricalDomain, theme: Theme, opts?: CategoricalYAxisOptions): void;
+export {};

package/dist/esm/charts/heatmap/heatmap.d.ts

@@ -0,0 +1,117 @@
+import type { ColumnDataMap } from "../../data/view-reader";
+import type { WebGLContextManager } from "../../webgl/context-manager";
+import { AbstractChart } from "../chart-base";
+import { PlotLayout } from "../../layout/plot-layout";
+import type { CategoricalLevel } from "../../axis/categorical-axis";
+import type { FacetGrid } from "../../layout/facet-grid";
+import type { AxisMode, NumericCategoryDomain } from "../common/category-axis-resolver";
+import { type HeatmapCell, type HeatmapPipelineResult } from "./heatmap-build";
+import { type HeatmapLocations } from "./heatmap-render";
+/**
+ * One heatmap in a facet-grid layout. Each facet corresponds to one
+ * user-selected column in the `Color` slot; its `pipeline` holds the
+ * cell data, and `layout` is the cell's `PlotLayout` from `buildFacetGrid`.
+ * `instanceStart`/`instanceCount` give the range of the packed
+ * cell/colorT buffers that belong to this facet.
+ */
+export interface HeatmapFacet {
+    label: string;
+    pipeline: HeatmapPipelineResult;
+    layout: PlotLayout;
+    instanceStart: number;
+    instanceCount: number;
+    /**
+     * Origins used to rebase cell positions before f32 narrowing —
+     * matches the per-axis convention in `SeriesChart._categoryOrigin`.
+     * `0` for non-numeric axes; for numeric (especially datetime) axes
+     * pinned to `xNumericDomain.min` / `yNumericDomain.min` so the
+     * shader's projection matrix can be built in rebased space.
+     */
+    xOrigin: number;
+    yOrigin: number;
+}
+/**
+ * Heatmap chart. `yIdx` maps 1:1 to the arrow column iteration order
+ * (after skipping `__ROW_PATH_N__` metadata). `xIdx` is the row index
+ * post-`rowOffset`.
+ *
+ * With one user column in the `Color` slot the chart renders a single
+ * heatmap filling the canvas. With more than one, each column becomes
+ * its own heatmap in a facet grid; all facets share a common color
+ * scale and a single legend.
+ */
+export declare class HeatmapChart extends AbstractChart {
+    _program: WebGLProgram | null;
+    _locations: HeatmapLocations | null;
+    _cornerBuffer: WebGLBuffer | null;
+    _gradientCache: import("../../webgl/gradient-texture").GradientTextureCache | null;
+    _xLevels: CategoricalLevel[];
+    _yLevels: CategoricalLevel[];
+    _yColumnNames: string[];
+    _numX: number;
+    _numY: number;
+    _rowOffset: number;
+    _xAxisMode: AxisMode;
+    _yAxisMode: AxisMode;
+    _xPositions: Float64Array | null;
+    _yPositions: Float64Array | null;
+    _xNumericDomain: NumericCategoryDomain | null;
+    _yNumericDomain: NumericCategoryDomain | null;
+    /**
+     * Single-plot rebase origins. Datetime numeric axes carry ~1.7e12
+     * timestamps which the f32 GPU pipeline cannot resolve below
+     * ~256ms; the cell upload subtracts these and the projection
+     * matrix is built with the same values so its `tx`/`ty` terms stay
+     * small enough for f32 cancellation in the shader. `0` for
+     * categorical or numeric-non-date axes.
+     */
+    _xOrigin: number;
+    _yOrigin: number;
+    _cells: HeatmapCell[];
+    _cells2D: (HeatmapCell | null)[];
+    _uploadedCells: number;
+    _colorMin: number;
+    _colorMax: number;
+    _aggName: string;
+    _hoveredCell: HeatmapCell | null;
+    _lastLayout: PlotLayout | null;
+    /**
+     * Last cursor position (canvas-CSS pixels) recorded by
+     * `handleHeatmapHover`. Used as the tooltip anchor instead of the
+     * cell center so the hover label tracks the mouse — necessary
+     * because heatmap cells can be many pixels wide and a center-anchored
+     * tooltip drifts away from the cursor.
+     */
+    _hoveredMouseX: number;
+    _hoveredMouseY: number;
+    _facets: HeatmapFacet[];
+    _facetGrid: FacetGrid | null;
+    _hoveredFacetIdx: number;
+    /**
+     * Bound accessor so the interact module can trigger a chrome redraw.
+     */
+    _renderChromeOverlay: () => void;
+    protected tooltipCallbacks(): {
+        onHover: (mx: number, my: number) => void;
+        onLeave: () => void;
+        onPin: (mx: number, my: number) => void;
+        onUnpin: () => void;
+    };
+    /**
+     * Resolve a clicked heatmap cell into a `PerspectiveClickDetail`
+     * and emit both `perspective-click` and
+     * `perspective-global-filter selected:true`. `xIdx` indexes the
+     * outer (group-by) hierarchy; `yIdx` indexes the column-side
+     * hierarchy (split-by + value-column splits). Each level is read
+     * directly from the pre-resolved `_xLevels` / `_yLevels` labels.
+     *
+     * Representative source row: `xIdx + _rowOffset` — the row in the
+     * pivoted view that owns this category. Sufficient for the
+     * `row.{col}` lookups consumers typically do; not authoritative for
+     * cells that aggregate across many source rows.
+     */
+    private _emitHeatmapClickSelect;
+    uploadAndRender(glManager: WebGLContextManager, columns: ColumnDataMap, startRow: number, endRow: number): Promise<void>;
+    _fullRender(glManager: WebGLContextManager): void;
+    protected destroyInternal(): void;
+}

package/dist/esm/charts/map/map.d.ts

@@ -0,0 +1,67 @@
+import { CartesianChart } from "../cartesian/cartesian";
+import type { Glyph } from "../cartesian/glyph";
+import type { WebGLContextManager } from "../../webgl/context-manager";
+import type { PlotLayout } from "../../layout/plot-layout";
+import type { Theme } from "../../theme/theme";
+import type { Canvas2D } from "../canvas-types";
+import type { ZoomConfig } from "../../interaction/zoom-controller";
+import type { PluginConfig } from "../chart";
+/**
+ * Map-mode base for cartesian charts. Reuses the entire cartesian
+ * pipeline (build, hit-test, zoom controller, lazy tooltips, faceting,
+ * theme, gradient texture) and swaps three behaviors:
+ *
+ *  - `projectPoint(lon, lat)` Mercator-projects incoming columns so
+ *    the rest of the pipeline operates in meter-space (linear
+ *    projection matrix, screen-space splat radius, hit-test grid all
+ *    "just work").
+ *  - `_renderMode = "map"` flips the render-frame branches to skip
+ *    cartesian gridlines and axes, insert a basemap layer before the
+ *    glyph draw, and use the map-specific chrome (attribution).
+ *  - `getZoomConfig()` returns `lockAspect: true` so wheel zoom keeps
+ *    `dataPerPixel` uniform on both axes (required: Mercator
+ *    preserves angle, glyphs distort otherwise).
+ *
+ * Concrete map plugin tags (`map-scatter`, `map-line`, `map-density`)
+ * pin a glyph in their nullary constructor exactly like the cartesian
+ * convenience subclasses.
+ */
+export declare class MapChart extends CartesianChart {
+    _renderMode: "map";
+    private _tileLayer;
+    constructor(glyph: Glyph);
+    projectPoint(lon: number, lat: number): [number, number];
+    protected getZoomConfig(): ZoomConfig;
+    setPluginConfig(cfg: PluginConfig): void;
+    renderBackground(glManager: WebGLContextManager, layout: PlotLayout, projection: Float32Array, domain: {
+        xMin: number;
+        xMax: number;
+        yMin: number;
+        yMax: number;
+    }, xOrigin: number, yOrigin: number): void;
+    renderMapChrome(canvas: Canvas2D | null, layout: PlotLayout, theme: Theme, dpr: number): void;
+    protected destroyInternal(): void;
+}
+/**
+ * Map Scatter — Mercator scatter on a raster basemap. Same glyph as
+ * `X/Y Scatter`; only projection and chrome differ.
+ */
+export declare class MapScatterChart extends MapChart {
+    constructor();
+}
+/**
+ * Map Line — Mercator polyline on a raster basemap. Same glyph as
+ * `X/Y Line`.
+ */
+export declare class MapLineChart extends MapChart {
+    constructor();
+}
+/**
+ * Map Density — Mercator KDE on a raster basemap. Same glyph as
+ * `Density`; the four `gradient_color_mode` variants
+ * (density/mean/extreme/signed) are all available on the map too
+ * because the glyph reads `_pluginConfig` directly.
+ */
+export declare class MapDensityChart extends MapChart {
+    constructor();
+}

package/dist/esm/charts/registry.d.ts

@@ -0,0 +1,14 @@
+import type { ChartImplementation } from "./chart";
+type ChartImplCtor = new () => ChartImplementation;
+/**
+ * Map from `ChartTypeConfig.tag` to a factory returning the chart-impl
+ * class. Consumed by `renderer.worker.ts` which `await`s the factory
+ * before constructing the impl.
+ *
+ * Eager chart types resolve immediately — `Promise.resolve(Class)` is
+ * a microtask, no I/O. Map plugins resolve via dynamic `import()` so
+ * the bundler emits the tile-rendering subsystem and the map-mode
+ * subclasses as a separate chunk; non-map users never fetch it.
+ */
+export declare const CHART_IMPLS: Record<string, () => Promise<ChartImplCtor>>;
+export {};

package/dist/esm/charts/series/glyphs/draw-areas.d.ts

@@ -0,0 +1,30 @@
+import type { WebGLContextManager } from "../../../webgl/context-manager";
+import type { SeriesChart } from "../series";
+type GL = WebGL2RenderingContext | WebGLRenderingContext;
+/**
+ * Area glyph for {@link SeriesChart}. Owns its program + per-series
+ * strip buffers privately.
+ */
+export declare class AreaGlyph {
+    private _program;
+    private _buffers;
+    private ensureProgram;
+    /**
+     * Drop persistent area buffers. Subsequent draws no-op until rebuild.
+     */
+    invalidateBuffers(chart: SeriesChart): void;
+    /**
+     * Build per-series strip buffers for area glyphs. Reads stacked
+     * y0/y1 from `chart._areaBarIndex` (cached at data load) and
+     * unstacked values from `_samples`. Single GPU upload per series;
+     * subsequent frames just rebind.
+     */
+    rebuildBuffers(chart: SeriesChart, glManager: WebGLContextManager): void;
+    /**
+     * Bind persistent strip buffers and dispatch one TRIANGLE_STRIP per
+     * series-run. Skips hidden series.
+     */
+    draw(chart: SeriesChart, gl: GL, _glManager: WebGLContextManager, projLeft: Float32Array, projRight: Float32Array, opacity: number): void;
+    destroy(chart: SeriesChart): void;
+}
+export {};

package/dist/esm/charts/series/glyphs/draw-bars.d.ts

@@ -0,0 +1,15 @@
+import type { WebGLContextManager } from "../../../webgl/context-manager";
+import type { SeriesChart } from "../series";
+/**
+ * Re-export of the bar discriminator value so `series-render.ts` can
+ * filter the `_bars` columnar storage without pulling the full
+ * `series-build` types into its import surface.
+ */
+export declare const BAR_TYPE_BAR_VAL = 0;
+type GL = WebGL2RenderingContext | WebGLRenderingContext;
+/**
+ * Draw the bar-typed subset of `chart._bars` as instanced quads. Assumes
+ * the caller has already `useProgram`'d the bar shader and set uniforms.
+ */
+export declare function drawBars(chart: SeriesChart, gl: GL, glManager: WebGLContextManager): void;
+export {};

package/dist/esm/charts/series/glyphs/draw-lines.d.ts

@@ -0,0 +1,34 @@
+import type { WebGLContextManager } from "../../../webgl/context-manager";
+import type { SeriesChart } from "../series";
+type GL = WebGL2RenderingContext | WebGLRenderingContext;
+/**
+ * Line glyph for {@link SeriesChart}. Owns its program + per-series
+ * GPU buffers privately; chart routes lifecycle through
+ * `_glyphs.lines`.
+ */
+export declare class LineGlyph {
+    private _program;
+    private _buffers;
+    private ensureProgram;
+    /**
+     * Drop persistent line buffers. Subsequent draws will no-op until
+     * the next `rebuildBuffers` call.
+     */
+    invalidateBuffers(chart: SeriesChart): void;
+    /**
+     * Rebuild the per-series GPU buffers for line glyphs. Called once
+     * per data load (and once after `restyle()` because palette colors
+     * are captured on the {@link LineSeriesEntry}). The buffer contents
+     * encode `[x,y]` points in run-major order; one `bufferData` per
+     * series. After this, every `draw` call rebinds + dispatches with
+     * no further uploads until the next data load.
+     */
+    rebuildBuffers(chart: SeriesChart, glManager: WebGLContextManager): void;
+    /**
+     * Bind the persistent vertex buffers and dispatch one instanced draw
+     * per (series, run). Skips hidden series via `_hiddenSeries`.
+     */
+    draw(chart: SeriesChart, gl: GL, glManager: WebGLContextManager, projLeft: Float32Array, projRight: Float32Array): void;
+    destroy(chart: SeriesChart): void;
+}
+export {};