@kymoscope/sdk 0.0.0-stage → 0.1.1

package/dist/types/lib/recordings/mf4Writer.d.ts

@@ -0,0 +1,20 @@
+/**
+ * A minimal ASAM MDF 4.10 file: ID, HD, FH (+ its MD comment), one sorted data group (record id size 0) with one
+ * channel group: a float64 master channel (column 0, Time, sync type time) and one float64 channel per other
+ * column, each named by a TX block, its unit in another TX; one DT block, last, with the records row-major.
+ * Blocks are 8-byte aligned. The metadata comes first, built from the plan's exact row count (`head`); then each
+ * chunk's records (`append`), so the file streams to its sink (never one buffer); `end` checks the count held.
+ * Block layouts: ASAM MDF 4.1 (ID 64 B; header 24 B = id, reserved, length, link count).
+ */
+import type { Chunk } from '../importers/combine';
+import type { OutColumn } from '../importers/run';
+export declare class Mf4Writer {
+    #private;
+    constructor(columns: OutColumn[], startTime: string | null, rows: number);
+    /** One chunk's records, row-major float64. */
+    append(c: Chunk): Uint8Array<ArrayBuffer>;
+    /** The header said `rows` records: anything else would be a corrupt file. */
+    end(): void;
+    /** Everything before the records: ID, HD, FH, the TX/MD blocks, DG, CG, the CNs and the DT header. */
+    head(): Uint8Array<ArrayBuffer>;
+}

