@perspective-dev/viewer-charts 4.3.0

package/dist/esm/data/split-groups.d.ts

@@ -0,0 +1,20 @@
+import type { ColumnDataMap } from "./view-reader";
+export interface SplitGroup {
+    /**
+     * Composite prefix (e.g., "East", "East|Enterprise" for multi-level).
+     */
+    prefix: string;
+    /**
+     * Map of base column name → full Arrow column name ("prefix|base").
+     */
+    colNames: Map<string, string>;
+}
+/**
+ * Group Arrow column names by their split prefix (everything before the
+ * last "|"). A split exists for a prefix only when every `requiredBases`
+ * entry has a non-empty column present for that prefix. `optionalBases`
+ * are included when present but do not gate group inclusion.
+ *
+ * Empty/falsy entries in either base list are skipped.
+ */
+export declare function buildSplitGroups(columns: ColumnDataMap, requiredBases: string[], optionalBases?: string[]): SplitGroup[];

package/dist/esm/data/view-reader.d.ts

@@ -0,0 +1,35 @@
+import type { View } from "@perspective-dev/client";
+export interface ColumnData {
+    type: "float32" | "float64" | "int32" | "string";
+    values?: Float32Array | Float64Array | Int32Array;
+    /**
+     * Dictionary key indices for string columns.
+     */
+    indices?: Int32Array;
+    /**
+     * Dictionary values for string columns.
+     */
+    dictionary?: string[];
+    /**
+     * Arrow validity bitfield (1 bit per row).
+     */
+    valid?: Uint8Array;
+}
+export type ColumnDataMap = Map<string, ColumnData>;
+export interface TypedArrayWindowOptions {
+    start_row?: number;
+    end_row?: number;
+    start_col?: number;
+    end_col?: number;
+    float32?: boolean;
+}
+/**
+ * Fetches all columns from a View using `with_typed_arrays` and
+ * builds a `ColumnDataMap`. The `values` typed arrays and `valid`
+ * bitmaps are zero-copy views into WASM memory and remain valid only
+ * for the duration of the `render` callback — if `render` returns a
+ * `Promise`, the underlying `with_typed_arrays` call awaits it before
+ * releasing the backing Arrow buffer. Callers must not retain any
+ * `ColumnData` reference past `render`'s resolution.
+ */
+export declare function viewToColumnDataMap(view: View, render: (data: ColumnDataMap) => void | Promise<void>, options?: TypedArrayWindowOptions): Promise<void>;

package/dist/esm/event-detail.d.ts

@@ -0,0 +1,28 @@
+import type { ViewConfig } from "@perspective-dev/client";
+/**
+ * Detail payload for the `perspective-click` CustomEvent dispatched on
+ * the `<perspective-viewer>` host when the user clicks a chart glyph.
+ * Shape matches the equivalent type in `@perspective-dev/viewer-datagrid`
+ * so consumers can listen to either plugin uniformly.
+ */
+export interface PerspectiveClickDetail {
+    /**
+     * Source-view row data — keys are column names, values are scalar
+     * cell values. Empty `{}` when the click hit a non-leaf aggregate
+     * (e.g. a treemap branch).
+     */
+    row: Record<string, unknown>;
+    /**
+     * Aggregate column(s) the click targeted. Single-entry for series /
+     * heatmap / tree charts; multi-entry would only appear for plugins
+     * that surface multiple measures per glyph (none today).
+     */
+    column_names: string[];
+    /**
+     * Pre-built `viewer.restore({ filter })` patch — concatenates the
+     * group_by and split_by pivot values at the click target as
+     * `[<col>, "==", <value>]` clauses.
+     */
+    config: Partial<ViewConfig>;
+}
+export { PerspectiveSelectDetail } from "@perspective-dev/viewer/src/ts/extensions.js";

package/dist/esm/index.d.ts

@@ -0,0 +1,3 @@
+export type { PerspectiveClickDetail } from "./event-detail";
+export { PerspectiveSelectDetail } from "./event-detail";
+export declare function register(...plugin_names: string[]): void;

package/dist/esm/interaction/hit-test.d.ts

