@kymoscope/sdk 0.0.0-stage → 0.1.1

package/dist/types/components/MultiBandCanvasChart.d.ts

@@ -0,0 +1,156 @@
+import type { AxisLineStyle } from '../lib/panelChartSettings';
+import type { PlotSeries } from '../types/plotSeries';
+import { type PointColumns } from '../lib/data/pointColumns';
+import type { LiveZoomBus } from '../lib/render/liveZoomBus';
+/**
+ * A live feed the chart pulls straight from, every animation frame, on its own
+ * rAF loop — bypassing React entirely so incoming samples never re-render the app
+ * (the per-sample App re-render was the dominant main-thread stall). `pull`
+ * returns min/max-decimated points (keyed by column) for the requested window;
+ * `xBounds` is the buffer's current full x-extent (drives the auto-scroll target).
+ */
+export interface LiveChartSource {
+    /**
+     * The points to draw, as layers (`cutX`: the display edge, see latestT; live
+     * points past it are left out). A layer that comes back as the same object as
+     * last time (datasets under a live overlay, a beacon's reference) is measured
+     * and handed to the line renderer once; the others every time the data changes.
+     */
+    pull: (x0: number, x1: number, maxPoints: number, cutX?: number) => PointColumns[];
+    xBounds: () => [number, number] | null;
+    /** X of the newest sample (the live position). Lets "follow" track a channel
+     *  that is not monotonic, like lap distance. Defaults to the max of `xBounds`. */
+    latestX?: () => number | null;
+    /** Changes whenever the source's data does (e.g. samples received). When the
+     *  data and the view are unchanged the chart skips the pull: on an X that is
+     *  not the time axis (lap distance) and in beacon views a pull re-decimates
+     *  the whole buffer, and data arrives in bursts (~10 per second), so pulling
+     *  every frame recomputed the same points ~50 times a second. */
+    version?: () => number;
+    /** Newest received value of each column it carries (the legend's idle read-out).
+     *  Columns it doesn't carry (e.g. a beacon reference) read their value at the
+     *  newest sample's X. Without it the chart scans the points from the right,
+     *  which only finds the newest sample when X is time. */
+    latestValues?: (columns: string[]) => Map<string, number>;
+    /** X span covered by the newest `seconds` of samples, so a seconds window can
+     *  follow a channel that is not time (lap distance). Without it the window's
+     *  seconds are X units (right for a time X). */
+    spanForSeconds?: (seconds: number) => number;
+    /** Seconds of data buffered: the widest seconds window. Defaults to the X extent. */
+    bufferedSeconds?: () => number;
+    /** Time of the newest sample, and X at a given time. Together they enable
+     *  smooth playout (see advancePlayout): the trace advances every frame instead
+     *  of in a step per received message. */
+    latestT?: () => number;
+    xAtTime?: (t: number) => number;
+}
+/**
+ * Per-series X gap threshold: consecutive valid points farther apart than this
+ * are not joined by a line. Derived from the series' OWN median spacing so a
+ * co-plotted source at a different sample rate can't shrink it — a global
+ * threshold lets a dense live feed collapse the bound below an imported
+ * dataset's spacing and shatter that line into disconnected dots.
+ */
+export declare function joinGapThresholdForColumn(pts: PointColumns, column: string, xSpan: number): number;
+/** A series' min–max envelope across datasets: shaded under its traces, in its band and scale. */
+export interface MultibandEnvelope {
+    /** The base series (its per-dataset copies have ids `${seriesId}__N`). */
+    seriesId: string;
+    color: string;
+    x: Float64Array;
+    lo: Float64Array;
+    hi: Float64Array;
+}
+export interface MultiBandCanvasChartProps {
+    /** Min–max envelopes shaded under the traces. */
+    envelopes?: MultibandEnvelope[];
+    xLabel: string;
+    series: PlotSeries[];
+    /** The points, as layers (each a source: a dataset, a live stream, a reference). */
+    points: PointColumns[];
+    /** Physical units per column name (from file); shown next to scale values on the right. */
+    columnUnits?: Record<string, string>;
+    height?: number;
+    onPlotContextMenu?: (e: {
+        clientX: number;
+        clientY: number;
+        /** Set after a right-drag on the plot area; horizontal span → X zoom. */
+        zoomXRange?: [number, number] | null;
+    }) => void;
+    /** When this value changes (e.g. custom plot background), styles are re-read from CSS. */
+    backgroundToken?: string;
+    /**
+     * Externally controlled X zoom range (in data coordinates). `null` = full extent.
+     * Pair with `onViewXRangeChange` to sync zoom across multiple charts.
+     */
+    viewXRange?: [number, number] | null;
+    onViewXRangeChange?: (range: [number, number] | null) => void;
+    /** Real-time linked-zoom bus: while one chart is being zoomed it broadcasts its
+     *  live X view so siblings follow each frame (not just on commit). */
+    liveZoom?: LiveZoomBus;
+    /** This chart's id on the bus (so it ignores its own broadcasts). */
+    liveZoomId?: string;
+    /**
+     * True full data x-extent. Provide when `points` are a decimated SUBSET of the
+     * data (out-of-core), so zoom-out is bounded by the real dataset extent instead
+     * of the current view — otherwise zoom-out snaps straight to full. When omitted
+     * the extent is derived from `points` (correct for fully in-memory data).
+     */
+    fullXRange?: [number, number] | null;
+    /** When set, left-drag shifts the named dataset along X. */
+    shiftMode?: {
+        label: string;
+        onDragStart: () => void;
+        onDragOffset: (deltaDataX: number) => void;
+    };
+    /** X axis: vertical interior grid lines only. null color = use theme. */
+    xAxisLine?: AxisLineStyle;
+    /** Y axis: horizontal interior grid lines only. null color = use theme. */
+    yAxisLine?: AxisLineStyle;
+    /** Grid: outer plot border only. null color = use theme. */
+    gridLine?: AxisLineStyle;
+    /** Data trace thickness in CSS px. */
+    lineWidth?: number;
+    /**
+     * Show each channel's newest value in the legend while nothing is hovered.
+     * Set for panels fed by a live stream, where "the latest sample" is the
+     * current reading; a static file has no current value, so it keeps the dash.
+     */
+    showLatestValues?: boolean;
+    /**
+     * When set, the chart is fed by a live stream: it pulls decimated points from
+     * this source every animation frame (no React at data rate) and auto-scrolls
+     * the X window to the live edge, eased at refresh rate. Auto-scroll yields the
+     * moment the user zooms (a manual `viewXRange`) but the live pull continues, so
+     * a zoomed live chart still updates. Overrides the `points` prop for rendering.
+     */
+    liveSource?: LiveChartSource;
+    /**
+     * Fixed live-scroll window in SECONDS (on a non-time X, the span the newest N
+     * seconds cover — see LiveChartSource.spanForSeconds). With `null`/undefined
+     * the auto-scroll tracks the whole buffer extent, which WIDENS as the ring fills
+     * (a continuous zoom-out that collapses the scroll speed ~100× — see
+     * {@link liveWindowTarget}). A fixed value pins the window to the last N seconds
+     * so the trace scrolls at a constant rate.
+     */
+    liveWindowSeconds?: number | null;
+    /**
+     * While auto-scrolling, the wheel zooms by changing the
+     * live window (seconds) instead of freezing a manual range, so the view keeps
+     * following the newest samples. Called once the gesture settles; `null` = All.
+     */
+    onLiveWindowChange?: (seconds: number | null) => void;
+    /**
+     * How the wheel zooms a live chart. 'follow': the window stays on the newest
+     * sample and the wheel resizes it (the global seconds window on a time axis via
+     * `onLiveWindowChange`, a per-chart span in X units on any other channel).
+     * 'free': the wheel freezes a manual range (data inside it keeps updating).
+     * Defaults to 'follow' when `onLiveWindowChange` is given, else 'free'.
+     */
+    liveZoomMode?: 'follow' | 'free';
+    /** Reports the chart's CSS pixel width (the wrap's clientWidth) on mount and
+     *  whenever it changes. Lets an out-of-core parent size its decimation budget
+     *  to the actual on-screen resolution instead of a fixed overdrawn count. */
+    onPlotWidthCss?: (cssWidth: number) => void;
+}
+export declare function MultiBandCanvasChart({ xLabel, series, points, columnUnits, height, onPlotContextMenu, backgroundToken, viewXRange, onViewXRangeChange, liveZoom, liveZoomId, fullXRange, shiftMode, xAxisLine, yAxisLine, gridLine, lineWidth, envelopes, showLatestValues, liveSource, liveWindowSeconds, onLiveWindowChange, liveZoomMode, onPlotWidthCss, }: MultiBandCanvasChartProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/ParallelCoordsChart.d.ts

@@ -0,0 +1,21 @@
+/** One column per axis (rows aligned), with an optional colour per row: a value or a category. */
+export interface ParallelColumns {
+    length: number;
+    columns: ArrayLike<number>[];
+    colorValue?: ArrayLike<number>;
+    /** A category per row: an index into `colorLabels`. */
+    colorIndex?: ArrayLike<number>;
+    colorLabels?: string[];
+}
+export interface ParallelCoordsChartProps {
+    rows: ParallelColumns;
+    axes: string[];
+    color?: string;
+    colorByNumeric?: boolean;
+    backgroundToken?: string;
+    onPlotContextMenu?: (e: {
+        clientX: number;
+        clientY: number;
+    }) => void;
+}
+export declare function ParallelCoordsChart({ rows, axes, color, colorByNumeric, backgroundToken, onPlotContextMenu, }: ParallelCoordsChartProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/PolarChart.d.ts

@@ -0,0 +1,17 @@
+export interface PolarChartProps {
+    angles: ArrayLike<number>;
+    radii: ArrayLike<number>;
+    angleLabel: string;
+    radiusLabel: string;
+    color?: string;
+    mode?: 'waveform' | 'rose';
+    radiusMin?: number;
+    radiusMax?: number;
+    height?: number;
+    backgroundToken?: string;
+    onPlotContextMenu?: (e: {
+        clientX: number;
+        clientY: number;
+    }) => void;
+}
+export declare function PolarChart({ angles, radii, angleLabel, radiusLabel, color, mode, radiusMin, radiusMax, height, backgroundToken, onPlotContextMenu, }: PolarChartProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/QQPlotChart.d.ts

@@ -0,0 +1,16 @@
+/** Q-Q pairs as columns, both ascending. */
+export interface QQColumns {
+    length: number;
+    theoretical: ArrayLike<number>;
+    sample: ArrayLike<number>;
+}
+export interface QQPlotChartProps {
+    points: QQColumns;
+    color?: string;
+    backgroundToken?: string;
+    onPlotContextMenu?: (e: {
+        clientX: number;
+        clientY: number;
+    }) => void;
+}
+export declare function QQPlotChart({ points, color, backgroundToken, onPlotContextMenu, }: QQPlotChartProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/RadarChart.d.ts

@@ -0,0 +1,17 @@
+export interface RadarSeries {
+    name: string;
+    values: number[];
+}
+export interface RadarChartProps {
+    axes: string[];
+    series: RadarSeries[];
+    fill?: boolean;
+    /** The first series' color (the others follow the palette). */
+    color?: string;
+    backgroundToken?: string;
+    onPlotContextMenu?: (e: {
+        clientX: number;
+        clientY: number;
+    }) => void;
+}
+export declare function RadarChart({ axes, series, fill, color, backgroundToken, onPlotContextMenu, }: RadarChartProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/RocChart.d.ts

@@ -0,0 +1,12 @@
+export interface RocChartProps {
+    scores: ArrayLike<number>;
+    labels: ArrayLike<number>;
+    mode?: 'roc' | 'pr';
+    color?: string;
+    backgroundToken?: string;
+    onPlotContextMenu?: (e: {
+        clientX: number;
+        clientY: number;
+    }) => void;
+}
+export declare function RocChart({ scores, labels, mode, color, backgroundToken, onPlotContextMenu, }: RocChartProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/SankeyChart.d.ts

@@ -0,0 +1,15 @@
+export interface SankeyLink {
+    source: string;
+    target: string;
+    value: number;
+}
+export interface SankeyChartProps {
+    nodeNames: string[];
+    links: SankeyLink[];
+    backgroundToken?: string;
+    onPlotContextMenu?: (e: {
+        clientX: number;
+        clientY: number;
+    }) => void;
+}
+export declare function SankeyChart({ nodeNames, links, backgroundToken, onPlotContextMenu, }: SankeyChartProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/SpectrogramChart.d.ts

@@ -0,0 +1,16 @@
+export interface SpectrogramChartProps {
+    signal: ArrayLike<number>;
+    sampleRate?: number;
+    windowSize?: number;
+    overlap?: number;
+    winFunc?: 'hann' | 'rectangular';
+    yMode?: 'amplitude' | 'db';
+    logFreq?: boolean;
+    label?: string;
+    backgroundToken?: string;
+    onPlotContextMenu?: (e: {
+        clientX: number;
+        clientY: number;
+    }) => void;
+}
+export declare function SpectrogramChart({ signal, sampleRate, windowSize, overlap, winFunc, yMode, logFreq, label, backgroundToken, onPlotContextMenu, }: SpectrogramChartProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/SpectrogramWaterfall.d.ts

@@ -0,0 +1,14 @@
+export interface SpectrogramWaterfallProps {
+    signal: ArrayLike<number>;
+    sampleRate: number;
+    windowSize: number;
+    overlap: number;
+    winFunc: 'hann' | 'rectangular';
+    yMode: 'db' | 'amplitude';
+    backgroundToken?: string;
+    onPlotContextMenu?: (e: {
+        clientX: number;
+        clientY: number;
+    }) => void;
+}
+export declare function SpectrogramWaterfall({ signal, sampleRate, windowSize, overlap, winFunc, yMode, backgroundToken, onPlotContextMenu }: SpectrogramWaterfallProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/SpectrumChart.d.ts

@@ -0,0 +1,17 @@
+export interface SpectrumChartProps {
+    signal: ArrayLike<number>;
+    sampleRate?: number;
+    label: string;
+    xMode?: 'hz' | 'order';
+    yMode?: 'amplitude' | 'db';
+    window?: 'hann' | 'rectangular';
+    color?: string;
+    logX?: boolean;
+    height?: number;
+    backgroundToken?: string;
+    onPlotContextMenu?: (e: {
+        clientX: number;
+        clientY: number;
+    }) => void;
+}
+export declare function SpectrumChart({ signal, sampleRate, label, xMode, yMode, window: winProp, color, logX, height, backgroundToken, onPlotContextMenu, }: SpectrumChartProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/TreemapChart.d.ts

@@ -0,0 +1,14 @@
+export interface TreemapNode {
+    name: string;
+    parent: string;
+    value: number;
+}
+export interface TreemapChartProps {
+    nodes: TreemapNode[];
+    backgroundToken?: string;
+    onPlotContextMenu?: (e: {
+        clientX: number;
+        clientY: number;
+    }) => void;
+}
+export declare function TreemapChart({ nodes, backgroundToken, onPlotContextMenu, }: TreemapChartProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/ViolinChart.d.ts

@@ -0,0 +1,17 @@
+export interface ViolinGroup {
+    label: string;
+    values: ArrayLike<number>;
+}
+export interface ViolinChartProps {
+    groups: ViolinGroup[];
+    color?: string;
+    showBox?: boolean;
+    bandwidth?: number;
+    orientation?: 'vertical' | 'horizontal';
+    backgroundToken?: string;
+    onPlotContextMenu?: (e: {
+        clientX: number;
+        clientY: number;
+    }) => void;
+}
+export declare function ViolinChart({ groups, color, showBox, bandwidth, orientation, backgroundToken, onPlotContextMenu, }: ViolinChartProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/XYScatterChart.d.ts

@@ -0,0 +1,47 @@
+import type { AxisLineStyle, XyAxisScaleSettings, XyFitSettings } from '../lib/panelChartSettings';
+import { type XYColumns } from '../lib/data/xyColumns';
+export interface XYPoint {
+    x: number;
+    y: number;
+    /** Optional color value for colormap mode. Normalized to [0,1] by App.tsx. */
+    c?: number;
+    /** Optional dataset index for per-dataset coloring (multi-dataset mode). */
+    d?: number;
+}
+export interface XYScatterChartProps {
+    /** Every point to draw: columns (drawn as they are, on the GPU) or XYPoint objects. */
+    points: XYPoint[] | XYColumns;
+    xLabel: string;
+    yLabel: string;
+    color?: string;
+    /**
+     * Per-dataset colors (index === point.d). When present (multi-dataset mode),
+     * points are colored by their dataset and this takes precedence over the
+     * colormap `c` values.
+     */
+    datasetColors?: string[];
+    /** Label for the color axis (shown in legend). */
+    colorLabel?: string;
+    /** Raw min/max of the color column for the legend labels. */
+    colorRange?: [number, number];
+    height?: number;
+    /** Scatter dot radius in CSS pixels. Default 1.8. */
+    pointRadius?: number;
+    /** Points, a line through them in data order, or both. Default points. */
+    drawMode?: 'points' | 'lines' | 'both';
+    /** Line width in CSS px (lines). Default 1. */
+    lineWidth?: number;
+    /** When this value changes (e.g. custom plot background), styles are re-read from CSS. */
+    backgroundToken?: string;
+    onPlotContextMenu?: (e: {
+        clientX: number;
+        clientY: number;
+    }) => void;
+    xAxisLine?: AxisLineStyle;
+    yAxisLine?: AxisLineStyle;
+    gridLine?: AxisLineStyle;
+    fitSettings?: XyFitSettings | null;
+    xScale?: XyAxisScaleSettings | null;
+    yScale?: XyAxisScaleSettings | null;
+}
+export declare function XYScatterChart({ points, xLabel, yLabel, color, datasetColors, colorLabel, colorRange, height, pointRadius, drawMode, lineWidth, backgroundToken, onPlotContextMenu, xAxisLine, yAxisLine, gridLine, fitSettings, xScale, yScale, }: XYScatterChartProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/XYZMeshChart.d.ts

@@ -0,0 +1,68 @@
+export interface XYZPoint {
+    x: number;
+    y: number;
+    z: number;
+}
+/** Points as columns: one array per axis, `length` long. */
+export interface XYZColumns {
+    length: number;
+    x: ArrayLike<number>;
+    y: ArrayLike<number>;
+    z: ArrayLike<number>;
+}
+/**
+ * Heights over a uniform grid: `w` × `h` values row by row, column c at
+ * x[0] + c·(x[1] − x[0])/(w − 1), row r at y[0] + r·(y[1] − y[0])/(h − 1).
+ * NaN leaves a hole.
+ */
+export interface XYZSurface {
+    w: number;
+    h: number;
+    values: ArrayLike<number>;
+    x: [number, number];
+    y: [number, number];
+}
+export type XYZViewMode = '3d' | 'xy' | 'xz' | 'yz';
+export interface XYZAlarmPlane {
+    axis: 'x' | 'y' | 'z';
+    value: number;
+    color: string;
+    style: 'solid' | 'dashed' | 'dotted';
+    width: number;
+}
+export interface XYZMeshChartProps {
+    points: XYZPoint[] | XYZColumns;
+    /** A surface over a uniform grid, drawn with (or instead of) the points. */
+    surface?: XYZSurface;
+    xLabel: string;
+    yLabel: string;
+    zLabel: string;
+    height?: number;
+    /** When this value changes (e.g. custom plot background), styles are re-read from CSS. */
+    backgroundToken?: string;
+    /** Optional per-axis data ranges. Points outside are filtered; axes use these bounds. */
+    xRange?: [number, number];
+    yRange?: [number, number];
+    zRange?: [number, number];
+    /** 3D perspective (default) or 2D projection onto a chosen plane. */
+    viewMode?: XYZViewMode;
+    /** Radius of sample markers in CSS pixels (2D views and 3D). Default 4. */
+    pointRadius?: number;
+    /** Alarm planes — each renders as a semi-transparent plane in 3D or a line in 2D projections. */
+    alarms?: XYZAlarmPlane[];
+    /** Show Delaunay triangulated surface. Default false. */
+    showMesh?: boolean;
+    /** Mesh rendering style. Default 'filled'. */
+    meshStyle?: 'filled' | 'wireframe' | 'both';
+    /** Triangle fill opacity 0–1. Default 0.85. */
+    meshOpacity?: number;
+    onPlotContextMenu?: (e: {
+        clientX: number;
+        clientY: number;
+    }) => void;
+}
+export type XYZMeshChartHandle = {
+    /** Reset camera to the default framing (same as double‑click on the chart). */
+    autoscale: () => void;
+};
+export declare const XYZMeshChart: import("react").ForwardRefExoticComponent<XYZMeshChartProps & import("react").RefAttributes<XYZMeshChartHandle>>;

package/dist/types/components/dashboardGridLayout.d.ts

@@ -0,0 +1,50 @@
+/** Horizontal virtual columns (was 12; finer = smoother drag/resize). */
+export declare const DASHBOARD_GRID_COLS = 96;
+/** Virtual rows for the dashboard area; rows use 1fr so they fill the viewport. */
+export declare const DASHBOARD_GRID_ROWS = 96;
+/** Fallback row height (only used if grid-template-rows isn't applied). */
+export declare const DASHBOARD_ROW_HEIGHT_PX = 4;
+export declare const DASHBOARD_GRID_GAP_PX = 2;
+/** Hard cap on the number of charts we auto-arrange. */
+export declare const MAX_DASHBOARD_PANELS = 16;
+export type DashboardPanelKind = 'multiband' | 'xyscatter' | 'xyzmesh' | 'histogram' | 'polar' | 'spectrum' | 'boxplot' | 'spectrogram' | 'heatmap' | 'violin' | 'confusion' | 'roc' | 'losscurve' | 'controlchart' | 'parallelcoords' | 'embedding' | 'flamegraph' | 'barchart' | 'radar' | 'areachart' | 'cdfchart' | 'bubblechart' | 'treemap' | 'sankey' | 'calibration' | 'qqplot' | 'gantt' | 'gauge';
+export interface DashboardGridRect {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+export interface DashboardPanel {
+    id: string;
+    kind: DashboardPanelKind;
+    rect: DashboardGridRect;
+    /** User-defined chart title. When empty/undefined the kind label is used. */
+    title?: string;
+}
+/** Legacy 12-col grid → current scale (96 / 12 = 8). */
+export declare const LEGACY_GRID_SCALE = 8;
+export declare const MIN_PANEL_W: Record<DashboardPanelKind, number>;
+export declare const MIN_PANEL_H: Record<DashboardPanelKind, number>;
+export declare function rectsOverlap(a: DashboardGridRect, b: DashboardGridRect): boolean;
+export declare function clampRectForKind(kind: DashboardPanelKind, r: DashboardGridRect, cols: number, rows?: number): DashboardGridRect;
+/**
+ * A chart's grid rectangle after a pointer drag of (dxPx, dyPx) on a board of
+ * `board` CSS pixels: 'move' shifts it, 'resize' moves its bottom-right corner.
+ * The result stays on the grid and never shrinks below the kind's minimum; a
+ * move past an edge trims the chart rather than stopping it. Call
+ * it on pointermove with the rectangle from pointerdown, then store the result
+ * with `charts.setLayout`.
+ */
+export declare function dragLayout(kind: DashboardPanelKind, start: DashboardGridRect, mode: 'move' | 'resize', dxPx: number, dyPx: number, board: {
+    width: number;
+    height: number;
+}, cols?: number, rows?: number): DashboardGridRect;
+export declare function layoutPanelsValid(panels: DashboardPanel[], cols?: number, rows?: number): boolean;
+/** Place a new panel without overlapping existing ones. */
+export declare function suggestNewPanelRect(kind: DashboardPanelKind, existing: DashboardPanel[], cols?: number): DashboardGridRect;
+export declare function newPanel(kind: DashboardPanelKind, existing: DashboardPanel[]): DashboardPanel;
+/**
+ * Reposition every panel onto the recursive split layout. Order in the input
+ * array decides which slot each panel takes.
+ */
+export declare function arrangeAutoLayout(panels: DashboardPanel[], cols?: number, rows?: number): DashboardPanel[];

package/dist/types/components/liveFollowEase.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Fraction of the remaining gap to close this animation frame for an exponential
+ * (critically-damped) follow: `value += (target - value) * factor`.
+ *
+ * Derived from the frame time so the motion is frame-rate independent — the same
+ * wall-clock easing whether the display runs at 60, 120 or 360 Hz. Two 8 ms
+ * steps close the same gap as one 16 ms step. `tauMs` is the time constant: the
+ * gap shrinks by 1/e every `tauMs` of real time.
+ */
+export declare function followEaseFactor(dtMs: number, tauMs: number): number;

package/dist/types/components/liveWindow.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Compute the live auto-scroll X target from the buffer's extent and an optional
+ * fixed time window (seconds).
+ *
+ * WHY: with no window the chart tracks the whole extent `[oldest, newest]`. While
+ * a live stream fills the ring, `oldest` is pinned (nothing evicts yet) and
+ * `newest` grows, so the window WIDENS from ~0 to the full buffer span (~120 s) —
+ * a continuous zoom-out. Since scroll speed = plotWidth / span, that collapses the
+ * left-ward motion ~100× as it fills (measured 1788 → 16 px/s), so near-full the
+ * trace crawls. A FIXED window keeps the span constant → constant scroll speed.
+ *
+ * The left edge clamps to `oldest`, so the window still grows with the data until
+ * it reaches `windowSeconds` (no empty gutter early), then pins to
+ * `[newest - windowSeconds, newest]` and scrolls at a steady rate. `null`/≤0 keeps
+ * the full-extent ("All") behaviour.
+ */
+export declare function liveWindowTarget(oldest: number, newest: number, windowSeconds: number | null, latest?: number): [number, number];
+/**
+ * How many decimation buckets the live pull should request: ~2 per DEVICE pixel
+ * of the plot, clamped to a sane range.
+ *
+ * WHY: a fixed low budget (2000) left the bucket wider than the sample spacing at
+ * common windows, so most buckets held 2+ samples and rendered as min→max
+ * vertical bars ~1 px apart — on fast channels (RPM, throttle, gear) the trace
+ * became a comb that flickered as it slid sub-pixel, and looked low-resolution.
+ * Sizing to the actual plot pixels makes buckets ≤ one sample at typical windows
+ * (a plain continuous polyline through the real samples) while denser views
+ * (All/2 m) pack the bars sub-pixel into an honest solid envelope. The floor
+ * covers the not-yet-measured first frame; the cap bounds the per-frame pull and
+ * point-array cost on very large displays.
+ */
+export declare function livePullMaxPoints(plotWCss: number, dpr: number): number;
+/** Narrowest live window a wheel zoom-in can reach, in seconds. */
+export declare const LIVE_MIN_WINDOW_S = 0.5;
+/**
+ * Next live window (seconds) after one wheel tick on a live time axis. The span
+ * changes but the window stays pinned to the live edge, so zooming shows more or
+ * less history while the newest samples keep scrolling in. The current span is
+ * clamped to what is actually buffered (`extent`), so a 30 s window over 10 s of
+ * data zooms from 10 s, not from an invisible 30 s. Zooming out to the whole
+ * buffer returns `null` ("All").
+ */
+export declare function liveZoomWindow(windowSeconds: number | null, extent: number, zoomIn: boolean, minSpan?: number): number | null;
+/**
+ * Smooth playout of a bursty live feed. Samples arrive in messages (10–30 per
+ * second, capped by plan), each carrying a burst of samples, so drawing up to
+ * the newest sample moves the trace in steps at the message rate however fast
+ * the chart repaints. Instead the drawn edge is a display time that advances
+ * with the wall clock every frame, held about one message behind the newest
+ * sample (the burst length, smoothed), with a gentle pull toward that lag so a
+ * feed faster or slower than real time is followed too.
+ */
+export interface Playout {
+    /** Display time; null until the first sample. */
+    d: number | null;
+    /** Newest sample time seen. */
+    lastT: number;
+    /** Smoothed burst length (data seconds per message). */
+    burst: number;
+}
+export declare function createPlayout(): Playout;
+/** Advance `p` one frame (`dtMs`) given the newest sample time `t`; the display time. */
+export declare function advancePlayout(p: Playout, t: number, dtMs: number): number;

package/dist/types/components/multiBandHover.d.ts

@@ -0,0 +1,44 @@
+import type { PointColumns } from '../lib/data/pointColumns';
+/** X in data units under a cursor pixel, for the current view. */
+export declare function dataXAtPx(px: number, left: number, plotW: number, xmin: number, xmax: number): number;
+/**
+ * Value of each channel under the cursor, keyed by column.
+ *
+ * Resolved from the cursor's X in data units — never from a point index. A live
+ * stream rebuilds its points several times a second off a rolling buffer, so an
+ * index walks to ever newer samples and the readout drifts away from where the
+ * user pointed.
+ *
+ * Each column is searched independently, across every layer: in multi-dataset
+ * mode a layer carries only its own source's columns (`Speed__0` or
+ * `Speed__1`, never both), so the globally nearest point says nothing about the
+ * others.
+ *
+ * `columns` are the plotted columns to resolve — nothing else is read.
+ *
+ * `reachByCol` bounds how far that column's nearest sample may be, in data
+ * units — pass its line-join threshold so a channel reads out exactly where its
+ * line is drawn, and stays absent over a gap or over chart a live feed has not
+ * reached yet. A column with no entry is unbounded.
+ *
+ * The scan is linear because points are in SAMPLE order, which is sorted by X
+ * only when X is a monotonic channel. Plotted against lap distance, a live
+ * buffer spanning a lap boundary runs 3900→4897 and then restarts at 0; a
+ * bisection lands in the wrong branch and reports no data over half the chart.
+ */
+export declare function valuesUnderCursor(layers: PointColumns[], targetX: number, columns: string[], reachByCol?: Map<string, number>): Map<string, number>;
+/**
+ * Value of each column at the point nearest to `x` that has it (each layer
+ * sorted by X). Binary search, then a short walk outwards: O(log n), not a full
+ * scan. Across layers, the nearest one wins.
+ */
+export declare function valuesNearX(layers: PointColumns[], columns: string[], x: number, maxWalk?: number): Map<string, number>;
+/**
+ * Newest numeric value of each requested column — the live edge of the feed.
+ * Shown in the legend while nothing is hovered, so an untouched chart reads out
+ * the current value of every channel instead of a placeholder. Scans backwards
+ * (last layer first) and stops as soon as every column is resolved, so trailing
+ * gaps (a signal missing from the last few frames) fall back to its last real
+ * sample.
+ */
+export declare function latestValuesByColumn(layers: PointColumns[], columns: string[]): Map<string, number>;

package/dist/types/embed/Attribution.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Shown on every chart of an unlicensed page (TradingView-style attribution). Never blocks
+ * use. Styled inline so it renders the same in React hosts and shadow roots.
+ */
+export declare function Attribution(): import("react/jsx-runtime").JSX.Element;