package/dist/types/lib/render/chartFonts.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Font families every chart draws its canvas text with. Set through
+ * `engine.charts.setFonts()`.
+ * ponytail: page-global (canvas text can't inherit CSS); per-chart fonts would
+ * need the family threaded through every renderer.
+ */
+export declare const chartFonts: {
+    sans: string;
+    mono: string;
+};

package/dist/types/lib/render/colorBucket.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Map a normalized value in [0, 1] to one of `buckets` integer slots
+ * (0 … buckets-1), clamping out-of-range inputs. Used to batch colormapped
+ * scatter points into a handful of Path2D fills instead of one fill per point.
+ */
+export declare function quantizeBucket(value: number, buckets: number): number;

package/dist/types/lib/render/contours.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Isolines of a grid of values (marching squares). The grid's samples sit at
+ * integer positions (column i, row j); a segment's ends are fractional
+ * positions between them. NaN samples leave their squares out.
+ */
+export type Segment = [number, number, number, number];
+/** `n` levels evenly spaced strictly inside (lo, hi). */
+export declare function contourLevels(lo: number, hi: number, n: number): number[];
+export declare function contourSegments(values: ArrayLike<number>, w: number, h: number, level: number): Segment[];
+/**
+ * Boundaries of cells centred on `centres` (ascending): midway between
+ * neighbours, the outer ones half a neighbour gap out. n centres → n + 1 edges.
+ */
+export declare function edgesFromCentres(centres: ArrayLike<number>): Float64Array;
+/** True when the values strictly increase (usable as cell centres). */
+export declare function increasing(v: ArrayLike<number>): boolean;

package/dist/types/lib/render/cssColor.d.ts

@@ -0,0 +1,2 @@
+/** A CSS colour (any syntax the canvas takes) as RGBA in 0..1, read back from one painted pixel. */
+export declare function cssRgba(color: string, alpha: number): [number, number, number, number];

package/dist/types/lib/render/frames.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Frame scheduling and resize observation that keep working when a chart lives
+ * in another browser window (charts.openWindow). A window's ResizeObserver only
+ * reports during that window's own rendering, and a hidden or minimised window
+ * stops its animation frames — so charts observe with their element's window
+ * and ask every open window for the next frame.
+ */
+export declare function addFrameWindow(w: Window): void;
+export declare function removeFrameWindow(w: Window): void;
+/** requestAnimationFrame from whichever open window paints first; the callback runs once. */
+export declare function raf(cb: FrameRequestCallback): number;
+export declare function cancelRaf(handle: number | null | undefined): void;
+/** Count one frame whose drawn picture changed (data or view), for the perf HUD. */
+export declare function notePaint(el: Element | null): void;
+/** Changed frames drawn so far by the charts inside `host`. */
+export declare function paintsWithin(host: Element): number;
+/** True when no window that can show a chart is visible. */
+export declare function allFramesHidden(): boolean;
+/**
+ * ResizeObserver with the same interface that observes each element with its
+ * own window's observer, so charts in a popup report size changes as they happen.
+ */
+export declare class AnyWindowResizeObserver {
+    #private;
+    constructor(cb: ResizeObserverCallback);
+    observe(el: Element, options?: ResizeObserverOptions): void;
+    unobserve(el: Element): void;
+    disconnect(): void;
+}
+/**
+ * A chart's draw, at most once per frame, of whatever is newest then:
+ * - `schedule()` queues a draw for the next frame, keeping one already queued
+ *   (cancelling and re-queuing on every change starved a chart whose data
+ *   changed every frame: the draw was pushed back forever);
+ * - `now()` draws at once if the chart hasn't drawn in this frame yet, else
+ *   queues: data replaced from a requestAnimationFrame loop arrives during a
+ *   frame's callbacks, where a requested frame only runs on the next one, so
+ *   always queueing painted every other frame. `document.timeline` holds the
+ *   frame's time until the next frame, so several changes in one frame still
+ *   make one draw.
+ */
+export declare function createDrawScheduler(draw: () => void, doc: () => Document | null | undefined): {
+    schedule(): void;
+    now(): void;
+    cancel(): void;
+};

package/dist/types/lib/render/gl3d.d.ts

@@ -0,0 +1,63 @@
+export type Vec3Tuple = [number, number, number];
+export interface Gpu3dBounds {
+    minX: number;
+    maxX: number;
+    minY: number;
+    maxY: number;
+    minZ: number;
+    maxZ: number;
+}
+export type Gpu3dView = 
+/** Perspective, through the orbit camera (`f` = 1 / tan(fov / 2)); data X→world x, Z→y (up), Y→z. */
+{
+    kind: '3d';
+    eye: Vec3Tuple;
+    right: Vec3Tuple;
+    up: Vec3Tuple;
+    fwd: Vec3Tuple;
+    f: number;
+}
+/** Data axis `h` (0 x, 1 y, 2 z) across, `v` up, the plot rectangle filled. */
+ | {
+    kind: '2d';
+    h: 0 | 1 | 2;
+    v: 0 | 1 | 2;
+};
+export interface Gpu3dStyle {
+    /** 256 RGBA colours along the colour axis. */
+    palette: Uint8Array;
+    /** Data axis the colour follows (0 x, 1 y, 2 z). */
+    colorAxis: 0 | 1 | 2;
+    pointRadius: number;
+    /** The mesh/surface: filled, its wire, both (or neither: points only). */
+    fill: boolean;
+    wire: boolean;
+    fillAlpha: number;
+    wireColor: [number, number, number, number];
+}
+export interface Gpu3d {
+    resize(cssWidth: number, cssHeight: number, dpr: number): void;
+    /** The axis box: data outside it is not drawn. */
+    setBounds(b: Gpu3dBounds): void;
+    setView(v: Gpu3dView, plot: {
+        left: number;
+        top: number;
+        width: number;
+        height: number;
+    }): void;
+    /** The points (null: none). Non-finite points are not drawn. */
+    setPoints(x: ArrayLike<number> | null, y?: ArrayLike<number>, z?: ArrayLike<number>): void;
+    /** Triangles over the points, as index triples (null: no mesh). */
+    setTriangles(idx: Uint32Array | null): void;
+    /**
+     * Heights over a uniform grid (null: none): `w` × `h` values row by row, row
+     * r at y0 + r·(y1 − y0)/(h − 1), column c at x0 + c·(x1 − x0)/(w − 1).
+     * NaN leaves a hole. At most {@link maxTextureSize} a side.
+     */
+    setSurface(z: ArrayLike<number> | null, w?: number, h?: number, x?: [number, number], y?: [number, number]): void;
+    setStyle(s: Gpu3dStyle): void;
+    readonly maxTextureSize: number;
+    render(): void;
+    dispose(): void;
+}
+export declare function createGpu3d(canvas: HTMLCanvasElement | OffscreenCanvas): Gpu3d | null;

package/dist/types/lib/render/glLines.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Minimal WebGL2 polyline renderer for chart data lines — the part whose cost
+ * scales with point count. Axes/grid/labels/hover stay on Canvas-2D (cheap,
+ * O(ticks)). One instanced draw call per polyline; the GPU makes draw cost
+ * ~independent of point count, which is the flat-performance lever.
+ *
+ * Rendering model: each polyline segment is one INSTANCED quad, and the fragment
+ * shader computes the analytic distance from the pixel to the segment (a capsule
+ * SDF) to derive edge coverage. Two reasons this replaces the earlier
+ * triangle-strip ribbon + MSAA approach:
+ *
+ * 1. NO SHIMMER WITHOUT SNAPPING. MSAA coverage changes in discrete sample-count
+ *    steps as a near-vertical edge (gear step, RPM spike) moves sub-pixel, so a
+ *    live scroll made edges shimmer unless the view was snapped to whole device
+ *    pixels — and that snap turned slow scrolls (wide X ranges) into visible 1px
+ *    lurches. Analytic coverage varies SMOOTHLY with sub-pixel position, so the
+ *    trace can scroll continuously (no snap) with stable, crisp edges at any
+ *    scroll speed.
+ * 2. CORRECT JOINS. A previous analytic attempt carried a signed distance on
+ *    shared ribbon vertices; the averaged-miter distance is wrong at sharp
+ *    corners, visibly so on stepped channels. Per-segment capsules have no miter
+ *    at all: every segment ends in a round cap, and consecutive capsules overlap
+ *    into a clean round join.
+ *
+ * Coordinates are CSS pixels (top-left origin, y down). The renderer maps them to
+ * clip space and handles devicePixelRatio via the canvas backing size + viewport.
+ */
+/** A polyline to draw: interleaved [x0,y0, x1,y1, …] in CSS px + an RGBA color. */
+export interface GlLineBatch {
+    points: Float32Array;
+    color: [number, number, number, number];
+    /** Optional clip rect in CSS px (top-left origin). Drawing is scissored to it. */
+    clip?: {
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    };
+    /** Line thickness in CSS px; defaults to the renderer's `lineWidth`. */
+    width?: number;
+}
+export interface GlLineRenderer {
+    /** Resize the backing store for a CSS size at the given devicePixelRatio. */
+    resize(cssWidth: number, cssHeight: number, dpr: number): void;
+    /** Clear and draw all polylines for the current frame. */
+    draw(batches: GlLineBatch[]): void;
+    dispose(): void;
+}
+/** Parse `#rrggbb`, `#rgb` or `#rrggbbaa` to an RGBA tuple in 0..1 (the hex alpha times `alpha`). */
+export declare function hexToRgba(hex: string, alpha?: number): [number, number, number, number];
+/** Segment instances drawable from a points array: consecutive point pairs. */
+export declare function segmentInstanceCount(pointsLength: number): number;
+/** Extra half-width (CSS px) the quad extends beyond the visible line so the
+ *  analytic feather (~1.75 device px smoothstep) always has geometry to land in. */
+export declare const AA_FEATHER = 2.5;
+/** Lines render at this multiple of device resolution, box-filtered down in draw(). */
+export declare const SUPERSAMPLE = 2;
+export declare function compile(gl: WebGL2RenderingContext, type: number, src: string): WebGLShader | null;
+/** Create a renderer, or null if WebGL2 is unavailable / setup failed.
+ *  `lineWidth` is the line thickness in CSS pixels. Accepts an OffscreenCanvas
+ *  too, so the same renderer can run inside a Web Worker. */
+export declare function createGlLineRenderer(canvas: HTMLCanvasElement | OffscreenCanvas, lineWidth?: number): GlLineRenderer | null;

package/dist/types/lib/render/glPlot.d.ts

@@ -0,0 +1,36 @@
+export type Rgba = [number, number, number, number];
+export interface GpuPlot {
+    resize(cssWidth: number, cssHeight: number, dpr: number): void;
+    /** Data window and the plot rectangle (CSS px) it maps to. */
+    setView(xmin: number, xmax: number, ymin: number, ymax: number, plot: {
+        left: number;
+        top: number;
+        width: number;
+        height: number;
+    }): void;
+    /**
+     * Filled area between `lo` and `hi` along `x`: a trapezoid from point i to
+     * i+1, skipped where `starts[i + 1]` is set (a new trace) or a value is not finite.
+     */
+    setBands(id: string, x: ArrayLike<number>, lo: ArrayLike<number>, hi: ArrayLike<number>, color: Rgba, starts?: Uint8Array): void;
+    /** Rectangles [x0, x1] × [y0, y1], each the colour `palette[k[i]]` (one colour when `k` is absent). */
+    setRects(id: string, x0: ArrayLike<number>, x1: ArrayLike<number>, y0: ArrayLike<number>, y1: ArrayLike<number>, palette: Rgba[], k?: ArrayLike<number>): void;
+    /** A line through the points in order, broken where `starts[i]` is set or a value is not finite. */
+    setLine(id: string, x: ArrayLike<number>, y: ArrayLike<number>, color: Rgba, width: number, starts?: Uint8Array): void;
+    /**
+     * A grid of `w` × `h` values (row-major, row 0 at `y0`) over [x0, x1] × [y0, y1],
+     * coloured through `palette` (256 RGBA colours) from `vmin` to `vmax`; NaN
+     * cells are left empty. A new range alone: {@link setGridRange}.
+     */
+    setGrid(id: string, values: Float32Array, w: number, h: number, extent: [number, number, number, number], palette: Uint8Array, vmin: number, vmax: number): void;
+    /** A grid's colour range, without sending its values again. */
+    setGridRange(id: string, vmin: number, vmax: number): void;
+    /** Largest grid side the GPU takes. */
+    readonly maxTextureSize: number;
+    remove(id: string): void;
+    /** Remove every layer but `ids`. */
+    keep(ids: string[]): void;
+    render(): void;
+    dispose(): void;
+}
+export declare function createGpuPlot(canvas: HTMLCanvasElement | OffscreenCanvas): GpuPlot | null;

package/dist/types/lib/render/glPoints.d.ts

@@ -0,0 +1,37 @@
+export type GpuPointsColor = {
+    kind: 'single';
+    rgba: [number, number, number, number];
+}
+/** `rgba[i]` for a point's value v in 0..1 is the texel at round(v * 255). */
+ | {
+    kind: 'colormap';
+    palette: Uint8Array;
+}
+/** One colour per dataset index (at most 256). */
+ | {
+    kind: 'dataset';
+    palette: Uint8Array;
+};
+export interface GpuPointsRenderer {
+    resize(cssWidth: number, cssHeight: number, dpr: number): void;
+    /**
+     * The points: `x`, `y`, and per point either a 0..1 colour value or a dataset
+     * index in `k` (ignored for a single colour). Non-finite points are dropped.
+     * `breakOnK`: the line also breaks where `k` changes (one per dataset).
+     * `radius`: each point's own radius (CSS px) instead of the style's.
+     */
+    setData(x: ArrayLike<number>, y: ArrayLike<number>, k?: ArrayLike<number>, breakOnK?: boolean, radius?: ArrayLike<number>): void;
+    setStyle(color: GpuPointsColor, radiusCss: number, alpha: number): void;
+    /** What to draw: the points, a line through them in order, or both (line width in CSS px). */
+    setDraw(points: boolean, lines: boolean, lineWidthCss: number): void;
+    /** Data window and the plot rectangle (CSS px) it maps to. */
+    setView(xmin: number, xmax: number, ymin: number, ymax: number, plot: {
+        left: number;
+        top: number;
+        width: number;
+        height: number;
+    }): void;
+    render(): void;
+    dispose(): void;
+}
+export declare function createGpuPointsRenderer(canvas: HTMLCanvasElement | OffscreenCanvas): GpuPointsRenderer | null;

package/dist/types/lib/render/glSeries.d.ts

@@ -0,0 +1,67 @@
+export interface GpuSeriesStyle {
+    color: [number, number, number, number];
+    bandTop: number;
+    bandBottom: number;
+    scaleMin: number;
+    scaleMax: number;
+    /** Median consecutive |Δx| of the column (0 if unknown): drives gap-splitting. */
+    gapMedian: number;
+    /** Line thickness in CSS px; defaults to the renderer's `lineWidth`. */
+    width?: number;
+}
+export interface GpuSeriesRenderer {
+    resize(cssWidth: number, cssHeight: number, dpr: number): void;
+    /**
+     * Upload a layer's data: shared X (and trace starts), one Y column per series.
+     * `xs` null: the layer's X and starts as last uploaded (new values only).
+     */
+    setData(layer: number, xs: Float64Array | null, breaks: Uint8Array | undefined, columns: Float32Array[]): void;
+    /** Per-series styles of a layer (same order as its columns) and the plot's X extent in px. */
+    setStyles(layer: number, styles: GpuSeriesStyle[], left: number, plotW: number): void;
+    /** Drop a layer. */
+    clearLayer(layer: number): void;
+    setView(xmin: number, xmax: number): void;
+    render(): void;
+    dispose(): void;
+}
+/**
+ * One series' points as uploaded: the finite ones only (X relative to the
+ * layer origin), with a trace start flag (255) per point. A start that falls on
+ * a dropped sample moves to the next kept one, as the on-main path flushes its
+ * polyline there. Null when every point is finite (the layer's X serves as is).
+ */
+export declare function compactSeries(xs: Float64Array, xRel: Float32Array, starts: Uint8Array, col: Float32Array): {
+    x: Float32Array;
+    y: Float32Array;
+    starts: Uint8Array;
+} | null;
+/**
+ * Every series of a layer in one set of arrays, back to back, each starting a new
+ * trace (so no segment joins the end of one series to the start of the next),
+ * with each point's series index. `counts` are the points per series.
+ */
+export declare function packLayer(xs: Float64Array, breaks: Uint8Array | undefined, columns: Float32Array[]): {
+    origin: number;
+    x: Float32Array;
+    y: Float32Array;
+    starts: Uint8Array;
+    sid: Float32Array;
+    counts: number[];
+};
+/** Points per device pixel in view above which a layer is drawn from its per-pixel min/max. */
+export declare const RESAMPLE_DENSITY = 4;
+/**
+ * Every series of a layer over [xmin, xmax] as per-bucket min/max (`nb` buckets),
+ * packed like {@link packLayer}: per bucket, at its centre, the min then the max
+ * (one point when they're equal); a bucket with no value is left out, so a gap
+ * stays a gap. The nearest sample on each side of the window is kept as is, so
+ * lines run on to the plot edges. `xs` must be ascending.
+ */
+export declare function resampleLayer(xs: Float64Array, columns: Float32Array[], origin: number, xmin: number, xmax: number, nb: number): {
+    x: Float32Array;
+    y: Float32Array;
+    starts: Uint8Array;
+    sid: Float32Array;
+    bucket: number;
+};
+export declare function createGpuSeriesRenderer(canvas: HTMLCanvasElement | OffscreenCanvas, lineWidth?: number): GpuSeriesRenderer | null;

package/dist/types/lib/render/heatGrid.d.ts

@@ -0,0 +1,9 @@
+import type { HeatGrid } from '../../components/HeatmapChart';
+/**
+ * The grid to draw at most `maxW` columns wide: wider grids (a matrix over
+ * millions of rows) average each run of columns into one.
+ */
+export declare function narrowed(g: HeatGrid, maxW: number): {
+    grid: HeatGrid;
+    per: number;
+};

package/dist/types/lib/render/hitGrid.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Nearest point under the pointer without scanning every point: the points
+ * bucketed into hit-radius cells over the plot (one pass, made on the first
+ * hover after the data or the view change), then a 3×3 cell lookup per move.
+ */
+export interface HitGrid {
+    cell: number;
+    nx: number;
+    ny: number;
+    start: Uint32Array;
+    ix: Uint32Array;
+}
+/** Points 0..n-1 at plot coordinates (`px(i)`, `py(i)`, 0..w × 0..h; outside or NaN: not hit). */
+export declare function buildHitGrid(n: number, w: number, h: number, cell: number, px: (i: number) => number, py: (i: number) => number): HitGrid;
+/** The point nearest (`mx`, `my`) within `r` (and within its own `reach`, when given), or null. */
+export declare function nearestInGrid(g: HitGrid, mx: number, my: number, r: number, px: (i: number) => number, py: (i: number) => number, reach?: (i: number) => number): number | null;

package/dist/types/lib/render/liveZoomBus.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Tiny in-memory pub/sub so linked multiband charts can follow the chart being
+ * actively zoomed IN REAL TIME, instead of only catching up when the gesture
+ * commits to React ~140ms after it settles.
+ *
+ * The driving chart publishes its live X view on every wheel tick; sibling charts
+ * apply it to their internal view refs and redraw — no React re-render and no
+ * data re-query (they just stretch their existing points, same as the driver).
+ * The debounced commit still fires afterwards to refine + formally sync everyone.
+ */
+export type LiveZoomRange = [number, number] | null;
+type Listener = (fromId: string, range: LiveZoomRange) => void;
+export interface LiveZoomBus {
+    publish(fromId: string, range: LiveZoomRange): void;
+    subscribe(fn: Listener): () => void;
+}
+export declare function createLiveZoomBus(): LiveZoomBus;
+export {};

package/dist/types/lib/render/margins.d.ts

@@ -0,0 +1,14 @@
+export interface Margins {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+}
+/**
+ * A chart's margins at its size: `m`, or almost none when it is a thumbnail
+ * (narrower than 200 px or shorter than 120: a grid of many charts), where the
+ * plot fills it and the caller draws no axis labels or legend.
+ */
+export declare function fitMargins(m: Margins, w: number, h: number): Margins & {
+    tiny: boolean;
+};

package/dist/types/lib/render/offscreenLineRenderer.d.ts

@@ -0,0 +1,53 @@
+import { type GpuSeriesStyle } from './glSeries';
+/**
+ * Main-thread handle to the OffscreenCanvas line worker. The worker owns the GL
+ * context and keeps the data on the GPU (projected in the shader); the main
+ * thread posts a layer's points only when they change ({@link setData}), its
+ * styles when only those change ({@link setStyle}), and the X view window per
+ * frame of a zoom/pan ({@link setView}). The chart's GL canvas is transferred to
+ * the worker once via `transferControlToOffscreen()`. Returns null if unsupported.
+ *
+ * {@link setData} carries the X window the data belongs to. Each message the
+ * worker receives renders a frame, so posting data and view separately would
+ * paint one frame of NEW data through the OLD window — visible as the trace
+ * jumping away from the axes and snapping back. A live stream changes both on
+ * every rebuild (~8 Hz), which turned that into continuous flicker.
+ */
+/** How the worker draws one series: its Y scale and band, colour, width, gap rule. */
+export type OffscreenSeriesStyle = GpuSeriesStyle;
+/** What a layer is drawn with besides its points: series styles, plot X extent, X window. */
+export interface OffscreenLayerFrame {
+    styles: OffscreenSeriesStyle[];
+    left: number;
+    plotW: number;
+    /** X window this layer is drawn through. Sent with the data/styles so no frame is
+     *  ever drawn with the two out of sync. */
+    xmin: number;
+    xmax: number;
+}
+export interface OffscreenLayerData extends OffscreenLayerFrame {
+    /** Null: the layer's X and trace starts as last sent (new values only). */
+    xs: Float64Array | null;
+    /** 1 where an independent trace starts (never joined to the previous point). */
+    breaks?: Uint8Array;
+    /** One Y column per style, same order. Transferred to the worker. */
+    columns: Float32Array[];
+}
+export interface OffscreenChartRenderer {
+    resize(w: number, h: number, dpr: number): void;
+    /** New points for a layer (uploaded to the GPU). The worker draws every layer it holds. */
+    setData(layer: number, data: OffscreenLayerData): void;
+    /** Same points, new styles (Y scales, bands, colours) or plot size: no data moves. */
+    setStyle(layer: number, frame: OffscreenLayerFrame): void;
+    clear(layer: number): void;
+    setView(xmin: number, xmax: number): void;
+    dispose(): void;
+}
+export declare function createOffscreenChartRenderer(canvas: HTMLCanvasElement, lineWidth?: number): OffscreenChartRenderer | null;
+/**
+ * The same renderer on the main thread through the page's shared WebGL
+ * context (see sharedGl): for charts past the contexts a page may own. Each
+ * message the worker would get is applied and drawn at once, then copied into
+ * the chart's canvas.
+ */
+export declare function createSharedChartRenderer(canvas: HTMLCanvasElement, lineWidth?: number): OffscreenChartRenderer | null;

package/dist/types/lib/render/offscreenLineWorker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/lib/render/plotFrame.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Where a chart's plot is on screen and what its numeric axes span: the plot
+ * rectangle (CSS px from the chart's top-left) and the data range across each
+ * numeric axis. Charts publish it every time they draw; overlays convert with
+ * it (annotations pinned to X, alarm lines).
+ */
+export interface AxisSpan {
+    /** Value at the left (X) or bottom (Y) of the plot. */
+    v0: number;
+    /** Value at the right (X) or top (Y) of the plot. */
+    v1: number;
+    log?: boolean;
+}
+export interface PlotFrame {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+    x?: AxisSpan;
+    y?: AxisSpan;
+}
+/** Pixel of a value on the frame's X axis (the frame must have one). */
+export declare const frameXToPx: (f: PlotFrame, x: number) => number;
+export declare const frameXFromPx: (f: PlotFrame, px: number) => number;
+/** Pixel of a value on the frame's Y axis (the frame must have one). */
+export declare const frameYToPx: (f: PlotFrame, y: number) => number;
+/** The latest frame of one chart; listeners hear only real changes (charts publish on every draw). */
+export declare function createPlotFrameStore(): {
+    get: () => PlotFrame | null;
+    set: (f: PlotFrame | null) => void;
+    subscribe: (l: () => void) => () => void;
+};
+export type PlotFrameStore = ReturnType<typeof createPlotFrameStore>;
+/** The chart frame's plot-frame setter, for the chart drawing inside it (a no-op elsewhere). */
+export declare const PlotFrameContext: import("react").Context<(f: PlotFrame | null) => void>;
+export declare const usePublishPlotFrame: () => (f: PlotFrame | null) => void;

package/dist/types/lib/render/resample.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Indices of the samples to draw for an ascending `x` over [xmin, xmax] split
+ * into `buckets` (about two per device pixel): per bucket, those of its
+ * smallest and largest `y` in the order they come (M4), plus the nearest sample
+ * on each side of the window so lines run on to the plot edges. A series of
+ * millions of samples draws as a few thousand with the same picture. When the
+ * window holds fewer samples than `buckets`, every sample in it.
+ */
+export declare function m4Indices(x: ArrayLike<number>, y: ArrayLike<number>, xmin: number, xmax: number, buckets: number): Uint32Array;
+/**
+ * {@link m4Indices} for samples evenly spaced along X (X is the index, 0..n-1):
+ * no X array needed.
+ */
+export declare function m4IndexRange(y: ArrayLike<number>, buckets: number): Uint32Array;
+/** `a` at `ix` (a gather), as a new Float64Array. */
+export declare function gatherAt(a: ArrayLike<number>, ix: Uint32Array): Float64Array;
+/** Whether `x` never decreases (NaN anywhere: no). */
+export declare function isAscendingArray(x: ArrayLike<number>): boolean;

package/dist/types/lib/render/sharedGl.d.ts

@@ -0,0 +1,38 @@
+/**
+ * WebGL contexts for charts. A page gets only so many (Chrome keeps 16 and
+ * drops the oldest past that, its charts going blank), so the first charts
+ * get their own and the rest draw through ONE shared context: each draws into
+ * the shared canvas at its own size, then copies the picture into its own
+ * canvas (a GPU copy). The renderers can't tell the difference: they get a
+ * canvas-like object whose `getContext` is the shared context and whose size is
+ * the chart's own.
+ */
+export interface GlLease {
+    /** The canvas to create the renderer on (the chart's own, or a stand-in for the shared one). */
+    canvas: HTMLCanvasElement | OffscreenCanvas;
+    /** True when drawing through the shared context: call `present` after each render. */
+    shared: boolean;
+    /** Copy what was just drawn into the chart's canvas (shared only; a no-op otherwise). */
+    present(): void;
+    release(): void;
+}
+/** Whether a chart may still own a context (a worker of its own, say). */
+export declare function canOwnGl(): boolean;
+/** Count a context a chart owns outside `leaseGl` (a worker's); returns its release. */
+export declare function ownGl(): () => void;
+/**
+ * A context for the chart canvas `visible`: its own while the budget lasts,
+ * else the shared one (the chart's canvas then shows copies through 2D).
+ */
+export declare function leaseGl(visible: HTMLCanvasElement): GlLease;
+/** `make()` once per context and key. */
+export declare function cachedPerContext<T>(gl: WebGL2RenderingContext, key: string, make: () => T): T;
+/**
+ * A renderer made by `make` on the context due to the chart canvas `visible`
+ * (see leaseGl): its `render()` also copies the picture in when the context is
+ * shared, its `dispose()` gives the lease back. Null when `make` fails.
+ */
+export declare function onLeasedGl<T extends {
+    render(): void;
+    dispose(): void;
+}>(visible: HTMLCanvasElement, make: (canvas: HTMLCanvasElement | OffscreenCanvas) => T | null): T | null;

package/dist/types/lib/render/useGlPlot.d.ts

@@ -0,0 +1,7 @@
+import { type RefObject } from 'react';
+import { type GpuPlot } from './glPlot';
+/**
+ * A glPlot on the chart's GL canvas, made on first use and sized to the chart
+ * (CSS px); null without WebGL2 (the chart then draws on its 2D canvas).
+ */
+export declare function useGlPlot(glRef: RefObject<HTMLCanvasElement | null>): (w: number, h: number) => GpuPlot | null;

package/dist/types/lib/savedLayout.d.ts

@@ -0,0 +1,45 @@
+import { type DashboardPanel } from '../components/dashboardGridLayout';
+import { DEFAULT_XY_POINT_RADIUS, DEFAULT_XYZ_POINT_RADIUS, type PanelChartSettings } from './panelChartSettings';
+import type { PlotSeries } from '../types/plotSeries';
+export { DEFAULT_XY_POINT_RADIUS, DEFAULT_XYZ_POINT_RADIUS };
+export declare const SAVED_LAYOUT_VERSION: 9;
+export interface Worksheet {
+    id: string;
+    name: string;
+    panels: DashboardPanel[];
+    panelChartSettings: Record<string, PanelChartSettings>;
+    panelChartBackgrounds: Record<string, string | null>;
+    xKey: string;
+}
+export interface TyresPlotSavedLayout {
+    version: typeof SAVED_LAYOUT_VERSION;
+    worksheets: Worksheet[];
+    activeWorksheetId?: string;
+    panels: DashboardPanel[];
+    xKey: string;
+    /** @deprecated v7+ stores series per-panel inside `panelChartSettings`. */
+    series: PlotSeries[];
+    /** @deprecated v7+ stores addColumn per-panel inside `panelChartSettings`. */
+    addColumn: string;
+    /** @deprecated Legacy single-chart fields; superseded by `panelChartSettings` for XY / 3D panels. */
+    xyXCol: string;
+    /** @deprecated See `panelChartSettings`. */
+    xyYCol: string;
+    xyColor: string;
+    chartPlotHeight: number;
+    xyPlotHeight: number;
+    /** @deprecated Replaced by `panelChartBackgrounds`. Kept for loading old files. */
+    chartBackground: string | null;
+    /** Per-panel chart background. `null` / missing = follow app theme. */
+    panelChartBackgrounds: Record<string, string | null>;
+    /** @deprecated Use per-panel entries in `panelChartSettings`. */
+    xyPointRadius: number;
+    /** @deprecated Use per-panel entries in `panelChartSettings`. */
+    xyzPointRadius: number;
+    /** Per-panel options for multiband, X–Y scatter and 3D charts (key = panel `id`). */
+    panelChartSettings: Record<string, PanelChartSettings>;
+}
+/** Accept v2–v9; normalize to current shape + panel settings. */
+export declare function parseSavedLayoutFile(v: unknown): TyresPlotSavedLayout | null;
+/** @deprecated use parseSavedLayoutFile */
+export declare function isTyresPlotSavedLayout(v: unknown): v is TyresPlotSavedLayout;