@@ -0,0 +1,30 @@
+export interface HitBounds {
+    xMin: number;
+    xMax: number;
+    yMin: number;
+    yMax: number;
+}
+/**
+ * Wraps SpatialGrid with dirty-flag bookkeeping + the cell-size heuristic
+ * (~√n cells), so chart code no longer repeats the insertion loop scaffold.
+ * Callers drive the iteration through `rebuild` and the `visit` callback,
+ * which lets scatter (flat array) and line (series-indexed array) share
+ * the same code path.
+ */
+export declare class SpatialHitTester {
+    private _grid;
+    private _dirty;
+    markDirty(): void;
+    get isDirty(): boolean;
+    /**
+     * Rebuild the grid. `forEachPoint` is called once with an insert
+     * function; the caller drives iteration. Cleared when `pointCount`
+     * is zero.
+     */
+    rebuild(bounds: HitBounds, pointCount: number, forEachPoint: (insert: (idx: number, x: number, y: number) => void) => void): void;
+    /**
+     * Query the nearest point within `radiusPx` of (dataX, dataY).
+     */
+    query(dataX: number, dataY: number, radiusPx: number, pxPerDataX: number, pxPerDataY: number, xData: Float32Array | null, yData: Float32Array | null): number;
+    clear(): void;
+}

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

@@ -0,0 +1,19 @@
+import type { CssBounds, HostSink } from "./tooltip-controller";
+/**
+ * Host-side `HostSink` that materializes pinned tooltips as a `<div>`
+ * next to the GL canvas, and applies cursor changes to the canvas's
+ * own `style.cursor`. Host-only — depends on `document` /
+ * `getComputedStyle`.
+ */
+export declare class DomHostSink implements HostSink {
+    private _glCanvas;
+    private _parent;
+    private _div;
+    constructor(glCanvas: HTMLCanvasElement, parent: HTMLElement);
+    pin(lines: string[], pos: {
+        px: number;
+        py: number;
+    }, bounds: CssBounds): void;
+    dismiss(): void;
+    setCursor(cursor: string): void;
+}

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

@@ -0,0 +1,46 @@
+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`).
+ */
+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;
+};
+/**
+ * `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.
+ */
+export declare class MessageHostSink implements HostSink {
+    private _send;
+    constructor(send: (msg: HostSinkEnvelope) => void);
+    pin(lines: string[], pos: {
+        px: number;
+        py: number;
+    }, bounds: CssBounds): void;
+    dismiss(): void;
+    setCursor(cursor: string): void;
+    emitUserClick(payload: UserClickPayload): void;
+    emitUserSelect(payload: UserSelectPayload): void;
+}

package/dist/esm/interaction/lazy-tooltip.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Serial-checked async tooltip cache.
+ *
+ * Every chart family that paints tooltip text from a lazy row fetch
+ * needs the same dance: each hover (or pin) bumps a serial; the async
+ * line-build resolves later; if the user has moved on by then the
+ * resolved lines must be discarded so we don't paint stale text.
+ *
+ * Hit-test logic stays per-chart — that genuinely diverges (spatial
+ * grid for cartesian, walk-visible-nodes for treemap, angular for
+ * sunburst). The serial discipline is what was getting copy-pasted.
+ *
+ * `Target` is whatever identity the chart uses for hover/pin (flat
+ * slot index, node id, etc.); it's stored on `hoveredTarget` so the
+ * render path can tell whether cached `lines` belong to the currently
+ * hovered entity (some charts paint tooltip text only when both
+ * agree).
+ */
+export declare class LazyTooltip<Target> {
+    /**
+     * Cached lines for the latest committed hover, or `null`.
+     */
+    lines: string[] | null;
+    /**
+     * Identity of the entity `lines` describe. `null` when cleared.
+     */
+    hoveredTarget: Target | null;
+    private _hoverSerial;
+    private _pinSerial;
+    /**
+     * Begin a new hover. Call this only when the hovered entity has
+     * actually changed. Clears the cached lines, records the new
+     * target, bumps the hover serial, and returns the new value — pass
+     * it back to {@link commitHover} from your async resolver to gate
+     * the write.
+     */
+    beginHover(target: Target): number;
+    /**
+     * Commit a freshly-resolved line list for `serial`. Returns true
+     * when the write happened (caller should repaint), false when the
+     * serial was stale.
+     */
+    commitHover(serial: number, lines: string[]): boolean;
+    /**
+     * Clear hover state (mouse left, view changed, etc.).
+     */
+    clearHover(): void;
+    /**
+     * Begin a pin operation. Returns the serial; pass it to
+     * {@link isPinFresh} from your async resolver.
+     */
+    beginPin(): number;
+    /**
+     * True when `serial` still names the latest pin attempt.
+     */
+    isPinFresh(serial: number): boolean;
+    /**
+     * Bump the pin serial without starting a new pin (e.g. dismiss).
+     */
+    invalidatePin(): void;
+}

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

