velo-plot 1.15.0 → 2.0.0

package/dist/react.js

@@ -1,12 +1,12 @@
-import { c as k } from "./createStackedChart-CjsKcOvX.js";
-import { S as x, u as C } from "./createStackedChart-CjsKcOvX.js";
-import { useRef as n, useState as a, useEffect as m, useCallback as f } from "react";
+import { S as x, u as C } from "./SciPlot-GJvw7GJo.js";
+import { useRef as n, useState as a, useEffect as k, useCallback as f } from "react";
+import { c as m } from "./createStackedChart-DJSmqerD.js";
 function A(c) {
   const s = n(null), r = n(null), [i, l] = a(null), [d, u] = a(!1), o = n(c);
-  o.current = c, m(() => {
+  o.current = c, k(() => {
     const t = s.current;
     if (!t) return;
-    const e = k({
+    const e = m({
       ...o.current,
       container: t
     });

package/dist/renderer/CandlestickRenderer.d.ts

@@ -6,7 +6,7 @@
  * Each candle is represented by a body (box) and a wick (line/thin box)
  * Returns a Float32Array of interleaved [x, y] coordinates for TRIANGLES
  */
-export declare function interleaveCandlestickData(x: Float32Array | Float64Array, open: Float32Array | Float64Array, high: Float32Array | Float64Array, low: Float32Array | Float64Array, close: Float32Array | Float64Array, width: number): {
+export declare function interleaveCandlestickData(x: Float32Array | Float64Array, open: Float32Array | Float64Array, high: Float32Array | Float64Array, low: Float32Array | Float64Array, close: Float32Array | Float64Array, width: number, hollow?: boolean): {
     bullish: Float32Array;
     bearish: Float32Array;
 };

package/dist/renderer/ChartSeriesRenderer.d.ts

@@ -0,0 +1,6 @@
+import { NativeWebGLRenderer } from './NativeWebGLRenderer';
+import { GpuChartRenderer } from './GpuChartRenderer';
+
+export type ChartSeriesRenderer = NativeWebGLRenderer | GpuChartRenderer;
+export type ChartRendererBackend = "webgl" | "webgpu";
+export declare function getRendererBackend(renderer: ChartSeriesRenderer): ChartRendererBackend;

package/dist/renderer/GpuChartRenderer.d.ts

@@ -0,0 +1,23 @@
+import { GpuRenderer, GpuRendererOptions } from '../gpu/adapter/gpuRenderer';
+import { NativeRenderOptions, NativeSeriesRenderData } from './native/types';
+
+export declare class GpuChartRenderer {
+    private gpu;
+    private dpr;
+    private readonly canvas;
+    constructor(gpu: GpuRenderer, canvas: HTMLCanvasElement);
+    get available(): boolean;
+    get backend(): "webgpu" | "webgl";
+    setDPR(dpr: number): void;
+    createBuffer(id: string, data: Float32Array): void;
+    updateBuffer(id: string, data: Float32Array, offsetInBytes: number): boolean;
+    getBuffer(id: string): WebGLBuffer | undefined;
+    deleteBuffer(id: string): void;
+    createColormapTexture(id: string, data: Uint8Array): void;
+    getTexture(id: string): WebGLTexture | undefined;
+    render(series: NativeSeriesRenderData[], options: NativeRenderOptions): void;
+    resize(): void;
+    getLimits(): Record<string, unknown>;
+    destroy(): void;
+}
+export declare function createGpuChartRenderer(canvas: HTMLCanvasElement, options?: GpuRendererOptions): Promise<GpuChartRenderer | null>;

package/dist/renderer/index.d.ts

@@ -3,7 +3,10 @@
  */
 export { NativeWebGLRenderer, interleaveData, interleaveStepData, interleaveBandData, interleaveErrorData, interleaveBoxPlotData, interleaveWaterfallData, parseColor, type NativeSeriesRenderData, type NativeRenderOptions, } from './NativeWebGLRenderer';
 export { type IWebGLRenderer, type SeriesRenderData, type RenderOptions, createRenderer, createNativeRenderer, } from './RendererInterface';
+export { GpuChartRenderer, createGpuChartRenderer } from './GpuChartRenderer';
 export { WebGPURenderer, type WebGPURendererOptions } from './WebGPURenderer';
+export type { ChartSeriesRenderer, ChartRendererBackend } from './ChartSeriesRenderer';
+export { getRendererBackend } from './ChartSeriesRenderer';
 export * from './shaders';
 export * from './radar';
 export { interleaveBarData, calculateBarWidth } from './BarRenderer';

package/dist/renderer/spike/WebGLGridSpike.d.ts

@@ -0,0 +1,40 @@
+/**
+ * WebGL grid spike — batched GL_LINES renderer for axis grid lines.
+ * Labels remain on Canvas 2D; this spike covers grid lines only.
+ * @module renderer/spike/WebGLGridSpike
+ */
+export interface GridLineSpec {
+    /** Plot area in CSS pixels */
+    plotArea: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    /** Pixel X positions for vertical grid lines */
+    xLines: number[];
+    /** Pixel Y positions for horizontal grid lines */
+    yLines: number[];
+    /** Canvas width (physical pixels) */
+    width: number;
+    /** Canvas height (physical pixels) */
+    height: number;
+    /** Line color RGBA 0–1 */
+    color?: [number, number, number, number];
+    /** Line width in pixels */
+    lineWidth?: number;
+}
+/** Build interleaved [x,y] vertex pairs for GL_LINES from tick pixel positions */
+export declare function buildGridLineVertices(spec: GridLineSpec): Float32Array;
+export declare class WebGLGridSpike {
+    private gl;
+    private program;
+    private buffer;
+    private aPosition;
+    private uResolution;
+    private uColor;
+    constructor(canvas: HTMLCanvasElement);
+    /** Upload vertices and draw grid lines */
+    draw(spec: GridLineSpec): number;
+    destroy(): void;
+}

package/dist/testing/baselines/v1.15.0.json.d.ts

@@ -0,0 +1,51 @@
+declare const _default: {
+  "version": "1.17.0",
+  "recordedAt": "2026-07-05",
+  "notes": "Stage 1 baselines. Headless CI uses effective FPS (render throughput when rAF throttled) via scripts/benchmark-scenario-eval.mjs smoke floors.",
+  "regressionThreshold": 0.10,
+  "webgpuMinFpsRatio": 0.95,
+  "scenarios": {
+    "line-1m-pan": {
+      "minAvgFps": 50,
+      "maxAvgFrameTimeMs": 20,
+      "points": 1000000,
+      "description": "1M line points, continuous pan/zoom simulation"
+    },
+    "candlestick-500k": {
+      "minAvgFps": 45,
+      "maxAvgFrameTimeMs": 22,
+      "points": 500000,
+      "description": "500k OHLC bars with PluginVirtualization"
+    },
+    "stack-5pane-resize": {
+      "minAvgFps": 48,
+      "maxAvgFrameTimeMs": 21,
+      "description": "5-pane stack divider drag (batched overlay redraw)"
+    },
+    "line-200k-webgl": {
+      "minAvgFps": 45,
+      "description": "200k line WebGL baseline for renderer compare"
+    },
+    "line-200k-webgpu": {
+      "minAvgFps": 42,
+      "description": "200k line WebGPU — target ≥95% of WebGL FPS"
+    },
+    "boxplot-5k-webgpu": {
+      "minAvgFps": 50,
+      "description": "5k boxplot series on WebGPU chart path"
+    },
+    "grid-canvas2d-dpr2": {
+      "maxAvgFrameUs": 1200,
+      "dpr": 2,
+      "description": "Canvas 2D grid+minor at 1920×1080 @2x"
+    },
+    "grid-webgl-dpr2": {
+      "maxAvgFrameUs": 400,
+      "dpr": 2,
+      "description": "WebGL grid spike lines only @2x"
+    }
+  }
+}
+;
+
+export default _default;

package/dist/testing/gridSpikeBenchmark.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Grid rendering benchmark — Canvas 2D vs WebGL spike comparison.
+ * @module testing/gridSpikeBenchmark
+ */
+export interface GridBenchmarkResult {
+    backend: "canvas2d" | "webgl";
+    dpr: number;
+    width: number;
+    height: number;
+    xTicks: number;
+    yTicks: number;
+    lineSegments: number;
+    avgFrameUs: number;
+    p95FrameUs: number;
+    frames: number;
+}
+export interface GridCompareResult {
+    canvas2d: GridBenchmarkResult;
+    webgl: GridBenchmarkResult | null;
+    /** Positive = WebGL faster */
+    gainPercent: number;
+    recommendation: "implement" | "defer";
+}
+/** Benchmark Canvas 2D grid via OverlayRenderer.drawGrid */
+export declare function benchmarkCanvasGrid(options?: {
+    width?: number;
+    height?: number;
+    dpr?: number;
+    xTickCount?: number;
+    yTickCount?: number;
+    frames?: number;
+    showMinor?: boolean;
+}): GridBenchmarkResult;
+/** Benchmark WebGL grid spike (returns null if WebGL unavailable) */
+export declare function benchmarkWebGLGrid(options?: {
+    width?: number;
+    height?: number;
+    dpr?: number;
+    xTickCount?: number;
+    yTickCount?: number;
+    frames?: number;
+}): GridBenchmarkResult | null;
+/** Compare backends; recommends implement if WebGL ≥20% faster */
+export declare function compareGridBackends(options?: {
+    dpr?: number;
+    frames?: number;
+}): GridCompareResult;
+/** Vertex builder smoke test (no GL required) */
+export declare function countGridVertices(xTickCount: number, yTickCount: number): number;

package/dist/testing/index.d.ts

@@ -68,6 +68,8 @@ export interface BenchmarkResult {
     pointsRendered: number;
     /** Points per second throughput */
     throughput: number;
+    /** Render-only throughput (1000 / avgFrameTime); can exceed wall FPS */
+    renderFps?: number;
 }
 export interface BenchmarkOptions {
     /** Duration of benchmark in ms (default: 5000) */
@@ -223,3 +225,6 @@ export declare function waitForFrames(count?: number): Promise<void>;
  * Wait for a specified duration
  */
 export declare function waitFor(ms: number): Promise<void>;
+export { benchmarkCanvasGrid, benchmarkWebGLGrid, compareGridBackends, countGridVertices, type GridBenchmarkResult, type GridCompareResult, } from './gridSpikeBenchmark';
+export { getBaseline, compareScenarioToBaseline, buildStage1Report, effectiveBenchmarkFps, HEADLESS_LOW_FRAME_THRESHOLD, SMOKE_FLOORS, type Stage1ScenarioResult, type Stage1BrowserReport, } from './stage1BrowserBench';
+export { evaluateRendererCompare, type RendererCompareResult, } from './rendererBenchmark';

package/dist/testing/rendererBenchmark.d.ts

@@ -0,0 +1,13 @@
+import { BenchmarkResult } from './index';
+
+export interface RendererCompareResult {
+    webgl: BenchmarkResult;
+    webgpu: BenchmarkResult | null;
+    webgpuActive: boolean;
+    /** webgpuFps / webglFps — ≥1 means WebGPU is faster or equal */
+    fpsRatio: number;
+    /** Meets ADR target: WebGPU ≥ 95% of WebGL FPS */
+    meetsTarget: boolean;
+    recommendation: "webgpu-ready" | "webgl-faster" | "webgpu-unavailable";
+}
+export declare function evaluateRendererCompare(webgl: BenchmarkResult, webgpu: BenchmarkResult | null, webgpuActive: boolean, minRatio?: number): RendererCompareResult;

package/dist/testing/stage1BrowserBench.d.ts

@@ -0,0 +1,42 @@
+import { BenchmarkResult } from './index';
+import { default as baseline } from './baselines/v1.15.0.json';
+
+export interface Stage1ScenarioResult {
+    id: string;
+    benchmark: BenchmarkResult;
+    passed: boolean;
+    failures: string[];
+    baselineMinFps?: number;
+}
+export interface Stage1BrowserReport {
+    timestamp: number;
+    version: string;
+    scenarios: Stage1ScenarioResult[];
+    allPassed: boolean;
+    regressionThreshold: number;
+}
+export interface BaselineScenario {
+    minAvgFps?: number;
+    maxAvgFrameTimeMs?: number;
+    maxAvgFrameUs?: number;
+    dpr?: number;
+    points?: number;
+    description?: string;
+}
+/** When wall-clock frame count is below this, headless rAF is unreliable — use renderFps. */
+export declare const HEADLESS_LOW_FRAME_THRESHOLD = 30;
+/** Headless smoke floors (renderFps or effective FPS). Desktop uses baseline minAvgFps. */
+export declare const SMOKE_FLOORS: Record<string, number>;
+/** Pick wall or render FPS depending on headless throttling artifacts. */
+export declare function effectiveBenchmarkFps(result: Pick<BenchmarkResult, "avgFps" | "renderFps" | "frameCount">, isHeadless: boolean): number;
+export declare function getBaseline(): typeof baseline;
+/** Compare a benchmark result against v1.15 baseline for a scenario */
+export declare function compareScenarioToBaseline(scenarioId: string, result: BenchmarkResult | {
+    avgFrameUs: number;
+    backend?: string;
+}): {
+    passed: boolean;
+    failures: string[];
+};
+/** Build a full Stage 1 report from scenario results */
+export declare function buildStage1Report(scenarios: Stage1ScenarioResult[]): Stage1BrowserReport;

package/dist/trading/datafeed.d.ts

@@ -0,0 +1,48 @@
+/**
+ * UDF-inspired datafeed contract for trading charts (Stage 2.24).
+ */
+export interface SymbolInfo {
+    symbol: string;
+    name: string;
+    description?: string;
+    timezone?: string;
+    session?: string;
+    pricescale?: number;
+    minmov?: number;
+}
+export interface Bar {
+    time: number;
+    open: number;
+    high: number;
+    low: number;
+    close: number;
+    volume?: number;
+}
+export interface HistoryRequest {
+    symbol: string;
+    resolution: string;
+    from: number;
+    to: number;
+}
+export interface SubscribeBarsRequest {
+    symbol: string;
+    resolution: string;
+    onBar: (bar: Bar) => void;
+}
+/**
+ * TradingView UDF-style adapter surface.
+ */
+export interface DatafeedAdapter {
+    resolveSymbol(symbol: string): Promise<SymbolInfo>;
+    getBars(request: HistoryRequest): Promise<Bar[]>;
+    subscribeBars(request: SubscribeBarsRequest): () => void;
+}
+/** Convert bars to typed OHLC arrays for velo-plot series. */
+export declare function barsToOhlc(bars: Bar[]): {
+    x: Float64Array;
+    open: Float32Array;
+    high: Float32Array;
+    low: Float32Array;
+    close: Float32Array;
+    volume: Float32Array;
+};

package/dist/trading/index.d.ts

@@ -0,0 +1,29 @@
+/**
+ * velo-plot/trading — focused trading dashboard bundle (Stage 2).
+ * Tree-shakes scientific/3D plugins; includes stacked charts, indicators, drawings, replay.
+ */
+export { createChart } from '../core/Chart';
+export { createStackedChart } from '../core/stacked/createStackedChart';
+export type { Chart, ChartOptions } from '../core/Chart';
+export type { StackedChart, StackedChartOptions, StackedPaneConfig, } from '../core/stacked/types';
+export { mapToBusinessDayScale, isBusinessDay, businessDaySpanMs, type TimeScaleOptions, type BusinessDayMapping, } from '../core/time/TimeScale';
+export { isBusinessDayScaleActive, applyBusinessDayX, formatBusinessDayTick, } from '../core/time/applyTimeScale';
+export { addIndicatorToChart, buildIndicatorPaneFromPreset, computeIndicatorFromSeries, type AddIndicatorOptions, type AddIndicatorResult, type IndicatorPresetName, } from '../core/indicator/addIndicator';
+export { computeHeikinAshi } from '../core/chart/heikinAshi';
+export type { CandlestickMarker, CandlestickMarkerPosition, CandlestickMarkerShape, } from '../core/chart/candlestickMarkers';
+export type { PriceAlertOptions } from '../core/chart/ChartAlerts';
+export type { PositionLineOptions } from '../core/chart/positionLines';
+export { PluginAnnotations } from '../plugins/annotations';
+export type { Annotation, AnnotationType } from '../plugins/annotations';
+export { PluginDrawingTools } from '../plugins/drawing-tools';
+export type { DrawingMode, DrawingToolsAPI } from '../plugins/drawing-tools';
+export { PluginReplay } from '../plugins/replay';
+export type { ReplayAPI } from '../plugins/replay';
+export { PluginKeyboard } from '../plugins/keyboard';
+export { PluginStreaming } from '../plugins/streaming';
+export { ChartGroup } from '../core/sync';
+export { barsToOhlc, type DatafeedAdapter, type SymbolInfo, type Bar, type HistoryRequest, } from './datafeed';
+export { createMockDatafeed } from './mockDatafeed';
+export { generateBusinessDayOhlcv, generateContinuousOhlcv, findLowestBarIndex, findHighestBarIndex, type OhlcvData, type OhlcvOptions, } from './ohlcvGenerator';
+export type { SeriesOptions, SeriesData, AxisOptions, Bounds, } from '../types';
+export { DARK_THEME, LIGHT_THEME, DEFAULT_THEME } from '../theme';

package/dist/trading/mockDatafeed.d.ts

@@ -0,0 +1,9 @@
+import { DatafeedAdapter } from './datafeed';
+
+export interface MockDatafeedOptions {
+    symbol?: string;
+    barMs?: number;
+    basePrice?: number;
+    seed?: number;
+}
+export declare function createMockDatafeed(options?: MockDatafeedOptions): DatafeedAdapter;

package/dist/trading/ohlcvGenerator.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Seeded OHLCV generators for trading demos and tests.
+ */
+export interface OhlcvData {
+    x: Float64Array;
+    open: Float32Array;
+    high: Float32Array;
+    low: Float32Array;
+    close: Float32Array;
+    volume: Float32Array;
+}
+export interface OhlcvOptions {
+    startMs?: number;
+    seed?: number;
+}
+/** Mulberry32 PRNG — deterministic when seed is provided. */
+export declare function mulberry32(seed: number): () => number;
+/** OHLCV with business-day timestamps (weekends skipped in data). */
+export declare function generateBusinessDayOhlcv(n: number, startMsOrOptions?: number | OhlcvOptions, legacySeed?: number): OhlcvData;
+/** OHLCV with consecutive calendar days (includes weekends). */
+export declare function generateContinuousOhlcv(n: number, startMsOrOptions?: number | OhlcvOptions, legacySeed?: number): OhlcvData;
+/** Index of the bar with the lowest low. */
+export declare function findLowestBarIndex(low: Float32Array): number;
+/** Index of the bar with the highest high. */
+export declare function findHighestBarIndex(high: Float32Array): number;

package/dist/trading.d.ts

@@ -0,0 +1 @@
+export * from './trading/index'

package/dist/trading.js

@@ -0,0 +1,95 @@
+import { D as P, f as b, L as v, a as B, b as E, e as S, d as U, c as H } from "./ChartCore-BhQ4j7f5.js";
+import { c as k } from "./createStackedChart-DJSmqerD.js";
+import { c as _, b as R, f as G, i as K, a as j, m as X } from "./axisFormat-SPX-CD5s.js";
+import { PluginAnnotations as q } from "./plugins/annotations.js";
+import { P as J, a as N, b as O, c as Q } from "./mockDatafeed-Cdg5hKEo.js";
+import { P as W } from "./index-DoYxf1cV.js";
+import { P as $ } from "./index-BMiZoKmm.js";
+import { C as te } from "./index-CUGS98p4.js";
+const p = 864e5;
+function w(e) {
+  let a = e >>> 0;
+  return () => {
+    a = a + 1831565813 >>> 0;
+    let t = Math.imul(a ^ a >>> 15, 1 | a);
+    return t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t, ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+function h(e) {
+  return e !== void 0 ? w(e) : Math.random;
+}
+function D(e, a, t = Date.UTC(2024, 0, 2)) {
+  const l = typeof e == "object" ? e : { startMs: e, seed: a };
+  return {
+    startMs: l.startMs ?? t,
+    seed: l.seed
+  };
+}
+function x(e, a = Date.UTC(2024, 0, 2), t) {
+  const { startMs: l, seed: d } = D(a, t), n = h(d), u = new Float64Array(e), c = new Float32Array(e), f = new Float32Array(e), m = new Float32Array(e), s = new Float32Array(e), y = new Float32Array(e);
+  let i = l, r = 100;
+  for (let o = 0; o < e; o++) {
+    for (; new Date(i).getUTCDay() === 0 || new Date(i).getUTCDay() === 6; )
+      i += p;
+    u[o] = i, c[o] = r;
+    const A = (n() - 0.48) * 3;
+    s[o] = r + A, f[o] = Math.max(c[o], s[o]) + n() * 1.5, m[o] = Math.min(c[o], s[o]) - n() * 1.5, y[o] = 5e5 + n() * 2e6, r = s[o], i += p;
+  }
+  return { x: u, open: c, high: f, low: m, close: s, volume: y };
+}
+function g(e, a = Date.UTC(2024, 0, 1), t) {
+  const { startMs: l, seed: d } = D(
+    a,
+    t,
+    Date.UTC(2024, 0, 1)
+  ), n = h(d), u = new Float64Array(e), c = new Float32Array(e), f = new Float32Array(e), m = new Float32Array(e), s = new Float32Array(e), y = new Float32Array(e);
+  let i = 100;
+  for (let r = 0; r < e; r++) {
+    u[r] = l + r * p, c[r] = i;
+    const o = (n() - 0.48) * 3;
+    s[r] = i + o, f[r] = Math.max(c[r], s[r]) + n() * 1.5, m[r] = Math.min(c[r], s[r]) - n() * 1.5, y[r] = 5e5 + n() * 2e6, i = s[r];
+  }
+  return { x: u, open: c, high: f, low: m, close: s, volume: y };
+}
+function M(e) {
+  let a = 0;
+  for (let t = 1; t < e.length; t++)
+    e[t] < e[a] && (a = t);
+  return a;
+}
+function T(e) {
+  let a = 0;
+  for (let t = 1; t < e.length; t++)
+    e[t] > e[a] && (a = t);
+  return a;
+}
+export {
+  te as ChartGroup,
+  P as DARK_THEME,
+  b as DEFAULT_THEME,
+  v as LIGHT_THEME,
+  q as PluginAnnotations,
+  J as PluginDrawingTools,
+  W as PluginKeyboard,
+  N as PluginReplay,
+  $ as PluginStreaming,
+  B as addIndicatorToChart,
+  _ as applyBusinessDayX,
+  O as barsToOhlc,
+  E as buildIndicatorPaneFromPreset,
+  R as businessDaySpanMs,
+  S as computeHeikinAshi,
+  U as computeIndicatorFromSeries,
+  H as createChart,
+  Q as createMockDatafeed,
+  k as createStackedChart,
+  T as findHighestBarIndex,
+  M as findLowestBarIndex,
+  G as formatBusinessDayTick,
+  x as generateBusinessDayOhlcv,
+  g as generateContinuousOhlcv,
+  K as isBusinessDay,
+  j as isBusinessDayScaleActive,
+  X as mapToBusinessDayScale
+};
+//# sourceMappingURL=trading.js.map

package/dist/trading.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"trading.js","sources":["../src/trading/ohlcvGenerator.ts"],"sourcesContent":["/**\n * Seeded OHLCV generators for trading demos and tests.\n */\n\nexport interface OhlcvData {\n  x: Float64Array;\n  open: Float32Array;\n  high: Float32Array;\n  low: Float32Array;\n  close: Float32Array;\n  volume: Float32Array;\n}\n\nexport interface OhlcvOptions {\n  startMs?: number;\n  seed?: number;\n}\n\nconst MS_DAY = 86_400_000;\n\n/** Mulberry32 PRNG — deterministic when seed is provided. */\nexport function mulberry32(seed: number): () => number {\n  let s = seed >>> 0;\n  return () => {\n    s = (s + 0x6d2b79f5) >>> 0;\n    let t = Math.imul(s ^ (s >>> 15), 1 | s);\n    t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;\n    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;\n  };\n}\n\nfunction resolveRand(seed?: number): () => number {\n  return seed !== undefined ? mulberry32(seed) : Math.random;\n}\n\nfunction resolveOptions(\n  startMsOrOptions: number | OhlcvOptions,\n  legacySeed?: number,\n  defaultStartMs = Date.UTC(2024, 0, 2),\n): { startMs: number; seed?: number } {\n  const opts: OhlcvOptions =\n    typeof startMsOrOptions === \"object\"\n      ? startMsOrOptions\n      : { startMs: startMsOrOptions, seed: legacySeed };\n  return {\n    startMs: opts.startMs ?? defaultStartMs,\n    seed: opts.seed,\n  };\n}\n\n/** OHLCV with business-day timestamps (weekends skipped in data). */\nexport function generateBusinessDayOhlcv(\n  n: number,\n  startMsOrOptions: number | OhlcvOptions = Date.UTC(2024, 0, 2),\n  legacySeed?: number,\n): OhlcvData {\n  const { startMs, seed } = resolveOptions(startMsOrOptions, legacySeed);\n  const rand = resolveRand(seed);\n\n  const x = new Float64Array(n);\n  const open = new Float32Array(n);\n  const high = new Float32Array(n);\n  const low = new Float32Array(n);\n  const close = new Float32Array(n);\n  const volume = new Float32Array(n);\n\n  let t = startMs;\n  let price = 100;\n\n  for (let i = 0; i < n; i++) {\n    while (new Date(t).getUTCDay() === 0 || new Date(t).getUTCDay() === 6) {\n      t += MS_DAY;\n    }\n    x[i] = t;\n    open[i] = price;\n    const change = (rand() - 0.48) * 3;\n    close[i] = price + change;\n    high[i] = Math.max(open[i], close[i]) + rand() * 1.5;\n    low[i] = Math.min(open[i], close[i]) - rand() * 1.5;\n    volume[i] = 500_000 + rand() * 2_000_000;\n    price = close[i];\n    t += MS_DAY;\n  }\n\n  return { x, open, high, low, close, volume };\n}\n\n/** OHLCV with consecutive calendar days (includes weekends). */\nexport function generateContinuousOhlcv(\n  n: number,\n  startMsOrOptions: number | OhlcvOptions = Date.UTC(2024, 0, 1),\n  legacySeed?: number,\n): OhlcvData {\n  const { startMs, seed } = resolveOptions(\n    startMsOrOptions,\n    legacySeed,\n    Date.UTC(2024, 0, 1),\n  );\n  const rand = resolveRand(seed);\n\n  const x = new Float64Array(n);\n  const open = new Float32Array(n);\n  const high = new Float32Array(n);\n  const low = new Float32Array(n);\n  const close = new Float32Array(n);\n  const volume = new Float32Array(n);\n\n  let price = 100;\n  for (let i = 0; i < n; i++) {\n    x[i] = startMs + i * MS_DAY;\n    open[i] = price;\n    const change = (rand() - 0.48) * 3;\n    close[i] = price + change;\n    high[i] = Math.max(open[i], close[i]) + rand() * 1.5;\n    low[i] = Math.min(open[i], close[i]) - rand() * 1.5;\n    volume[i] = 500_000 + rand() * 2_000_000;\n    price = close[i];\n  }\n\n  return { x, open, high, low, close, volume };\n}\n\n/** Index of the bar with the lowest low. */\nexport function findLowestBarIndex(low: Float32Array): number {\n  let idx = 0;\n  for (let i = 1; i < low.length; i++) {\n    if (low[i] < low[idx]) idx = i;\n  }\n  return idx;\n}\n\n/** Index of the bar with the highest high. */\nexport function findHighestBarIndex(high: Float32Array): number {\n  let idx = 0;\n  for (let i = 1; i < high.length; i++) {\n    if (high[i] > high[idx]) idx = i;\n  }\n  return idx;\n}\n"],"names":["MS_DAY","mulberry32","seed","s","resolveRand","resolveOptions","startMsOrOptions","legacySeed","defaultStartMs","opts","generateBusinessDayOhlcv","n","startMs","rand","x","open","high","low","close","volume","t","price","i","change","generateContinuousOhlcv","findLowestBarIndex","idx","findHighestBarIndex"],"mappings":"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"}

package/dist/types.d.ts

@@ -69,8 +69,10 @@ export interface AxisOptions {
     labelRotation?: number;
     /** Target number of tick divisions on this axis (default: 8 for X, 6 for Y) */
     tickCount?: number;
+    /** Trading time scale (Stage 2) — business-day gaps, session presets */
+    timeScale?: import('./core/time/TimeScale').TimeScaleOptions;
 }
-export type SeriesType = "line" | "scatter" | "line+scatter" | "step" | "step+scatter" | "band" | "area" | "bar" | "heatmap" | "candlestick" | "polar" | "radar" | "boxplot" | "waterfall" | "gauge" | "sankey" | "ternary" | "indicator";
+export type SeriesType = "line" | "scatter" | "line+scatter" | "step" | "step+scatter" | "band" | "area" | "bar" | "heatmap" | "candlestick" | "heikin-ashi" | "polar" | "radar" | "boxplot" | "waterfall" | "gauge" | "sankey" | "ternary" | "indicator";
 /** Step mode defines where the step occurs */
 export type StepMode = "before" | "after" | "center";
 /** Error bar direction */
@@ -202,6 +204,8 @@ export interface SeriesOptions {
     maxPoints?: number;
     /** Identifier for stacking series (same ID will be stacked together) */
     stackId?: string;
+    /** Buy/sell markers on candlestick series (Stage 2.14) */
+    markers?: import('./core/chart/candlestickMarkers').CandlestickMarker[];
 }
 export interface SeriesUpdateData {
     /** New X values */
@@ -509,7 +513,14 @@ export interface ChartOptions {
     container: HTMLDivElement;
     /** Stable chart id (used by sync groups; auto-generated if omitted) */
     id?: string;
-    /** Renderer backend selection (default: 'webgl') */
+    /**
+     * Renderer backend selection (default: `'webgl'`).
+     * `'webgl'` uses WebGL2 via `NativeWebGLRenderer`.
+     * `'webgpu'` uses the GPU abstraction layer (WebGPU when available, otherwise
+     * falls back to WebGL2 with a console warning). Use `chart.getActiveRenderer()`
+     * to inspect the runtime backend. Boxplot/waterfall series render on WebGL only.
+     * @see docs/adr/001-webgpu-renderer-strategy.md
+     */
     renderer?: "webgl" | "webgpu";
     /** X-axis configuration */
     xAxis?: AxisOptions;
@@ -752,6 +763,15 @@ export interface ChartEventMap {
     dataLoading: DataLoadingEvent;
     deltaMeasure: DeltaMeasurement;
     peakMeasure: PeakMeasurement;
+    /** Price alert triggered (Stage 2.18) */
+    alert: {
+        id: string;
+        price: number;
+        direction: "above" | "below" | "cross";
+        seriesId?: string;
+        triggeredAt: number;
+        triggerPrice: number;
+    };
 }
 /** GPU uniform values */
 export interface Uniforms {