@perspective-dev/viewer-charts 4.3.0

package/dist/esm/charts/candlestick/glyphs/draw-ohlc.d.ts

@@ -0,0 +1,33 @@
+import type { WebGLContextManager } from "../../../webgl/context-manager";
+import type { CandlestickChart } from "../candlestick";
+type GL = WebGL2RenderingContext | WebGLRenderingContext;
+/**
+ * OHLC bar glyph. Owns the OHLC program + per-color persistent segment
+ * buffers built per data load. Co-tenanted with `BodyWickGlyph` on
+ * `CandlestickChart`; only one of the two is active per frame depending
+ * on `_defaultChartType`.
+ */
+export declare class OHLCGlyph {
+    private _program;
+    private _buffers;
+    private ensureProgram;
+    /**
+     * Drop persistent OHLC vertex buffers. Called from data-load (before
+     * `rebuildBuffers`) and from chart-destroy paths.
+     */
+    invalidateBuffers(chart: CandlestickChart): void;
+    /**
+     * Pre-build the per-group OHLC instance buffers. Each candle emits 3
+     * line segments (H–L, open tick, close tick); layout per instance is
+     * `[start.x, start.y, end.x, end.y]`. Single GPU upload per group per
+     * data load.
+     */
+    rebuildBuffers(chart: CandlestickChart, glManager: WebGLContextManager): void;
+    /**
+     * Bind the persistent up/down OHLC buffers and dispatch one instanced
+     * draw per color group.
+     */
+    draw(chart: CandlestickChart, gl: GL, glManager: WebGLContextManager, projection: Float32Array): void;
+    destroy(chart: CandlestickChart): void;
+}
+export {};

package/dist/esm/charts/canvas-types.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Either flavor of 2D canvas the chart code may paint to. The chart's
+ * gridline and chrome canvases are `OffscreenCanvas` once the Host
+ * transfers rendering control to the Renderer (which it does in
+ * `LocalTransport` to validate that the chart code is DOM-free for
+ * worker mode). The GL canvas is also `HTMLCanvasElement | OffscreenCanvas`
+ * via WebGL's `gl.canvas`.
+ */
+export type Canvas2D = HTMLCanvasElement | OffscreenCanvas;
+/**
+ * 2D rendering context for either canvas flavor. The `OffscreenCanvas`
+ * variant is missing only `getContextAttributes` and `drawFocusIfNeeded` —
+ * neither used by the chart render paths.
+ */
+export type Context2D = CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D;

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

@@ -0,0 +1,14 @@
+import type { ColumnDataMap } from "../../data/view-reader";
+import type { WebGLContextManager } from "../../webgl/context-manager";
+import type { CartesianChart } from "./cartesian";
+/**
+ * First-chunk init: compile the glyph program, reset data extents,
+ * resolve column roles and split groups, pre-allocate CPU + GPU buffers.
+ */
+export declare function initCartesianPipeline(chart: CartesianChart, glManager: WebGLContextManager, columns: ColumnDataMap, endRow: number): void;
+/**
+ * Process one data chunk: extract positions + optional color/size per
+ * point, extend extents, write into per-series slots, capture tooltip
+ * data, and let the glyph upload its own GPU attribute buffers.
+ */
+export declare function processCartesianChunk(chart: CartesianChart, glManager: WebGLContextManager, columns: ColumnDataMap, startRow: number, chunkLength: number, endRow: number): void;

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

@@ -0,0 +1,20 @@
+import type { CartesianChart } from "./cartesian";
+/**
+ * Update {@link CartesianChart._hoveredIndex} for the given mouse
+ * position. Triggers a chrome re-render if the hovered index changes.
+ *
+ * In faceted mode, the hit test first resolves which facet the mouse is
+ * over, then restricts the search to that facet's series slice. This
+ * makes hover local to a facet; coordinated ghost indicators in other
+ * facets are painted by the chrome overlay.
+ */
+export declare function handleCartesianHover(chart: CartesianChart, mx: number, my: number): void;
+/**
+ * Show a sticky (pinned) tooltip at the given point, anchored to the
+ * GL canvas's parent via the tooltip controller.
+ *
+ * In faceted mode, resolves the source facet from `pointIdx` and uses
+ * that cell's layout so the tooltip anchors to the correct sub-plot.
+ */
+export declare function showCartesianPinnedTooltip(chart: CartesianChart, pointIdx: number): void;
+export declare function dismissCartesianPinnedTooltip(chart: CartesianChart): void;

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

