@photonviz/core 0.3.1 → 0.4.0

package/dist/index.d.ts

@@ -1380,6 +1380,25 @@ interface PlotTitleOptions {
     align?: "left" | "center" | "right";
 }
 
+/**
+ * Shared image-export helpers used by Plot / Plot3D / PolarPlot. Each plot
+ * composites its layers into a single 2D canvas, then these turn that canvas into
+ * a data URL / Blob / download / clipboard image.
+ */
+/** Options accepted by the export methods. */
+interface ExportOptions {
+    /** Fill color behind the plot (default the theme page color; `"transparent"` keeps alpha). */
+    background?: string;
+    /** Encoder quality 0..1 for lossy types (`image/jpeg`, `image/webp`). */
+    quality?: number;
+}
+/** Turn a canvas into a `Blob` (default PNG). */
+declare function canvasToBlob(canvas: HTMLCanvasElement, type?: string, quality?: number): Promise<Blob | null>;
+/** Download a canvas as an image file (PNG by default). */
+declare function downloadCanvas(canvas: HTMLCanvasElement, filename?: string, type?: string, quality?: number): Promise<void>;
+/** Copy a canvas to the clipboard as a PNG. Throws where the browser can't. */
+declare function copyCanvasToClipboard(canvas: HTMLCanvasElement): Promise<void>;
+
 interface AxisScaleOptions {
     type?: ScaleType;
     /** Fixed domain. If omitted, the axis autoscales to the data. */
@@ -1469,7 +1488,10 @@ interface GraphInput extends Omit<GraphOptions, "x" | "y"> {
 /**
  * A Canvas2D overlay marker drawn above the data, projected through the scales:
  * a full-width/height guide line (`span`), a shaded range (`band`), a rectangle
- * (`box`), or text (`label`). `yAxis` targets a secondary axis where relevant.
+ * (`box`), text (`label`), an arbitrary segment (`line` — trendlines), a segment
+ * extended past its end (`ray`), or Fibonacci retracement levels (`fib`). `yAxis`
+ * targets a secondary axis where relevant. All coordinates are in data space, so
+ * annotations pan and zoom with the chart.
  */
 type Annotation = {
     type: "span";
@@ -1492,6 +1514,7 @@ type Annotation = {
     y: Range;
     color?: string;
     border?: string;
+    label?: string;
     yAxis?: string;
 } | {
     type: "label";
@@ -1502,7 +1525,42 @@ type Annotation = {
     font?: string;
     align?: "left" | "center" | "right";
     yAxis?: string;
+} | {
+    type: "line";
+    x0: number;
+    y0: number;
+    x1: number;
+    y1: number;
+    color?: string;
+    width?: number;
+    dash?: number[];
+    label?: string;
+    yAxis?: string;
+} | {
+    type: "ray";
+    x0: number;
+    y0: number;
+    x1: number;
+    y1: number;
+    color?: string;
+    width?: number;
+    dash?: number[];
+    label?: string;
+    yAxis?: string;
+} | {
+    type: "fib";
+    x0: number;
+    x1: number;
+    high: number;
+    low: number;
+    ratios?: number[];
+    color?: string;
+    fill?: boolean;
+    label?: string;
+    yAxis?: string;
 };
+/** An interactive drawing tool: click-drag on the plot to place the shape. */
+type DrawTool = "trendline" | "hline" | "ray" | "fib" | "rect";
 /** One line of the hover tooltip header, produced by {@link PlotOptions.hoverReadout}. */
 interface HoverReadoutRow {
     label: string;
@@ -1531,6 +1589,10 @@ interface PlotOptions {
     interactive?: boolean;
     /** Show the built-in toolbar (home + pan/box/X/Y zoom modes). Default true. */
     showToolbar?: boolean;
+    /** Add drawing tools (trendline / horizontal / ray / Fibonacci / rectangle) to the toolbar. Default false. */
+    drawingTools?: boolean;
+    /** Accessible label for the chart (sets `role="img"` + `aria-label`). Auto-summarized if omitted. */
+    ariaLabel?: string;
     /** Initial interaction mode. Default `"pan"`. */
     mode?: InteractionMode;
     /** Enable hover crosshair + tooltip. Default true. */
@@ -1578,6 +1640,7 @@ interface PlotOptions {
  */
 declare class Plot {
     private container;
+    private ariaLabel?;
     private gridCanvas;
     private dataCanvas;
     private axisCanvas;
@@ -1619,6 +1682,13 @@ declare class Plot {
     private lastEmittedX;
     private lastEmittedCursor;
     private linkedCursorX;
+    private drawTool;
+    private drawings;
+    private pendingDrawing;
+    private drawToolCbs;
+    private hoverDrawing;
+    private selectedDrawing;
+    private drawMenu;
     private tooltip;
     /** A point clicked to pin its details, until another click clears it. */
     private selected;
@@ -1637,8 +1707,13 @@ declare class Plot {
     /** Pixel x-position (and title x) for each y axis, by draw order per side. */
     private yAxisPositions;
     private register;
+    /** Set the chart's accessible label (`aria-label`). Pass `undefined` to auto-summarize. */
+    setAriaLabel(text: string | undefined): void;
+    /** A one-line text summary of the chart (title + series), for a11y / tooltips. */
+    describe(): string;
+    private updateAria;
     /**
-     * Register a layer built outside core (e.g. `@photonviz/map`). Use with
+     * Register a layer built outside core (a custom WebGL2 `Layer`). Use with
      * {@link context} to construct the layer against this plot's WebGL2 context.
      */
     add<T extends Layer>(layer: T): T;
@@ -1700,6 +1775,41 @@ declare class Plot {
     addAnnotation(a: Annotation): () => void;
     /** Remove all annotations. */
     clearAnnotations(): void;
+    /** Activate a drawing tool (click-drag on the plot to place), or `null` to stop drawing. */
+    setDrawTool(tool: DrawTool | null): void;
+    /** The active drawing tool, or `null`. */
+    getDrawTool(): DrawTool | null;
+    /** Subscribe to draw-tool changes (used by the toolbar). Returns an unsubscribe fn. */
+    onDrawToolChange(cb: (t: DrawTool | null) => void): () => void;
+    /** Add a drawing programmatically (same shapes the tools produce). */
+    addDrawing(a: Annotation): void;
+    /** All user drawings (trendlines, fib levels, …). */
+    getDrawings(): Annotation[];
+    /** Remove every user drawing. */
+    clearDrawings(): void;
+    /** Canvas-space pixel → data coordinates on the x + primary y scale. */
+    private dataAtPx;
+    /** Build the annotation for a draw tool from its start + current data points. */
+    private buildDrawing;
+    private drawingYScale;
+    /** Editable handle points (data space) for a drawing; `[]` if it has none. */
+    private drawingHandlePts;
+    /** Move handle `i` of a drawing to a new data-space point (all editable types). */
+    private setDrawingHandle;
+    /** Translate a whole drawing by a data-space delta (drag the body). */
+    private translateDrawing;
+    /** Cursor→drawing distance in px (segment for line/ray, edges for box/fib, the line for span). */
+    private drawingBodyDist;
+    /** Topmost drawing under the cursor and its handle (handle −1 = body, index −1 = none). */
+    private hitDrawing;
+    private removeDrawing;
+    private hideDrawMenu;
+    /** Right-click context menu for a drawing: rename, recolor, delete. */
+    private showDrawMenu;
+    /** Recolor a drawing: a box keeps its translucent fill + opaque border; others take the color directly. */
+    private recolorDrawing;
+    /** Prompt for a label on a drawing (double-click / context menu). */
+    private renameDrawing;
     /** Compute an STFT of `signal` and render it as a heatmap (time × frequency). */
     addHeatmapSpectrogram(signal: ArrayLike<number>, opts?: {
         fftSize?: number;
@@ -1748,6 +1858,20 @@ declare class Plot {
     onModeChange(cb: (mode: InteractionMode) => void): void;
     /** Reset to the home view: explicit domains restored, auto axes re-fit to data. */
     home(): void;
+    /**
+     * Composite this plot's layers (grid → data → axes/labels) into a single 2D
+     * canvas at device resolution. `background` fills behind the plot (default the
+     * theme's page color; pass `"transparent"` to keep alpha).
+     */
+    private compositeCanvas;
+    /** Export the current view as a data URL (default PNG). */
+    toDataURL(type?: string, opts?: ExportOptions): string;
+    /** Export the current view as a `Blob` (default PNG). */
+    toBlob(type?: string, opts?: ExportOptions): Promise<Blob | null>;
+    /** Download the current view as an image (PNG by default). */
+    downloadImage(filename?: string, type?: string, opts?: ExportOptions): Promise<void>;
+    /** Copy the current view to the clipboard as a PNG. Throws if the browser can't. */
+    copyToClipboard(opts?: ExportOptions): Promise<void>;
     /** Re-fit auto axes to the data: x over all series, each y axis over its own series. */
     autoscale(): void;
     destroy(): void;
@@ -1823,6 +1947,15 @@ interface ToolbarHost {
     getMode(): InteractionMode;
     home(): void;
     onModeChange(cb: (mode: InteractionMode) => void): void;
+    /** Optional: download the current view as a PNG. Adds a toolbar button when present. */
+    download?(): void;
+    /** Optional: interactive drawing tools. Adds a tool group (trendline / hline / ray / fib / rect / clear) when present. */
+    drawTools?: {
+        set(tool: string | null): void;
+        get(): string | null;
+        clear(): void;
+        onChange(cb: (tool: string | null) => void): void;
+    };
 }
 interface ToolbarTheme {
     bg: string;
@@ -1952,6 +2085,16 @@ declare class PolarPlot {
     getRotation(): number;
     /** Set the rotation offset (radians, CCW) and redraw. */
     setRotation(rad: number): void;
+    /** Composite grid → data → overlay into one canvas at device resolution. */
+    private compositeCanvas;
+    /** Export the current view as a data URL (default PNG). */
+    toDataURL(type?: string, opts?: ExportOptions): string;
+    /** Export the current view as a `Blob` (default PNG). */
+    toBlob(type?: string, opts?: ExportOptions): Promise<Blob | null>;
+    /** Download the current view as an image (PNG by default). */
+    downloadImage(filename?: string, type?: string, opts?: ExportOptions): Promise<void>;
+    /** Copy the current view to the clipboard as a PNG. */
+    copyToClipboard(opts?: ExportOptions): Promise<void>;
     destroy(): void;
     private resize;
     requestRender(): void;
@@ -2456,6 +2599,8 @@ interface Plot3DOptions {
     hover?: boolean;
     /** Show a reset-view (home) button. Default true. */
     resetButton?: boolean;
+    /** Show a download-PNG button. Default true. */
+    downloadButton?: boolean;
     /** Draw grid lines on the back walls of the cube. Default true. */
     gridPlanes?: boolean;
     /** Auto-orbit the camera: `true` for a default speed, or radians/frame. Default off. */
@@ -2509,6 +2654,7 @@ declare class Plot3D {
     private colorbarDiv;
     private tooltip;
     private resetBtn;
+    private downloadBtn;
     private hoverEnabled;
     /** Screen position (device px) of the picked point, for the highlight ring. */
     private hoverHit;
@@ -2551,6 +2697,16 @@ declare class Plot3D {
     removeLayer(layer: Layer3D): void;
     /** Re-fit the axes to the data and redraw — call after a layer's `setData(...)`. */
     refresh(): void;
+    /** Copy the current 3D frame (already composited on one canvas) into a fresh canvas. */
+    private compositeCanvas;
+    /** Export the current view as a data URL (default PNG). */
+    toDataURL(type?: string, opts?: ExportOptions): string;
+    /** Export the current view as a `Blob` (default PNG). */
+    toBlob(type?: string, opts?: ExportOptions): Promise<Blob | null>;
+    /** Download the current view as an image (PNG by default). */
+    downloadImage(filename?: string, type?: string, opts?: ExportOptions): Promise<void>;
+    /** Copy the current view to the clipboard as a PNG. */
+    copyToClipboard(opts?: ExportOptions): Promise<void>;
     destroy(): void;
     private recompute;
     /** Build tick-mark line geometry + tick/title labels from the data bounds. */
@@ -2746,6 +2902,54 @@ declare function trueRange(high: ArrayLike<number>, low: ArrayLike<number>, clos
 declare function atr(high: ArrayLike<number>, low: ArrayLike<number>, close: ArrayLike<number>, period?: number): Float64Array;
 /** Index of the first non-NaN value (−1 if all NaN). Handy for trimming warm-up. */
 declare function firstFinite(values: ArrayLike<number>): number;
+interface Stochastic {
+    k: Float64Array;
+    d: Float64Array;
+}
+/** Stochastic oscillator: %K over `kPeriod`, %D = SMA(%K, dPeriod). Values 0..100. */
+declare function stochastic(high: ArrayLike<number>, low: ArrayLike<number>, close: ArrayLike<number>, kPeriod?: number, dPeriod?: number): Stochastic;
+interface Channel {
+    middle: Float64Array;
+    upper: Float64Array;
+    lower: Float64Array;
+}
+/** Keltner Channels: EMA(period) ± mult·ATR(atrPeriod). */
+declare function keltner(high: ArrayLike<number>, low: ArrayLike<number>, close: ArrayLike<number>, period?: number, mult?: number, atrPeriod?: number): Channel;
+/** On-Balance Volume — a running signed volume total (no warm-up). */
+declare function obv(close: ArrayLike<number>, volume: ArrayLike<number>): Float64Array;
+interface Ichimoku {
+    conversion: Float64Array;
+    base: Float64Array;
+    spanA: Float64Array;
+    spanB: Float64Array;
+}
+/**
+ * Ichimoku lines (conversion/base/spanA/spanB). Spans are returned **unshifted**
+ * (traditional charts project the cloud forward by `basePeriod` bars).
+ */
+declare function ichimoku(high: ArrayLike<number>, low: ArrayLike<number>, convPeriod?: number, basePeriod?: number, spanBPeriod?: number): Ichimoku;
+interface Adx {
+    adx: Float64Array;
+    plusDI: Float64Array;
+    minusDI: Float64Array;
+}
+/** Wilder's ADX (+DI / −DI / ADX) over `period` (default 14). */
+declare function adx(high: ArrayLike<number>, low: ArrayLike<number>, close: ArrayLike<number>, period?: number): Adx;
+interface SuperTrend {
+    trend: Float64Array;
+    direction: Float64Array;
+}
+/**
+ * SuperTrend (ATR bands with trend-following flip). `trend` is the line; `direction`
+ * is +1 (up / support below price) or −1 (down / resistance above price).
+ */
+declare function superTrend(high: ArrayLike<number>, low: ArrayLike<number>, close: ArrayLike<number>, period?: number, mult?: number): SuperTrend;
+interface FibLevel {
+    ratio: number;
+    price: number;
+}
+/** Fibonacci retracement price levels between a `high` and `low` (standard ratios). */
+declare function fibRetracements(high: number, low: number, ratios?: number[]): FibLevel[];
 
 /**
  * Chart-type transforms: turn raw OHLC(V) into the geometry a specialist finance
@@ -2929,9 +3133,880 @@ interface DepthHandle {
 }
 declare function addDepth(plot: Plot, opts: DepthOptions): DepthHandle;
 
+/**
+ * A tiny dependency-free CSV parser + typed-array column access — the common
+ * "load a CSV and plot a column" path. Handles quoted fields, escaped quotes
+ * (`""`), and `\n` / `\r\n` line endings.
+ */
+interface CSVOptions {
+    /** Field delimiter. Default `","`. */
+    delimiter?: string;
+    /** Treat the first row as headers. Default `true`. */
+    header?: boolean;
+    /** Drop blank lines. Default `true`. */
+    skipEmpty?: boolean;
+}
+/** A parsed CSV: header names + string rows, with typed column accessors. */
+interface Table {
+    headers: string[];
+    rows: string[][];
+    /** Number of data rows. */
+    readonly length: number;
+    /** A column's raw string values (by name or index). */
+    column(name: string | number): string[];
+    /** A column parsed to a `Float64Array` (non-numeric cells become `NaN`). */
+    numeric(name: string | number): Float64Array;
+}
+/** Parse CSV text into a {@link Table}. */
+declare function parseCSV(text: string, opts?: CSVOptions): Table;
+
+/**
+ * Largest-Triangle-Three-Buckets (LTTB) downsampling — reduce a series to
+ * `threshold` points while preserving its visual shape (peaks/troughs), the
+ * standard technique for plotting very long line series. First and last points
+ * are always kept.
+ */
+declare function lttb(x: ArrayLike<number>, y: ArrayLike<number>, threshold: number): {
+    x: Float64Array;
+    y: Float64Array;
+};
+
+/**
+ * Pure ML classification-evaluation metrics: confusion matrix, ROC + AUC,
+ * precision–recall + average precision, calibration (reliability) + ECE, plus
+ * TensorBoard-style EMA smoothing for training curves. All array→struct, zero
+ * deps, unit-tested. Import from `@photonviz/core`; the `addX` builders in
+ * `ml/charts.ts` render these onto a {@link Plot}.
+ */
+/** A confusion matrix: raw counts plus a row-normalized (recall) view. */
+interface ConfusionMatrix {
+    /** Row-major counts, length `classes*classes`; row = true label, col = predicted. */
+    counts: Float64Array;
+    /** Row-normalized: every row sums to 1 (a row with no support stays all-zero). */
+    normalized: Float64Array;
+    /** Per-true-class support (row totals). */
+    support: Float64Array;
+    classes: number;
+}
+/**
+ * Confusion matrix of integer class labels. `classes` defaults to
+ * `max(label) + 1`; out-of-range labels are ignored.
+ */
+declare function confusionMatrix(yTrue: ArrayLike<number>, yPred: ArrayLike<number>, classes?: number): ConfusionMatrix;
+/** A receiver-operating-characteristic curve and its area. */
+interface RocCurve {
+    /** False-positive rate (x), starting at 0. */
+    fpr: Float64Array;
+    /** True-positive rate (y), starting at 0. */
+    tpr: Float64Array;
+    /** Score threshold at each vertex (`+Inf` for the origin). */
+    thresholds: Float64Array;
+    /** Area under the curve (`NaN` when a class is absent). */
+    auc: number;
+}
+/**
+ * ROC curve for binary `labels` (0/1) ranked by `scores` (higher = more positive).
+ * Ties at equal scores are collapsed to a single vertex; AUC by the trapezoid rule.
+ */
+declare function rocCurve(scores: ArrayLike<number>, labels: ArrayLike<number>): RocCurve;
+/** A precision–recall curve and its average precision. */
+interface PrCurve {
+    /** Recall (x), starting at 0. */
+    recall: Float64Array;
+    /** Precision (y), starting at 1. */
+    precision: Float64Array;
+    /** Score threshold at each vertex (`+Inf` for the leading point). */
+    thresholds: Float64Array;
+    /** Average precision — Σ (Rₙ − Rₙ₋₁)·Pₙ (`NaN` with no positives). */
+    ap: number;
+    /** Positive base rate (a no-skill classifier's precision). */
+    baseline: number;
+}
+/** Precision–recall curve for binary `labels` (0/1) ranked by `scores`. */
+declare function prCurve(scores: ArrayLike<number>, labels: ArrayLike<number>): PrCurve;
+/** A reliability diagram: predicted confidence vs. observed frequency, per bin. */
+interface CalibrationCurve {
+    /** Mean predicted probability in each bin (`NaN` if empty). */
+    meanPredicted: Float64Array;
+    /** Observed positive fraction in each bin (`NaN` if empty). */
+    fractionPositive: Float64Array;
+    /** Sample count per bin. */
+    binCount: Float64Array;
+    /** Expected Calibration Error — Σ (nᵦ/N)·|accᵦ − confᵦ|. */
+    ece: number;
+}
+/**
+ * Reliability diagram of predicted probabilities `scores` (in [0,1]) against
+ * binary `labels`, using `bins` equal-width confidence buckets. Empty bins are
+ * `NaN` (skip them when plotting).
+ */
+declare function calibrationCurve(scores: ArrayLike<number>, labels: ArrayLike<number>, bins?: number): CalibrationCurve;
+/**
+ * TensorBoard-style debiased EMA smoothing of a noisy training curve. `weight`
+ * in [0,1) is the momentum (0 = raw, →1 = very smooth). Non-finite inputs pass
+ * through untouched and don't advance the average.
+ */
+declare function emaSmooth(values: ArrayLike<number>, weight?: number): Float64Array;
+
+/**
+ * Pure, dependency-free dimensionality reduction for embedding projections.
+ * {@link pca} projects an `n×d` matrix onto its top-`k` principal components via
+ * covariance power-iteration with deflation — deterministic (no RNG), so tests
+ * and re-renders are stable. Pair with {@link addEmbedding}. For t-SNE/UMAP,
+ * feed precomputed 2-D coordinates straight into the builder.
+ */
+/** The result of {@link pca}: projected scores + the components they project onto. */
+interface PcaResult {
+    /** Projected coordinates, row-major `n×k`. */
+    scores: Float64Array;
+    /** Principal-component directions, row-major `k×d` (unit vectors). */
+    components: Float64Array;
+    /** Explained-variance ratio per component, length `k`. */
+    explained: Float64Array;
+    /** Per-column mean subtracted before projection, length `d`. */
+    mean: Float64Array;
+    n: number;
+    d: number;
+    k: number;
+}
+/** Z-score each of the `d` columns of a row-major `n×d` matrix (unit variance). */
+declare function standardize(data: ArrayLike<number>, n: number, d: number): Float64Array;
+/**
+ * Principal component analysis of a row-major `n×d` matrix, projected to `k`
+ * dims (default 2). Centers columns, forms the `d×d` covariance, then extracts
+ * the top-`k` eigenvectors by power iteration + deflation. Deterministic.
+ */
+declare function pca(data: ArrayLike<number>, n: number, d: number, k?: number): PcaResult;
+
+/**
+ * Convenience builders for ML / deep-learning charts. Each takes a {@link Plot}
+ * and composes existing layers (`addHeatmap`/`addLine`/`addScatter`/`addBar`/
+ * `addArea`) from the pure metrics in `ml/metrics.ts` and reducers in
+ * `ml/reduce.ts` — the same free-function style as the finance builders. No new
+ * WebGL layers. Import from `@photonviz/core`.
+ */
+
+/** tab10 categorical palette, cycled by class index. */
+declare const ML_PALETTE: readonly string[];
+interface ConfusionMatrixOptions {
+    yTrue: ArrayLike<number>;
+    yPred: ArrayLike<number>;
+    /** Number of classes; inferred from the labels when omitted. */
+    classes?: number;
+    colormap?: ColormapName;
+    /** Shade by row-normalized recall instead of raw counts. Default false. */
+    normalize?: boolean;
+    /** Draw the value inside each cell. Default true. */
+    annotate?: boolean;
+}
+interface ConfusionMatrixHandle {
+    heatmap: HeatmapLayer;
+    classes: number;
+}
+/**
+ * Confusion matrix as a heatmap with the true class 0 at the **top** (sklearn
+ * orientation) and per-cell value labels. Give the {@link Plot} `[0,classes]`
+ * axes; set categorical ticks for class names.
+ */
+declare function addConfusionMatrix(plot: Plot, opts: ConfusionMatrixOptions): ConfusionMatrixHandle;
+interface RocCurveOptions {
+    scores: ArrayLike<number>;
+    labels: ArrayLike<number>;
+    color?: string;
+    /** Shade the area under the curve. Default false. */
+    fill?: boolean;
+    /** Draw the y=x chance diagonal. Default true. */
+    showChance?: boolean;
+    name?: string;
+}
+interface RocCurveHandle {
+    line: LineLayer;
+    area?: AreaLayer;
+    auc: number;
+}
+/** ROC curve (FPR→TPR) with the chance diagonal and AUC in the series name. */
+declare function addRocCurve(plot: Plot, opts: RocCurveOptions): RocCurveHandle;
+interface PrCurveOptions {
+    scores: ArrayLike<number>;
+    labels: ArrayLike<number>;
+    color?: string;
+    fill?: boolean;
+    /** Draw the no-skill baseline at the positive base rate. Default true. */
+    showBaseline?: boolean;
+    name?: string;
+}
+interface PrCurveHandle {
+    line: LineLayer;
+    area?: AreaLayer;
+    ap: number;
+}
+/** Precision–recall curve with the no-skill baseline and AP in the series name. */
+declare function addPrCurve(plot: Plot, opts: PrCurveOptions): PrCurveHandle;
+interface CalibrationOptions {
+    scores: ArrayLike<number>;
+    labels: ArrayLike<number>;
+    bins?: number;
+    color?: string;
+    name?: string;
+}
+interface CalibrationHandle {
+    line: LineLayer;
+    points: ScatterLayer;
+    ece: number;
+}
+/** Reliability diagram: mean predicted probability vs. observed frequency + the perfect diagonal. */
+declare function addCalibration(plot: Plot, opts: CalibrationOptions): CalibrationHandle;
+interface EmbeddingOptions {
+    /** 2-D coordinates (t-SNE/UMAP/PCA output). */
+    x: ArrayLike<number>;
+    y: ArrayLike<number>;
+    /** Categorical class per point → one colored, legend-named series each. */
+    labels?: ArrayLike<number> | string[];
+    /** Names indexed by numeric label. */
+    classNames?: string[];
+    /** Continuous value per point → a single colormap series (ignored if `labels`). */
+    colorBy?: ArrayLike<number>;
+    colormap?: ColormapName;
+    palette?: readonly string[];
+    size?: number;
+    /** Per-point hover text (metadata). */
+    text?: ArrayLike<string>;
+    name?: string;
+    renderType?: RenderType;
+}
+interface EmbeddingHandle {
+    layers: ScatterLayer[];
+}
+/**
+ * Embedding scatter — one colored series per class when `labels` are given (a
+ * legend-ready projector), a single colormap series for a continuous `colorBy`,
+ * or a plain scatter otherwise. Use `pick: "xy"` on the {@link Plot} for hover.
+ */
+declare function addEmbedding(plot: Plot, opts: EmbeddingOptions): EmbeddingHandle;
+interface DecisionBoundaryOptions {
+    /** Row-major grid of predicted class / probability, row 0 at the bottom. */
+    values: ArrayLike<number>;
+    cols: number;
+    rows: number;
+    extent: {
+        x: Range;
+        y: Range;
+    };
+    colormap?: ColormapName;
+    domain?: Range;
+    /** Training points drawn over the field. */
+    points?: {
+        x: ArrayLike<number>;
+        y: ArrayLike<number>;
+        labels?: ArrayLike<number> | string[];
+        classNames?: string[];
+        palette?: readonly string[];
+        size?: number;
+    };
+}
+interface DecisionBoundaryHandle {
+    heatmap: HeatmapLayer;
+    points: ScatterLayer[];
+}
+/** A decision-boundary field (heatmap) with the training points scattered on top. */
+declare function addDecisionBoundary(plot: Plot, opts: DecisionBoundaryOptions): DecisionBoundaryHandle;
+interface FeatureImportanceOptions {
+    names: string[];
+    values: ArrayLike<number>;
+    color?: string;
+    /** Sort by descending magnitude. Default true. */
+    sort?: boolean;
+    /** Keep only the top-N features. */
+    top?: number;
+    /** Label each bar with its feature name (inside the plot). Default true. */
+    annotate?: boolean;
+    name?: string;
+    renderType?: RenderType;
+}
+interface FeatureImportanceHandle {
+    bars: BarLayer;
+    order: number[];
+}
+/** Feature importance as sorted horizontal bars (most important on top). */
+declare function addFeatureImportance(plot: Plot, opts: FeatureImportanceOptions): FeatureImportanceHandle;
+interface ShapBeeswarmOptions {
+    /** SHAP values per feature: `values[f]` is the row across all samples. */
+    values: number[][];
+    names: string[];
+    /** Feature values (same shape) → point color via a diverging colormap. */
+    featureValues?: number[][];
+    colormap?: ColormapName;
+    size?: number;
+    /** Vertical spread of each feature band, 0..1. Default 0.8. */
+    spread?: number;
+    name?: string;
+}
+interface ShapBeeswarmHandle {
+    scatter: ScatterLayer;
+    order: number[];
+}
+/**
+ * SHAP beeswarm — features stacked by mean |SHAP| (most important on top), each
+ * a horizontal swarm of per-sample points jittered by density and colored by the
+ * feature's value (low→high). A single scatter for one shared colorbar.
+ */
+declare function addShapBeeswarm(plot: Plot, opts: ShapBeeswarmOptions): ShapBeeswarmHandle;
+interface PartialDependenceOptions {
+    x: ArrayLike<number>;
+    /** Mean prediction over the grid. */
+    pd: ArrayLike<number>;
+    /** Optional per-instance ICE curves, each parallel to `x`. */
+    ice?: number[][];
+    color?: string;
+    iceColor?: string;
+    width?: number;
+    name?: string;
+    renderType?: RenderType;
+}
+interface PartialDependenceHandle {
+    pd: LineLayer;
+    ice: LineLayer[];
+}
+/** Partial-dependence line with faint ICE curves behind it. */
+declare function addPartialDependence(plot: Plot, opts: PartialDependenceOptions): PartialDependenceHandle;
+interface AttentionMapOptions {
+    /** Attention weights, query×key: a flat row-major array or a 2-D array. */
+    weights: ArrayLike<number> | number[][];
+    /** Required with a flat `weights`. */
+    queries?: number;
+    keys?: number;
+    colormap?: ColormapName;
+    /** Draw each weight in its cell (small maps only). Default false. */
+    annotate?: boolean;
+}
+interface AttentionMapHandle {
+    heatmap: HeatmapLayer;
+    queries: number;
+    keys: number;
+}
+/** Transformer attention as a heatmap with query 0 at the top, key 0 at the left. */
+declare function addAttentionMap(plot: Plot, opts: AttentionMapOptions): AttentionMapHandle;
+interface TrainingSeries {
+    name?: string;
+    x?: ArrayLike<number>;
+    y: ArrayLike<number>;
+    color?: string;
+}
+interface TrainingCurvesOptions {
+    series: TrainingSeries[];
+    /** EMA smoothing weight 0..1 (0 = raw). Default 0.6. */
+    smoothing?: number;
+    /** Draw the faint raw curve behind the smoothed one. Default true. */
+    showRaw?: boolean;
+    /** Mark the best epoch of each series. */
+    best?: "min" | "max";
+    width?: number;
+    palette?: readonly string[];
+    renderType?: RenderType;
+}
+interface TrainingCurvesHandle {
+    raw: LineLayer[];
+    smoothed: LineLayer[];
+}
+/**
+ * Training curves with TensorBoard-style EMA smoothing — a faint raw line under
+ * a bold smoothed one per series, each streamable via `setData`. Optionally
+ * marks the best epoch. Pair with `renderType: "dynamic"` for live updates.
+ */
+declare function addTrainingCurves(plot: Plot, opts: TrainingCurvesOptions): TrainingCurvesHandle;
+interface RidgeGroup {
+    label?: string;
+    values: ArrayLike<number>;
+}
+interface RidgelineOptions {
+    /** One distribution per group (e.g. a layer's weights per epoch). */
+    groups: RidgeGroup[];
+    /** KDE sample count. Default 96. */
+    points?: number;
+    /** Ridge overlap, 0 = touching, 1 = one full row of overlap. Default 1. */
+    overlap?: number;
+    palette?: readonly string[];
+    /** Fill each ridge. Default true. */
+    fill?: boolean;
+    /** Shared x-range; inferred from the data when omitted. */
+    range?: Range;
+}
+interface RidgelineHandle {
+    areas: AreaLayer[];
+    lines: LineLayer[];
+}
+/**
+ * Ridgeline / joyplot — one KDE per group, vertically offset (TensorBoard's
+ * "distributions over time"). Ridge `i` is baselined at `y=i`; `overlap` lets
+ * neighbours interleave. Feed per-epoch weight/activation samples.
+ */
+declare function addRidgeline(plot: Plot, opts: RidgelineOptions): RidgelineHandle;
+interface BeeswarmOptions {
+    bins?: number;
+    spread?: number;
+}
+/**
+ * Deterministic 1-D beeswarm: given point x-positions, return a symmetric
+ * vertical offset per point (in ±spread/2) so overlapping points fan out by
+ * local density. Pure — no RNG. Backs {@link addShapBeeswarm}.
+ */
+declare function beeswarmLayout(x: ArrayLike<number>, opts?: BeeswarmOptions): number[];
+
+/**
+ * Squarified treemap — a pure layout plus a {@link Plot} builder that composes
+ * the existing {@link PatchesLayer} (one rect patch per item) and a centered
+ * label annotation per cell. Import from `@photonviz/core`.
+ */
+
+/** A weighted item to lay into the treemap. */
+interface TreemapItem {
+    label: string;
+    value: number;
+    /** Explicit fill; otherwise a palette color is cycled by index. */
+    color?: string;
+}
+/** A laid-out cell: the input item plus its axis-aligned rect `[x0,y0]`–`[x1,y1]`. */
+interface TreemapCell {
+    label: string;
+    value: number;
+    color?: string;
+    x0: number;
+    y0: number;
+    x1: number;
+    y1: number;
+}
+/** The rectangle the layout fills. */
+interface TreemapExtent {
+    x: [number, number];
+    y: [number, number];
+}
+/** tab10-ish default palette, cycled by index for items without a color. */
+declare const TREEMAP_PALETTE: readonly string[];
+/**
+ * Squarified treemap layout: sizes rects ∝ `value`, packing them into `extent`
+ * with aspect ratios kept near 1. Pure — no side effects. Zero/negative values
+ * and empty input yield no cells.
+ */
+declare function treemapLayout(items: readonly TreemapItem[], extent?: TreemapExtent): TreemapCell[];
+interface TreemapOptions {
+    items: TreemapItem[];
+    extent?: TreemapExtent;
+    /** Palette cycled by index for items lacking a `color`. Defaults to {@link TREEMAP_PALETTE}. */
+    colors?: string[];
+    opacity?: number;
+    name?: string;
+    renderType?: RenderType;
+    /** Draw a centered label per cell (tiny cells are skipped). Default true. */
+    labels?: boolean;
+}
+/**
+ * Add a squarified treemap: one filled rect {@link Patch} per item plus centered
+ * labels. Composes {@link Plot.addPatches} — low-risk, no new layer type.
+ */
+declare function addTreemap(plot: Plot, opts: TreemapOptions): PatchesLayer;
+
+/**
+ * Funnel chart — a pure layout plus a {@link Plot} builder that composes the
+ * existing {@link PatchesLayer} (one centered trapezoid per stage) with a
+ * centered label per stage. Import from `@photonviz/core`.
+ */
+
+/** One funnel stage: a labeled weighted value. */
+interface FunnelItem {
+    label: string;
+    value: number;
+    /** Explicit fill; otherwise a palette color is cycled by index. */
+    color?: string;
+}
+/** A laid-out stage: the input item plus its trapezoid polygon ring. */
+interface FunnelStage {
+    label: string;
+    value: number;
+    color?: string;
+    /** Closed polygon ring (4 corners) in data space. */
+    poly: {
+        x: number[];
+        y: number[];
+    };
+}
+interface FunnelLayoutOptions {
+    /** Full plot width the largest stage spans. Default 1 (extent `[-0.5, 0.5]`). */
+    width?: number;
+    /** Total stack height. Default 1 (extent `[0, 1]`, top stage first). */
+    height?: number;
+    /** Bottom width of the last stage as a fraction of its value width. Default 0.4. */
+    neck?: number;
+}
+/** tab10-ish default palette, cycled by index for stages without a color. */
+declare const FUNNEL_PALETTE: readonly string[];
+/**
+ * Funnel layout: centered trapezoids stacked top-to-bottom, each stage's top
+ * width ∝ its value and bottom width ∝ the next value (the last stage tapers to
+ * a `neck` fraction of its own width). Pure — no side effects.
+ */
+declare function funnelLayout(items: readonly FunnelItem[], opts?: FunnelLayoutOptions): FunnelStage[];
+interface FunnelOptions {
+    items: FunnelItem[];
+    width?: number;
+    height?: number;
+    neck?: number;
+    /** Palette cycled by index for stages lacking a `color`. Defaults to {@link FUNNEL_PALETTE}. */
+    colors?: string[];
+    opacity?: number;
+    name?: string;
+    renderType?: RenderType;
+    /** Draw a centered label per stage. Default true. */
+    labels?: boolean;
+}
+/**
+ * Add a funnel chart: one filled trapezoid {@link Patch} per stage plus centered
+ * labels. Composes {@link Plot.addPatches} — low-risk, no new layer type.
+ */
+declare function addFunnel(plot: Plot, opts: FunnelOptions): PatchesLayer;
+
+/**
+ * Sunburst (radial icicle) builder. Renders a hierarchy as concentric annular
+ * sectors — one ring per depth, angular span ∝ summed leaf value — by
+ * tessellating each sector into a polygon {@link Patch} ring. Pure
+ * {@link sunburstLayout} does the math; {@link addSunburst} composes the
+ * existing {@link PatchesLayer}. Import from `@photonviz/core`.
+ */
+
+/** A node in the input hierarchy; `value` counts only for leaves. */
+interface SunburstNode {
+    name: string;
+    value?: number;
+    color?: string;
+    children?: SunburstNode[];
+}
+/** Tunables for {@link sunburstLayout}. */
+interface SunburstLayoutOptions {
+    /** Radial thickness of each depth ring, in data units. Default 1. */
+    ringWidth?: number;
+    /** Inner radius of the depth-0 ring (hole at the center). Default 0. */
+    center?: number;
+    /** Angle of the first sector edge, radians. Default `Math.PI / 2` (12 o'clock). */
+    startAngle?: number;
+}
+/** One laid-out sector: angular range `[a0,a1]` (radians) and radial ring `[r0,r1]`. */
+interface SunburstArc {
+    name: string;
+    depth: number;
+    a0: number;
+    a1: number;
+    r0: number;
+    r1: number;
+    color?: string;
+}
+/**
+ * Lay a hierarchy out into flat annular sectors. Angular span is proportional to
+ * summed leaf value; each depth occupies its own radius ring. Side-effect-free.
+ */
+declare function sunburstLayout(root: SunburstNode, opts?: SunburstLayoutOptions): SunburstArc[];
+/** Options for {@link addSunburst}. */
+interface SunburstOptions {
+    root: SunburstNode;
+    /** Radial thickness of each depth ring, in data units. Default 1. */
+    ringWidth?: number;
+    /** Explicit palette, cycled by node index. Falls back to a built-in palette. */
+    colors?: string[];
+    /** Fill opacity, 0..1. Default 1. */
+    opacity?: number;
+    name?: string;
+    /** Buffer-usage hint; set `"dynamic"` when streaming. Default `"static"`. */
+    renderType?: RenderType;
+}
+/**
+ * Build a sunburst from a hierarchy and add it as a {@link PatchesLayer} centered
+ * at (0,0). Set the plot's `equalAspect: true` so the rings stay circular.
+ */
+declare function addSunburst(plot: Plot, opts: SunburstOptions): PatchesLayer;
+
+/**
+ * Radial gauge builder. Draws a background track arc, a colored value arc over
+ * `[min,max]` mapped to an angular sweep (default 220°, 200°→-20°), and a needle.
+ * Pure {@link gaugeLayout} produces tessellated polygons; {@link addGauge}
+ * composes the existing {@link PatchesLayer}. Import from `@photonviz/core`.
+ */
+
+/** An annular-sector polygon, tessellated into a single ring. */
+interface Ring {
+    x: number[];
+    y: number[];
+}
+/** A `{value, color}` band; the arc takes the color of the highest one `value` reaches. */
+interface GaugeThreshold {
+    value: number;
+    color: string;
+}
+/** Tunables for {@link gaugeLayout}. */
+interface GaugeLayoutOptions {
+    value: number;
+    /** Value at the start of the sweep. Default 0. */
+    min?: number;
+    /** Value at the end of the sweep. Default 100. */
+    max?: number;
+    /** Angle of the sweep start, degrees. Default 200. */
+    startAngle?: number;
+    /** Angle of the sweep end, degrees. Default -20. */
+    endAngle?: number;
+    /** Outer radius, data units. Default 1. */
+    radius?: number;
+    /** Inner (track) radius, data units. Default 0.7. */
+    innerRadius?: number;
+}
+/**
+ * Compute the gauge geometry: a full background sector, a value sector clamped to
+ * `[min,max]`, and a thin needle triangle from the center to the value angle.
+ * Angles sweep from `startAngle` to `endAngle` (degrees). Side-effect-free.
+ */
+declare function gaugeLayout(opts: GaugeLayoutOptions): {
+    bg: Ring;
+    value: Ring;
+    needle: {
+        x: number[];
+        y: number[];
+    };
+};
+/** Options for {@link addGauge}. */
+interface GaugeOptions {
+    value: number;
+    /** Value at the start of the sweep. Default 0. */
+    min?: number;
+    /** Value at the end of the sweep. Default 100. */
+    max?: number;
+    /** `{value,color}` bands; the value arc takes the color of the highest one reached. */
+    thresholds?: GaugeThreshold[];
+    /** Value-arc color when no thresholds apply. Default blue. */
+    color?: string;
+    /** Background-track color. Default a muted gray. */
+    trackColor?: string;
+    /** Angle of the sweep start, degrees. Default 200. */
+    startAngle?: number;
+    /** Angle of the sweep end, degrees. Default -20. */
+    endAngle?: number;
+    /** Needle color. Default a dark slate. */
+    needleColor?: string;
+    /** Center label text; defaults to the numeric value. Pass `false` to omit. */
+    label?: string | false;
+    name?: string;
+    /** Buffer-usage hint; set `"dynamic"` when streaming. Default `"static"`. */
+    renderType?: RenderType;
+}
+/**
+ * Build a radial gauge (track + value arc + needle) and add it as a
+ * {@link PatchesLayer} centered at (0,0), with an optional center label.
+ * Set the plot's `equalAspect: true` so it stays circular.
+ */
+declare function addGauge(plot: Plot, opts: GaugeOptions): PatchesLayer;
+
+/** A node: a display `name` and an optional explicit fill `color`. */
+interface SankeyNode {
+    name: string;
+    color?: string;
+}
+/** A flow from node index `source` to node index `target` carrying `value`. */
+interface SankeyLink {
+    source: number;
+    target: number;
+    value: number;
+}
+/** Tuning for the pure {@link sankeyLayout}. All in normalized-extent units. */
+interface SankeyLayoutOptions {
+    /** Drawing box. Defaults to x `[0,1]`, y `[0,1]`. */
+    extent?: {
+        x?: Range;
+        y?: Range;
+    };
+    /** Node rectangle width along x. Default 0.02. */
+    nodeWidth?: number;
+    /** Vertical gap between stacked nodes, as a fraction of the y extent. Default 0.02. */
+    nodePadding?: number;
+}
+/** One laid-out node rectangle, keyed by node index `i`. */
+interface SankeyNodeRect {
+    i: number;
+    x0: number;
+    y0: number;
+    x1: number;
+    y1: number;
+}
+/** One laid-out ribbon polygon (closed ring), keyed by link index. */
+interface SankeyRibbon {
+    link: number;
+    x: number[];
+    y: number[];
+}
+/** Result of {@link sankeyLayout}: node rectangles and link ribbons. */
+interface SankeyLayoutResult {
+    nodeRects: SankeyNodeRect[];
+    ribbons: SankeyRibbon[];
+}
+/**
+ * Pure, side-effect-free Sankey layout. Assigns each node a layer by longest
+ * path from the sources, stacks nodes vertically by throughput, and traces each
+ * link as a bezier ribbon between its source and target edges.
+ */
+declare function sankeyLayout(nodes: SankeyNode[], links: SankeyLink[], opts?: SankeyLayoutOptions): SankeyLayoutResult;
+/** Options for {@link addSankey}. */
+interface SankeyOptions {
+    nodes: SankeyNode[];
+    links: SankeyLink[];
+    /** Drawing box in data space. Defaults to x `[0,1]`, y `[0,1]`. */
+    extent?: {
+        x?: Range;
+        y?: Range;
+    };
+    nodeWidth?: number;
+    nodePadding?: number;
+    /** Per-node colors (by index); overridden by a node's own `color`. */
+    colors?: string[];
+    /** Layer fill opacity (0..1), forwarded to the patches layer. Default 1. */
+    opacity?: number;
+    name?: string;
+    renderType?: RenderType;
+    /** Draw node name labels. Default true. */
+    labels?: boolean;
+}
+/**
+ * Build a Sankey diagram on `plot`: one node rectangle {@link Patch} per node
+ * plus one semi-transparent ribbon patch per link (colored from its source
+ * node), added as a single {@link PatchesLayer}. Node name labels are added as
+ * plot annotations unless `labels` is false.
+ */
+declare function addSankey(plot: Plot, opts: SankeyOptions): PatchesLayer;
+
+/**
+ * Chord diagram — a pure circular layout plus a {@link Plot} builder that composes
+ * the existing {@link PatchesLayer}: thin annular sectors for the group arcs and
+ * bezier-bounded ribbons for the flows between groups, with labels outside each
+ * arc. Import from `@photonviz/core`. Use `equalAspect: true` so it stays circular.
+ */
+
+/** tab10-ish default palette, cycled by group index. */
+declare const CHORD_PALETTE: readonly string[];
+/** A laid-out group arc as a closed ring of `x`/`y` (thin annular sector). */
+interface ChordGroupArc {
+    i: number;
+    x: number[];
+    y: number[];
+}
+/** A laid-out ribbon between groups `i` and `j` as a closed ring of `x`/`y`. */
+interface ChordRibbon {
+    i: number;
+    j: number;
+    x: number[];
+    y: number[];
+}
+/** The result of {@link chordLayout}: outer group arcs plus inter-group ribbons. */
+interface ChordLayoutResult {
+    groupArcs: ChordGroupArc[];
+    ribbons: ChordRibbon[];
+}
+/** Tunable geometry for {@link chordLayout}. */
+interface ChordLayoutOptions {
+    /** Outer radius of the group arcs. Default 1. */
+    radius?: number;
+    /** Total angular gap (radians) split evenly between groups. Default 0.1·2π. */
+    padAngle?: number;
+    /** Thickness of the outer arc as a fraction of `radius`. Default 0.06. */
+    arcWidth?: number;
+    /** Points sampled along each connecting bezier edge of a ribbon. Default 24. */
+    samples?: number;
+}
+/**
+ * Chord layout: groups sit around a circle with angular span ∝ their row-sum
+ * (standard chord convention), separated by `padAngle`. Each group's arc is
+ * sub-divided per target `j`; a ribbon between `i` and `j` is bounded by the two
+ * matching sub-arcs and closed by quadratic beziers curving through the center.
+ * Pure — no side effects. Empty/zero-flow input yields empty arrays.
+ */
+declare function chordLayout(matrix: number[][], opts?: ChordLayoutOptions): ChordLayoutResult;
+interface ChordOptions {
+    /** Square flow matrix; `matrix[i][j]` is the flow from group `i` to group `j`. */
+    matrix: number[][];
+    /** Optional group labels, placed just outside each arc. */
+    labels?: string[];
+    /** Outer radius. Default 1. */
+    radius?: number;
+    /** Palette cycled by group index. Defaults to {@link CHORD_PALETTE}. */
+    colors?: string[];
+    /** Ribbon fill opacity, 0..1. Default 0.65. */
+    opacity?: number;
+    name?: string;
+    renderType?: RenderType;
+}
+/**
+ * Add a chord diagram: opaque per-group outer arcs plus semi-transparent ribbons
+ * (colored by their source group) as {@link Patch}es, with labels outside each
+ * arc. Composes {@link Plot.addPatches} — set `equalAspect: true` on the plot.
+ */
+declare function addChord(plot: Plot, opts: ChordOptions): PatchesLayer;
+
+/**
+ * Parallel coordinates — a pure per-dimension normalization plus a {@link Plot}
+ * builder that composes existing {@link LineLayer}s: one polyline per row crossing
+ * N vertical axes, each axis drawn as a `span` guide with a name label on top.
+ * Import from `@photonviz/core`.
+ */
+
+/** tab10-ish default palette, cycled by row index (or by `colorBy` band). */
+declare const PARALLEL_PALETTE: readonly string[];
+/** A laid-out axis: its dimension name, x position, and observed value range. */
+interface ParallelAxis {
+    dim: string;
+    x: number;
+    min: number;
+    max: number;
+}
+/** A laid-out row as a polyline of N points (one per dimension). */
+interface ParallelLine {
+    row: number;
+    x: number[];
+    y: number[];
+}
+/** The result of {@link parallelLayout}: axis metadata plus per-row polylines. */
+interface ParallelLayoutResult {
+    axes: ParallelAxis[];
+    lines: ParallelLine[];
+}
+/**
+ * Parallel-coordinates layout: axis `i` sits at `x = i`; each dimension's values
+ * are normalized to `y ∈ [0,1]` by its own min/max (a flat dimension maps to 0.5).
+ * Each row becomes an N-point polyline. Pure — no side effects. Non-finite values
+ * fall back to the axis midpoint.
+ */
+declare function parallelLayout(dimensions: string[], rows: number[][]): ParallelLayoutResult;
+interface ParallelOptions {
+    /** One name per axis, left to right. */
+    dimensions: string[];
+    /** Data rows, each parallel to `dimensions`. */
+    rows: number[][];
+    /** Optional per-row value mapped through a palette ramp for coloring. */
+    colorBy?: number[];
+    /** Palette cycled by row index (or banded by `colorBy`). Defaults to {@link PARALLEL_PALETTE}. */
+    colors?: string[];
+    /** Polyline width in px. Default 1. */
+    width?: number;
+    /** Line opacity, 0..1. Default 0.7. */
+    opacity?: number;
+    name?: string;
+    renderType?: RenderType;
+}
+/** The layers created by {@link addParallelCoordinates}: one {@link LineLayer} per row. */
+interface ParallelHandle {
+    lines: LineLayer[];
+}
+/**
+ * Add a parallel-coordinates plot: each row as a {@link Plot.addLine} polyline
+ * (colored via `colorBy` ramp or a cycled palette), each axis as a vertical
+ * `span` guide, plus a dimension-name label at the top of every axis.
+ */
+declare function addParallelCoordinates(plot: Plot, opts: ParallelOptions): ParallelHandle;
+
 /** Parse a CSS hex/rgb color string into normalized RGBA (0..1). */
 declare function parseColor(input: string): [number, number, number, number];
 /** Normalized RGBA (0..1) back to a CSS `rgba(...)` string. */
 declare function toColorCss(c: readonly [number, number, number, number]): string;
 
-export { type Annotation, AreaLayer, type AreaOptions, type AreaSeries, Axis, type AxisConfig, type AxisFrame, type AxisScaleOptions, Bar3DLayer, type Bar3DOptions, BarLayer, type BarOptions, type BarSeries, type BollingerBands, type BollingerHandle, type BollingerOptions, type Bounds, type Bounds3, type BoxGroup, BoxLayer, type BoxOptions, type BoxStats, type Brick, type Candle, type CandlestickData, CandlestickLayer, type CandlestickOptions, CategoricalScale, type Color, type ColorInfo, type ColormapName, Contour3DLayer, type Contour3DOptions, ContourLayer, type ContourOptions, type Density, type DepthCurves, type DepthHandle, type DepthOptions, type Dim, type DrawState, ErrorBarLayer, type ErrorBarOptions, type ForceLayoutOptions, type GraphInput, GraphLayer, type GraphOptions, type GroupedBarOptions, HeatmapLayer, type HeatmapOptions, type HeikinAshiOptions, HexbinLayer, type HexbinOptions, type Histogram, type HoverReadoutRow, ImageLayer, type ImageOptions, type ImageSource, type InteractionMode, IsosurfaceLayer, type IsosurfaceOptions, type Layer, type Layer3D, type Layout, type LegendOptions, Line3DLayer, type Line3DOptions, LineLayer, type LineOptions, LinearScale, LogScale, type Macd, type MarkerShape, type Ohlc, type OhlcArrays, type OhlcInput, OhlcLayer, type OhlcOptions, OrdinalTimeScale, type Patch, PatchesLayer, type PatchesOptions, type PfColumn, type PickMode, PieLayer, type PieOptions, Plot, Plot3D, type Plot3DOptions, type PlotOptions, type PlotTitleOptions, PointCloudLayer, type PointCloudOptions, type PolarLineOptions, type PolarOptions, PolarPlot, type PolarScatterOptions, type PolarSeries, Quiver3DLayer, type Quiver3DOptions, QuiverLayer, type QuiverOptions, type RGB, type Range, type RenderType, type RenkoOptions, type ResolvedAxisStyle, type Scale, type ScaleType, ScatterLayer, type ScatterOptions, type Spectrogram, type StackedAreaOptions, type StackedBarOptions, StemLayer, type StemOptions, SurfaceLayer, type SurfaceOptions, TRANSFORM_GLSL, TRANSFORM_UNIFORMS, type Theme, type Tick, type TicksSpec, TimeScale, type ToolbarHost, type ToolbarTheme, VolumeLayer, type VolumeOptions, type VolumeProfile, type VolumeProfileOptions, type YAxisOptions, addBollinger, addDepth, addHeikinAshi, addRenko, addVolumeProfile, atr, autoTicks, bollinger, boxStats, bufferUsage, colormap, colormapLUT, createProgram, createToolbar, darkTheme, defaultFormat, depth, earcut, ema, fft, firstFinite, forceLayout, heikinAshi, histogram, kde, lightTheme, lineBreak, linkX, macd, makeScale, marchingCubes, parseColor, pointAndFigure, quantileSorted, renko, resolveAxisStyle, resolveTicks, rollingStd, rsi, setTransformUniforms, sma, spectrogram, toColorCss, trueRange, uniformLocations, volumeProfile, vwap, withMinorTicks, wma };
+export { type Adx, type Annotation, AreaLayer, type AreaOptions, type AreaSeries, type AttentionMapHandle, type AttentionMapOptions, Axis, type AxisConfig, type AxisFrame, type AxisScaleOptions, Bar3DLayer, type Bar3DOptions, BarLayer, type BarOptions, type BarSeries, type BeeswarmOptions, type BollingerBands, type BollingerHandle, type BollingerOptions, type Bounds, type Bounds3, type BoxGroup, BoxLayer, type BoxOptions, type BoxStats, type Brick, CHORD_PALETTE, type CSVOptions, type CalibrationCurve, type CalibrationHandle, type CalibrationOptions, type Candle, type CandlestickData, CandlestickLayer, type CandlestickOptions, CategoricalScale, type Channel, type ChordGroupArc, type ChordLayoutOptions, type ChordLayoutResult, type ChordOptions, type ChordRibbon, type Color, type ColorInfo, type ColormapName, type ConfusionMatrix, type ConfusionMatrixHandle, type ConfusionMatrixOptions, Contour3DLayer, type Contour3DOptions, ContourLayer, type ContourOptions, type DecisionBoundaryHandle, type DecisionBoundaryOptions, type Density, type DepthCurves, type DepthHandle, type DepthOptions, type Dim, type DrawState, type DrawTool, type EmbeddingHandle, type EmbeddingOptions, ErrorBarLayer, type ErrorBarOptions, type ExportOptions, FUNNEL_PALETTE, type FeatureImportanceHandle, type FeatureImportanceOptions, type FibLevel, type ForceLayoutOptions, type FunnelItem, type FunnelLayoutOptions, type FunnelOptions, type FunnelStage, type GaugeLayoutOptions, type GaugeOptions, type GaugeThreshold, type GraphInput, GraphLayer, type GraphOptions, type GroupedBarOptions, HeatmapLayer, type HeatmapOptions, type HeikinAshiOptions, HexbinLayer, type HexbinOptions, type Histogram, type HoverReadoutRow, type Ichimoku, ImageLayer, type ImageOptions, type ImageSource, type InteractionMode, IsosurfaceLayer, type IsosurfaceOptions, type Layer, type Layer3D, type Layout, type LegendOptions, Line3DLayer, type Line3DOptions, LineLayer, type LineOptions, LinearScale, LogScale, ML_PALETTE, type Macd, type MarkerShape, type Ohlc, type OhlcArrays, type OhlcInput, OhlcLayer, type OhlcOptions, OrdinalTimeScale, PARALLEL_PALETTE, type ParallelAxis, type ParallelHandle, type ParallelLayoutResult, type ParallelLine, type ParallelOptions, type PartialDependenceHandle, type PartialDependenceOptions, type Patch, PatchesLayer, type PatchesOptions, type PcaResult, type PfColumn, type PickMode, PieLayer, type PieOptions, Plot, Plot3D, type Plot3DOptions, type PlotOptions, type PlotTitleOptions, PointCloudLayer, type PointCloudOptions, type PolarLineOptions, type PolarOptions, PolarPlot, type PolarScatterOptions, type PolarSeries, type PrCurve, type PrCurveHandle, type PrCurveOptions, Quiver3DLayer, type Quiver3DOptions, QuiverLayer, type QuiverOptions, type RGB, type Range, type RenderType, type RenkoOptions, type ResolvedAxisStyle, type RidgeGroup, type RidgelineHandle, type RidgelineOptions, type Ring, type RocCurve, type RocCurveHandle, type RocCurveOptions, type SankeyLayoutOptions, type SankeyLayoutResult, type SankeyLink, type SankeyNode, type SankeyNodeRect, type SankeyOptions, type SankeyRibbon, type Scale, type ScaleType, ScatterLayer, type ScatterOptions, type ShapBeeswarmHandle, type ShapBeeswarmOptions, type Spectrogram, type StackedAreaOptions, type StackedBarOptions, StemLayer, type StemOptions, type Stochastic, type SunburstArc, type SunburstLayoutOptions, type SunburstNode, type SunburstOptions, type SuperTrend, SurfaceLayer, type SurfaceOptions, TRANSFORM_GLSL, TRANSFORM_UNIFORMS, TREEMAP_PALETTE, type Table, type Theme, type Tick, type TicksSpec, TimeScale, type ToolbarHost, type ToolbarTheme, type TrainingCurvesHandle, type TrainingCurvesOptions, type TrainingSeries, type TreemapCell, type TreemapExtent, type TreemapItem, type TreemapOptions, VolumeLayer, type VolumeOptions, type VolumeProfile, type VolumeProfileOptions, type YAxisOptions, addAttentionMap, addBollinger, addCalibration, addChord, addConfusionMatrix, addDecisionBoundary, addDepth, addEmbedding, addFeatureImportance, addFunnel, addGauge, addHeikinAshi, addParallelCoordinates, addPartialDependence, addPrCurve, addRenko, addRidgeline, addRocCurve, addSankey, addShapBeeswarm, addSunburst, addTrainingCurves, addTreemap, addVolumeProfile, adx, atr, autoTicks, beeswarmLayout, bollinger, boxStats, bufferUsage, calibrationCurve, canvasToBlob, chordLayout, colormap, colormapLUT, confusionMatrix, copyCanvasToClipboard, createProgram, createToolbar, darkTheme, defaultFormat, depth, downloadCanvas, earcut, ema, emaSmooth, fft, fibRetracements, firstFinite, forceLayout, funnelLayout, gaugeLayout, heikinAshi, histogram, ichimoku, kde, keltner, lightTheme, lineBreak, linkX, lttb, macd, makeScale, marchingCubes, obv, parallelLayout, parseCSV, parseColor, pca, pointAndFigure, prCurve, quantileSorted, renko, resolveAxisStyle, resolveTicks, rocCurve, rollingStd, rsi, sankeyLayout, setTransformUniforms, sma, spectrogram, standardize, stochastic, sunburstLayout, superTrend, toColorCss, treemapLayout, trueRange, uniformLocations, volumeProfile, vwap, withMinorTicks, wma };