@@ -0,0 +1,27 @@
+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`.
+ *
+ * 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.
+ */
+export declare class RawEventForwarder {
+    private _element;
+    private _emit;
+    private _pointerId;
+    private _onWheel;
+    private _onPointerDown;
+    private _onPointerMove;
+    private _onPointerUp;
+    private _onPointerLeave;
+    private _onClick;
+    private _onDblClick;
+    attach(element: HTMLElement, emit: (e: InteractionEvent) => void): void;
+    detach(): void;
+}

package/dist/esm/interaction/spatial-grid.d.ts

@@ -0,0 +1,15 @@
+export declare class SpatialGrid {
+    private _cells;
+    private _xMin;
+    private _yMin;
+    private _cellSize;
+    private _cols;
+    constructor(xMin: number, xMax: number, yMin: number, yMax: number, cellSize: number);
+    private _cellKey;
+    insert(index: number, x: number, y: number): void;
+    /**
+     * Find the nearest point to (dataX, dataY) within the given radius,
+     * measured in pixel distance using the provided scale factors.
+     */
+    query(dataX: number, dataY: number, radiusPx: number, pxPerDataX: number, pxPerDataY: number, xData: Float32Array, yData: Float32Array): number;
+}

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

@@ -0,0 +1,193 @@
+import type { Canvas2D } from "../charts/canvas-types";
+import type { PlotLayout } from "../layout/plot-layout";
+import type { Theme } from "../theme/theme";
+/**
+ * Minimal positioning input — PlotLayout satisfies this.
+ */
+export interface CssBounds {
+    cssWidth: number;
+    cssHeight: number;
+}
+export interface TooltipCallbacks {
+    /**
+     * RAF-throttled mouse position in CSS pixels, relative to the GL
+     * canvas (host already subtracted `getBoundingClientRect`).
+     */
+    onHover(mx: number, my: number): void;
+    /**
+     * Fires on mouseleave; skipped while a pinned tooltip is active.
+     */
+    onLeave(): void;
+    /**
+     * Fires on click with mouse position. Return true to consume the click
+     * (skipping the default pin/dismiss flow — used for legend clicks).
+     */
+    onClickPre?(mx: number, my: number): boolean;
+    /**
+     * Fires when a click should pin the current hover target.
+     */
+    onPin?(mx: number, my: number): void;
+    /**
+     * Fires on dblclick (treemap drill-up gesture). Optional — charts
+     * that don't bind a handler simply ignore the event.
+     */
+    onDblClick?(mx: number, my: number): void;
+    /**
+     * Fires when an active pin is dismissed by a click on the
+     * already-pinned target (the "click again to unpin" gesture in
+     * `dispatchClick`). Chart impls hook this to emit a
+     * `perspective-global-filter` with `selected: false`. Does *not*
+     * fire on the implicit dismiss inside `pin()` that replaces an
+     * existing pin — that path is followed by a fresh `onPin` which
+     * emits its own `selected: true`.
+     */
+    onUnpin?(): void;
+}
+export interface RenderTooltipOptions {
+    /**
+     * Draw a dashed crosshair at `pos`. Used by scatter/line.
+     */
+    crosshair?: boolean;
+    /**
+     * Draw a ring of `radius` CSS pixels at `pos`. Used to highlight a
+     * hovered point. Omit for bars (where the bar itself highlights).
+     */
+    highlightRadius?: number;
+}
+/**
+ * Side-channel from the chart back to the host's DOM. The chart calls
+ * into a sink rather than touching the DOM itself; the host
+ * materializes the actual visual (`<div>` for pinned tooltip, cursor
+ * mutation on the GL canvas).
+ *
+ *   - `MessageHostSink` (in worker/) — forwards calls over a
+ *                              `postMessage`-shaped channel back to
+ *                              the host.
+ *   - `DomHostSink` (in host transport) — receives the matching
+ *                              envelopes and applies them to the DOM.
+ *
+ * The controller's `_pinned` flag is the source of truth for whether
+ * hover updates are gated; the sink only owns the visual artifact.
+ */
+export interface HostSink {
+    pin(lines: string[], pos: {
+        px: number;
+        py: number;
+    }, bounds: CssBounds): void;
+    dismiss(): void;
+    setCursor(cursor: string): void;
+    /**
+     * Forward a `perspective-click` to the host. Optional — only the
+     * worker-bound `MessageHostSink` implements it; `DomHostSink` (the
+     * host-side consumer of pin/dismiss) never sees user-event calls,
+     * so omits the implementation.
+     */
+    emitUserClick?(detail: UserClickPayload): void;
+    /**
+     * Forward a `perspective-global-filter` to the host with the
+     * `selected: true` / `selected: false` semantics. The host owns the
+     * `removeConfigs` history (mirrors datagrid's
+     * `model._last_insert_configs`); the sink only ships the new state.
+     */
+    emitUserSelect?(payload: UserSelectPayload): void;
+}
+/**
+ * Plain-object payload for `HostSink.emitUserClick`. Matches
+ * `PerspectiveClickDetail` byte-for-byte; defined locally to avoid a
+ * cycle through `event-detail.ts`.
+ */
+export interface UserClickPayload {
+    row: Record<string, unknown>;
+    column_names: string[];
+    config: {
+        filter?: unknown[];
+    };
+}
+/**
+ * Plain-object payload for `HostSink.emitUserSelect`. The host
+ * transport reconstructs a `PerspectiveSelectDetail` class instance
+ * from this plus its cached `_lastInsertConfig`.
+ */
+export interface UserSelectPayload {
+    selected: boolean;
+    row: Record<string, unknown>;
+    column_names: string[];
+    insertConfig: {
+        filter?: unknown[];
+    };
+}
+/**
+ * Owns the hover/click/dblclick state machine and the pinned-tooltip
+ * lifecycle. The renderer drives this purely through
+ * `dispatchHover` / `dispatchLeave` / `dispatchClick` /
+ * `dispatchDblClick` — the host's `RawEventForwarder` captures DOM
+ * events on the GL canvas and posts them as `InteractionEvent`s.
+ *
+ * Pinning + cursor changes go through a {@link HostSink} so the actual
+ * DOM mutations happen host-side regardless of where the chart runs.
+ */
+export declare class TooltipController {
+    private _callbacks;
+    private _hoverRAFId;
+    private _hoverTimeoutId;
+    private _host;
+    private _pinned;
+    get isPinned(): boolean;
+    /**
+     * Replace the active host sink. Dismisses any existing pin via the
+     * prior sink so we never leak a pinned artifact across resets —
+     * though in practice each chart instance uses one sink for its
+     * lifetime.
+     */
+    setHost(sink: HostSink): void;
+    /**
+     * Forward a cursor change to the host. No-op when no host sink is
+     * installed (chart constructed without a transport).
+     */
+    setCursor(cursor: string): void;
+    /**
+     * Install the chart's tooltip callbacks. The renderer drives the
+     * controller via `dispatchHover` / `dispatchLeave` /
+     * `dispatchClick` / `dispatchDblClick`; this controller never
+     * touches the DOM directly.
+     */
+    attach(callbacks: TooltipCallbacks): void;
+    detach(): void;
+    /**
+     * Schedule an `onHover` callback for the given canvas-relative
+     * coords. Coalesces multiple calls within one animation frame so
+     * pointer streams don't backlog the chart's hit-test path.
+     *
+     * Workers ship with `requestAnimationFrame` (DedicatedWorkerGlobalScope
+     * exposes it for OffscreenCanvas painting), so the same coalescer
+     * works in both modes. We fall back to setTimeout if RAF is missing
+     * (e.g. node tests without a polyfill).
+     */
+    dispatchHover(mx: number, my: number): void;
+    dispatchLeave(): void;
+    dispatchClick(mx: number, my: number): void;
+    dispatchDblClick(mx: number, my: number): void;
+    /**
+     * Pin a tooltip (or replace an active one). Forwards through the
+     * configured sink and flips the controller's pinned flag so hover
+     * dispatch is suppressed until dismissal.
+     */
+    pin(lines: string[], pos: {
+        px: number;
+        py: number;
+    }, bounds: CssBounds): void;
+    dismiss(): void;
+}
+/**
+ * Paint a canvas tooltip (crosshair, highlight ring, box + text) onto
+ * `canvas`. The helper normalizes the 2D context to a DPR-scaled
+ * identity transform on entry and restores prior state on exit, so it
+ * composes cleanly with other chrome painters that may have already
+ * called `initCanvas` on the same canvas — re-applying `scale(dpr,dpr)`
+ * blind would double-scale in that case, misplacing the tooltip
+ * proportionally to its distance from the origin.
+ */
+export declare function renderCanvasTooltip(canvas: Canvas2D | null, pos: {
+    px: number;
+    py: number;
+}, lines: string[], layout: PlotLayout, theme: Theme, dpr: number, options?: RenderTooltipOptions): void;

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

@@ -0,0 +1,106 @@
+import type { PlotLayout } from "../layout/plot-layout";
+export interface ZoomState {
+    scaleX: number;
+    scaleY: number;
+    normTranslateX: number;
+    normTranslateY: number;
+}
+/**
+ * Runtime config for `ZoomController`. Not part of `ZoomState` — wired
+ * by the owning chart at construction, not serialized with zoom level.
+ *
+ * `lockAxis` pins one axis at `scale=1, translate=0` and suppresses
+ * wheel / pan updates on that axis, leaving the other axis fully
+ * zoomable. Categorical axes are the typical candidates.
+ *
+ * `lockAspect` keeps `dataPerPixel` equal on both axes by padding the
+ * narrower axis of the rendered domain to match the plot rect's aspect
+ * ratio. Required by map plugins (Mercator preserves local angle, so
+ * map glyphs distort under independent X/Y zoom), and useful for any
+ * cartesian view where stretching points along one axis would lie
+ * about the data.
+ */
+export interface ZoomConfig {
+    lockAxis?: "x" | "y" | null;
+    lockAspect?: boolean;
+}
+export declare const MAX_ZOOM = 100000;
+export declare const MIN_ZOOM = 1;
+export declare class ZoomController {
+    private _scaleX;
+    private _scaleY;
+    private _normTX;
+    private _normTY;
+    private _baseXMin;
+    private _baseXMax;
+    private _baseYMin;
+    private _baseYMax;
+    private _lockAxis;
+    private _lockAspect;
+    private _element;
+    private _layout;
+    private _onUpdate;
+    private _pointerDown;
+    private _lastPointerX;
+    private _lastPointerY;
+    private _onWheel;
+    private _onPointerDown;
+    private _onPointerMove;
+    private _onPointerUp;
+    get lockedAxis(): "x" | "y" | null;
+    get scaleX(): number;
+    get scaleY(): number;
+    set scaleX(v: number);
+    set scaleY(v: number);
+    get normTranslateX(): number;
+    get normTranslateY(): number;
+    set normTranslateX(v: number);
+    set normTranslateY(v: number);
+    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.
+     *
+     * `_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.
+     *
+     * 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.
+     */
+    setBaseDomain(xMin: number, xMax: number, yMin: number, yMax: number): void;
+    /**
+     * Apply config. Called once by the chart during `setZoomController`.
+     * Locking an axis snaps its `scale`/`translate` to identity so any
+     * pre-existing state on that axis is cleared; subsequent wheel /
+     * pan events leave the locked axis alone.
+     */
+    configure(config: ZoomConfig): void;
+    isDefault(): boolean;
+    getVisibleDomain(): {
+        xMin: number;
+        xMax: number;
+        yMin: number;
+        yMax: number;
+    };
+    attach(element: HTMLElement, layout: PlotLayout, onUpdate: () => void): void;
+    updateLayout(layout: PlotLayout): void;
+    detach(): void;
+    reset(): void;
+    serialize(): ZoomState;
+    restore(state: ZoomState): void;
+}

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