@@ -0,0 +1,26 @@
+import type { WebGLContextManager } from "../../webgl/context-manager";
+import type { CartesianChart } from "./cartesian";
+/**
+ * Full-frame render: gridlines → glyph draw inside the plot-frame
+ * scissor → chrome overlay (axes + legend + tooltip).
+ *
+ * Branches on `_facetConfig.facet_mode`:
+ *
+ *   - `"overlay"` (legacy): a single plot rect; all split series are
+ *     drawn together, distinguished by color. This is the pre-facet
+ *     behavior, preserved for manual opt-in via `plugin_config.facet_mode`.
+ *   - `"grid"` (default): when splits are present, `_splitGroups` laid
+ *     out as a grid of sub-plots by {@link buildFacetGrid}. When splits
+ *     are absent, falls through to the single-plot path — identical to
+ *     the `"overlay"` case with 0 splits, so the non-split render path
+ *     is byte-for-byte unchanged from before this feature.
+ */
+export declare function renderCartesianFrame(chart: CartesianChart, glManager: WebGLContextManager): void;
+/**
+ * Redraw the chrome canvas only. Used for lightweight hover updates.
+ */
+export declare function renderCartesianChromeOverlay(chart: CartesianChart): void;
+/**
+ * Map a flat slotted index back to its series (facet) index.
+ */
+export declare function seriesFromIndex(chart: CartesianChart, flatIdx: number): number;

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

