@perspective-dev/viewer-charts 4.5.0 → 4.5.1

package/dist/esm/axis/bar-axis.d.ts

@@ -18,6 +18,14 @@ export type BarCategoryAxis = {
     domain: AxisDomain;
     ticks: number[];
 };
+export type BarValueAxis = {
+    mode: "category";
+    domain: CategoricalDomain;
+} | {
+    mode: "numeric";
+    domain: AxisDomain;
+    ticks: number[];
+};
 /**
  * Render a numeric date-aware axis along the bottom of the plot. Aliases
  * the bar-axis bottom variant so heatmap can share the implementation.
@@ -42,7 +50,7 @@ export interface BarAxesFormatters {
     /** Formatter for the numeric category axis (when `catAxis.mode === "numeric"`). */
     category?: (v: number) => string;
 }
-export declare function renderBarAxesChrome(canvas: Canvas2D, catAxis: BarCategoryAxis, valueDomain: AxisDomain, valueTicks: number[], layout: PlotLayout, theme: Theme, dpr: number, altDomain?: AxisDomain, altTicks?: number[], isHorizontal?: boolean, formatters?: BarAxesFormatters): void;
+export declare function renderBarAxesChrome(canvas: Canvas2D, catAxis: BarCategoryAxis, valueAxis: BarValueAxis, layout: PlotLayout, theme: Theme, dpr: number, altAxis: BarValueAxis | undefined, isHorizontal?: boolean, formatters?: BarAxesFormatters): void;
 /**
  * Render gridlines at the numeric axis ticks. In vertical bar charts
  * the gridlines run horizontally at numeric Y ticks; in horizontal bar

package/dist/esm/axis/categorical-axis.d.ts

@@ -16,8 +16,6 @@ interface LevelTickLayout {
     size: number;
     rotation: 0 | 45 | 90;
 }
-declare function categoryIndexToPixelX(layout: PlotLayout, index: number): number;
-export declare const categoryIndexToPixel: typeof categoryIndexToPixelX;
 export declare function measureCategoricalLevels(domain: CategoricalDomain, plotWidth: number): LevelTickLayout[];
 export declare function measureCategoricalLevelWidths(domain: CategoricalDomain): number[];
 export declare function measureCategoricalAxisHeight(domain: CategoricalDomain, plotWidth: number): number;

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

@@ -4,6 +4,7 @@ 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 { CategoricalDomain } from "../../axis/categorical-axis";
 import type { GradientTextureCache } from "../../webgl/gradient-texture";
 import type { Glyph } from "./glyph";
 import type { LabelInterner } from "./label-interner";
@@ -93,6 +94,31 @@ export declare class CartesianChart extends AbstractChart {
     _sizeName: string;
     _labelName: string;
     _colorIsString: boolean;
+    /**
+     * When the X (or Y) axis source column is post-aggregation
+     * `string`-typed, the build pipeline writes per-row dictionary slot
+     * indices into `_xData` (or `_yData`) instead of numeric values,
+     * and the render pass dispatches `renderCategoricalXTicks` /
+     * `renderCategoricalYTicks` instead of the numeric axis painter.
+     *
+     * The companion `_xCategoryDictionary` / `_xCategorySeen` pair is
+     * built lazily during `processCartesianChunk` in first-seen row
+     * order; `(null)` is appended on first encounter of an invalid row
+     * rather than reserved at slot 0, so charts without missing values
+     * don't get a phantom slot.
+     *
+     * `_xCategoryDomain` is materialized once per frame in
+     * `cartesian-render` and held for chrome overlay redraws (same
+     * lifecycle as `_lastXDomain` on the numeric path).
+     */
+    _xIsString: boolean;
+    _yIsString: boolean;
+    _xCategoryDictionary: string[];
+    _yCategoryDictionary: string[];
+    _xCategorySeen: Map<string, number>;
+    _yCategorySeen: Map<string, number>;
+    _xCategoryDomain: CategoricalDomain | null;
+    _yCategoryDomain: CategoricalDomain | null;
     _splitGroups: SplitGroup[];
     _xMin: number;
     _xMax: number;

package/dist/esm/charts/common/category-axis-resolver.d.ts

@@ -1,5 +1,5 @@
 import type { ColumnDataMap, ColumnData } from "../../data/view-reader";
