@perspective-dev/viewer-charts 4.3.0

package/dist/esm/webgl/buffer-pool.d.ts

@@ -0,0 +1,62 @@
+type GL = WebGL2RenderingContext | WebGLRenderingContext;
+export interface ManagedBuffer {
+    buffer: WebGLBuffer;
+    byteCapacity: number;
+}
+export declare class BufferPool {
+    private _gl;
+    private _buffers;
+    private _totalCapacity;
+    private _maxCapacity;
+    constructor(gl: GL);
+    get totalCapacity(): number;
+    get maxCapacity(): number;
+    set maxCapacity(cap: number);
+    ensureCapacity(totalRows: number): void;
+    /**
+     * Read-only lookup by name. Returns the existing managed buffer, or
+     * `undefined` if no buffer has been allocated under that name yet.
+     *
+     * Render-path callers that bind buffers for `drawArrays` /
+     * `drawArraysInstanced` MUST use this rather than `getOrCreate`:
+     * the latter recreates (zero-initialized) when `_totalCapacity` has
+     * grown past the current `byteCapacity`. That recreate is desired
+     * during `upload` (where `bufferSubData` immediately writes the
+     * actual data) but catastrophic during render — it wipes the
+     * previous draw's vertex data, leaving `drawArrays` to issue
+     * against zeros and produce no visible glyphs (a one-frame blank
+     * plot area while gridlines/chrome remain correct).
+     *
+     * Specifically, `ensureBufferCapacity(totalRows)` from a pending
+     * draw updates `_totalCapacity` *before* its matching `uploadChunk`
+     * has run; a pan/zoom-induced render landing in that window would
+     * otherwise see `requiredBytes > byteCapacity` and recreate.
+     */
+    peek(name: string): ManagedBuffer | undefined;
+    getOrCreate(name: string, componentsPerVertex: number, bytesPerElement: number): ManagedBuffer;
+    /**
+     * Upload `data` into the named GPU buffer at `byteOffset`. The
+     * buffer is sized lazily by `getOrCreate` to
+     * `_totalCapacity × componentsPerVertex × data.BYTES_PER_ELEMENT`.
+     * Callers MUST keep `byteOffset + data.byteLength` within that
+     * capacity — `bufferSubData` raises `INVALID_VALUE` on overflow
+     * and the upload is silently dropped at the GL layer.
+     *
+     * Common pitfall: passing a module-level scratch typed array whose
+     * `length` exceeds the current frame's valid-data count. Scratch
+     * buffers in chart impls grow monotonically across frames; the
+     * GPU buffer is sized to the *current* `_totalCapacity`. After a
+     * renderer-session reset (e.g. plugin disconnect/reconnect) the
+     * GPU buffer is fresh while the scratch retains its historical-
+     * peak length, and the upload writes past the buffer end. Always
+     * pass `data.subarray(0, n × componentsPerVertex)` when uploading
+     * from a scratch.
+     *
+     * Set `BUFFER_POOL_STRICT = true` in `config.ts` to convert
+     * overflows from opaque GL errors into descriptive throws at the
+     * offending stack frame.
+     */
+    upload(name: string, data: Float32Array | Int32Array, byteOffset: number, componentsPerVertex?: number): WebGLBuffer;
+    releaseAll(): void;
+}
+export {};

package/dist/esm/webgl/context-manager.d.ts