@@ -0,0 +1,239 @@
+import type { ColumnDataMap } from "../../data/view-reader";
+import type { WebGLContextManager } from "../../webgl/context-manager";
+import { AbstractChart } from "../chart-base";
+import { SpatialHitTester } from "../../interaction/hit-test";
+import { PlotLayout } from "../../layout/plot-layout";
+import { type AxisDomain } from "../../axis/numeric-axis";
+import type { GradientTextureCache } from "../../webgl/gradient-texture";
+import type { Glyph } from "./glyph";
+import type { LabelInterner } from "./label-interner";
+import { LazyTooltip } from "../../interaction/lazy-tooltip";
+export interface SplitGroup {
+    prefix: string;
+    xColName: string;
+    yColName: string;
+    colorColName: string;
+    sizeColName: string;
+    labelColName: string;
+}
+/**
+ * Unified continuous (numeric X/Y) chart. Glyphs plug in to render
+ * points, lines, or (future) areas over the shared data pipeline:
+ * streaming chunk upload, per-series slotted buffer layout, pan/zoom,
+ * spatial hit testing, chrome overlay, tooltip controller.
+ *
+ * Fields are package-internal (no `private`) so the split helper
+ * modules and glyphs can read/write them.
+ */
+export declare class CartesianChart extends AbstractChart {
+    readonly glyph: Glyph;
+    constructor(glyph: Glyph);
+    /**
+     * Rendering pipeline selector. `"cartesian"` is the default —
+     * draws axes, gridlines, and ticks via the chrome canvas.
+     * `"map"` (set by `MapChart` subclasses) suppresses cartesian
+     * chrome and inserts a raster tile layer underneath the glyph
+     * draw in `_fullRender`, so the same glyphs (point / line /
+     * density) render on top of a basemap.
+     *
+     * Read in `cartesian-render.ts` at three branch points; the
+     * `"cartesian"` path is byte-for-byte unchanged by the addition
+     * of this enum.
+     */
+    _renderMode: "cartesian" | "map";
+    /**
+     * Per-point data-space projection hook. Default is identity; map
+     * subclasses override to map (lon, lat) → Mercator meters. Called
+     * from `processCartesianChunk` immediately after the NaN guard,
+     * before extent accumulation and the `_xData` / `_yData` slot
+     * writes — so every downstream consumer (axis domain, projection
+     * matrix, spatial hit-test, glyph buffers) sees projected space
+     * uniformly. Returning `[NaN, NaN]` from a subclass discards the
+     * row (e.g. Mercator's ±85° latitude clamp).
+     */
+    projectPoint(x: number, y: number): [number, number];
+    /**
+     * Paint a per-frame background inside the plot-frame scissor,
+     * before the glyph draw. Map subclasses override to render the
+     * raster tile basemap; the default no-op leaves cartesian charts
+     * byte-for-byte unchanged.
+     *
+     * Called once per facet in faceted mode (each call's `projection`
+     * and `domain` are that cell's), wrapped in the cell's scissor —
+     * just like `glyph.drawSeries`.
+     *
+     * `xOrigin` / `yOrigin` are the rebase origins the projection
+     * matrix bakes in (see `buildProjectionMatrix`). Glyphs ship
+     * pre-rebased positions, so the background pass must subtract
+     * them from absolute-domain coords (e.g. tile Mercator extents)
+     * before uploading vertex positions; otherwise the matrix
+     * over-corrects and the background lands off-screen by
+     * `sx * xOrigin` clip units.
+     */
+    renderBackground(_glManager: import("../../webgl/context-manager").WebGLContextManager, _layout: import("../../layout/plot-layout").PlotLayout, _projection: Float32Array, _domain: {
+        xMin: number;
+        xMax: number;
+        yMin: number;
+        yMax: number;
+    }, _xOrigin: number, _yOrigin: number): void;
+    /**
+     * Paint chrome (attribution, scale bar) for map mode on top of the
+     * chrome canvas, in place of the cartesian axes/gridlines/legend.
+     * Called only when `_renderMode === "map"`. Default no-op so
+     * cartesian charts still go through `renderAxesChrome`.
+     */
+    renderMapChrome(_canvas: import("../canvas-types").Canvas2D | null, _layout: import("../../layout/plot-layout").PlotLayout, _theme: import("../../theme/theme").Theme, _dpr: number): void;
+    _gradientCache: GradientTextureCache | null;
+    _xName: string;
+    _yName: string;
+    _xLabel: string;
+    _yLabel: string;
+    _xIsRowIndex: boolean;
+    _colorName: string;
+    _sizeName: string;
+    _labelName: string;
+    _colorIsString: boolean;
+    _splitGroups: SplitGroup[];
+    _xMin: number;
+    _xMax: number;
+    _yMin: number;
+    _yMax: number;
+    /**
+     * Origin used to rebase x values before f32 narrowing. With datetime
+     * x columns the absolute timestamp is ~1.7e12, beyond f32 precision;
+     * storing `(x - _xOrigin)` keeps sub-millisecond fidelity in the
+     * `_xData` mirror, the GPU position attribute, and the projection
+     * matrix's `tx` term, avoiding the catastrophic cancellation that
+     * would otherwise push points outside the clip volume. NaN until
+     * the first valid x sample is observed.
+     */
+    _xOrigin: number;
+    _yOrigin: number;
+    _colorMin: number;
+    _colorMax: number;
+    _sizeMin: number;
+    _sizeMax: number;
+    /**
+     * `domain_mode: "expand"` accumulators. The build pipeline seeds
+     * `_xMin/_xMax/_yMin/_yMax/_colorMin/_colorMax/_sizeMin/_sizeMax`
+     * from these instead of `±Infinity` when expand mode is active, so
+     * the per-row scan naturally unions new data into the running
+     * extent. Mirrored back from the live fields at the end of every
+     * `processCartesianChunk` so multi-chunk uploads accumulate into
+     * the same union. Cleared via `resetExpandedDomain` (called from
+     * the worker's `resetAllZooms` and the view-config setters on
+     * `AbstractChart`).
+     */
+    _expandedXMin: number;
+    _expandedXMax: number;
+    _expandedYMin: number;
+    _expandedYMax: number;
+    _expandedColorMin: number;
+    _expandedColorMax: number;
+    _expandedSizeMin: number;
+    _expandedSizeMax: number;
+    _seriesCapacity: number;
+    _seriesUploadedCounts: number[];
+    _maxSeriesUploaded: number;
+    _xData: Float32Array | null;
+    _yData: Float32Array | null;
+    _colorData: Float32Array | null;
+    /**
+     * Source view row index for each slot in `_xData` / `_yData`,
+     * sized and laid out identically. Split expansion duplicates the
+     * same arrow source row across every series; this sidecar stores
+     * that source index so lazy tooltip fetches can retrieve the
+     * original row. Int32 for compactness — at 1M points this is
+     * ~4 MB, a small fraction of the ~70 MB that the prior eager
+     * row-data buffers cost.
+     */
+    _rowIndexData: Int32Array | null;
+    /**
+     * Slot-indexed string store for the scatter "Label" column. `null`
+     * when no label column was wired. See {@link LabelInterner} — the
+     * three formerly-separate label fields (`_labelData`,
+     * `_labelDictionary`, `_labelDictMap`) live there as one unit, so
+     * future label-related state stays cohesive instead of accreting
+     * sibling fields on the chart.
+     */
+    _labels: LabelInterner | null;
+    _dataCount: number;
+    _uniqueColorLabels: Map<string, number>;
+    /**
+     * Lazy-tooltip cache. `lines` is `null` until the async row fetch
+     * resolves — the chrome overlay skips the tooltip text box in
+     * that state but still paints the crosshair + highlight ring
+     * from geometry data so the hover cue is immediate. The
+     * controller owns the serial dance that drops stale resolves
+     * when the user moves before the fetch returns. Target type is
+     * the flat slot index of the hovered point.
+     */
+    _lazyTooltip: LazyTooltip<number>;
+    _stagingPositions: Float32Array | null;
+    _stagingColors: Float32Array | null;
+    _stagingSizes: Float32Array | null;
+    _stagingChunkSize: number;
+    _hitTest: SpatialHitTester;
+    _lastLayout: PlotLayout | null;
+    _hoveredIndex: number;
+    _pinnedIndex: number;
+    /**
+     * Source facet for the current hover (`-1` when not over any facet).
+     * Drives coordinated hover indicator painting in other facets.
+     */
+    _hoveredFacet: number;
+    _facetGrid: import("../../layout/facet-grid").FacetGrid | null;
+    _lastXDomain: AxisDomain | null;
+    _lastYDomain: AxisDomain | null;
+    _lastXTicks: number[] | null;
+    _lastYTicks: number[] | null;
+    _lastGradientStops: import("../../theme/gradient").GradientStop[] | null;
+    _lastHasColorCol: boolean;
+    _lastLutStops: import("../../theme/gradient").GradientStop[] | null;
+    _lastLutSeriesPalette: [number, number, number][] | null;
+    _lastLutLabelCount: number;
+    protected tooltipCallbacks(): {
+        onHover: (mx: number, my: number) => void;
+        onLeave: () => void;
+        onPin: (mx: number, my: number) => void;
+        onUnpin: () => void;
+    };
+    /**
+     * Resolve a clicked cartesian point into a `PerspectiveClickDetail`
+     * and emit both `perspective-click` and
+     * `perspective-global-filter selected:true`.
+     *
+     * Cartesian charts don't use `group_by` for positioning; X and Y
+     * come from explicit user-selected columns. The only filter clause
+     * we can build is the split-by prefix (when present). The source
+     * row index is the chart's per-point `_rowIndexData[flatIdx]`
+     * mirror — same lookup the lazy tooltip uses.
+     */
+    private _emitCartesianClickSelect;
+    uploadAndRender(glManager: WebGLContextManager, columns: ColumnDataMap, startRow: number, endRow: number): Promise<void>;
+    resetExpandedDomain(): void;
+    _fullRender(glManager: WebGLContextManager): void;
+    protected destroyInternal(): void;
+}
+/**
+ * X/Y Scatter — continuous chart with the point glyph.
+ */
+export declare class ScatterChart extends CartesianChart {
+    constructor();
+}
+/**
+ * X/Y Line — continuous chart with the line glyph.
+ */
+export declare class LineChart extends CartesianChart {
+    constructor();
+}
+/**
+ * Density — continuous chart that rasterizes each row as an
+ * additive radial splat, producing a density field over the plot rect.
+ * Shares the cartesian pipeline (build, hit-test, zoom, facets,
+ * tooltips); the glyph swaps the per-point glyph for the heat
+ * accumulation + resolve pair.
+ */
+export declare class DensityChart extends CartesianChart {
+    constructor();
+}

