@photonviz/core 0.3.1 → 0.3.2

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,6 +1707,11 @@ 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
      * {@link context} to construct the layer against this plot's WebGL2 context.
@@ -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,499 @@ 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;
+};
+
+/**
+ * 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, 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, CHORD_PALETTE, type CSVOptions, 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, Contour3DLayer, type Contour3DOptions, ContourLayer, type ContourOptions, type Density, type DepthCurves, type DepthHandle, type DepthOptions, type Dim, type DrawState, type DrawTool, ErrorBarLayer, type ErrorBarOptions, type ExportOptions, FUNNEL_PALETTE, 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, 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 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 Ring, type SankeyLayoutOptions, type SankeyLayoutResult, type SankeyLink, type SankeyNode, type SankeyNodeRect, type SankeyOptions, type SankeyRibbon, type Scale, type ScaleType, ScatterLayer, type ScatterOptions, 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 TreemapCell, type TreemapExtent, type TreemapItem, type TreemapOptions, VolumeLayer, type VolumeOptions, type VolumeProfile, type VolumeProfileOptions, type YAxisOptions, addBollinger, addChord, addDepth, addFunnel, addGauge, addHeikinAshi, addParallelCoordinates, addRenko, addSankey, addSunburst, addTreemap, addVolumeProfile, adx, atr, autoTicks, bollinger, boxStats, bufferUsage, canvasToBlob, chordLayout, colormap, colormapLUT, copyCanvasToClipboard, createProgram, createToolbar, darkTheme, defaultFormat, depth, downloadCanvas, earcut, ema, fft, fibRetracements, firstFinite, forceLayout, funnelLayout, gaugeLayout, heikinAshi, histogram, ichimoku, kde, keltner, lightTheme, lineBreak, linkX, lttb, macd, makeScale, marchingCubes, obv, parallelLayout, parseCSV, parseColor, pointAndFigure, quantileSorted, renko, resolveAxisStyle, resolveTicks, rollingStd, rsi, sankeyLayout, setTransformUniforms, sma, spectrogram, stochastic, sunburstLayout, superTrend, toColorCss, treemapLayout, trueRange, uniformLocations, volumeProfile, vwap, withMinorTicks, wma };