@@ -0,0 +1,184 @@
+import { ShaderRegistry } from "./shader-registry";
+import { BufferPool } from "./buffer-pool";
+export type WebGLCanvas = HTMLCanvasElement | OffscreenCanvas;
+export interface WebGLContextManagerOptions {
+    /**
+     * If `true`, compile + link every shader in `SHADER_MANIFEST`
+     * during construction (and again after a context-loss/restore
+     * cycle). Trades ~30-100ms of init time for elimination of the
+     * compile/link cost on the first-frame path of every chart type
+     * that ends up rendered. Default `false` keeps the original
+     * lazy-compile behavior — programs are compiled on first
+     * `getOrCreate(name, ...)` call from a glyph's render path.
+     */
+    precompile?: boolean;
+}
+export declare class WebGLContextManager {
+    private _canvas;
+    private _gl;
+    private _isWebGL2;
+    private _shaders;
+    private _buffers;
+    private _uploadedCount;
+    private _cssWidth;
+    private _cssHeight;
+    private _dpr;
+    private _precompile;
+    private _frameCallback;
+    /**
+     * Per-instance `MessageChannel` used by `_yieldToTask` to resume a
+     * polling `awaitGpuFence` loop on the next task. Allocated lazily —
+     * the polling path is rarely hit when the GPU is idle, and many
+     * `WebGLContextManager` instances never need one.
+     *
+     * Must be per-instance: a module-level singleton races when two
+     * managers poll concurrently. Both call sites assign
+     * `port1.onmessage = resolve`, the second assignment overwrites the
+     * first, and the first poll's promise never settles — leaving its
+     * `awaitGpuFence` hung. The hang propagates up through the render
+     * scheduler's `present` → `uploadAndRender` → the worker's
+     * `uploadChunkAck` → the host's `with_typed_arrays` callback,
+     * stalling `draw()` indefinitely. (Now that fence waits across
+     * different `WebGLContextManager`s run in parallel inside one
+     * scheduler drain, the per-instance discipline matters even
+     * more — concurrent poll loops are the common case, not the
+     * exception.)
+     *
+     * Cost of per-instance allocation: one extra `MessageChannel` (two
+     * `MessagePort`s, ~negligible bytes, zero idle CPU) per chart on
+     * top of the per-chart proxy channel that the transport already
+     * holds. Bounded by chart count; safe even for pathological pages
+     * with hundreds of charts. The alternative — allocating a fresh
+     * channel on every `_yieldToTask` call — would churn ports on every
+     * fence poll (potentially many per frame on slow GPUs), which is
+     * far worse for the structured-clone subsystem than holding one
+     * port pair for the manager's lifetime.
+     */
+    private _yieldChannel;
+    constructor(canvas: WebGLCanvas, options?: WebGLContextManagerOptions);
+    get gl(): WebGL2RenderingContext | WebGLRenderingContext;
+    get isWebGL2(): boolean;
+    get shaders(): ShaderRegistry;
+    get bufferPool(): BufferPool;
+    get uploadedCount(): number;
+    set uploadedCount(count: number);
+    /**
+     * Resize the GL canvas's bitmap to match the host's CSS layout. The
+     * Host is responsible for measuring the DOM element (or otherwise
+     * deciding the target CSS size) and the device pixel ratio — the
+     * manager itself does not touch DOM, so the same code path works
+     * whether the canvas is an `HTMLCanvasElement` (in-process) or an
+     * `OffscreenCanvas` (in-process via transfer, or in a worker).
+     */
+    resize(cssWidth: number, cssHeight: number, dpr: number): void;
+    /**
+     * Pending dimensions to apply at the start of the next render.
+     * `null` when no resize is queued. See {@link requestResize} /
+     * {@link applyPendingResize}.
+     */
+    private _pendingResize;
+    /**
+     * Record a dimension change to be applied at the start of the
+     * next render's Phase 1, *before* `_fullRender` runs. The actual
+     * `canvas.width = N` assignment (which clears the drawing buffer
+     * per the WebGL spec) happens inside `applyPendingResize()`,
+     * paired in the same synchronous task as the paint that fills
+     * the new buffer.
+     *
+     * Why split the dimension change off from the existing
+     * {@link resize} method: in direct / in-process modes the
+     * GL canvas IS the host's visible canvas, and `canvas.width = N`
+     * is immediately observable to the browser's compositor as a
+     * cleared buffer. If the resize lands in the message handler
+     * (one task) but the matching `_fullRender` lands in the next
+     * RAF (a later task), the compositor cycles between them and
+     * presents one full frame of empty canvas — visible flicker.
+     * Deferring the dimension change to the same RAF as the paint
+     * eliminates the inter-frame gap; both happen inside Phase 1's
+     * un-yielded loop.
+     *
+     * Multiple `requestResize` calls before the next render coalesce
+     * to last-write-wins — five rapid width changes from a window
+     * drag produce one resize+paint, not five.
+     */
+    requestResize(cssWidth: number, cssHeight: number, dpr: number): void;
+    /**
+     * Apply any pending dimension change recorded by
+     * {@link requestResize}. Called by the scheduler's Phase 1
+     * (immediately before each entry's `fullRender`) and by the
+     * `snapshotPng` bypass path. Returns `true` when a resize was
+     * applied, `false` when there was nothing pending — useful for
+     * callers that want to skip a no-op render.
+     */
+    applyPendingResize(): boolean;
+    /**
+     * Last CSS width passed to `resize()`.
+     */
+    get cssWidth(): number;
+    /**
+     * Last CSS height passed to `resize()`.
+     */
+    get cssHeight(): number;
+    /**
+     * Last device pixel ratio passed to `resize()`.
+     */
+    get dpr(): number;
+    clear(): void;
+    /**
+     * Register a per-frame hook invoked at the end of each render. In
+     * blit-mode rendering, the worker installs a callback that
+     * transfers an `ImageBitmap` from `_canvas` (an `OffscreenCanvas`)
+     * back to the host so the visible display canvas can `drawImage`
+     * it. In direct mode the callback is left null and `endFrame` is a
+     * no-op.
+     *
+     * Pass `null` to detach.
+     */
+    setFrameCallback(cb: ((bitmap: ImageBitmap) => void) | null): void;
+    /**
+     * Called by chart impls at the bottom of `_fullRender` (and any
+     * other path that produces a complete frame). When a frame
+     * callback is registered AND the GL surface is an
+     * `OffscreenCanvas`, ship its current contents as an
+     * `ImageBitmap` to the host. Otherwise no-op — direct-mode
+     * rendering has nothing to ship; the visible canvas already holds
+     * the drawing buffer.
+     */
+    endFrame(): void;
+    /**
+     * Resolve when every GL command submitted up to this call has been
+     * executed by the GPU.
+     *
+     * On WebGL2 this issues a `fenceSync(SYNC_GPU_COMMANDS_COMPLETE)`
+     * and polls `clientWaitSync` with a zero timeout, yielding to the
+     * task queue between polls. The first poll passes
+     * `SYNC_FLUSH_COMMANDS_BIT` so the fence becomes reachable without
+     * a separate `gl.flush()`.
+     *
+     * On WebGL1 there is no fenceSync; we fall back to the blocking
+     * `gl.finish()`. This is acceptable in a worker — never call this
+     * from the main thread on a heavy frame.
+     *
+     * Used as a per-frame "GPU is idle" barrier so callers can serialize
+     * follow-on work (`endFrame` snapshot, present roundtrip, the next
+     * chunk upload) against actual GPU completion instead of the
+     * implicit, implementation-defined timing of `transferToImageBitmap`.
+     */
+    awaitGpuFence(): Promise<void>;
+    ensureBufferCapacity(totalRows: number): void;
+    /**
+     * Yield to the task queue between fence polls. We avoid
+     * `setTimeout(0)` because Chromium clamps nested `setTimeout` to
+     * ~4ms in workers, which would inflate the measured cost of
+     * `awaitGpuFence`. A reused per-instance `MessageChannel` lands the
+     * resume in the next task with sub-ms latency.
+     *
+     * `addEventListener(..., { once: true })` is used over
+     * `port1.onmessage = ...` so concurrent in-flight resumes (should
+     * any path ever introduce them) cannot clobber each other's
+     * resolvers — the previous module-level singleton lost a resolver
+     * on every overlap and hung one chart's `draw()` indefinitely.
+     */
+    private _yieldToTask;
+    destroy(): void;
+}