package/dist/esm/charts/cartesian/glyph.d.ts

@@ -0,0 +1,53 @@
+import type { WebGLContextManager } from "../../webgl/context-manager";
+import type { CartesianChart } from "./cartesian";
+/**
+ * A Glyph is a pluggable renderer for a {@link CartesianChart}. The
+ * chart owns all data and shared pipeline (init, chunk processing, hover,
+ * chrome, tooltip plumbing); the glyph owns its shader program, draw
+ * call, and per-glyph tooltip lines.
+ */
+export interface Glyph {
+    /**
+     * `"point"` for scatter-style markers; `"line"` for polylines;
+     * `"density"` for the density-field shader glyph.
+     */
+    readonly name: "point" | "line" | "density";
+    /**
+     * Compile the program + cache attrib/uniform locations on first
+     * frame. Subsequent frames are a no-op.
+     */
+    ensureProgram(chart: CartesianChart, glManager: WebGLContextManager): void;
+    /**
+     * Issue the draw call(s) for this glyph's visible geometry.
+     */
+    draw(chart: CartesianChart, glManager: WebGLContextManager, projection: Float32Array): void;
+    /**
+     * Issue draw calls for a single series' slice only. Used by
+     * faceted rendering: one facet per split, each facet's scissor
+     * clips to its plot rect and only that series rasterizes inside.
+     *
+     * Implementations should bind uniforms/buffers once (same as
+     * `draw`) and dispatch only the drawArrays call(s) for
+     * `seriesIdx`.
+     */
+    drawSeries(chart: CartesianChart, glManager: WebGLContextManager, projection: Float32Array, seriesIdx: number): void;
+    /**
+     * Per-hover tooltip content for the point at `flatIdx`. Returns a
+     * Promise because some glyphs (notably `PointGlyph`) need to fetch
+     * the source row from the view on demand for extra-column lookups.
+     * Glyphs whose tooltip is geometry-only (e.g. `LineGlyph`) return
+     * a microtask-resolved promise.
+     */
+    buildTooltipLines(chart: CartesianChart, flatIdx: number): Promise<string[]>;
+    /**
+     * Hover-overlay options (crosshair, highlight radius).
+     */
+    tooltipOptions(): {
+        crosshair: boolean;
+        highlightRadius: number;
+    };
+    /**
+     * Release GL resources created by `ensureProgram`.
+     */
+    destroy(chart: CartesianChart): void;
+}

