@photonviz/core 0.3.0 → 0.3.2

package/dist/index.d.ts

@@ -68,6 +68,13 @@ type Dim = "x" | "y";
  *  - `box-y`  drag selects a y-range only (full width band) — Y-only zoom
  */
 type InteractionMode = "pan" | "box" | "box-x" | "box-y";
+/**
+ * How a layer expects its data to change, mapped to a WebGL buffer-usage hint:
+ * `"static"` → `STATIC_DRAW` (upload once), `"dynamic"` → `DYNAMIC_DRAW` (stream
+ * via `setData`). Purely a performance hint — `setData` works either way. Default
+ * `"static"`. Set `"dynamic"` on layers you update every frame.
+ */
+type RenderType = "static" | "dynamic";
 type Range = readonly [number, number];
 interface Bounds {
     x: Range;
@@ -131,6 +138,8 @@ interface AreaOptions {
     /** Lower edge(s). Number or per-point array — pass cumulative to stack. */
     base?: number | ArrayLike<number>;
     color?: string | Color;
+    /** Buffer-usage hint; set `"dynamic"` when streaming via setData. Default `"static"`. */
+    renderType?: RenderType;
     name?: string;
     yAxis?: string;
 }
@@ -146,6 +155,7 @@ declare class AreaLayer implements Layer {
     private uniforms;
     private vertexCount;
     private color;
+    private usage;
     private xRef;
     private yRef;
     private xBounds;
@@ -179,6 +189,13 @@ interface BarOptions {
      */
     orientation?: "v" | "h";
     color?: string | Color;
+    /**
+     * Per-bar colors (overrides {@link color}). Handy for tinting each bar — e.g.
+     * volume bars green/red by the candle's direction. Length should match `x`.
+     */
+    colors?: Array<string | Color>;
+    /** Buffer-usage hint; set `"dynamic"` when streaming via setData. Default `"static"`. */
+    renderType?: RenderType;
     name?: string;
     yAxis?: string;
 }
@@ -194,6 +211,8 @@ declare class BarLayer implements Layer {
     private uniforms;
     private count;
     private color;
+    private colorsInput?;
+    private usage;
     private barWidth;
     private offset;
     private orientation;
@@ -202,9 +221,11 @@ declare class BarLayer implements Layer {
     private xBounds;
     private yBounds;
     constructor(gl: WebGL2RenderingContext, opts: BarOptions);
+    /** Per-bar color array (each bar uses its `colors[i]` or falls back to `color`). */
+    private buildColors;
     private buildRects;
-    /** Replace bar values and re-upload (for streaming). */
-    setData(x: ArrayLike<number>, y: ArrayLike<number>, base?: number | ArrayLike<number>): void;
+    /** Replace bar values (and optionally per-bar colors) and re-upload for streaming. */
+    setData(x: ArrayLike<number>, y: ArrayLike<number>, base?: number | ArrayLike<number>, colors?: Array<string | Color>): void;
     bounds(): {
         x: Range;
         y: Range;
@@ -228,6 +249,8 @@ interface BoxOptions {
     box?: boolean;
     /** Draw a violin (KDE) shape behind/instead of the box (default false). */
     violin?: boolean;
+    /** Buffer-usage hint; set `"dynamic"` when streaming via setData. Default `"static"`. */
+    renderType?: RenderType;
     yAxis?: string;
 }
 declare class BoxLayer implements Layer {
@@ -247,7 +270,15 @@ declare class BoxLayer implements Layer {
     private lineCount;
     private pointStart;
     private pointCount;
+    private width;
+    private showBox;
+    private showViolin;
+    private usage;
     constructor(gl: WebGL2RenderingContext, opts: BoxOptions);
+    /** Build box/whisker/violin geometry from the groups; sets refs, bounds and draw ranges. */
+    private build;
+    /** Replace the box groups and rebuild the geometry (for streaming). */
+    setData(groups: BoxGroup[], width?: number): void;
     bounds(): {
         x: Range;
         y: Range;
@@ -271,9 +302,29 @@ interface CandlestickOptions {
     downColor?: string | Color;
     /** Wick thickness in CSS px. Default 1.5. */
     wickWidth?: number;
+    /** Buffer-usage hint; set `"dynamic"` when streaming via setData. Default `"static"`. */
+    renderType?: RenderType;
     name?: string;
     yAxis?: string;
 }
+/** The OHLC of a single candle — used by {@link CandlestickLayer.updateLast}/`appendCandle`. */
+interface Candle {
+    x: number;
+    open: number;
+    high: number;
+    low: number;
+    close: number;
+}
+/** New OHLC arrays for {@link CandlestickLayer.setData} (colors/width stay fixed). */
+interface CandlestickData {
+    x: ArrayLike<number>;
+    open: ArrayLike<number>;
+    high: ArrayLike<number>;
+    low: ArrayLike<number>;
+    close: ArrayLike<number>;
+    /** Optional new body width; keeps the previous width if omitted. */
+    width?: number;
+}
 declare class CandlestickLayer implements Layer {
     readonly id: string;
     readonly name: string;
@@ -287,12 +338,120 @@ declare class CandlestickLayer implements Layer {
     private uBody;
     private uWick;
     private wickWidth;
+    private usage;
+    private up;
+    private down;
+    /** Body width in data units (median-derived unless the user fixed it). */
+    private bodyWidth;
+    private explicitWidth;
+    private xs;
+    private os;
+    private hs;
+    private ls;
+    private cs;
+    private rects;
+    private wicks;
+    private colors;
     private count;
     private xRef;
     private yRef;
     private xBounds;
     private yBounds;
     constructor(gl: WebGL2RenderingContext, opts: CandlestickOptions);
+    /** Copy the incoming OHLC arrays into the retained plain arrays. */
+    private ingest;
+    /** Write candle `i`'s body rect, wick segment and up/down color into the arrays. */
+    private emitCandle;
+    /** Recompute width/refs/bounds and refill the vertex arrays from the retained OHLC. */
+    private rebuild;
+    /** Re-upload all three per-candle buffers (after a full rebuild). */
+    private upload;
+    /** Replace every candle and re-upload (for streaming a whole new window). */
+    setData(data: CandlestickData): void;
+    /**
+     * Append one new candle (grows the series). Prefer {@link updateLast} for the
+     * in-progress candle and `appendCandle` only when a bar closes and a new one opens.
+     */
+    appendCandle(c: Candle): void;
+    /**
+     * Update the most recent candle in place — the cheap hot path for a live
+     * (forming) bar. Only that candle's 12 floats are re-uploaded; bounds are
+     * extended (never shrunk) to include it. No-op when the series is empty.
+     */
+    updateLast(c: Candle): void;
+    bounds(): {
+        x: Range;
+        y: Range;
+    } | null;
+    draw(state: DrawState): void;
+    dispose(): void;
+}
+
+/**
+ * An OHLC bar chart — the western cousin of the candlestick. Each period is a
+ * vertical low→high line with a left tick at the open and a right tick at the
+ * close, colored up/down by direction. Streams like {@link CandlestickLayer}.
+ */
+interface OhlcOptions {
+    /** Bar positions (data space — e.g. epoch ms on a time axis). */
+    x: ArrayLike<number>;
+    open: ArrayLike<number>;
+    high: ArrayLike<number>;
+    low: ArrayLike<number>;
+    close: ArrayLike<number>;
+    /** Total tick span in data units (each open/close tick is half of this). Default 70% of median spacing. */
+    width?: number;
+    /** Close ≥ open color. Default green. */
+    upColor?: string | Color;
+    /** Close < open color. Default red. */
+    downColor?: string | Color;
+    /** Line thickness in CSS px. Default 1.5. */
+    lineWidth?: number;
+    /** Buffer-usage hint; set `"dynamic"` when streaming via setData. Default `"static"`. */
+    renderType?: RenderType;
+    name?: string;
+    yAxis?: string;
+}
+declare class OhlcLayer implements Layer {
+    readonly id: string;
+    readonly name: string;
+    readonly colorCss: string;
+    readonly yAxis: string;
+    private gl;
+    private program;
+    private vao;
+    private buffers;
+    private uniforms;
+    private lineWidth;
+    private usage;
+    private up;
+    private down;
+    private barWidth;
+    private explicitWidth;
+    private xs;
+    private os;
+    private hs;
+    private ls;
+    private cs;
+    private segs;
+    private colors;
+    private count;
+    private xRef;
+    private yRef;
+    private xBounds;
+    private yBounds;
+    constructor(gl: WebGL2RenderingContext, opts: OhlcOptions);
+    private ingest;
+    /** Write bar `i`'s three segments (+ colors) at instance base `i * SEGS_PER_BAR`. */
+    private emitBar;
+    private rebuild;
+    private upload;
+    /** Replace every bar and re-upload (for streaming a whole new window). */
+    setData(data: CandlestickData): void;
+    /** Append one new bar (grows the series). */
+    appendCandle(c: Candle): void;
+    /** Update the most recent bar in place — the cheap hot path for a live bar. */
+    updateLast(c: Candle): void;
     bounds(): {
         x: Range;
         y: Range;
@@ -326,6 +485,8 @@ interface ContourOptions {
     /** Single line color; if omitted, levels are colored by a colormap. */
     color?: string | Color;
     colormap?: ColormapName;
+    /** Buffer-usage hint; set `"dynamic"` when streaming via setData. Default `"static"`. */
+    renderType?: RenderType;
     yAxis?: string;
 }
 declare class ContourLayer implements Layer {
@@ -340,7 +501,17 @@ declare class ContourLayer implements Layer {
     private xRef;
     private yRef;
     private ext;
+    private cols;
+    private rows;
+    private levelsOpt;
+    private cmap;
+    private fixedColor;
+    private usage;
     constructor(gl: WebGL2RenderingContext, opts: ContourOptions);
+    /** Marching-squares the scalar field into iso-line segments; sets vertexCount. */
+    private build;
+    /** Replace the scalar field and recompute the iso lines (for streaming). */
+    setData(values: ArrayLike<number>, cols?: number, rows?: number): void;
     bounds(): {
         x: Range;
         y: Range;
@@ -372,9 +543,20 @@ interface ErrorBarOptions {
     band?: boolean;
     /** Band fill opacity. Default 0.2. */
     bandOpacity?: number;
+    /** Buffer-usage hint; set `"dynamic"` when streaming via setData. Default `"static"`. */
+    renderType?: RenderType;
     name?: string;
     yAxis?: string;
 }
+/** New positions/errors for {@link ErrorBarLayer.setData} (styling stays fixed). */
+interface ErrorBarData {
+    x: ArrayLike<number>;
+    y: ArrayLike<number>;
+    yerr?: ErrInput;
+    yerrLow?: ErrInput;
+    yerrHigh?: ErrInput;
+    xerr?: ErrInput;
+}
 declare class ErrorBarLayer implements Layer {
     readonly id: string;
     readonly name: string;
@@ -395,6 +577,7 @@ declare class ErrorBarLayer implements Layer {
     private bandOpacity;
     private showWhiskers;
     private showBand;
+    private usage;
     private segCount;
     private capCount;
     private bandVerts;
@@ -403,6 +586,10 @@ declare class ErrorBarLayer implements Layer {
     private xBounds;
     private yBounds;
     constructor(gl: WebGL2RenderingContext, opts: ErrorBarOptions);
+    /** Recompute refs/bounds/counts and the whisker/cap/band vertex arrays from new data. */
+    private build;
+    /** Replace the data and re-upload (for streaming). */
+    setData(data: ErrorBarData): void;
     bounds(): {
         x: Range;
         y: Range;
@@ -421,9 +608,20 @@ interface GraphOptions {
     /** Node diameter in CSS pixels. Default 10. */
     nodeSize?: number;
     edgeColor?: string | Color;
+    /** Buffer-usage hint; set `"dynamic"` when streaming via setData. Default `"static"`. */
+    renderType?: RenderType;
     name?: string;
     yAxis?: string;
 }
+/** New nodes/edges for {@link GraphLayer.setData} (colors/size stay fixed). */
+interface GraphData {
+    /** Node positions. Omit both to run a force layout from `edges`. */
+    x?: ArrayLike<number>;
+    y?: ArrayLike<number>;
+    edges: ReadonlyArray<readonly [number, number]>;
+    /** Node count for the force layout when `x`/`y` are omitted. Defaults to max edge index + 1. */
+    nodeCount?: number;
+}
 /** A node-link graph: edges as line segments, nodes as round points. */
 declare class GraphLayer implements Layer {
     readonly id: string;
@@ -446,7 +644,15 @@ declare class GraphLayer implements Layer {
     private yRef;
     private xBounds;
     private yBounds;
+    private usage;
     constructor(gl: WebGL2RenderingContext, opts: GraphOptions);
+    /** Build node/edge vertex arrays from positions + edges; sets counts, refs and bounds. */
+    private build;
+    /**
+     * Replace nodes and edges (for streaming). When `x`/`y` are omitted, node
+     * positions are recomputed with the package's force layout from the edges.
+     */
+    setData(data: GraphData): void;
     bounds(): {
         x: Range;
         y: Range;
@@ -470,6 +676,8 @@ interface HeatmapOptions {
     domain?: Range;
     /** Bilinear filtering (default true) vs. hard cells. */
     smooth?: boolean;
+    /** Buffer-usage hint; set `"dynamic"` when streaming via setData. Default `"static"`. */
+    renderType?: RenderType;
     yAxis?: string;
 }
 declare class HeatmapLayer implements Layer {
@@ -484,7 +692,15 @@ declare class HeatmapLayer implements Layer {
     private xRef;
     private yRef;
     private ext;
+    private lut;
+    private fixedDomain;
+    private cols;
+    private rows;
     constructor(gl: WebGL2RenderingContext, opts: HeatmapOptions);
+    /** Bake a `cols*rows` value grid into the RGBA data texture via the colormap. */
+    private uploadValues;
+    /** Replace the value grid and re-bake the data texture (for streaming). */
+    setData(values: ArrayLike<number>, cols?: number, rows?: number): void;
     bounds(): {
         x: Range;
         y: Range;
@@ -501,6 +717,8 @@ interface HexbinOptions {
     colormap?: ColormapName;
     /** Count range mapped to the colormap. Defaults to [1, maxCount]. */
     domain?: Range;
+    /** Buffer-usage hint; set `"dynamic"` when streaming via setData. Default `"static"`. */
+    renderType?: RenderType;
     yAxis?: string;
 }
 declare class HexbinLayer implements Layer {
@@ -517,7 +735,15 @@ declare class HexbinLayer implements Layer {
     private yRef;
     private xBounds;
     private yBounds;
+    private cmap;
+    private explicitRadius;
+    private domain;
+    private usage;
     constructor(gl: WebGL2RenderingContext, opts: HexbinOptions);
+    /** Bin the points into hex cells; sets radius, refs, bounds and cell count. */
+    private build;
+    /** Replace the point arrays, re-bin and re-upload the cells (for streaming). */
+    setData(x: ArrayLike<number>, y: ArrayLike<number>): void;
     bounds(): {
         x: Range;
         y: Range;
@@ -542,6 +768,8 @@ interface ImageOptions {
     opacity?: number;
     /** Called after an async (URL) image finishes loading — wire to `plot.requestRender`. */
     onLoad?: () => void;
+    /** Buffer-usage hint; set `"dynamic"` when streaming via setData. Default `"static"`. */
+    renderType?: RenderType;
     name?: string;
     yAxis?: string;
 }
@@ -570,6 +798,10 @@ declare class ImageLayer implements Layer {
     private ready;
     private img;
     constructor(gl: WebGL2RenderingContext, opts: ImageOptions);
+    /** Point the texture at a new source: load a URL async, or upload a bitmap now. */
+    private setSource;
+    /** Replace the image source and re-upload the texture (for streaming). */
+    setData(source: ImageSource, onLoad?: () => void): void;
     private upload;
     bounds(): {
         x: Range;
@@ -629,6 +861,8 @@ interface LineOptions {
      * zoomed out (preserves peaks). Requires monotonic x; auto-detected. Default true.
      */
     decimate?: boolean;
+    /** Buffer-usage hint; set `"dynamic"` when streaming via setData. Default `"static"`. */
+    renderType?: RenderType;
 }
 declare class LineLayer implements Layer {
     readonly id: string;
@@ -657,6 +891,7 @@ declare class LineLayer implements Layer {
     private monotonic;
     private gpuDec;
     private step?;
+    private usage;
     private xRef;
     private yRef;
     private xs;
@@ -707,6 +942,8 @@ interface PatchesOptions {
     domain?: Range;
     /** Fill opacity, 0..1. Default 1. */
     opacity?: number;
+    /** Buffer-usage hint; set `"dynamic"` when streaming via setData. Default `"static"`. */
+    renderType?: RenderType;
     name?: string;
     yAxis?: string;
 }
@@ -730,7 +967,16 @@ declare class PatchesLayer implements Layer {
     private yRef;
     private xBounds;
     private yBounds;
+    private defRgba;
+    private opacity;
+    private cmap;
+    private domainOpt;
+    private usage;
     constructor(gl: WebGL2RenderingContext, opts: PatchesOptions);
+    /** Triangulate the patches and recompute refs/bounds/vertexCount into position/color arrays. */
+    private build;
+    /** Replace the patches and re-upload (for streaming). */
+    setData(patches: Patch[]): void;
     bounds(): {
         x: Range;
         y: Range;
@@ -754,6 +1000,8 @@ interface PieOptions {
     innerRadius?: number;
     /** Angle of the first slice edge, radians. Default `Math.PI / 2` (12 o'clock). */
     startAngle?: number;
+    /** Buffer-usage hint; set `"dynamic"` when streaming via setData. Default `"static"`. */
+    renderType?: RenderType;
     name?: string;
     yAxis?: string;
 }
@@ -777,7 +1025,19 @@ declare class PieLayer implements Layer {
     private yRef;
     private xBounds;
     private yBounds;
+    private cx;
+    private cy;
+    private R;
+    private rIn;
+    private start;
+    private colorsOpt;
+    private cmap;
+    private usage;
     constructor(gl: WebGL2RenderingContext, opts: PieOptions);
+    /** Recompute vertexCount and the position/color triangle soup from new slice values. */
+    private build;
+    /** Replace the slice values and re-upload (for streaming). */
+    setData(values: ArrayLike<number>): void;
     bounds(): {
         x: Range;
         y: Range;
@@ -806,6 +1066,8 @@ interface QuiverOptions {
         colormap?: ColormapName;
         domain?: Range;
     };
+    /** Buffer-usage hint; set `"dynamic"` when streaming via setData. Default `"static"`. */
+    renderType?: RenderType;
     name?: string;
     yAxis?: string;
 }
@@ -825,6 +1087,9 @@ declare class QuiverLayer implements Layer {
     private width;
     private headSize;
     private useVertexColor;
+    private explicitScale;
+    private colorBy;
+    private usage;
     private count;
     private xRef;
     private yRef;
@@ -832,6 +1097,10 @@ declare class QuiverLayer implements Layer {
     private yBounds;
     constructor(gl: WebGL2RenderingContext, opts: QuiverOptions);
     private bindInstanceAttribs;
+    /** Recompute count/refs/bounds and the arrow+color arrays from new x/y/u/v. */
+    private build;
+    /** Replace the data and re-upload (for streaming). */
+    setData(x: ArrayLike<number>, y: ArrayLike<number>, u: ArrayLike<number>, v: ArrayLike<number>): void;
     bounds(): {
         x: Range;
         y: Range;
@@ -865,6 +1134,8 @@ interface ScatterOptions {
         /** Value range mapped to [0,1]. Defaults to the data min/max. */
         domain?: Range;
     };
+    /** Buffer-usage hint; set `"dynamic"` when streaming via setData. Default `"static"`. */
+    renderType?: RenderType;
 }
 declare class ScatterLayer implements Layer {
     readonly id: string;
@@ -879,6 +1150,7 @@ declare class ScatterLayer implements Layer {
     private count;
     private size;
     private marker;
+    private usage;
     private color;
     private useVertexColor;
     private labels?;
@@ -912,6 +1184,8 @@ interface StemOptions {
     width?: number;
     /** Tip marker diameter in CSS px (0 hides). Default 6. */
     markerSize?: number;
+    /** Buffer-usage hint; set `"dynamic"` when streaming via setData. Default `"static"`. */
+    renderType?: RenderType;
     name?: string;
     yAxis?: string;
 }
@@ -931,6 +1205,7 @@ declare class StemLayer implements Layer {
     private width;
     private markerSize;
     private count;
+    private usage;
     private baseline;
     private xRef;
     private yRef;
@@ -939,6 +1214,10 @@ declare class StemLayer implements Layer {
     private xBounds;
     private yBounds;
     constructor(gl: WebGL2RenderingContext, opts: StemOptions);
+    /** Recompute count/refs/bounds and the stem+tip vertex arrays from new x/y. */
+    private build;
+    /** Replace the data and re-upload (for streaming). */
+    setData(x: ArrayLike<number>, y: ArrayLike<number>): void;
     bounds(): {
         x: Range;
         y: Range;
@@ -1017,8 +1296,32 @@ declare class CategoricalScale implements Scale {
     ticks(): Tick[];
     formatTick(value: number): string;
 }
-type ScaleType = "linear" | "log" | "time" | "categorical";
-declare function makeScale(type: ScaleType, domain?: Range, factors?: string[]): Scale;
+/**
+ * An **ordinal time** axis — the standard financial x-axis. Bars are plotted at
+ * evenly-spaced integer indices `0..n-1` (like {@link CategoricalScale}, so the
+ * domain is the band `[-0.5, n-1+0.5]`), which **collapses market gaps**
+ * (weekends, overnight, holidays) instead of leaving blank space the way a real
+ * {@link TimeScale} would. Each index carries a timestamp; ticks are placed at
+ * natural calendar boundaries (day / month / year, or hour / minute when zoomed
+ * in) and subsampled toward the target count, so labels stay readable at any zoom.
+ *
+ * Plot your candles/bars at `x = 0,1,2,…` and pass the per-bar epoch-ms `times`.
+ */
+declare class OrdinalTimeScale implements Scale {
+    readonly type = "ordinal-time";
+    readonly log = false;
+    times: number[];
+    domain: Range;
+    constructor(times?: ArrayLike<number>);
+    norm(value: number): number;
+    invert(t: number): number;
+    /** Timestamp at a (rounded, clamped) index. */
+    private timeAt;
+    ticks(target?: number): Tick[];
+    formatTick(value: number): string;
+}
+type ScaleType = "linear" | "log" | "time" | "categorical" | "ordinal-time";
+declare function makeScale(type: ScaleType, domain?: Range, factors?: string[], times?: ArrayLike<number>): Scale;
 
 /** Pixel geometry of the plot, in CSS pixels. The plot region excludes margins. */
 interface Layout {
@@ -1077,12 +1380,37 @@ 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. */
     domain?: Range;
     /** Factor labels for a `"categorical"` axis (fixes the domain to the bands). */
     factors?: string[];
+    /**
+     * Per-index epoch-ms timestamps for an `"ordinal-time"` axis (finance/session
+     * axis). Plot bars at integer indices `0..times.length-1`; gaps collapse and
+     * ticks show calendar dates.
+     */
+    times?: ArrayLike<number>;
 }
 /** Legend placement + styling. `legend: true` uses all defaults. */
 interface LegendOptions {
@@ -1100,6 +1428,8 @@ interface YAxisOptions extends AxisConfig {
     domain?: Range;
     /** Factor labels for a `"categorical"` axis. */
     factors?: string[];
+    /** Per-index epoch-ms timestamps for an `"ordinal-time"` axis. */
+    times?: ArrayLike<number>;
     /** Which side to draw the axis on. Default `"right"` for secondary axes. */
     side?: "left" | "right";
     /** Axis + label color (secondary axes often match their series). */
@@ -1158,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";
@@ -1181,6 +1514,7 @@ type Annotation = {
     y: Range;
     color?: string;
     border?: string;
+    label?: string;
     yAxis?: string;
 } | {
     type: "label";
@@ -1191,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;
@@ -1220,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. */
@@ -1267,6 +1640,7 @@ interface PlotOptions {
  */
 declare class Plot {
     private container;
+    private ariaLabel?;
     private gridCanvas;
     private dataCanvas;
     private axisCanvas;
@@ -1303,6 +1677,18 @@ declare class Plot {
     private hoverReadout?;
     /** Cursor position while the pointer is pressed, when `crosshair`. */
     private pressPx;
+    private viewListeners;
+    private cursorListeners;
+    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;
@@ -1321,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.
@@ -1359,6 +1750,8 @@ declare class Plot {
     addStem(opts: StemOptions): StemLayer;
     addQuiver(opts: QuiverOptions): QuiverLayer;
     addCandlestick(opts: CandlestickOptions): CandlestickLayer;
+    /** An OHLC bar chart (low→high line with open/close ticks). Streams like candlesticks. */
+    addOhlc(opts: OhlcOptions): OhlcLayer;
     /** Filled polygons (choropleth-capable). Rings are triangulated with earcut. */
     addPatches(opts: PatchesOptions): PatchesLayer;
     /** A pie / donut chart. Set `equalAspect: true` on the plot so it stays circular. */
@@ -1382,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;
@@ -1399,6 +1827,10 @@ declare class Plot {
     }): BarLayer;
     /** Register an additional named y axis. Series opt in via `addLine({ yAxis })`. */
     addYAxis(id: string, opts?: YAxisOptions): void;
+    /** Whether a y axis with this id exists (the primary is always `"y"`). */
+    hasYAxis(id: string): boolean;
+    /** Remove a secondary y axis. No-op for the primary `"y"` or an unknown id. */
+    removeYAxis(id: string): void;
     removeLayer(layer: Layer): void;
     /** Configure ticks/format/title for the x axis or a y axis (default primary "y"). */
     setAxis(dim: Dim | string, config: Partial<AxisConfig>): void;
@@ -1408,18 +1840,46 @@ declare class Plot {
         y?: Range;
         yAxes?: Record<string, Range>;
     }): void;
+    /**
+     * Subscribe to x-domain changes (pan / zoom / home / setView). Fires once per
+     * frame after the domain settles. Returns an unsubscribe function. See {@link linkX}.
+     */
+    onViewChange(cb: (x: Range) => void): () => void;
+    /**
+     * Subscribe to the hover cursor's data-space x (or `null` when it leaves the
+     * plot). Returns an unsubscribe function. Used to share a crosshair across panes.
+     */
+    onCursorMove(cb: (dataX: number | null) => void): () => void;
+    /** Draw a linked crosshair at this data-space x (pushed from another pane), or clear it with `null`. */
+    setLinkedCursor(dataX: number | null): void;
     private setYDomain;
     setMode(mode: InteractionMode): void;
     getMode(): InteractionMode;
     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;
     private resize;
     requestRender(): void;
     private primaryY;
+    /** Fire view/cursor listeners once the frame's x-domain + cursor are settled. */
+    private emitLinks;
     render(): void;
     /** Named series that can appear in the legend: any layer exposing name + colorCss. */
     private legendEntries;
@@ -1466,12 +1926,36 @@ declare class Plot {
     private zoomAround;
 }
 
+/**
+ * Link the x-axis (pan / zoom) and hover crosshair of several plots so they move
+ * together — the standard multi-pane financial layout (price on top, volume /
+ * RSI / MACD below, all sharing one time axis). The plots should share the same
+ * x-scale semantics (e.g. all `ordinal-time` over the same bars).
+ *
+ * ```ts
+ * const detach = linkX([pricePlot, volumePlot, rsiPlot]);
+ * // …later: detach();
+ * ```
+ *
+ * @returns a function that unlinks them again.
+ */
+declare function linkX(plots: Plot[]): () => void;
+
 /** The subset of Plot the toolbar drives. Kept minimal to avoid an import cycle. */
 interface ToolbarHost {
     setMode(mode: InteractionMode): void;
     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;
@@ -1533,6 +2017,8 @@ interface PolarLineOptions {
     width?: number;
     /** Connect the last point back to the first. */
     closed?: boolean;
+    /** Buffer-usage hint; set `"dynamic"` when streaming via setData. Default `"static"`. */
+    renderType?: RenderType;
 }
 interface PolarScatterOptions {
     theta: ArrayLike<number>;
@@ -1541,6 +2027,8 @@ interface PolarScatterOptions {
     size?: number;
     /** Optional per-point labels (one per point), shown as the title of the click-pinned info box. */
     labels?: ArrayLike<string>;
+    /** Buffer-usage hint; set `"dynamic"` when streaming via setData. Default `"static"`. */
+    renderType?: RenderType;
 }
 /** A live handle to update a polar series with new (theta, r) data. */
 interface PolarSeries {
@@ -1597,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;
@@ -1672,6 +2170,8 @@ interface Bar3DOptions {
         domain?: Range;
     };
     name?: string;
+    /** Buffer-usage hint; set `"dynamic"` when streaming via setData. Default `"static"`. */
+    renderType?: RenderType;
 }
 /** 3D bars (columns) on an x/z grid, lit like the surface and optionally colormapped. */
 declare class Bar3DLayer implements Layer3D {
@@ -1682,15 +2182,24 @@ declare class Bar3DLayer implements Layer3D {
     private program;
     private vao;
     private buffers;
+    private instBuf;
     private uniforms;
     private count;
     private width;
     private b3;
     private cInfo;
     private positions;
+    private base;
+    private optWidth?;
+    private colorByOpt?;
+    private usage;
     private lightDir;
     private ambient;
     constructor(gl: WebGL2RenderingContext, opts: Bar3DOptions);
+    /** Build the per-bar instances (base/height/color) and (re)upload the instance buffer. */
+    private build;
+    /** Stream new bar positions/heights (instances rebuilt). Call `plot.refresh()` after. */
+    setData(x: ArrayLike<number>, z: ArrayLike<number>, y: ArrayLike<number>): void;
     bounds3(): Bounds3 | null;
     colorInfo(): ColorInfo | null;
     pickData(): {
@@ -1716,6 +2225,8 @@ interface Contour3DOptions {
     color?: string | Color;
     colormap?: ColormapName;
     name?: string;
+    /** Buffer-usage hint; set `"dynamic"` when streaming via setData. Default `"static"`. */
+    renderType?: RenderType;
 }
 /**
  * 3D contour: iso-height lines of a grid, each drawn at its own level height
@@ -1733,7 +2244,24 @@ declare class Contour3DLayer implements Layer3D {
     private vertCount;
     private b3;
     private cInfo;
+    private cmapName;
+    private fixed;
+    private levelsOpt?;
+    private cols;
+    private rows;
+    private extentX;
+    private extentZ;
+    private usage;
     constructor(gl: WebGL2RenderingContext, opts: Contour3DOptions);
+    /** Marching-squares the grid at each iso level and (re)upload the line buffer. */
+    private build;
+    /** Stream a new scalar field (contours recomputed). Call `plot.refresh()` after. */
+    setData(values: ArrayLike<number>, opts?: {
+        cols?: number;
+        rows?: number;
+        extentX?: Range;
+        extentZ?: Range;
+    }): void;
     bounds3(): Bounds3 | null;
     colorInfo(): ColorInfo | null;
     draw(gl: WebGL2RenderingContext, mvp: Mat4): void;
@@ -1756,6 +2284,8 @@ interface IsosurfaceOptions {
     /** Fill opacity 0..1. Default 1. */
     opacity?: number;
     name?: string;
+    /** Buffer-usage hint; set `"dynamic"` when streaming via setData. Default `"static"`. */
+    renderType?: RenderType;
 }
 /** A marching-cubes isosurface of a 3D scalar volume, lit and solid-colored. */
 declare class IsosurfaceLayer implements Layer3D {
@@ -1771,9 +2301,18 @@ declare class IsosurfaceLayer implements Layer3D {
     private color;
     private opacity;
     private b3;
+    private usage;
     private lightDir;
     private ambient;
     constructor(gl: WebGL2RenderingContext, opts: IsosurfaceOptions);
+    /** Run marching cubes and (re)upload the interleaved pos/normal vertex buffer. */
+    private build;
+    /** Stream a new volume + iso level (marching-cubes mesh recomputed). Call `plot.refresh()` after. */
+    setData(values: ArrayLike<number>, dims: [number, number, number], isoLevel: number, extent?: {
+        x: Range;
+        y: Range;
+        z: Range;
+    }): void;
     bounds3(): Bounds3 | null;
     /** Set the light direction (world space) and ambient term (0..1). */
     setLight(dir: [number, number, number], ambient: number): void;
@@ -1787,6 +2326,8 @@ interface Line3DOptions {
     z: ArrayLike<number>;
     color?: string | Color;
     name?: string;
+    /** Buffer-usage hint; set `"dynamic"` when streaming via setData. Default `"static"`. */
+    renderType?: RenderType;
 }
 /** A 3D polyline / path (`GL_LINE_STRIP`). */
 declare class Line3DLayer implements Layer3D {
@@ -1802,6 +2343,7 @@ declare class Line3DLayer implements Layer3D {
     private color;
     private b3;
     private positions;
+    private usage;
     constructor(gl: WebGL2RenderingContext, opts: Line3DOptions);
     bounds3(): Bounds3 | null;
     pickData(): {
@@ -1831,6 +2373,8 @@ interface PointCloudOptions {
     labels?: ArrayLike<string>;
     /** Series name (legend / colorbar label). */
     name?: string;
+    /** Buffer-usage hint; set `"dynamic"` when streaming via setData. Default `"static"`. */
+    renderType?: RenderType;
 }
 declare class PointCloudLayer implements Layer3D {
     readonly id: string;
@@ -1849,6 +2393,7 @@ declare class PointCloudLayer implements Layer3D {
     private labels?;
     /** Interleaved pos(3)+color(3)+size(1); positions are streamed in place. */
     private data;
+    private usage;
     constructor(gl: WebGL2RenderingContext, opts: PointCloudOptions);
     private updateBounds;
     /** Stream new point positions (same count keeps colors/sizes). Call `plot.refresh()` after. */
@@ -1883,6 +2428,8 @@ interface Quiver3DOptions {
     /** Arrowhead length as a fraction of the arrow. Default 0.28. */
     headSize?: number;
     name?: string;
+    /** Buffer-usage hint; set `"dynamic"` when streaming via setData. Default `"static"`. */
+    renderType?: RenderType;
 }
 /** A 3D vector field: each arrow is a shaft + a 4-wing arrowhead, drawn as lines. */
 declare class Quiver3DLayer implements Layer3D {
@@ -1898,7 +2445,16 @@ declare class Quiver3DLayer implements Layer3D {
     private b3;
     private cInfo;
     private positions;
+    private base;
+    private scale;
+    private headSize;
+    private colorByOpt?;
+    private usage;
     constructor(gl: WebGL2RenderingContext, opts: Quiver3DOptions);
+    /** Build the arrow line geometry (shaft + 4-wing head) and (re)upload the vertex buffer. */
+    private build;
+    /** Stream a new vector field (arrows rebuilt). Call `plot.refresh()` after. */
+    setData(x: ArrayLike<number>, y: ArrayLike<number>, z: ArrayLike<number>, u: ArrayLike<number>, v: ArrayLike<number>, w: ArrayLike<number>): void;
     bounds3(): Bounds3 | null;
     colorInfo(): ColorInfo | null;
     pickData(): {
@@ -1921,6 +2477,8 @@ interface SurfaceOptions {
     name?: string;
     /** Render the grid as a wireframe (lines) instead of a lit filled surface. */
     wireframe?: boolean;
+    /** Buffer-usage hint; set `"dynamic"` when streaming via setData. Default `"static"`. */
+    renderType?: RenderType;
 }
 declare class SurfaceLayer implements Layer3D {
     readonly id: string;
@@ -1935,9 +2493,23 @@ declare class SurfaceLayer implements Layer3D {
     private cmapName;
     private vDomain;
     private wireframe;
+    private cols;
+    private rows;
+    private extentX;
+    private extentZ;
+    private usage;
     private lightDir;
     private ambient;
     constructor(gl: WebGL2RenderingContext, opts: SurfaceOptions);
+    /** Build the mesh (positions/normals/colors or wireframe) and (re)upload the vertex buffer. */
+    private build;
+    /** Stream a new height grid (mesh/normals/wireframe rebuilt). Call `plot.refresh()` after. */
+    setData(values: ArrayLike<number>, opts?: {
+        cols?: number;
+        rows?: number;
+        extentX?: Range;
+        extentZ?: Range;
+    }): void;
     bounds3(): Bounds3;
     colorInfo(): ColorInfo;
     /** Set the light direction (world space) and ambient term (0..1). */
@@ -1962,6 +2534,8 @@ interface VolumeOptions {
     /** Overall opacity multiplier. Default 1. */
     density?: number;
     name?: string;
+    /** Buffer-usage hint; set `"dynamic"` when streaming via setData. Default `"static"`. */
+    renderType?: RenderType;
 }
 /**
  * Direct volume rendering: GPU raymarching through a 3D texture with front-to-back
@@ -1983,8 +2557,15 @@ declare class VolumeLayer implements Layer3D {
     private density;
     private cmapName;
     private vDomain;
+    private dims;
+    private domainOpt?;
+    private usage;
     private camLocal;
     constructor(gl: WebGL2RenderingContext, opts: VolumeOptions);
+    /** Normalize the scalar field and (re)upload it into the R8 3D texture. */
+    private uploadVolume;
+    /** Stream a new scalar volume (same dims); re-uploads the 3D texture. Call `plot.refresh()` after. */
+    setData(values: ArrayLike<number>): void;
     bounds3(): Bounds3;
     colorInfo(): ColorInfo;
     /** Set the camera position in world space; converted to the volume's [0,1] local space. */
@@ -2018,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. */
@@ -2071,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;
@@ -2113,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. */
@@ -2241,6 +2835,8 @@ interface Density {
  */
 declare function kde(values: ArrayLike<number>, lo: number, hi: number, points?: number, bandwidth?: number): Density;
 
+/** Map a layer's {@link RenderType} to a WebGL buffer-usage hint (default STATIC_DRAW). */
+declare function bufferUsage(gl: WebGL2RenderingContext, renderType?: RenderType): number;
 /** Compile + link a vertex/fragment program. */
 declare function createProgram(gl: WebGL2RenderingContext, vert: string, frag: string): WebGLProgram;
 /** Cache uniform locations for a program by name. */
@@ -2268,9 +2864,768 @@ declare function uniformLocations(gl: WebGL2RenderingContext, program: WebGLProg
  */
 declare function earcut(data: number[], holeIndices?: number[], dim?: number): number[];
 
+/** Simple moving average over `period` samples. */
+declare function sma(values: ArrayLike<number>, period: number): Float64Array;
+/** Weighted moving average (linear weights 1..period, newest heaviest). */
+declare function wma(values: ArrayLike<number>, period: number): Float64Array;
+/**
+ * Exponential moving average, α = 2/(period+1). Seeded with the SMA of the first
+ * `period` samples at index `period-1` (the standard convention).
+ */
+declare function ema(values: ArrayLike<number>, period: number): Float64Array;
+/** Rolling population standard deviation over `period` samples. */
+declare function rollingStd(values: ArrayLike<number>, period: number): Float64Array;
+interface BollingerBands {
+    middle: Float64Array;
+    upper: Float64Array;
+    lower: Float64Array;
+}
+/** Bollinger Bands: SMA(period) ± `k`·rollingStd(period). Defaults 20, 2. */
+declare function bollinger(close: ArrayLike<number>, period?: number, k?: number): BollingerBands;
+/** Wilder's RSI over `period` (default 14). Values in 0..100; warm-up is NaN. */
+declare function rsi(close: ArrayLike<number>, period?: number): Float64Array;
+interface Macd {
+    macd: Float64Array;
+    signal: Float64Array;
+    histogram: Float64Array;
+}
+/** MACD: EMA(fast) − EMA(slow), its EMA(signal) line, and the histogram. Defaults 12/26/9. */
+declare function macd(close: ArrayLike<number>, fast?: number, slow?: number, signalPeriod?: number): Macd;
+/**
+ * Volume-weighted average price, cumulative from the first sample: running
+ * Σ(typical·volume) / Σ(volume), where typical = (high+low+close)/3.
+ */
+declare function vwap(high: ArrayLike<number>, low: ArrayLike<number>, close: ArrayLike<number>, volume: ArrayLike<number>): Float64Array;
+/** True range per bar: max(H−L, |H−prevC|, |L−prevC|). First bar is H−L. */
+declare function trueRange(high: ArrayLike<number>, low: ArrayLike<number>, close: ArrayLike<number>): Float64Array;
+/** Wilder's Average True Range over `period` (default 14). */
+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
+ * chart needs. Each returns plain arrays you render with existing layers
+ * (candlestick, bar, area, scatter) — see the `Plot.add*` helpers that wrap them.
+ */
+interface Ohlc {
+    open: ArrayLike<number>;
+    high: ArrayLike<number>;
+    low: ArrayLike<number>;
+    close: ArrayLike<number>;
+}
+interface OhlcArrays {
+    open: Float64Array;
+    high: Float64Array;
+    low: Float64Array;
+    close: Float64Array;
+}
+/**
+ * Heikin-Ashi candles — a smoothed OHLC that filters noise and makes trends
+ * obvious. Output has the same length; feed it to a candlestick layer.
+ *
+ *   haClose = (o+h+l+c)/4
+ *   haOpen  = (prevHaOpen + prevHaClose)/2   (seed: (o₀+c₀)/2)
+ *   haHigh  = max(h, haOpen, haClose)
+ *   haLow   = min(l, haOpen, haClose)
+ */
+declare function heikinAshi(d: Ohlc): OhlcArrays;
+/** One brick / box for Renko & Line-break (each renders as a wickless candle body). */
+interface Brick {
+    /** Sequential column index (0..n-1); bricks are evenly spaced, time is discarded. */
+    x: number;
+    open: number;
+    close: number;
+    /** `true` when close > open (up brick). */
+    up: boolean;
+}
+/**
+ * Renko bricks from a close series. A new brick is emitted each time price moves
+ * a full `brickSize` from the last brick's close (multiple bricks if it jumps
+ * several sizes). Time is discarded — bricks are placed at successive indices.
+ */
+declare function renko(close: ArrayLike<number>, brickSize: number): Brick[];
+/**
+ * Three-line-break (generalised to `lines`): a new up brick when close exceeds
+ * the highest close of the last `lines` bricks, a down brick when it breaks the
+ * lowest; otherwise nothing. Bricks are placed at successive indices.
+ */
+declare function lineBreak(close: ArrayLike<number>, lines?: number): Brick[];
+/** One P&F column: a run of X's (rising) or O's (falling) spanning `from`→`to`. */
+interface PfColumn {
+    col: number;
+    kind: "X" | "O";
+    from: number;
+    to: number;
+    /** Box centers filled in this column (for plotting the X/O glyphs). */
+    boxes: number[];
+}
+/**
+ * Point & Figure columns. Price is quantised to `boxSize`; a column of X's grows
+ * while price rises, O's while it falls, and the column flips only after a
+ * `reversal`-box move against it. Time is discarded.
+ */
+declare function pointAndFigure(high: ArrayLike<number>, low: ArrayLike<number>, boxSize: number, reversal?: number): PfColumn[];
+interface VolumeProfile {
+    /** Bin center price for each level (length = bins). */
+    levels: Float64Array;
+    /** Total volume traded in each price bin. */
+    volume: Float64Array;
+    binSize: number;
+    priceMin: number;
+    priceMax: number;
+    /** Bin index of the highest-volume level (the Point of Control). */
+    pocIndex: number;
+}
+/**
+ * Volume profile — a histogram of traded volume by price level. Plot it as
+ * horizontal bars (`orientation:"h"`) with `levels` on the y axis.
+ */
+declare function volumeProfile(price: ArrayLike<number>, volume: ArrayLike<number>, bins?: number): VolumeProfile;
+interface DepthCurves {
+    /** Bid side: prices ascending toward mid, cumulative volume (best bid = largest cum). */
+    bidPrice: Float64Array;
+    bidCum: Float64Array;
+    /** Ask side: prices ascending away from mid, cumulative volume. */
+    askPrice: Float64Array;
+    askCum: Float64Array;
+}
+/**
+ * Order-book depth curves. `bids`/`asks` are `[price, size]` pairs (any order);
+ * returns cumulative-volume step curves ready for two step-area layers.
+ */
+declare function depth(bids: ArrayLike<readonly [number, number]>, asks: ArrayLike<readonly [number, number]>): DepthCurves;
+
+/**
+ * Convenience builders for specialist finance charts. Each takes a {@link Plot}
+ * and composes existing layers from a transform/indicator — mirroring the
+ * `addMap(plot, …)` free-function style. Import from `@photonviz/core`.
+ */
+
+/** Raw OHLC input shared by the candle-style helpers. */
+interface OhlcInput {
+    x: ArrayLike<number>;
+    open: ArrayLike<number>;
+    high: ArrayLike<number>;
+    low: ArrayLike<number>;
+    close: ArrayLike<number>;
+}
+interface HeikinAshiOptions extends Omit<CandlestickOptions, "open" | "high" | "low" | "close"> {
+    open: ArrayLike<number>;
+    high: ArrayLike<number>;
+    low: ArrayLike<number>;
+    close: ArrayLike<number>;
+}
+/** Heikin-Ashi candles: smooth the OHLC, then draw it as a candlestick layer. */
+declare function addHeikinAshi(plot: Plot, opts: HeikinAshiOptions): CandlestickLayer;
+interface RenkoOptions {
+    close: ArrayLike<number>;
+    /** Fixed brick height in price units. */
+    brickSize: number;
+    upColor?: string | Color;
+    downColor?: string | Color;
+    name?: string;
+    yAxis?: string;
+    renderType?: RenderType;
+}
+/**
+ * Renko chart — bricks at successive integer indices (time discarded). Rendered
+ * as wickless candles, so pair it with an `ordinal-time`/linear x axis.
+ */
+declare function addRenko(plot: Plot, opts: RenkoOptions): CandlestickLayer;
+interface VolumeProfileOptions {
+    /** Price per sample (typically close). */
+    price: ArrayLike<number>;
+    volume: ArrayLike<number>;
+    /** Number of price bins. Default 24. */
+    bins?: number;
+    color?: string | Color;
+    /** Highlight the Point-of-Control bin with this color. */
+    pocColor?: string | Color;
+    name?: string;
+    yAxis?: string;
+    renderType?: RenderType;
+}
+/** Volume-by-price histogram as horizontal bars (price on the y axis). */
+declare function addVolumeProfile(plot: Plot, opts: VolumeProfileOptions): BarLayer;
+interface BollingerOptions {
+    x: ArrayLike<number>;
+    close: ArrayLike<number>;
+    period?: number;
+    k?: number;
+    /** Line color for the bands + middle. Default light blue. */
+    color?: string | Color;
+    /** Fill color between the bands (omit to skip the fill). */
+    bandColor?: string | Color;
+    width?: number;
+    yAxis?: string;
+    renderType?: RenderType;
+}
+/** Bollinger Bands: a shaded band between upper/lower plus the three lines. */
+interface BollingerHandle {
+    band?: AreaLayer;
+    upper: LineLayer;
+    middle: LineLayer;
+    lower: LineLayer;
+}
+declare function addBollinger(plot: Plot, opts: BollingerOptions): BollingerHandle;
+interface DepthOptions {
+    /** `[price, size]` levels (any order). */
+    bids: ArrayLike<readonly [number, number]>;
+    asks: ArrayLike<readonly [number, number]>;
+    bidColor?: string | Color;
+    askColor?: string | Color;
+    yAxis?: string;
+    renderType?: RenderType;
+}
+/** Order-book depth: cumulative bid/ask volume as two filled areas. */
+interface DepthHandle {
+    bid: AreaLayer;
+    ask: AreaLayer;
+}
+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 Bounds, type Bounds3, type BoxGroup, BoxLayer, type BoxOptions, type BoxStats, CandlestickLayer, type CandlestickOptions, CategoricalScale, type Color, type ColorInfo, type ColormapName, Contour3DLayer, type Contour3DOptions, ContourLayer, type ContourOptions, type Density, type Dim, type DrawState, ErrorBarLayer, type ErrorBarOptions, type ForceLayoutOptions, type GraphInput, GraphLayer, type GraphOptions, type GroupedBarOptions, HeatmapLayer, type HeatmapOptions, 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 MarkerShape, type Patch, PatchesLayer, type PatchesOptions, 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 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 YAxisOptions, autoTicks, boxStats, colormap, colormapLUT, createProgram, createToolbar, darkTheme, defaultFormat, earcut, fft, forceLayout, histogram, kde, lightTheme, makeScale, marchingCubes, parseColor, quantileSorted, resolveAxisStyle, resolveTicks, setTransformUniforms, spectrogram, toColorCss, uniformLocations, withMinorTicks };
+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 };