package/dist/esm/webgl/gradient-texture.d.ts

@@ -0,0 +1,17 @@
+import { type GradientStop } from "../theme/gradient";
+import type { WebGLContextManager } from "./context-manager";
+export interface GradientTextureCache {
+    texture: WebGLTexture;
+    lastStops: GradientStop[] | null;
+}
+/**
+ * Allocate a 256×1 RGBA8 texture (once) and re-upload the LUT only when
+ * `stops` has changed since the last call. Typical render path: zero
+ * GPU work beyond binding an already-uploaded texture.
+ */
+export declare function ensureGradientTexture(glManager: WebGLContextManager, cache: GradientTextureCache | null, stops: GradientStop[]): GradientTextureCache;
+/**
+ * Bind `texture` to a texture unit and set the sampler uniform. Call after
+ * `useProgram`.
+ */
+export declare function bindGradientTexture(glManager: WebGLContextManager, texture: WebGLTexture, samplerLoc: WebGLUniformLocation | null, unit?: number): void;

package/dist/esm/webgl/instanced-attrs.d.ts

@@ -0,0 +1,44 @@
+import type { WebGLContextManager } from "./context-manager";
+type GL = WebGL2RenderingContext | WebGLRenderingContext;
+export interface Instancing {
+    setDivisor(location: number, divisor: number): void;
+    drawArraysInstanced(mode: number, first: number, count: number, instances: number): void;
+}
+/**
+ * Return an Instancing helper for the given GL context. On WebGL2, native
+ * `vertexAttribDivisor`/`drawArraysInstanced` are used; on WebGL1 the
+ * ANGLE_instanced_arrays extension is looked up and cached by caller.
+ * Negative attribute locations (optimized-out attributes) are tolerated by
+ * `setDivisor` and ignored.
+ */
+export declare function getInstancing(glManager: WebGLContextManager): Instancing;
+/**
+ * Allocate the static `[0, 1, 2, 3]` line-strip corner buffer used by
+ * every instanced line/wick glyph: each corner index is multiplied by
+ * `LINE_WIDTH_PX` in the shader to expand a 2-vertex segment into a
+ * `TRIANGLE_STRIP` quad. Identical contents across all callers; one
+ * helper avoids the four-way `createBuffer` / `bufferData` boilerplate.
+ */
+export declare function createLineCornerBuffer(gl: GL): WebGLBuffer;
+/**
+ * Allocate the static `[(0,0), (1,0), (0,1), (1,1)]` quad-strip corner
+ * buffer used by instanced rect glyphs (candlestick body). Used as a
+ * `vec2 a_corner` attribute that the shader scales by per-instance
+ * width/height to expand into a `TRIANGLE_STRIP` rect.
+ */
+export declare function createQuadCornerBuffer(gl: GL): WebGLBuffer;
+/**
+ * Bind a per-instance float attribute from a named buffer in the buffer
+ * pool. Returns `true` when the bind happened, `false` when the buffer
+ * has not yet been allocated (caller should skip the draw rather than
+ * paint zero data). No-op return `true` when `attr` is negative
+ * (optimized-out attribute — drawing the rest is still valid).
+ *
+ * Render-path uses `peek`, never `getOrCreate`: the latter recreates
+ * with zero-initialized contents when `_totalCapacity` has grown past
+ * the current buffer, which would wipe the previous draw's vertex
+ * data and leave `drawArraysInstanced` to render zeros. See
+ * {@link BufferPool#peek} for the full rationale.
+ */
+export declare function bindInstancedFloatAttr(glManager: WebGLContextManager, instancing: Instancing, attr: number, name: string, components: number): boolean;
+export {};