package/dist/esm/charts/cartesian/glyphs/density.d.ts

@@ -0,0 +1,142 @@
+import type { WebGLContextManager } from "../../../webgl/context-manager";
+import type { CartesianChart } from "../cartesian";
+import type { Glyph } from "../glyph";
+/**
+ * Density-field glyph. Each cartesian row is rasterized as an additive
+ * radial splat into an RGBA float FBO; a fullscreen pass resolves the
+ * accumulated density (and optional color-weighted average) through the
+ * chart's gradient LUT and composites the result inside the plot rect.
+ *
+ * The user-facing `gradient_color_mode` plugin field selects between:
+ *
+ *  - `density` — alpha and hue from density alone.
+ *  - `mean` — density-weighted average of color-t (default).
+ *  - `extreme` — sign-aware MAX of per-point color deviation. Requires
+ *    a second accumulation target; uses `OES_draw_buffers_indexed`
+ *    MRT in one pass when available, otherwise falls back to two
+ *    sequential splat passes.
+ *  - `signed` — net positive vs. negative accumulation via the
+ *    `G - 0.5·R` identity. Requires a float-capable framebuffer; on
+ *    `UNSIGNED_BYTE` fallback the glyph silently degrades to `mean`
+ *    with a one-line console warning.
+ */
+export declare class DensityGlyph implements Glyph {
+    readonly name: "density";
+    private _cache;
+    ensureProgram(chart: CartesianChart, glManager: WebGLContextManager): void;
+    draw(chart: CartesianChart, glManager: WebGLContextManager, projection: Float32Array): void;
+    drawSeries(chart: CartesianChart, glManager: WebGLContextManager, projection: Float32Array, seriesIdx: number): void;
+    buildTooltipLines(chart: CartesianChart, flatIdx: number): Promise<string[]>;
+    tooltipOptions(): {
+        crosshair: boolean;
+        highlightRadius: number;
+    };
+    destroy(chart: CartesianChart): void;
+    /**
+     * Resize the heat (and, when allocated, extreme + MRT) targets to
+     * the current canvas bitmap size. The canvas backing store changes
+     * on DPR or layout updates, so we compare cached dimensions and
+     * re-allocate when stale.
+     */
+    private ensureHeatTarget;
+    /**
+     * Re-allocate the storage for one accumulation texture using the
+     * cached format triple. Called both at first draw and on every
+     * canvas-size change.
+     */
+    private allocAccumTexture;
+    /**
+     * Lazily allocate the extreme-mode accumulation texture + its
+     * framebuffers. Sized to match the heat target. Also probes
+     * `OES_draw_buffers_indexed` once per cache; if available, builds
+     * the MRT framebuffer with both textures attached.
+     */
+    private ensureExtremeTarget;
+    /**
+     * Compile (and cache) the single-target extreme splat program — the
+     * fallback two-pass path's second pass. Reuses the splat vertex
+     * shader so `v_color_t` semantics match the heat pass.
+     */
+    private ensureExtremeSplatProgram;
+    /**
+     * Compile (and cache) the MRT splat program. Only safe to call
+     * after `cache.indexedBlend` resolves truthy — the program's
+     * `#extension GL_EXT_draw_buffers : require` would fail to
+     * compile on contexts without multi-render-target support.
+     */
+    private ensureMrtSplatProgram;
+    /**
+     * Resolve the active mode for this frame. Folds in the silent
+     * downgrades to `mean` with a one-shot console warning:
+     *
+     *  - `signed` requires a float-capable framebuffer
+     *    (`EXT_color_buffer_float` on WebGL2 in practice).
+     *  - `extreme` requires `gl.MAX` blend and a second color
+     *    attachment, both of which are WebGL2-only here. On WebGL1
+     *    we could probe `EXT_blend_minmax` + `WEBGL_draw_buffers`
+     *    but degrading is simpler and the context manager prefers
+     *    WebGL2 already.
+     */
+    private activeMode;
+    private warnDowngradeOnce;
+    /**
+     * Shared splat → resolve pipeline. `dispatchSplats(cb)` iterates
+     * the series ranges the caller wants drawn, invoking
+     * `cb(slotOffset, count)` per range — `drawSeries` passes a single
+     * range, `draw` iterates every series. Internally branches on the
+     * active color mode: density/mean/signed share the single-target
+     * heat-only pass, `extreme` runs either an MRT single-pass or two
+     * sequential passes depending on extension support.
+     */
+    private runSplatAndResolve;
+    /**
+     * Single-target accumulation into the heat FBO. ADD blend; writes
+     * `(w, w·t, 0, 0)`. Used by every mode except `extreme` on the
+     * MRT path (which does this work and the extreme pass in one go).
+     */
+    private runHeatPass;
+    /**
+     * Second pass of the two-pass extreme path. MAX blend; writes
+     * sign-split deviation magnitudes into the extreme FBO. Skipped
+     * entirely on the MRT fast path.
+     */
+    private runExtremePass;
+    /**
+     * MRT fast path: one splat draw writes density (ADD) and extreme
+     * (MAX) in the same invocation by routing `gl_FragData[0]` /
+     * `gl_FragData[1]` to attachments 0 and 1 with per-attachment
+     * blend equations.
+     */
+    private runMrtExtremePass;
+    /**
+     * Clear the currently bound framebuffer's color attachment(s) to
+     * fully transparent, bypassing scissor so leftovers from a prior
+     * facet's region don't bleed into this pass's full sample range.
+     * Restores the scissor state on exit.
+     */
+    private clearTarget;
+    /**
+     * Upload the per-frame splat-program uniforms (projection, splat
+     * radius, intensity, color range). Shared by the heat-only pass,
+     * the extreme single-target pass, and the MRT pass since each
+     * program exposes the same uniform layout.
+     */
+    private bindSplatProgram;
+    /**
+     * Bind the static unit-quad corner buffer (divisor 0) and per-
+     * instance position + color attributes (divisor 1), then iterate
+     * the caller's series ranges issuing one instanced draw each.
+     */
+    private bindAndDispatchInstanced;
+    /**
+     * Reset the per-instance divisors so subsequent draws (in this or
+     * another chart) don't inherit the instanced bindings.
+     */
+    private unbindSplatInstancing;
+    /**
+     * Resolve pass on the canvas FBO. Standard alpha composite. Reads
+     * the heat FBO (always) and, in `extreme` mode, the extreme FBO.
+     * Uploads the mode int that the resolve frag branches on.
+     */
+    private runResolvePass;
+}