-import type { CategoricalLevel } from "../../axis/categorical-axis";
+import type { CategoricalDomain, CategoricalLevel } from "../../axis/categorical-axis";
 export interface CategoryAxisResult {
     /**
      * Fully materialized hierarchical levels — labels and group runs are
@@ -88,3 +88,45 @@ export declare function synthesizeStringLevel(rp: ColumnData, numRows: number, l
  * from `rowPaths.length === 0`.
  */
 export declare function resolveCategoryAxis(columns: ColumnDataMap, numRows: number, groupByLen: number, levelTypes?: string[]): CategoryAxisResult;
+export interface ValueCategoryColumn {
+    /**
+     * Source aggregate column name; used only for the axis label fallback.
+     */
+    name: string;
+    /**
+     * Post-aggregation perspective type string from `chart._columnTypes`
+     * (`"string"` is what triggers categorical mode).
+     */
+    type: string;
+    /**
+     * The actual `ColumnData` from the view. May be undefined when the
+     * caller couldn't resolve the column (treated as all-null).
+     */
+    data: ColumnData | undefined;
+}
+export interface ValueCategoryDomain {
+    /**
+     * Single-level `CategoricalDomain` shared across all input columns.
+     * `levels[0].labels` is the dictionary in slot order.
+     */
+    domain: CategoricalDomain;
+    /**
+     * Per-column slot-index buffers. Length === `numCategories`.
+     * Indexed in the same order as the input `columns` array.
+     */
+    perColumnSlots: Int32Array[];
+}
+/**
+ * Build a single shared categorical domain across one or more aggregate
+ * columns that land on the same axis side (primary or alt). Implements
+ * the "all-or-nothing per axis side" rule: returns `null` (= caller stays
+ * numeric) when any column is non-string; otherwise returns a single-
+ * level domain with the dictionary built in first-seen row order plus
+ * per-column slot indices the build pipeline writes into its pixel/slot
+ * buffer.
+ *
+ * Null / invalid rows surface as a `"(null)"` slot that's lazily added
+ * to the dictionary on first encounter — no reserved slot 0 when the
+ * data has no missing values.
+ */
+export declare function resolveValueCategoryDomain(columns: ValueCategoryColumn[], numRows: number, rowOffset: number, axisLabel: string): ValueCategoryDomain | null;

package/dist/esm/charts/common/expand-domain.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Numeric extent — used by series + candlestick build pipelines for
+ * value / category axis domains.
+ */
+export interface Domain {
+    min: number;
+    max: number;
+}
+/**
+ * Union `next` (a freshly-computed extent) with `prev` (the prior
+ * accumulator) IN PLACE on `next`, then return a fresh copy to store
+ * back as the new accumulator. Idempotent when `prev` is null — `next`
+ * is left untouched.
+ *
+ * Used by the `domain_mode: "expand"` mirror-back step in the series /
+ * candlestick / cartesian build pipelines: mutating `next` in place
+ * means every downstream assignment that reads from the pipeline
+ * result struct automatically picks up the grown extent.
+ */
+export declare function expandDomainInPlace(prev: Domain | null, next: Domain): Domain;

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

@@ -1,6 +1,13 @@
 import { AbstractChart } from "../chart-base";
+import type { ColumnDataMap } from "../../data/view-reader";
 import { NodeStore } from "./node-store";
 import { LazyTooltip } from "../../interaction/lazy-tooltip";
+/**
+ * Sentinel fallback for the Size slot when the user hasn't picked one:
+ * use the first non-metadata column in the incoming view. Tree charts
+ * still need *some* numeric-ish column to size geometry.
+ */
+export declare function firstNonMetadataColumn(columns: ColumnDataMap): string;
 /**
  * Shared state for hierarchical charts (treemap, sunburst). Holds the
  * tree store + streaming-insert scaffolding + per-row tooltip data

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

@@ -1,4 +1,8 @@
-import type { Context2D } from "../canvas-types";
+import type { Canvas2D, Context2D } from "../canvas-types";
+import type { PlotRect } from "../../layout/plot-layout";
+import type { GradientStop } from "../../theme/gradient";
+import type { Vec3 } from "../../theme/palette";
+import type { Theme } from "../../theme/theme";
 import type { TreeChartBase } from "./tree-chart";
 /**
  * Click target for one breadcrumb segment. Tree-chart hit-testing
@@ -29,3 +33,21 @@ export declare function renderBreadcrumbs(chart: TreeChartBase & {
  * (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;
+/**
+ * Paint a color legend (categorical swatches or numeric gradient bar)
+ * for a tree chart. Shared by sunburst + treemap; both consult
+ * `_colorMode` / `_uniqueColorLabels.size` / `_colorMin..max` the same
+ * way.
+ *
+ * `categoricalRect`, when non-null, is used as the explicit rect for
+ * the categorical-swatch variant (sunburst's faceted mode passes
+ * `FacetGrid.legendRect` here). Numeric mode always derives from a
+ * synthetic single-plot `PlotLayout` to match the legacy per-chart
+ * branch — its gradient bar's vertical span doesn't fit the
+ * categorical legend's compact rect.
+ *
+ * Returns silently when the color slot is empty, when categorical mode
+ * has only one label, or when numeric mode has a degenerate
+ * (`min >= max`) extent.
+ */
+export declare function renderTreeColorLegend(chart: TreeChartBase, canvas: Canvas2D, palette: Vec3[], stops: GradientStop[], theme: Theme, cssWidth: number, cssHeight: number, categoricalRect?: PlotRect | null): void;

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

@@ -0,0 +1,46 @@
+import type { TreeChartBase } from "./tree-chart";
+/**
+ * Common subset of `TreemapChart` / `SunburstChart` reached by the
+ * shared interaction helpers — anything that lives on `TreeChartBase`
+ * plus the pinned/hover/facet-drill state the two charts both declare
+ * with identical shape but on the subclass (so we type it as an
+ * intersection).
+ */
+export type TreeInteractChart = TreeChartBase & {
+    _pinnedNodeId: number;
+    _hoveredNodeId: number;
+    _facetDrillRoots: Map<string, number>;
+};
+/**
+ * Emit `perspective-click` + `perspective-global-filter selected:true`
+ * for a treemap/sunburst node. The path is walked via `ancestorNames`
+ * and split into split-by prefix + group-by levels using
+ * `_splitBy.length` as the boundary; faceted mode keeps the depth-0
+ * ancestor as the split prefix.
+ */
+export declare function emitTreeNodeEvent(chart: TreeInteractChart, nodeId: number, kind: "leaf" | "branch"): Promise<void>;
+/**
+ * Build tooltip lines for `nodeId`: ancestor name path + aggregate
+ * value + (numeric) color value + per-row tooltip columns from
+ * `_lazyRows` for leaves. The leaf branch awaits the source-view row
+ * fetch; branch nodes have no underlying row so they emit a Children
+ * count instead.
+ */
+export declare function buildTreeTooltipLines(chart: TreeInteractChart, nodeId: number): Promise<string[]>;
+/**
+ * Pin a tooltip at the chart-supplied anchor. Lines are fetched lazily;
+ * the `_pinnedNodeId` check on resolve discards stale results from a
+ * prior pin or dismissal.
+ */
+export declare function showTreePinnedTooltip(chart: TreeInteractChart, nodeId: number, anchor: {
+    cx: number;
+    cy: number;
+}, renderChromeOverlay: () => void): void;
+export declare function dismissTreePinnedTooltip(chart: TreeInteractChart): void;
+/**
+ * Drill the clicked facet (or the whole chart in non-facet mode).
+ * Faceted drill walks up to the facet root (top-level child of
+ * `_rootId`), records the new drill node under that facet's label, and
+ * re-renders.
+ */
+export declare function treeDrillTo(chart: TreeInteractChart, nodeId: number, renderFrame: () => void): void;

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

@@ -19,14 +19,21 @@ export declare class LineGlyph {
      * 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.
+     * encode `[x,y]` points for every cat in `[start, end]`; one
+     * `bufferData` per series. After this, every `draw` call rebinds +
+     * dispatches with no further uploads until the next data load.
+     *
+     * Gap behavior at synthesized cells is handled in the shader via
+     * `u_interp_alpha` (set per draw based on the series'
+     * `interpolateMode`): `skip` → 0 (invisible segments touching a
+     * synthesized endpoint), `solid` → 1, `transparent` → 0.5.
      */
     rebuildBuffers(chart: SeriesChart, glManager: WebGLContextManager): void;
     /**
      * Bind the persistent vertex buffers and dispatch one instanced draw
-     * per (series, run). Skips hidden series via `_hiddenSeries`.
+     * per series. Skips hidden series via `_hiddenSeries`. Gap /
+     * transparency rendering is governed by `u_interp_alpha`, set per
+     * series.
      */
     draw(chart: SeriesChart, gl: GL, glManager: WebGLContextManager, projLeft: Float32Array, projRight: Float32Array): void;
     destroy(chart: SeriesChart): void;

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

@@ -1,7 +1,7 @@
 import type { ColumnDataMap } from "../../data/view-reader";
-import type { CategoricalLevel } from "../../axis/categorical-axis";
+import type { CategoricalDomain, CategoricalLevel } from "../../axis/categorical-axis";
 import { type AxisMode, type NumericCategoryDomain } from "../common/category-axis-resolver";
-import { type ChartType, type ColumnChartConfig } from "./series-type";
+import { type ChartType, type ColumnChartConfig, type InterpolateMode } from "./series-type";
 export interface SeriesInfo {
     seriesId: number;
     aggIdx: number;
@@ -13,6 +13,24 @@ export interface SeriesInfo {
     axis: 0 | 1;
     chartType: ChartType;
     stack: boolean;
+    /**
+     * First / last category index this series contributes data to, in
+     * the post-Pass-2 sample grid. For line+any mode and area+solid:
+     * every cell in `[start, end]` has a value (real or synthesized).
+     * For area+skip: `[start, end]` is the real-data extent; interior
+     * cells with `sampleValid=0` are gaps. `start = -1` (with `end = -1`)
+     * means the series has no real samples — downstream skips it.
+     */
+    start: number;
+    end: number;
+    /**
+     * Resolved interpolation mode for this aggregate. The build
+     * pipeline reads it to decide whether Pass 2 runs for area
+     * (and which fills to apply); the line glyph reads it at draw
+     * time to set `u_interp_alpha`. Always one of the three modes;
+     * never the legacy boolean form.
+     */
+    interpolateMode: InterpolateMode;
 }
 /**
  * Logical bar/area record. Synthesized on demand from {@link BarColumns}
@@ -215,6 +233,24 @@ export interface SeriesPipelineResult {
         max: number;
     } | null;
     hasRightAxis: boolean;
+    /**
+     * Per-axis-side value mode discriminator. `"category"` fires when
+     * every aggregate on that side is post-aggregation `string`-typed
+     * (all-or-nothing rule). Bar y0/y1 then hold dictionary slot
+     * indices and the chrome overlay paints a categorical axis on
+     * that side. `null` for the alt side when there are no series
+     * pinned to alt.
+     */
+    leftValueAxisMode: "numeric" | "category";
+    rightValueAxisMode: "numeric" | "category" | null;
+    /**
+     * Single-level `CategoricalDomain` shared across every aggregate
+     * on the corresponding side. Set only when that side's mode is
+     * `"category"`; the chrome renderer in `series-render` materializes
+     * the side's `BarCategoryAxis` from this.
+     */
+    leftValueCategoryDomain: CategoricalDomain | null;
+    rightValueCategoryDomain: CategoricalDomain | null;
 }
 /**
  * Pure pipeline: turn a raw `ColumnDataMap` into (a) columnar stacked

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

@@ -1,10 +1,7 @@
 import type { WebGLContextManager } from "../../webgl/context-manager";
 import { type SeriesChart } from "./series";
 /**
- * Upload bar instance buffers from the columnar `_bars` storage. Filters
- * to bar-typed records only (areas draw as triangle strips). Skips
- * hidden series. Re-called from data-load and legend-toggle paths; the
- * scratch buffers and `_visibleBarIndices` are reused across calls.
+ * Upload bar instance buffers from the columnar `_bars` storage.
  */
 export declare function uploadBarInstances(chart: SeriesChart, glManager: WebGLContextManager): void;
 /**

package/dist/esm/charts/series/series-type.d.ts

@@ -1,9 +1,10 @@
 export type ChartType = "bar" | "line" | "scatter" | "area";
 /**
- * Per-column entry inside the viewer's `columns_config` map. The map itself
- * is typed as `Record<string, any>` at the plugin boundary because
- * `columns_config` is shared across plugins; this interface documents the
- * keys the Y-bar glyph router consumes.
+ * Per-column interpolation mode for line / area glyphs.
+ */
+export type InterpolateMode = "skip" | "solid" | "transparent";
+/**
+ * Per-column entry inside the viewer's `columns_config` map.
  */
 export interface ColumnChartConfig {
     /**
@@ -11,39 +12,40 @@ export interface ColumnChartConfig {
      */
     chart_type?: string;
     /**
-     * Explicit stack override. If omitted: bar / area stack by default,
-     * line / scatter do not.
+     * Explicit stack override.
      */
     stack?: boolean;
     /**
      * Force this aggregate onto the secondary (right) Y axis,
      * independent of `autoAltYAxis` and the dual-axis ratio
-     * heuristic. Missing / false → axis assignment is driven by
-     * `autoAltYAxis` alone.
+     * heuristic.
      */
     alt_axis?: boolean;
+    /**
+     * Interpolation mode for line / area glyphs. See
+     * {@link InterpolateMode}. Legacy values `true` / `false` are also
+     * accepted by {@link resolveInterpolate} (mapped to `"solid"` /
+     * `"skip"`). Default `"skip"`. No effect on bar / scatter.
+     */
+    interpolate?: InterpolateMode;
 }
 /**
  * Resolve the render glyph for an aggregate base name. Lookup key is the
  * *base* (e.g. `"Sales"`); composite arrow columns like `"North|Sales"`
  * should strip the prefix before calling — the bar pipeline already
  * tracks aggregates as base names, so call sites pass the base directly.
- *
- * `fallback` is the plugin's default glyph (e.g. `"line"` for Y Line),
- * supplied by the plugin element via `setDefaultChartType`. Falls back to
- * `"bar"` when the plugin never set one.
  */
 export declare function resolveChartType(aggName: string, cfg: Record<string, ColumnChartConfig> | undefined, fallback?: ChartType): ChartType;
 /**
  * Resolve whether a series stacks with its aggregate siblings.
- * Default: `true` for bar/area, `false` for line/scatter. Overridable
- * per column via `columns_config[aggName].stack`.
  */
 export declare function resolveStack(aggName: string, chartType: ChartType, cfg: Record<string, ColumnChartConfig> | undefined): boolean;
 /**
  * Resolve whether a column is pinned to the secondary Y axis via
- * `columns_config[aggName].alt_axis`. Independent of `autoAltYAxis`:
- * when `true`, the per-column override forces axis 1 regardless of
- * the auto-split heuristic.
+ * `columns_config[aggName].alt_axis`.
  */
 export declare function resolveAltAxis(aggName: string, cfg: Record<string, ColumnChartConfig> | undefined): boolean;
+/**
+ * Resolve the interpolation mode for this aggregate.
+ */
+export declare function resolveInterpolate(aggName: string, chartType: ChartType, cfg: Record<string, ColumnChartConfig> | undefined): InterpolateMode;

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

@@ -4,6 +4,7 @@ import type { ZoomConfig } from "../../interaction/zoom-controller";
 import { CategoricalYChart } from "../common/categorical-y-chart";
 import { type PlotRect } from "../../layout/plot-layout";
 import { type AxisDomain } from "../../axis/numeric-axis";
+import type { CategoricalDomain } from "../../axis/categorical-axis";
 import { type SeriesChartRecord, type NumericCategoryDomain, type SeriesInfo, type BarColumns } from "./series-build";
 import { LineGlyph } from "./glyphs/draw-lines";
 import { ScatterGlyph } from "./glyphs/draw-scatter";
@@ -90,6 +91,21 @@ export declare class SeriesChart extends CategoricalYChart {
      */
     _primaryValueLabel: string;
     _altValueLabel: string;
+    /**
+     * Per-side value-axis mode. `"category"` fires when every
+     * aggregate on that side is post-aggregation `string`-typed
+     * (all-or-nothing rule, evaluated independently for primary and
+     * alt). When set, `_bars[].y0`/`y1` carry dictionary slot indices
+     * instead of numeric values, and the chrome overlay paints a
+     * categorical axis on that side.
+     *
+     * Read by `series-render.ts` to construct the `BarCategoryAxis`
+     * descriptor for the value-axis sides.
+     */
+    _leftValueAxisMode: "numeric" | "category";
+    _rightValueAxisMode: "numeric" | "category" | null;
+    _leftValueCategoryDomain: CategoricalDomain | null;
+    _rightValueCategoryDomain: CategoricalDomain | null;
     /**
      * (seriesId * 1e9 + catIdx) → bar-record index in `_bars`. Built once
      * per pipeline run for area-strip lookups; rebuilt on hidden-toggle

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

@@ -4,4 +4,4 @@ export declare function handleSunburstHover(chart: SunburstChart, mx: number, my
 export declare function handleSunburstClick(chart: SunburstChart, mx: number, my: number): void;
 export declare function showSunburstPinnedTooltip(chart: SunburstChart, nodeId: number): void;
 export declare function dismissSunburstPinnedTooltip(chart: SunburstChart): void;
-export declare function buildSunburstTooltipLines(chart: SunburstChart, nodeId: number): Promise<string[]>;
+export { buildTreeTooltipLines as buildSunburstTooltipLines } from "../common/tree-interact";

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

@@ -4,9 +4,4 @@ export declare function handleTreemapClick(chart: TreemapChart, mx: number, my:
 export declare function handleTreemapDblClick(chart: TreemapChart, mx: number, my: number): void;
 export declare function showTreemapPinnedTooltip(chart: TreemapChart, nodeId: number): void;
 export declare function dismissTreemapPinnedTooltip(chart: TreemapChart): void;
-/**
- * Build the tooltip for `nodeId`. The node's own name path + aggregate
- * value are derived from the tree; per-row tooltip columns come from
- * the `leafRowIdx` → column-buffer lookup (no per-node `Map`).
- */
-export declare function buildTreemapTooltipLines(chart: TreemapChart, nodeId: number): Promise<string[]>;
+export { buildTreeTooltipLines as buildTreemapTooltipLines } from "../common/tree-interact";

package/dist/esm/interaction/host-sink-message.d.ts

@@ -1,36 +1,18 @@
+import type { DismissTooltipMsg, PinTooltipMsg, SetCursorMsg, UserClickMsg, UserSelectMsg } from "../transport/protocol";
 import type { CssBounds, HostSink, UserClickPayload, UserSelectPayload } from "./tooltip-controller";
 /**
- * Envelope shape sent by `MessageHostSink`. The transport translates
- * each one into a corresponding `WorkerMsg` (`pinTooltip` /
- * `dismissTooltip` / `setCursor` / `userClick` / `userSelect`).
+ * The subset of `WorkerMsg`s that flow chart → host through a
+ * `MessageHostSink`. Identical to the worker-side post payloads so the
+ * sink can ship them straight to `WorkerRenderer.post` with no
+ * intermediate translation.
  */
-export type HostSinkEnvelope = {
-    kind: "pin";
-    payload: {
-        lines: string[];
-        pos: {
-            px: number;
-            py: number;
-        };
-        bounds: CssBounds;
-    };
-} | {
-    kind: "dismiss";
-} | {
-    kind: "setCursor";
-    cursor: string;
-} | {
-    kind: "userClick";
-    payload: UserClickPayload;
-} | {
-    kind: "userSelect";
-    payload: UserSelectPayload;
-};
+export type HostSinkEnvelope = PinTooltipMsg | DismissTooltipMsg | SetCursorMsg | UserClickMsg | UserSelectMsg;
 /**
  * `HostSink` that posts pin / dismiss / setCursor / user-event intents
- * over a `postMessage`-style channel. The host-side transport listens
- * for these envelopes and drives a `DomHostSink` for pin/dismiss and
- * dispatches `CustomEvent`s on the viewer for user events.
+ * over a `postMessage`-style channel as `WorkerMsg`s. The host-side
+ * transport listens for these and drives a `DomHostSink` for
+ * pin/dismiss and dispatches `CustomEvent`s on the viewer for user
+ * events.
  */
 export declare class MessageHostSink implements HostSink {
     private _send;

package/dist/esm/interaction/raw-event-forwarder.d.ts

@@ -1,15 +1,14 @@
 import type { InteractionEvent } from "../transport/protocol";
 /**
- * Worker-mode counterpart to {@link ZoomRouter}. Captures wheel /
- * pointer events on the GL canvas, normalizes coords to canvas-relative
- * CSS pixels, and emits semantic {@link InteractionEvent}s to the
- * Renderer over its transport. The Renderer (running in a Web Worker)
- * owns the `ZoomController`s and runs the actual hit-test + apply
- * logic — see `applyWheel` / `applyPan` in `zoom-router.ts`.
+ * Captures wheel / pointer events on the GL canvas, normalizes coords
+ * to canvas-relative CSS pixels, and emits semantic
+ * {@link InteractionEvent}s to the Renderer over its transport. The
+ * Renderer owns the `ZoomController`s and runs the actual hit-test +
+ * apply logic — see `applyWheel` / `applyPan` in `zoom-router.ts`.
  *
  * Pointer capture is set on `pointerdown` and released on `pointerup`
  * so drags continue to deliver `pointermove` events when the cursor
- * leaves the canvas, matching the in-process `ZoomRouter` behavior.
+ * leaves the canvas.
  */
 export declare class RawEventForwarder {
     private _element;

package/dist/esm/interaction/zoom-controller.d.ts

@@ -37,6 +37,8 @@ export declare class ZoomController {
     private _baseYMax;
     private _lockAxis;
     private _lockAspect;
+    private _xPinned;
+    private _yPinned;
     private _element;
     private _layout;
     private _onUpdate;
@@ -59,30 +61,37 @@ export declare class ZoomController {
     get baseXRange(): number;
     get baseYRange(): number;
     /**
-     * Update the base (full-data) domain that this controller's
-     * normalized translate is interpreted against, while preserving
-     * the *absolute* center of any user-applied pan.
+     * Update the base (full-data) domain. Each axis is handled
+     * independently:
      *
-     * `_normTX` / `_normTY` are stored as fractions of the base
-     * range, not absolute coordinates. A naive "swap base, keep
-     * normTranslate" update reinterprets the same fraction against a
-     * new range, so when an external `draw()` updates the extent
-     * (via `processCartesianChunk` → `setZoomBaseDomain`) the user's
-     * pan-offset visible center jumps to a different absolute
-     * position. With concurrent pan events feeding in offsets that
-     * were computed against the old base, the jump can project the
-     * visible center past the data entirely, leaving `_fullRender`
-     * to draw zero glyphs onto a freshly-cleared canvas — a blank
-     * bitmap reaches the host as a flicker.
+     *  - If the axis is at default (no user pan or zoom on this axis),
+     *    just swap the new base in — no further math needed.
+     *  - If the axis has been explicitly *pinned* (`pinAxis("x" | "y")`),
+     *    preserve its *absolute* visible center across the swap:
+     *    re-solve `_normT` so the data-space center is unchanged.
+     *    This is paused-frame-review semantics — the user has marked a
+     *    region of interest and wants it to stay put even as new data
+     *    flows in. No current caller pins, but the API is here so the
+     *    default rule below doesn't bake the choice in.
+     *  - Otherwise (the default — "follow"): keep `_normT` as-is and
+     *    just swap the new base. The visible window's *fractional*
+     *    position is preserved, so sliding windows slide with the data
+     *    and extending windows grow proportionally with the data.
      *
-     * When the user is in default state (no pan, no zoom — fresh
-     * controller, or just-reset), no rebase is needed; just swap the
-     * base and let the chart auto-fit to the new data. Otherwise
-     * recompute `_normTX` / `_normTY` so the visible center stays at
-     * the same absolute (data-coordinate) position before and after
-     * the swap.
+     * Per-axis handling matters because `_scaleX/_normTX` and
+     * `_scaleY/_normTY` are independent. A user who panned X to scroll
+     * through time should not force Y onto the rebase path — Y data
+     * updates should still flow through cleanly.
      */
     setBaseDomain(xMin: number, xMax: number, yMin: number, yMax: number): void;
+    /**
+     * Mark an axis as "pinned" so subsequent `setBaseDomain` calls
+     * preserve its *absolute* visible center (paused-frame-review
+     * semantics). Default-cleared on construction; both axes follow
+     * data growth fractionally until explicitly pinned.
+     */
+    pinAxis(axis: "x" | "y"): void;
+    unpinAxis(axis: "x" | "y"): void;
     /**
      * Apply config. Called once by the chart during `setZoomController`.
      * Locking an axis snaps its `scale`/`translate` to identity so any
@@ -90,6 +99,8 @@ export declare class ZoomController {
      * pan events leave the locked axis alone.
      */
     configure(config: ZoomConfig): void;
+    isXDefault(): boolean;
+    isYDefault(): boolean;
     isDefault(): boolean;
     getVisibleDomain(): {
         xMin: number;