package/dist/esm/webgl/plot-frame.d.ts

@@ -0,0 +1,39 @@
+import type { PlotLayout } from "../layout/plot-layout";
+type GL = WebGL2RenderingContext | WebGLRenderingContext;
+/**
+ * Return CSS-pixel dimensions of the GL canvas.
+ */
+export declare function cssSize(gl: GL, dpr: number): {
+    cssWidth: number;
+    cssHeight: number;
+};
+/**
+ * Clear the framebuffer + enable alpha blending. Call once per frame,
+ * before any per-plot-rect {@link withScissor} invocations. Faceted
+ * renderers call this once and then loop {@link withScissor} per cell
+ * so the inter-facet clears don't wipe each other's pixels.
+ */
+export declare function clearAndSetupFrame(gl: GL): void;
+/**
+ * Scissor-constrain `draw` to `layout.plotRect`. Caller handles
+ * projection / uniforms / VBO bindings inside `draw`; this helper only
+ * manages the scissor enable/disable bracket.
+ *
+ * Unlike {@link renderInPlotFrame}, this does *not* clear the
+ * framebuffer — so it's safe to call repeatedly per frame (one per
+ * facet). Pair with {@link clearAndSetupFrame} at the start of each
+ * frame.
+ */
+export declare function withScissor(gl: GL, layout: PlotLayout, dpr: number, draw: () => void): void;
+/**
+ * One-shot convenience: clear + setup blend + scissor + draw. Used by
+ * single-plot callers (bar / heatmap / candlestick / scatter-without-
+ * splits) that only draw into one plot rect per frame.
+ *
+ * Faceted callers must use {@link clearAndSetupFrame} +
+ * {@link withScissor} instead; calling this helper in a per-facet loop
+ * would clear the framebuffer on each invocation and wipe out every
+ * previously-drawn facet.
+ */
+export declare function renderInPlotFrame(gl: GL, layout: PlotLayout, dpr: number, draw: () => void): void;
+export {};