package/dist/esm/charts/cartesian/glyphs/lines.d.ts

@@ -0,0 +1,23 @@
+import type { WebGLContextManager } from "../../../webgl/context-manager";
+import type { CartesianChart } from "../cartesian";
+import type { Glyph } from "../glyph";
+/**
+ * Polyline glyph — instanced triangle-strip segments between adjacent
+ * same-series points. Segments are scoped per-series via byte-offset
+ * rebinding (see `drawLineSeries`); the shader reads the endpoints'
+ * raw color values and samples the gradient LUT via the same sign-
+ * aware `(v - cmin) / (cmax - cmin)` mapping the scatter glyph uses.
+ */
+export declare class LineGlyph implements Glyph {
+    readonly name: "line";
+    private _cache;
+    ensureProgram(_chart: CartesianChart, glManager: WebGLContextManager): void;
+    draw(chart: CartesianChart, glManager: WebGLContextManager, projection: Float32Array): void;
+    drawSeries(chart: CartesianChart, glManager: WebGLContextManager, projection: Float32Array, seriesIdx: number): void;
+    buildTooltipLines(chart: CartesianChart, flatIdx: number): Promise<string[]>;
+    tooltipOptions(): {
+        crosshair: boolean;
+        highlightRadius: number;
+    };
+    destroy(chart: CartesianChart): void;
+}