@@ -0,0 +1,48 @@
+import type { PlotLayout } from "../layout/plot-layout";
+import { type ZoomController } from "./zoom-controller";
+/**
+ * Resolver that maps a cursor position to `{ controller, layout }` —
+ * returns `null` when the cursor is not inside any facet. In
+ * independent-zoom mode the facet under the cursor owns its events; in
+ * shared-zoom mode the resolver always returns the same controller for
+ * every plot rect in the grid.
+ */
+export interface ZoomTarget {
+    controller: ZoomController;
+    layout: PlotLayout;
+}
+export type ZoomTargetResolver = (mx: number, my: number) => ZoomTarget | null;
+/**
+ * One set of wheel / pointer listeners on the GL canvas that dispatches
+ * zoom + pan events to a {@link ZoomController} resolved from the
+ * cursor position. Replaces `ZoomController.attach` so multiple
+ * controllers (one per facet) can coexist on a single canvas.
+ */
+export declare class ZoomRouter {
+    private _element;
+    private _resolve;
+    private _onUpdate;
+    private _pointerDown;
+    private _pointerTarget;
+    private _lastPointerX;
+    private _lastPointerY;
+    private _onWheel;
+    private _onPointerDown;
+    private _onPointerMove;
+    private _onPointerUp;
+    attach(element: HTMLElement, resolve: ZoomTargetResolver, onUpdate: () => void): void;
+    detach(): void;
+}
+/**
+ * Apply a wheel-zoom delta to the resolved target. Exported for
+ * re-use inside the worker, where the renderer dispatches interaction
+ * events forwarded from the host's `RawEventForwarder` instead of
+ * receiving DOM events directly.
+ */
+export declare function applyWheel(target: ZoomTarget, mouseX: number, mouseY: number, deltaY: number): void;
+/**
+ * Apply a drag-pan delta to the resolved target. Exported for the
+ * same reason as {@link applyWheel}: worker-mode interaction
+ * dispatch reuses the math without owning DOM listeners.
+ */
+export declare function applyPan(target: ZoomTarget, dx: number, dy: number): void;