package/dist/esm/webgl/program-cache.d.ts

@@ -0,0 +1,13 @@
+import type { WebGLContextManager } from "./context-manager";
+/**
+ * Compile (or fetch from the shader registry) a program and resolve a
+ * flat record of uniform + attribute locations keyed by name. Uniforms
+ * resolve to `WebGLUniformLocation | null`; attribs resolve to `number`.
+ *
+ * Each glyph drawer used to repeat ~10 lines of `gl.getUniformLocation`
+ * / `gl.getAttribLocation` calls — replacing those with one
+ * `compileProgram(...)` call shrinks the worker bundle by ~80 bytes per
+ * site (uniform/attrib name strings still ship — WebGL needs them
+ * verbatim — but the per-call wrapper goes away).
+ */
+export declare function compileProgram<C>(glManager: WebGLContextManager, key: string, vert: string, frag: string, uniforms: readonly string[], attrs: readonly string[]): C;

package/dist/esm/webgl/shader-manifest.d.ts

@@ -0,0 +1,53 @@
+import barVert from "../shaders/bar.vert.glsl";
+import barFrag from "../shaders/bar.frag.glsl";
+import lineVert from "../shaders/line.vert.glsl";
+import lineFrag from "../shaders/line.frag.glsl";
+import scatterVert from "../shaders/scatter.vert.glsl";
+import scatterFrag from "../shaders/scatter.frag.glsl";
+import areaVert from "../shaders/area.vert.glsl";
+import areaFrag from "../shaders/area.frag.glsl";
+import lineUniformVert from "../shaders/line-uniform.vert.glsl";
+import lineUniformFrag from "../shaders/line-uniform.frag.glsl";
+import yScatterVert from "../shaders/y-scatter.vert.glsl";
+import yScatterFrag from "../shaders/y-scatter.frag.glsl";
+import candlestickBodyVert from "../shaders/candlestick-body.vert.glsl";
+import candlestickBodyFrag from "../shaders/candlestick-body.frag.glsl";
+import heatmapVert from "../shaders/heatmap.vert.glsl";
+import heatmapFrag from "../shaders/heatmap.frag.glsl";
+import sunburstArcVert from "../shaders/sunburst-arc.vert.glsl";
+import sunburstArcFrag from "../shaders/sunburst-arc.frag.glsl";
+import treemapVert from "../shaders/treemap.vert.glsl";
+import treemapFrag from "../shaders/treemap.frag.glsl";
+import densitySplatVert from "../shaders/density-splat.vert.glsl";
+import densitySplatFrag from "../shaders/density-splat.frag.glsl";
+import densityExtremeFrag from "../shaders/density-extreme.frag.glsl";
+import densityMrtVert from "../shaders/density-mrt.vert.glsl";
+import densityMrtFrag from "../shaders/density-mrt.frag.glsl";
+import densityResolveVert from "../shaders/density-resolve.vert.glsl";
+import densityResolveFrag from "../shaders/density-resolve.frag.glsl";
+import tileVert from "../shaders/tile.vert.glsl";
+import tileFrag from "../shaders/tile.frag.glsl";
+/**
+ * One shader program in the build's static manifest. The `name` is the
+ * cache key consumed by `ShaderRegistry.getOrCreate(name, ...)` —
+ * call sites must pass the same name (and the same vert/frag source)
+ * for the cache to hit. The single source of truth for both fields is
+ * this file; glyph code re-imports from here so the manifest and the
+ * call sites can never drift.
+ */
+export interface ShaderSpec {
+    name: string;
+    vert: string;
+    frag: string;
+}
+/**
+ * Every WebGL program the build ships, keyed by cache name. Used by
+ * `ShaderRegistry.precompile(SHADER_MANIFEST)` to compile + link all
+ * programs eagerly during renderer construction so the first-frame
+ * path doesn't pay the compile cost inline.
+ *
+ * Names mirror the existing `getOrCreate` keys at each call site —
+ * the lazy path stays valid; precompile just primes the cache early.
+ */
+export declare const SHADER_MANIFEST: readonly ShaderSpec[];
+export { barVert, barFrag, lineVert, lineFrag, scatterVert, scatterFrag, areaVert, areaFrag, lineUniformVert, lineUniformFrag, yScatterVert, yScatterFrag, candlestickBodyVert, candlestickBodyFrag, heatmapVert, heatmapFrag, sunburstArcVert, sunburstArcFrag, treemapVert, treemapFrag, densitySplatVert, densitySplatFrag, densityExtremeFrag, densityMrtVert, densityMrtFrag, densityResolveVert, densityResolveFrag, tileVert, tileFrag, };