package/dist/esm/charts/cartesian/glyphs/points.d.ts

@@ -0,0 +1,24 @@
+import type { WebGLContextManager } from "../../../webgl/context-manager";
+import type { CartesianChart } from "../cartesian";
+import type { Glyph } from "../glyph";
+/**
+ * `gl.POINTS` glyph — one squared/antialiased point per data row. Color
+ * and size are driven by the shared `a_color_value` / `a_size_value`
+ * buffers; the vertex shader does sign-aware color-t mapping and samples
+ * the gradient LUT. One draw call per series (the slot layout leaves
+ * gaps at each series' tail that we can't safely include in a single
+ * draw — dispatching `count[s]` per series skips them).
+ */
+export declare class PointGlyph implements Glyph {
+    readonly name: "point";
+    private _cache;
+    ensureProgram(_chart: CartesianChart, glManager: WebGLContextManager): void;
+    draw(chart: CartesianChart, glManager: WebGLContextManager, projection: Float32Array): void;
+    drawSeries(chart: CartesianChart, glManager: WebGLContextManager, projection: Float32Array, seriesIdx: number): void;
+    buildTooltipLines(chart: CartesianChart, flatIdx: number): Promise<string[]>;
+    tooltipOptions(): {
+        crosshair: boolean;
+        highlightRadius: number;
+    };
+    destroy(_chart: CartesianChart): void;
+}

package/dist/esm/charts/cartesian/label-interner.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Slot-indexed string store for the scatter "Label" column. Strings
+ * are deduplicated across split-by facets so identical labels share a
+ * dictionary entry; the per-slot `Int32Array` then holds dictionary
+ * indices (`-1` means "no label for this slot").
+ */
+export declare class LabelInterner {
+    readonly data: Int32Array;
+    readonly dictionary: string[];
+    private readonly dictMap;
+    constructor(capacity: number);
+    /**
+     * Insert (or look up) `label` and write its dictionary index into
+     * the slot at `flatIdx`. Returns the assigned dictionary index.
+     */
+    set(flatIdx: number, label: string): number;
+    /**
+     * Resolve a slot's label string, or `null` if unset.
+     */
+    get(flatIdx: number): string | null;
+}

package/dist/esm/charts/cartesian/tooltip-lines.d.ts

@@ -0,0 +1,11 @@
+import type { CartesianChart } from "./cartesian";
+/**
+ * Build the per-row tooltip for a point-style glyph (scatter, gradient
+ * heatmap). Resolves the source arrow row via the chart's lazy row
+ * fetcher, then surfaces every non-null column under the (split-aware)
+ * prefix filter formatted by column type.
+ *
+ * Returns `[]` when the chart has no row-index mirror or no fetcher;
+ * callers should fall back to a geometry-only tooltip in that case.
+ */
+export declare function buildPointRowTooltipLines(chart: CartesianChart, flatIdx: number): Promise<string[]>;