package/dist/esm/webgl/shader-registry.d.ts

@@ -0,0 +1,22 @@
+import type { ShaderSpec } from "./shader-manifest";
+type GL = WebGL2RenderingContext | WebGLRenderingContext;
+export declare class ShaderRegistry {
+    private _gl;
+    private _programs;
+    constructor(gl: GL);
+    /**
+     * Compile + link every program in `specs` eagerly. Used by
+     * `WebGLContextManager` when constructed with `precompile: true`
+     * so the first-frame path doesn't pay the compile cost inline.
+     *
+     * Compilation is synchronous and serial — single-digit ms per
+     * program on a modern GPU. With `KHR_parallel_shader_compile`
+     * (browser-supported but not yet wired here) the work could be
+     * dispatched to driver threads; today we accept the wall-time
+     * cost in exchange for simpler code and a deterministic init.
+     */
+    precompile(specs: readonly ShaderSpec[]): void;
+    getOrCreate(name: string, vertSrc: string, fragSrc: string): WebGLProgram;
+    releaseAll(): void;
+}
+export {};

package/dist/esm/worker/dispatch.d.ts

@@ -0,0 +1,9 @@
+import type { ControlMsg } from "../transport/protocol";
+import type { WorkerRenderer } from "./renderer.worker";
+/**
+ * Stateless control-message dispatcher. The renderer instance is
+ * supplied by the caller so worker mode (one global instance) and
+ * in-process mode (one instance per host element) share the same
+ * routing logic.
+ */
+export declare function dispatch(r: WorkerRenderer, msg: ControlMsg): void;

package/dist/esm/worker/font-loader.d.ts

@@ -0,0 +1,2 @@
+import type { FontFaceDescriptor } from "../transport/protocol";
+export declare function loadFontDeduped(d: FontFaceDescriptor): Promise<void>;

package/dist/esm/worker/renderer.worker.d.ts

@@ -0,0 +1,115 @@
+import "./boot";
+import type { Client, Table, View } from "@perspective-dev/client";
+import { WebGLContextManager } from "../webgl/context-manager";
+import { ChartImplementation } from "../charts/chart";
+import { ZoomController } from "../interaction/zoom-controller";
+import type { InitMsg, InteractionEvent, LoadAndRenderMsg, WorkerMsg } from "../transport/protocol";
+export declare class WorkerRenderer {
+    chartImpl: ChartImplementation;
+    glManager: WebGLContextManager;
+    zoomController: ZoomController | null;
+    gridlines: OffscreenCanvas;
+    chrome: OffscreenCanvas;
+    cssWidth: number;
+    cssHeight: number;
+    dpr: number;
+    client: Client;
+    view: View;
+    /**
+     * Source `Table` opened once at bootstrap from the host-supplied
+     * `tableName`. Used by `loadAndRender` to fetch the source schema
+     * for group-by level types — the worker resolves it itself so the
+     * host's render path makes zero `Client`/`Table`/`View` awaits.
+     * Null when the host had no table loaded at init time.
+     */
+    table: Table | null;
+    controlPort: MessagePort;
+    /**
+     * Monotonic counter bumped by every `loadAndRender` entry. Captured
+     * locally as `myGen` and re-checked after each await — a stale
+     * value means a newer call has superseded this one and we must
+     * bail (throwing inside the `with_typed_arrays` callback so the
+     * wasm Arrow buffer release runs cleanly).
+     */
+    private _renderGen;
+    /**
+     * Active drag state. `pointerdown` resolves a target via the
+     * facet grid and stores it; `pointermove` consults this until
+     * `pointerup` clears it. Pointer capture itself is host-side.
+     */
+    private _dragTarget;
+    private _lastDragX;
+    private _lastDragY;
+    constructor(msg: InitMsg, client: Client, view: View, table: Table | null, controlPort: MessagePort, ImplClass: new () => ChartImplementation);
+    setViewByName(name: string): void;
+    /**
+     * Full data-fetch + render pipeline. Owns every `Client`/`Table`/
+     * `View` await on the render path:
+     *
+     *  1. Resolve metadata (`view.num_rows`, `view.schema`,
+     *     `view.expression_schema`, `table.schema`) in parallel.
+     *  2. Apply schema + viewer-config to the chart impl (replaces the
+     *     individual `setColumnTypes` / `setGroupByTypes` /
+     *     `setViewPivots` / `setColumnSlots` setters that used to
+     *     stream from the host).
+     *  3. Compute `totalRows` from `bufferPool.maxCapacity / numCols`
+     *     and grow the buffer pool to fit.
+     *  4. Run `view.with_typed_arrays`; the inner callback hands the
+     *     resulting `ColumnDataMap` straight to
+     *     `chartImpl.uploadAndRender` — no `postMessage`, no transfer.
+     *
+     * Mid-flight cancellation: each entry bumps `_renderGen` and
+     * captures `myGen`. After the metadata await we re-check; if a
+     * newer call has superseded this one, ack-and-return so the host
+     * promise resolves cleanly. Inside the `with_typed_arrays`
+     * callback the same check throws `StaleGenerationError` so the
+     * wasm Arrow buffer release path runs (callback's promise must
+     * reject for `with_typed_arrays` to unwind) before the next call
+     * proceeds — caught and swallowed here.
+     *
+     * Always sends `loadAndRenderAck` (even on stale drop) per the
+     * "resolve on stale" host contract.
+     */
+    loadAndRender(msg: LoadAndRenderMsg): Promise<void>;
+    redraw(): void;
+    resize(cssWidth: number, cssHeight: number, dpr: number): void;
+    clear(): void;
+    saveZoom(): any;
+    restoreZoom(state: any): void;
+    allZoomsDefault(): boolean;
+    resetAllZooms(): void;
+    resetExpandedDomain(): void;
+    /**
+     * Hit-test the cursor against the chart's facet grid (in faceted
+     * mode) or its current layout (single-plot). Mirrors the resolver
+     * `_setupZoomRouter` builds on the host for in-process mode — the
+     * worker owns the facet grid and controllers, so the resolution
+     * runs here.
+     */
+    private _resolveTarget;
+    onInteraction(event: InteractionEvent): void;
+    /**
+     * Read the chart impl's `TooltipController`. Charts that don't use
+     * one (no `attachTooltip` override) yield `null` and the
+     * mouse-event branches fall through.
+     */
+    private _tooltip;
+    /**
+     * Composite the three layers into a single PNG `Blob`.
+     */
+    snapshotPng(): Promise<Blob>;
+    destroy(): void;
+    post(msg: WorkerMsg, transfer?: Transferable[]): void;
+}
+/**
+ * In-process bootstrap. Used when the host loads this same module via
+ * `await import(workerURL)` to run the renderer on the main thread —
+ * skips the wasm / font / proxy-port plumbing because the host already
+ * owns a live `Client` and the document's `FontFaceSet` is the active
+ * one.
+ */
+export declare function bootstrapInProcess(opts: {
+    msg: InitMsg;
+    client: Client;
+    controlPort: MessagePort;
+}): Promise<WorkerRenderer>;

package/dist/esm/worker/session-host.d.ts

@@ -0,0 +1,26 @@
+import type { InitMsg } from "../transport/protocol";
+import type { WorkerRenderer } from "./renderer.worker";
+/**
+ * Adapter that satisfies the `MessagePort` shape `WorkerRenderer`
+ * expects (it only ever calls `.postMessage` on it). Outgoing posts
+ * get session-tagged on the way out so the host can route them to
+ * the right `RendererTransport` instance.
+ *
+ * The receive direction is handled exclusively by the worker-scope
+ * `self.addEventListener("message", …)` installed by `installSessionHost`;
+ * this adapter does not own a real port pair.
+ */
+export declare function makeSessionPort(sessionId: number): MessagePort;
+/**
+ * Install the shared message handler on the worker scope. One worker
+ * process hosts many `WorkerRenderer` instances, one per `sessionId`
+ * allocated by the host's `RendererTransport`; this listener
+ * demultiplexes incoming `ControlEnvelope`s and routes them to the
+ * matching renderer.
+ *
+ * The `bootstrap` callback constructs a `WorkerRenderer` from an
+ * `InitMsg` and a session-tagged port. It's injected so this module
+ * doesn't need to import `renderer.worker` for runtime bindings (avoids
+ * a runtime cycle — `renderer.worker` imports this module).
+ */
+export declare function installSessionHost(bootstrap: (msg: InitMsg, port: MessagePort) => Promise<WorkerRenderer>): void;

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@perspective-dev/viewer-charts",
+  "version": "4.3.0",
+  "description": "Perspective.js WebGL Plugin",
+  "unpkg": "./dist/cdn/perspective-viewer-charts.js",
+  "jsdelivr": "./dist/cdn/perspective-viewer-charts.js",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/esm/index.d.ts",
+      "default": "./dist/esm/perspective-viewer-charts.js"
+    },
+    "./src/*": "./src/*",
+    "./dist/*": "./dist/*",
+    "./cdn/": "./dist/cdn/",
+    "./esm/": "./dist/esm/",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist/**/*",
+    "src/**/*"
+  ],
+  "types": "dist/esm/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/perspective-dev/perspective"
+  },
+  "author": "",
+  "license": "Apache-2.0",
+  "devDependencies": {
+    "@perspective-dev/client": "",
+    "@perspective-dev/viewer": "",
+    "@perspective-dev/esbuild-plugin": "",
+    "@perspective-dev/test": "",
+    "@types/node": ">=22",
+    "lightningcss": "^1.29.0",
+    "typescript": ">=5 <6",
+    "webpack-glsl-minify": "1.5.0"
+  },
+  "scripts": {
+    "build": "node ./build.mjs",
+    "clean": "node ./clean.mjs"
+  }
+}