velo-plot 1.15.0 → 1.19.0

package/dist/plugins/index.d.ts

@@ -51,6 +51,8 @@ export { PluginBrokenAxis, type PluginBrokenAxisConfig, type BrokenAxisAPI, type
 export { PluginVideoRecorder, type PluginVideoRecorderConfig, type VideoRecorderAPI, type VideoRecorderOptions } from './video-recorder';
 export { PluginOffscreen, type PluginOffscreenConfig, type OffscreenAPI, type OffscreenStats, type OffscreenMode, type OffscreenTransferMode, type OffscreenFallbackMode } from './offscreen';
 export { PluginVirtualization, type PluginVirtualizationConfig, type VirtualizationAPI, type VirtualizationStats, type VirtualizationMode, type VirtualizationStrategy } from './virtualization';
+export { PluginDrawingTools, type PluginDrawingToolsConfig, type DrawingToolsAPI, type DrawingMode } from './drawing-tools';
+export { PluginReplay, type PluginReplayConfig, type ReplayAPI } from './replay';
 export { PluginROI, type PluginROIConfig, type RoiAPI, type RoiRegion, type RoiPoint, type RoiMaskResult, type RoiTool, type RoiEvent, type RoiSelectedEvent } from './roi';
 /**
  * Helper function to create a plugin with proper typing

package/dist/plugins/keyboard/index.d.ts

@@ -2,14 +2,8 @@ import { KeyBindingManager, DEFAULT_KEY_BINDINGS, KeyBinding, KeyBindingManagerO
 import { ChartPlugin } from '../types';
 
 export interface PluginKeyboardConfig extends Partial<KeyBindingManagerOptions> {
-    /** Additional shortcuts to register */
     extraShortcuts?: KeyBinding[];
 }
-/**
- * SciPlot Keyboard Plugin
- *
- * Adds support for keyboard shortcuts and hotkeys.
- */
-export declare function PluginKeyboard(_config?: PluginKeyboardConfig): ChartPlugin<PluginKeyboardConfig>;
+export declare function PluginKeyboard(config?: PluginKeyboardConfig): ChartPlugin<PluginKeyboardConfig>;
 export { KeyBindingManager, DEFAULT_KEY_BINDINGS };
 export default PluginKeyboard;

package/dist/plugins/keyboard.js

@@ -1,4 +1,4 @@
-import { D as n, K as r, P as s, P as K } from "../index-Ce2JgkH_.js";
+import { D as n, K as r, P as s, P as K } from "../index-DoYxf1cV.js";
 export {
   n as DEFAULT_KEY_BINDINGS,
   r as KeyBindingManager,

package/dist/plugins/lazy-load/types.d.ts

@@ -107,6 +107,13 @@ export interface LazyLoadAPI {
     loadVisible(): Promise<void>;
     /** Unload distant chunks */
     unloadDistant(): number;
+    /** Load only a visible data window (+ buffer) */
+    setDataWindow(opts: {
+        from: number;
+        to: number;
+        buffer?: number;
+        seriesId?: string;
+    }): Promise<void>;
     /** Get loading status */
     getLoadingStatus(seriesId: string): {
         loadedPoints: number;

package/dist/plugins/lazy-load.js

@@ -1,10 +1,10 @@
-const w = {
+const D = {
   name: "velo-plot-lazy-load",
   version: "1.0.0",
   description: "Lazy loading for large datasets with viewport-based chunking",
   provides: ["lazy-load", "data-streaming"],
   tags: ["performance", "data", "optimization"]
-}, v = {
+}, T = {
   enabled: !0,
   chunkSize: 1e4,
   viewportBuffer: 2,
@@ -23,167 +23,190 @@ const w = {
   },
   debug: !1
 };
-function A(p = {}) {
-  const n = { ...v, ...p };
-  let u = null;
-  const c = /* @__PURE__ */ new Map();
-  function x(t) {
-    return Math.floor(t / n.chunkSize);
+function B(w = {}) {
+  const a = { ...T, ...w };
+  let l = null;
+  const h = /* @__PURE__ */ new Map();
+  function L(t) {
+    return Math.floor(t / a.chunkSize);
   }
-  function z() {
-    if (!u) return null;
-    const t = u.data.getViewBounds();
+  function m() {
+    if (!l) return null;
+    const t = l.data.getViewBounds();
     return t ? { xMin: t.xMin, xMax: t.xMax } : null;
   }
-  async function k(t, o) {
-    if (!(t.chunks.has(o) || t.loading.has(o))) {
-      t.loading.add(o);
+  async function M(t, n) {
+    if (!(t.chunks.has(n) || t.loading.has(n))) {
+      t.loading.add(n);
       try {
-        const a = o * n.chunkSize, r = Math.min(
-          a + n.chunkSize,
+        const o = n * a.chunkSize, r = Math.min(
+          o + a.chunkSize,
           t.totalPoints
         );
-        n.debug && console.log(`[LazyLoad] Loading chunk ${o} for ${t.id} (${a}-${r})`);
-        const e = await t.provider.loadChunk(a, r);
-        t.chunks.set(o, e), t.loading.delete(o), await C(t);
-        const i = Array.from(t.chunks.values()).reduce(
-          (l, f) => l + (f.endIndex - f.startIndex),
+        a.debug && console.log(`[LazyLoad] Loading chunk ${n} for ${t.id} (${o}-${r})`);
+        const e = await t.provider.loadChunk(o, r);
+        t.chunks.set(n, e), t.loading.delete(n), await z(t);
+        const s = Array.from(t.chunks.values()).reduce(
+          (c, f) => c + (f.endIndex - f.startIndex),
           0
-        ), s = Math.ceil(t.totalPoints / n.chunkSize), h = {
+        ), i = Math.ceil(t.totalPoints / a.chunkSize), u = {
           seriesId: t.id,
-          loadedPoints: i,
+          loadedPoints: s,
           totalPoints: t.totalPoints,
-          progress: i / t.totalPoints,
-          currentChunk: o,
-          totalChunks: s
+          progress: s / t.totalPoints,
+          currentChunk: n,
+          totalChunks: i
         };
-        i === t.totalPoints ? n.onLoadComplete(h) : n.onLoadProgress(h);
-      } catch (a) {
-        t.loading.delete(o), n.onLoadError(a, t.id), n.debug && console.error(`[LazyLoad] Error loading chunk ${o}:`, a);
+        s === t.totalPoints ? a.onLoadComplete(u) : a.onLoadProgress(u);
+      } catch (o) {
+        t.loading.delete(n), a.onLoadError(o, t.id), a.debug && console.error(`[LazyLoad] Error loading chunk ${n}:`, o);
       }
     }
   }
-  async function C(t) {
-    var s, h;
-    if (!u) return;
-    const o = Array.from(t.chunks.entries()).sort((l, f) => l[0] - f[0]);
-    if (o.length === 0) return;
-    let a = 0;
-    for (const [, l] of o)
-      a += l.x.length;
-    const r = new Float32Array(a), e = new Float32Array(a);
-    let i = 0;
-    for (const [, l] of o)
-      r.set(l.x, i), e.set(l.y, i), i += l.x.length;
-    (h = (s = u.chart).updateSeries) == null || h.call(s, t.id, { x: r, y: e });
+  async function z(t) {
+    var i, u;
+    if (!l) return;
+    const n = Array.from(t.chunks.entries()).sort((c, f) => c[0] - f[0]);
+    if (n.length === 0) return;
+    let o = 0;
+    for (const [, c] of n)
+      o += c.x.length;
+    const r = new Float32Array(o), e = new Float32Array(o);
+    let s = 0;
+    for (const [, c] of n)
+      r.set(c.x, s), e.set(c.y, s), s += c.x.length;
+    (u = (i = l.chart).updateSeries) == null || u.call(i, t.id, { x: r, y: e });
   }
   async function g() {
-    if (!n.enabled || !u) return;
-    const t = z();
+    if (!a.enabled || !l) return;
+    const t = m();
     if (!t) return;
-    const o = n.viewportBuffer, a = t.xMax - t.xMin, r = {
-      xMin: t.xMin - a * o,
-      xMax: t.xMax + a * o
+    const n = a.viewportBuffer, o = t.xMax - t.xMin, r = {
+      xMin: t.xMin - o * n,
+      xMax: t.xMax + o * n
     };
-    for (const [, e] of c) {
-      const i = [], s = Math.ceil(e.totalPoints / n.chunkSize), h = Math.max(0, Math.floor(r.xMin / n.chunkSize)), l = Math.min(s - 1, Math.floor(r.xMax / n.chunkSize));
-      for (let d = h; d <= l; d++)
-        !e.chunks.has(d) && !e.loading.has(d) && i.push(d);
-      const f = Math.min(i.length, 10);
+    for (const [, e] of h) {
+      const s = [], i = Math.ceil(e.totalPoints / a.chunkSize), u = Math.max(0, Math.floor(r.xMin / a.chunkSize)), c = Math.min(i - 1, Math.floor(r.xMax / a.chunkSize));
+      for (let d = u; d <= c; d++)
+        !e.chunks.has(d) && !e.loading.has(d) && s.push(d);
+      const f = Math.min(s.length, 10);
       for (let d = 0; d < f; d++)
-        await k(e, i[d]);
-      if (n.preloadAdjacent && l + 1 < s) {
-        const d = l + 1;
-        !e.chunks.has(d) && !e.loading.has(d) && k(e, d);
+        await M(e, s[d]);
+      if (a.preloadAdjacent && c + 1 < i) {
+        const d = c + 1;
+        !e.chunks.has(d) && !e.loading.has(d) && M(e, d);
       }
     }
   }
-  function L() {
-    if (!n.autoUnload || !u || !z()) return 0;
-    let o = 0;
-    for (const [, a] of c)
-      if (a.chunks.size > n.maxLoadedChunks) {
-        const r = Array.from(a.chunks.entries()).sort(
-          (i, s) => i[1].loadedAt - s[1].loadedAt
-        ), e = a.chunks.size - n.maxLoadedChunks;
-        for (let i = 0; i < e; i++)
-          a.chunks.delete(r[i][0]), o++;
+  function b(t, n) {
+    const o = a.viewportBuffer, r = n.xMax - n.xMin, e = {
+      xMin: n.xMin - r * o,
+      xMax: n.xMax + r * o
+    }, s = Math.ceil(t.totalPoints / a.chunkSize), i = Math.max(0, Math.floor(e.xMin / a.chunkSize)), u = Math.min(s - 1, Math.floor(e.xMax / a.chunkSize));
+    return { startChunk: i, endChunk: u };
+  }
+  function x() {
+    if (!a.autoUnload || !l) return 0;
+    const t = m();
+    if (!t) return 0;
+    let n = 0;
+    for (const [, o] of h) {
+      let r = 0;
+      const { startChunk: e, endChunk: s } = b(o, t), i = Math.max(1, s - e + 1), u = Math.ceil(a.unloadThreshold * i), c = Math.max(0, e - u), f = s + u;
+      for (const d of Array.from(o.chunks.keys()))
+        (d < c || d > f) && (o.chunks.delete(d), r++);
+      if (o.chunks.size > a.maxLoadedChunks) {
+        const d = Array.from(o.chunks.entries()).sort(
+          (k, $) => k[1].loadedAt - $[1].loadedAt
+        ), U = o.chunks.size - a.maxLoadedChunks;
+        for (let k = 0; k < U; k++)
+          o.chunks.delete(d[k][0]), r++;
       }
-    return n.debug && o > 0 && console.log(`[LazyLoad] Unloaded ${o} chunks`), o;
+      r > 0 && (z(o), n += r);
+    }
+    return a.debug && n > 0 && console.log(`[LazyLoad] Unloaded ${n} chunks`), n;
   }
-  function m(t, o) {
-    const a = o.getTotalCount();
-    c.set(t, {
+  function P(t, n) {
+    const o = n.getTotalCount();
+    h.set(t, {
       id: t,
-      provider: o,
+      provider: n,
       chunks: /* @__PURE__ */ new Map(),
       loading: /* @__PURE__ */ new Set(),
-      totalPoints: a
-    }), n.debug && console.log(`[LazyLoad] Registered series ${t} with ${a} points`), n.onLoadStart({
+      totalPoints: o
+    }), a.debug && console.log(`[LazyLoad] Registered series ${t} with ${o} points`), a.onLoadStart({
       seriesId: t,
       loadedPoints: 0,
-      totalPoints: a,
+      totalPoints: o,
       progress: 0,
       currentChunk: 0,
-      totalChunks: Math.ceil(a / n.chunkSize)
-    }), n.autoLoad && g();
+      totalChunks: Math.ceil(o / a.chunkSize)
+    }), a.autoLoad && g();
   }
-  function S(t) {
-    c.delete(t), n.debug && console.log(`[LazyLoad] Unregistered series ${t}`);
+  function v(t) {
+    h.delete(t), a.debug && console.log(`[LazyLoad] Unregistered series ${t}`);
   }
-  async function b(t, o, a) {
-    const r = c.get(t);
+  async function C(t, n, o) {
+    const r = h.get(t);
     if (!r) return;
-    const e = x(o), i = x(a);
-    for (let s = e; s <= i; s++)
-      await k(r, s);
+    const e = L(n), s = L(o);
+    for (let i = e; i <= s; i++)
+      await M(r, i);
   }
-  function P(t) {
-    const o = c.get(t);
-    return o ? {
-      loadedPoints: Array.from(o.chunks.values()).reduce(
+  function A(t) {
+    const n = h.get(t);
+    return n ? {
+      loadedPoints: Array.from(n.chunks.values()).reduce(
         (r, e) => r + (e.endIndex - e.startIndex),
         0
       ),
-      totalPoints: o.totalPoints,
-      loadedChunks: o.chunks.size,
-      totalChunks: Math.ceil(o.totalPoints / n.chunkSize)
+      totalPoints: n.totalPoints,
+      loadedChunks: n.chunks.size,
+      totalChunks: Math.ceil(n.totalPoints / a.chunkSize)
     } : null;
   }
   function y() {
-    for (const [, t] of c)
+    for (const [, t] of h)
       t.chunks.clear(), t.loading.clear();
   }
-  const M = {
-    registerSeries: m,
-    unregisterSeries: S,
-    loadRange: b,
+  async function p(t) {
+    if (!l || !a.enabled) return;
+    const n = t.buffer ?? a.viewportBuffer, o = t.to - t.from, r = Math.max(0, Math.floor(t.from - o * n)), e = Math.ceil(t.to + o * n), s = t.seriesId ? [[t.seriesId, h.get(t.seriesId)]] : Array.from(h.entries()).map(([i, u]) => [i, u]);
+    for (const [i, u] of s)
+      u && await C(i, r, e);
+    a.autoUnload && x();
+  }
+  const S = {
+    registerSeries: P,
+    unregisterSeries: v,
+    loadRange: C,
     loadVisible: g,
-    unloadDistant: L,
-    getLoadingStatus: P,
+    unloadDistant: x,
+    setDataWindow: p,
+    getLoadingStatus: A,
     clear: y,
     updateConfig(t) {
-      Object.assign(n, t);
+      Object.assign(a, t);
     }
   };
   return {
-    manifest: w,
+    manifest: D,
     onInit(t) {
-      var o, a, r, e;
-      u = t, u.chart.lazyLoad = M, n.autoLoad && ((a = (o = u.chart).on) == null || a.call(o, "zoom", () => {
-        g(), n.autoUnload && L();
-      }), (e = (r = u.chart).on) == null || e.call(r, "pan", () => {
-        g(), n.autoUnload && L();
+      var n, o, r, e;
+      l = t, l.chart.lazyLoad = S, l.chart.setDataWindow = (s) => p(s), a.autoLoad && ((o = (n = l.chart).on) == null || o.call(n, "zoom", () => {
+        g(), a.autoUnload && x();
+      }), (e = (r = l.chart).on) == null || e.call(r, "pan", () => {
+        g(), a.autoUnload && x();
       }));
     },
     onDestroy(t) {
-      y(), delete t.chart.lazyLoad, u = null;
+      y(), delete t.chart.lazyLoad, delete t.chart.setDataWindow, l = null;
     },
-    api: M
+    api: S
   };
 }
 export {
-  A as PluginLazyLoad,
-  A as default
+  B as PluginLazyLoad,
+  B as default
 };
 //# sourceMappingURL=lazy-load.js.map

package/dist/plugins/lazy-load.js.map

@@ -1 +1 @@
-{"version":3,"file":"lazy-load.js","sources":["../../src/plugins/lazy-load/index.ts"],"sourcesContent":["/**\n * @fileoverview Lazy loading plugin for large datasets\n * @module plugins/lazy-load\n */\n\nimport type {\n  PluginLazyLoadConfig,\n  LazyLoadAPI,\n  DataProvider,\n  LazyLoadedSeries,\n  LoadProgressEvent,\n} from './types';\nimport type {\n  ChartPlugin,\n  PluginContext,\n  PluginManifest,\n} from '../types';\n\nconst manifest: PluginManifest = {\n  name: 'velo-plot-lazy-load',\n  version: '1.0.0',\n  description: 'Lazy loading for large datasets with viewport-based chunking',\n  provides: ['lazy-load', 'data-streaming'],\n  tags: ['performance', 'data', 'optimization'],\n};\n\nconst DEFAULT_CONFIG: Required<PluginLazyLoadConfig> = {\n  enabled: true,\n  chunkSize: 10000,\n  viewportBuffer: 2,\n  autoLoad: true,\n  autoUnload: true,\n  unloadThreshold: 5,\n  preloadAdjacent: true,\n  maxLoadedChunks: 100,\n  onLoadStart: () => {},\n  onLoadProgress: () => {},\n  onLoadComplete: () => {},\n  onLoadError: () => {},\n  debug: false,\n};\n\nexport function PluginLazyLoad(\n  userConfig: Partial<PluginLazyLoadConfig> = {}\n): ChartPlugin<PluginLazyLoadConfig> {\n  const config = { ...DEFAULT_CONFIG, ...userConfig };\n  let ctx: PluginContext | null = null;\n\n  // Registered series\n  const series = new Map<string, LazyLoadedSeries>();\n\n  /**\n   * Calculate chunk index from point index\n   */\n  function getChunkIndex(pointIndex: number): number {\n    return Math.floor(pointIndex / config.chunkSize);\n  }\n\n  /**\n   * Get visible range from chart\n   */\n  function getVisibleRange(): { xMin: number; xMax: number } | null {\n    if (!ctx) return null;\n    \n    // Get current view bounds from data context\n    const bounds = ctx.data.getViewBounds();\n    if (bounds) {\n      return { xMin: bounds.xMin, xMax: bounds.xMax };\n    }\n    \n    return null;\n  }\n\n  /**\n   * Load a specific chunk\n   */\n  async function loadChunk(\n    seriesInfo: LazyLoadedSeries,\n    chunkIndex: number\n  ): Promise<void> {\n    // Already loaded or loading\n    if (seriesInfo.chunks.has(chunkIndex) || seriesInfo.loading.has(chunkIndex)) {\n      return;\n    }\n\n    seriesInfo.loading.add(chunkIndex);\n\n    try {\n      const startIndex = chunkIndex * config.chunkSize;\n      const endIndex = Math.min(\n        startIndex + config.chunkSize,\n        seriesInfo.totalPoints\n      );\n\n      if (config.debug) {\n        console.log(`[LazyLoad] Loading chunk ${chunkIndex} for ${seriesInfo.id} (${startIndex}-${endIndex})`);\n      }\n\n      const chunk = await seriesInfo.provider.loadChunk(startIndex, endIndex);\n      \n      seriesInfo.chunks.set(chunkIndex, chunk);\n      seriesInfo.loading.delete(chunkIndex);\n\n      // Update chart data\n      await updateSeriesData(seriesInfo);\n\n      // Fire progress event\n      const loadedPoints = Array.from(seriesInfo.chunks.values()).reduce(\n        (sum, c) => sum + (c.endIndex - c.startIndex),\n        0\n      );\n\n      const totalChunks = Math.ceil(seriesInfo.totalPoints / config.chunkSize);\n      \n      const event: LoadProgressEvent = {\n        seriesId: seriesInfo.id,\n        loadedPoints,\n        totalPoints: seriesInfo.totalPoints,\n        progress: loadedPoints / seriesInfo.totalPoints,\n        currentChunk: chunkIndex,\n        totalChunks,\n      };\n\n      if (loadedPoints === seriesInfo.totalPoints) {\n        config.onLoadComplete(event);\n      } else {\n        config.onLoadProgress(event);\n      }\n\n    } catch (error) {\n      seriesInfo.loading.delete(chunkIndex);\n      config.onLoadError(error as Error, seriesInfo.id);\n      \n      if (config.debug) {\n        console.error(`[LazyLoad] Error loading chunk ${chunkIndex}:`, error);\n      }\n    }\n  }\n\n  /**\n   * Update series data from loaded chunks\n   */\n  async function updateSeriesData(seriesInfo: LazyLoadedSeries): Promise<void> {\n    if (!ctx) return;\n\n    // Merge all loaded chunks\n    const sortedChunks = Array.from(seriesInfo.chunks.entries()).sort((a, b) => a[0] - b[0]);\n    \n    if (sortedChunks.length === 0) return;\n\n    // Calculate total size\n    let totalSize = 0;\n    for (const [, chunk] of sortedChunks) {\n      totalSize += chunk.x.length;\n    }\n\n    // Allocate arrays\n    const x = new Float32Array(totalSize);\n    const y = new Float32Array(totalSize);\n\n    // Copy data\n    let offset = 0;\n    for (const [, chunk] of sortedChunks) {\n      x.set(chunk.x, offset);\n      y.set(chunk.y, offset);\n      offset += chunk.x.length;\n    }\n\n    // Update series\n    (ctx.chart as any).updateSeries?.(seriesInfo.id, { x, y });\n  }\n\n  /**\n   * Load visible data\n   */\n  async function loadVisible(): Promise<void> {\n    if (!config.enabled || !ctx) return;\n\n    const visibleRange = getVisibleRange();\n    if (!visibleRange) return;\n\n    const buffer = config.viewportBuffer;\n    const rangeWidth = visibleRange.xMax - visibleRange.xMin;\n    const buffered = {\n      xMin: visibleRange.xMin - rangeWidth * buffer,\n      xMax: visibleRange.xMax + rangeWidth * buffer,\n    };\n\n    for (const [, seriesInfo] of series) {\n      const chunksToLoad: number[] = [];\n      const totalChunks = Math.ceil(seriesInfo.totalPoints / config.chunkSize);\n\n      // Identify chunks within the buffered viewport\n      const startIdx = Math.max(0, Math.floor(buffered.xMin / config.chunkSize));\n      const endIdx = Math.min(totalChunks - 1, Math.floor(buffered.xMax / config.chunkSize));\n\n      for (let i = startIdx; i <= endIdx; i++) {\n        if (!seriesInfo.chunks.has(i) && !seriesInfo.loading.has(i)) {\n          chunksToLoad.push(i);\n        }\n      }\n\n      // Load chunks sequentially (limit to avoid flood)\n      const maxToLoad = Math.min(chunksToLoad.length, 10);\n      for (let i = 0; i < maxToLoad; i++) {\n        await loadChunk(seriesInfo, chunksToLoad[i]);\n      }\n\n      // Preload next adjacent chunk if enabled\n      if (config.preloadAdjacent && endIdx + 1 < totalChunks) {\n        const nextChunk = endIdx + 1;\n        if (!seriesInfo.chunks.has(nextChunk) && !seriesInfo.loading.has(nextChunk)) {\n          loadChunk(seriesInfo, nextChunk); // Fire and forget\n        }\n      }\n    }\n  }\n\n  /**\n   * Unload distant chunks\n   */\n  function unloadDistant(): number {\n    if (!config.autoUnload || !ctx) return 0;\n\n    const visibleRange = getVisibleRange();\n    if (!visibleRange) return 0;\n\n    let unloadedCount = 0;\n\n    for (const [, seriesInfo] of series) {\n      // TODO: Implement distance-based unloading logic\n      // For now, only maxLoadedChunks handles eviction\n\n      // Enforce max chunks limit\n      if (seriesInfo.chunks.size > config.maxLoadedChunks) {\n        const sortedChunks = Array.from(seriesInfo.chunks.entries()).sort(\n          (a, b) => a[1].loadedAt - b[1].loadedAt\n        );\n        \n        const toRemove = seriesInfo.chunks.size - config.maxLoadedChunks;\n        for (let i = 0; i < toRemove; i++) {\n          seriesInfo.chunks.delete(sortedChunks[i][0]);\n          unloadedCount++;\n        }\n      }\n    }\n\n    if (config.debug && unloadedCount > 0) {\n      console.log(`[LazyLoad] Unloaded ${unloadedCount} chunks`);\n    }\n\n    return unloadedCount;\n  }\n\n  /**\n   * Register a series\n   */\n  function registerSeries(seriesId: string, provider: DataProvider): void {\n    const totalPoints = provider.getTotalCount();\n    \n    series.set(seriesId, {\n      id: seriesId,\n      provider,\n      chunks: new Map(),\n      loading: new Set(),\n      totalPoints,\n    });\n\n    if (config.debug) {\n      console.log(`[LazyLoad] Registered series ${seriesId} with ${totalPoints} points`);\n    }\n\n    // Fire load start event\n    config.onLoadStart({\n      seriesId,\n      loadedPoints: 0,\n      totalPoints,\n      progress: 0,\n      currentChunk: 0,\n      totalChunks: Math.ceil(totalPoints / config.chunkSize),\n    });\n\n    // Auto-load if enabled\n    if (config.autoLoad) {\n      loadVisible();\n    }\n  }\n\n  /**\n   * Unregister a series\n   */\n  function unregisterSeries(seriesId: string): void {\n    series.delete(seriesId);\n    \n    if (config.debug) {\n      console.log(`[LazyLoad] Unregistered series ${seriesId}`);\n    }\n  }\n\n  /**\n   * Load specific range\n   */\n  async function loadRange(\n    seriesId: string,\n    startIndex: number,\n    endIndex: number\n  ): Promise<void> {\n    const seriesInfo = series.get(seriesId);\n    if (!seriesInfo) return;\n\n    const startChunk = getChunkIndex(startIndex);\n    const endChunk = getChunkIndex(endIndex);\n\n    for (let i = startChunk; i <= endChunk; i++) {\n      await loadChunk(seriesInfo, i);\n    }\n  }\n\n  /**\n   * Get loading status\n   */\n  function getLoadingStatus(seriesId: string) {\n    const seriesInfo = series.get(seriesId);\n    if (!seriesInfo) return null;\n\n    const loadedPoints = Array.from(seriesInfo.chunks.values()).reduce(\n      (sum, c) => sum + (c.endIndex - c.startIndex),\n      0\n    );\n\n    return {\n      loadedPoints,\n      totalPoints: seriesInfo.totalPoints,\n      loadedChunks: seriesInfo.chunks.size,\n      totalChunks: Math.ceil(seriesInfo.totalPoints / config.chunkSize),\n    };\n  }\n\n  /**\n   * Clear all data\n   */\n  function clear(): void {\n    for (const [, seriesInfo] of series) {\n      seriesInfo.chunks.clear();\n      seriesInfo.loading.clear();\n    }\n  }\n\n  // API implementation\n  const api: LazyLoadAPI & Record<string, unknown> = {\n    registerSeries,\n    unregisterSeries,\n    loadRange,\n    loadVisible,\n    unloadDistant,\n    getLoadingStatus,\n    clear,\n    updateConfig(newConfig: Partial<PluginLazyLoadConfig>) {\n      Object.assign(config, newConfig);\n    },\n  };\n\n  return {\n    manifest,\n\n    onInit(pluginCtx: PluginContext) {\n      ctx = pluginCtx;\n\n      // Attach to chart API\n      (ctx.chart as any).lazyLoad = api;\n\n      // Listen for zoom/pan if auto-load enabled\n      if (config.autoLoad) {\n        ctx.chart.on?.('zoom', () => {\n          loadVisible();\n          if (config.autoUnload) {\n            unloadDistant();\n          }\n        });\n\n        ctx.chart.on?.('pan', () => {\n          loadVisible();\n          if (config.autoUnload) {\n            unloadDistant();\n          }\n        });\n      }\n    },\n\n    onDestroy(pluginCtx: PluginContext) {\n      // Clear all data\n      clear();\n\n      // Remove from chart API\n      delete (pluginCtx.chart as any).lazyLoad;\n\n      ctx = null;\n    },\n\n    api,\n  };\n}\n\nexport default PluginLazyLoad;\n\n// Type exports\nexport type {\n  PluginLazyLoadConfig,\n  LazyLoadAPI,\n  DataProvider,\n  DataChunk,\n  LoadProgressEvent,\n} from './types';\n"],"names":["manifest","DEFAULT_CONFIG","PluginLazyLoad","userConfig","config","ctx","series","getChunkIndex","pointIndex","getVisibleRange","bounds","loadChunk","seriesInfo","chunkIndex","startIndex","endIndex","chunk","updateSeriesData","loadedPoints","sum","c","totalChunks","event","error","_a","_b","sortedChunks","a","b","totalSize","x","y","offset","loadVisible","visibleRange","buffer","rangeWidth","buffered","chunksToLoad","startIdx","endIdx","i","maxToLoad","nextChunk","unloadDistant","unloadedCount","toRemove","registerSeries","seriesId","provider","totalPoints","unregisterSeries","loadRange","startChunk","endChunk","getLoadingStatus","clear","api","newConfig","pluginCtx","_c","_d"],"mappings":"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"}
+{"version":3,"file":"lazy-load.js","sources":["../../src/plugins/lazy-load/index.ts"],"sourcesContent":["/**\n * @fileoverview Lazy loading plugin for large datasets\n * @module plugins/lazy-load\n */\n\nimport type {\n  PluginLazyLoadConfig,\n  LazyLoadAPI,\n  DataProvider,\n  LazyLoadedSeries,\n  LoadProgressEvent,\n} from './types';\nimport type {\n  ChartPlugin,\n  PluginContext,\n  PluginManifest,\n} from '../types';\n\nconst manifest: PluginManifest = {\n  name: 'velo-plot-lazy-load',\n  version: '1.0.0',\n  description: 'Lazy loading for large datasets with viewport-based chunking',\n  provides: ['lazy-load', 'data-streaming'],\n  tags: ['performance', 'data', 'optimization'],\n};\n\nconst DEFAULT_CONFIG: Required<PluginLazyLoadConfig> = {\n  enabled: true,\n  chunkSize: 10000,\n  viewportBuffer: 2,\n  autoLoad: true,\n  autoUnload: true,\n  unloadThreshold: 5,\n  preloadAdjacent: true,\n  maxLoadedChunks: 100,\n  onLoadStart: () => {},\n  onLoadProgress: () => {},\n  onLoadComplete: () => {},\n  onLoadError: () => {},\n  debug: false,\n};\n\nexport function PluginLazyLoad(\n  userConfig: Partial<PluginLazyLoadConfig> = {}\n): ChartPlugin<PluginLazyLoadConfig> {\n  const config = { ...DEFAULT_CONFIG, ...userConfig };\n  let ctx: PluginContext | null = null;\n\n  // Registered series\n  const series = new Map<string, LazyLoadedSeries>();\n\n  /**\n   * Calculate chunk index from point index\n   */\n  function getChunkIndex(pointIndex: number): number {\n    return Math.floor(pointIndex / config.chunkSize);\n  }\n\n  /**\n   * Get visible range from chart\n   */\n  function getVisibleRange(): { xMin: number; xMax: number } | null {\n    if (!ctx) return null;\n    \n    // Get current view bounds from data context\n    const bounds = ctx.data.getViewBounds();\n    if (bounds) {\n      return { xMin: bounds.xMin, xMax: bounds.xMax };\n    }\n    \n    return null;\n  }\n\n  /**\n   * Load a specific chunk\n   */\n  async function loadChunk(\n    seriesInfo: LazyLoadedSeries,\n    chunkIndex: number\n  ): Promise<void> {\n    // Already loaded or loading\n    if (seriesInfo.chunks.has(chunkIndex) || seriesInfo.loading.has(chunkIndex)) {\n      return;\n    }\n\n    seriesInfo.loading.add(chunkIndex);\n\n    try {\n      const startIndex = chunkIndex * config.chunkSize;\n      const endIndex = Math.min(\n        startIndex + config.chunkSize,\n        seriesInfo.totalPoints\n      );\n\n      if (config.debug) {\n        console.log(`[LazyLoad] Loading chunk ${chunkIndex} for ${seriesInfo.id} (${startIndex}-${endIndex})`);\n      }\n\n      const chunk = await seriesInfo.provider.loadChunk(startIndex, endIndex);\n      \n      seriesInfo.chunks.set(chunkIndex, chunk);\n      seriesInfo.loading.delete(chunkIndex);\n\n      // Update chart data\n      await updateSeriesData(seriesInfo);\n\n      // Fire progress event\n      const loadedPoints = Array.from(seriesInfo.chunks.values()).reduce(\n        (sum, c) => sum + (c.endIndex - c.startIndex),\n        0\n      );\n\n      const totalChunks = Math.ceil(seriesInfo.totalPoints / config.chunkSize);\n      \n      const event: LoadProgressEvent = {\n        seriesId: seriesInfo.id,\n        loadedPoints,\n        totalPoints: seriesInfo.totalPoints,\n        progress: loadedPoints / seriesInfo.totalPoints,\n        currentChunk: chunkIndex,\n        totalChunks,\n      };\n\n      if (loadedPoints === seriesInfo.totalPoints) {\n        config.onLoadComplete(event);\n      } else {\n        config.onLoadProgress(event);\n      }\n\n    } catch (error) {\n      seriesInfo.loading.delete(chunkIndex);\n      config.onLoadError(error as Error, seriesInfo.id);\n      \n      if (config.debug) {\n        console.error(`[LazyLoad] Error loading chunk ${chunkIndex}:`, error);\n      }\n    }\n  }\n\n  /**\n   * Update series data from loaded chunks\n   */\n  async function updateSeriesData(seriesInfo: LazyLoadedSeries): Promise<void> {\n    if (!ctx) return;\n\n    // Merge all loaded chunks\n    const sortedChunks = Array.from(seriesInfo.chunks.entries()).sort((a, b) => a[0] - b[0]);\n    \n    if (sortedChunks.length === 0) return;\n\n    // Calculate total size\n    let totalSize = 0;\n    for (const [, chunk] of sortedChunks) {\n      totalSize += chunk.x.length;\n    }\n\n    // Allocate arrays\n    const x = new Float32Array(totalSize);\n    const y = new Float32Array(totalSize);\n\n    // Copy data\n    let offset = 0;\n    for (const [, chunk] of sortedChunks) {\n      x.set(chunk.x, offset);\n      y.set(chunk.y, offset);\n      offset += chunk.x.length;\n    }\n\n    // Update series\n    (ctx.chart as any).updateSeries?.(seriesInfo.id, { x, y });\n  }\n\n  /**\n   * Load visible data\n   */\n  async function loadVisible(): Promise<void> {\n    if (!config.enabled || !ctx) return;\n\n    const visibleRange = getVisibleRange();\n    if (!visibleRange) return;\n\n    const buffer = config.viewportBuffer;\n    const rangeWidth = visibleRange.xMax - visibleRange.xMin;\n    const buffered = {\n      xMin: visibleRange.xMin - rangeWidth * buffer,\n      xMax: visibleRange.xMax + rangeWidth * buffer,\n    };\n\n    for (const [, seriesInfo] of series) {\n      const chunksToLoad: number[] = [];\n      const totalChunks = Math.ceil(seriesInfo.totalPoints / config.chunkSize);\n\n      // Identify chunks within the buffered viewport\n      const startIdx = Math.max(0, Math.floor(buffered.xMin / config.chunkSize));\n      const endIdx = Math.min(totalChunks - 1, Math.floor(buffered.xMax / config.chunkSize));\n\n      for (let i = startIdx; i <= endIdx; i++) {\n        if (!seriesInfo.chunks.has(i) && !seriesInfo.loading.has(i)) {\n          chunksToLoad.push(i);\n        }\n      }\n\n      // Load chunks sequentially (limit to avoid flood)\n      const maxToLoad = Math.min(chunksToLoad.length, 10);\n      for (let i = 0; i < maxToLoad; i++) {\n        await loadChunk(seriesInfo, chunksToLoad[i]);\n      }\n\n      // Preload next adjacent chunk if enabled\n      if (config.preloadAdjacent && endIdx + 1 < totalChunks) {\n        const nextChunk = endIdx + 1;\n        if (!seriesInfo.chunks.has(nextChunk) && !seriesInfo.loading.has(nextChunk)) {\n          loadChunk(seriesInfo, nextChunk); // Fire and forget\n        }\n      }\n    }\n  }\n\n  /**\n   * Chunk index range that should stay loaded for the current viewport.\n   */\n  function getKeepChunkRange(\n    seriesInfo: LazyLoadedSeries,\n    visibleRange: { xMin: number; xMax: number },\n  ): { startChunk: number; endChunk: number } {\n    const buffer = config.viewportBuffer;\n    const rangeWidth = visibleRange.xMax - visibleRange.xMin;\n    const buffered = {\n      xMin: visibleRange.xMin - rangeWidth * buffer,\n      xMax: visibleRange.xMax + rangeWidth * buffer,\n    };\n    const totalChunks = Math.ceil(seriesInfo.totalPoints / config.chunkSize);\n    const startChunk = Math.max(0, Math.floor(buffered.xMin / config.chunkSize));\n    const endChunk = Math.min(totalChunks - 1, Math.floor(buffered.xMax / config.chunkSize));\n    return { startChunk, endChunk };\n  }\n\n  /**\n   * Unload distant chunks\n   */\n  function unloadDistant(): number {\n    if (!config.autoUnload || !ctx) return 0;\n\n    const visibleRange = getVisibleRange();\n    if (!visibleRange) return 0;\n\n    let unloadedCount = 0;\n\n    for (const [, seriesInfo] of series) {\n      let seriesUnloaded = 0;\n      const { startChunk, endChunk } = getKeepChunkRange(seriesInfo, visibleRange);\n      const visibleSpan = Math.max(1, endChunk - startChunk + 1);\n      const thresholdChunks = Math.ceil(config.unloadThreshold * visibleSpan);\n      const keepStart = Math.max(0, startChunk - thresholdChunks);\n      const keepEnd = endChunk + thresholdChunks;\n\n      for (const chunkIndex of Array.from(seriesInfo.chunks.keys())) {\n        if (chunkIndex < keepStart || chunkIndex > keepEnd) {\n          seriesInfo.chunks.delete(chunkIndex);\n          seriesUnloaded++;\n        }\n      }\n\n      // Enforce max chunks limit (LRU eviction)\n      if (seriesInfo.chunks.size > config.maxLoadedChunks) {\n        const sortedChunks = Array.from(seriesInfo.chunks.entries()).sort(\n          (a, b) => a[1].loadedAt - b[1].loadedAt,\n        );\n\n        const toRemove = seriesInfo.chunks.size - config.maxLoadedChunks;\n        for (let i = 0; i < toRemove; i++) {\n          seriesInfo.chunks.delete(sortedChunks[i][0]);\n          seriesUnloaded++;\n        }\n      }\n\n      if (seriesUnloaded > 0) {\n        void updateSeriesData(seriesInfo);\n        unloadedCount += seriesUnloaded;\n      }\n    }\n\n    if (config.debug && unloadedCount > 0) {\n      console.log(`[LazyLoad] Unloaded ${unloadedCount} chunks`);\n    }\n\n    return unloadedCount;\n  }\n\n  /**\n   * Register a series\n   */\n  function registerSeries(seriesId: string, provider: DataProvider): void {\n    const totalPoints = provider.getTotalCount();\n    \n    series.set(seriesId, {\n      id: seriesId,\n      provider,\n      chunks: new Map(),\n      loading: new Set(),\n      totalPoints,\n    });\n\n    if (config.debug) {\n      console.log(`[LazyLoad] Registered series ${seriesId} with ${totalPoints} points`);\n    }\n\n    // Fire load start event\n    config.onLoadStart({\n      seriesId,\n      loadedPoints: 0,\n      totalPoints,\n      progress: 0,\n      currentChunk: 0,\n      totalChunks: Math.ceil(totalPoints / config.chunkSize),\n    });\n\n    // Auto-load if enabled\n    if (config.autoLoad) {\n      loadVisible();\n    }\n  }\n\n  /**\n   * Unregister a series\n   */\n  function unregisterSeries(seriesId: string): void {\n    series.delete(seriesId);\n    \n    if (config.debug) {\n      console.log(`[LazyLoad] Unregistered series ${seriesId}`);\n    }\n  }\n\n  /**\n   * Load specific range\n   */\n  async function loadRange(\n    seriesId: string,\n    startIndex: number,\n    endIndex: number\n  ): Promise<void> {\n    const seriesInfo = series.get(seriesId);\n    if (!seriesInfo) return;\n\n    const startChunk = getChunkIndex(startIndex);\n    const endChunk = getChunkIndex(endIndex);\n\n    for (let i = startChunk; i <= endChunk; i++) {\n      await loadChunk(seriesInfo, i);\n    }\n  }\n\n  /**\n   * Get loading status\n   */\n  function getLoadingStatus(seriesId: string) {\n    const seriesInfo = series.get(seriesId);\n    if (!seriesInfo) return null;\n\n    const loadedPoints = Array.from(seriesInfo.chunks.values()).reduce(\n      (sum, c) => sum + (c.endIndex - c.startIndex),\n      0\n    );\n\n    return {\n      loadedPoints,\n      totalPoints: seriesInfo.totalPoints,\n      loadedChunks: seriesInfo.chunks.size,\n      totalChunks: Math.ceil(seriesInfo.totalPoints / config.chunkSize),\n    };\n  }\n\n  /**\n   * Clear all data\n   */\n  function clear(): void {\n    for (const [, seriesInfo] of series) {\n      seriesInfo.chunks.clear();\n      seriesInfo.loading.clear();\n    }\n  }\n\n  /**\n   * Load a data window with optional buffer (viewport-aware windowing API).\n   */\n  async function setDataWindow(opts: {\n    from: number;\n    to: number;\n    buffer?: number;\n    seriesId?: string;\n  }): Promise<void> {\n    if (!ctx || !config.enabled) return;\n\n    const buffer = opts.buffer ?? config.viewportBuffer;\n    const span = opts.to - opts.from;\n    const startIndex = Math.max(0, Math.floor(opts.from - span * buffer));\n    const endIndex = Math.ceil(opts.to + span * buffer);\n\n    const targets = opts.seriesId\n      ? [[opts.seriesId, series.get(opts.seriesId)] as const]\n      : Array.from(series.entries()).map(([id, info]) => [id, info] as const);\n\n    for (const [seriesId, seriesInfo] of targets) {\n      if (!seriesInfo) continue;\n      await loadRange(seriesId, startIndex, endIndex);\n    }\n\n    if (config.autoUnload) {\n      unloadDistant();\n    }\n  }\n\n  // API implementation\n  const api: LazyLoadAPI & Record<string, unknown> = {\n    registerSeries,\n    unregisterSeries,\n    loadRange,\n    loadVisible,\n    unloadDistant,\n    setDataWindow,\n    getLoadingStatus,\n    clear,\n    updateConfig(newConfig: Partial<PluginLazyLoadConfig>) {\n      Object.assign(config, newConfig);\n    },\n  };\n\n  return {\n    manifest,\n\n    onInit(pluginCtx: PluginContext) {\n      ctx = pluginCtx;\n\n      // Attach to chart API\n      (ctx.chart as any).lazyLoad = api;\n      (ctx.chart as any).setDataWindow = (opts: {\n        from: number;\n        to: number;\n        buffer?: number;\n        seriesId?: string;\n      }) => setDataWindow(opts);\n\n      // Listen for zoom/pan if auto-load enabled\n      if (config.autoLoad) {\n        ctx.chart.on?.('zoom', () => {\n          loadVisible();\n          if (config.autoUnload) {\n            unloadDistant();\n          }\n        });\n\n        ctx.chart.on?.('pan', () => {\n          loadVisible();\n          if (config.autoUnload) {\n            unloadDistant();\n          }\n        });\n      }\n    },\n\n    onDestroy(pluginCtx: PluginContext) {\n      // Clear all data\n      clear();\n\n      // Remove from chart API\n      delete (pluginCtx.chart as any).lazyLoad;\n      delete (pluginCtx.chart as any).setDataWindow;\n\n      ctx = null;\n    },\n\n    api,\n  };\n}\n\nexport default PluginLazyLoad;\n\n// Type exports\nexport type {\n  PluginLazyLoadConfig,\n  LazyLoadAPI,\n  DataProvider,\n  DataChunk,\n  LoadProgressEvent,\n} from './types';\n"],"names":["manifest","DEFAULT_CONFIG","PluginLazyLoad","userConfig","config","ctx","series","getChunkIndex","pointIndex","getVisibleRange","bounds","loadChunk","seriesInfo","chunkIndex","startIndex","endIndex","chunk","updateSeriesData","loadedPoints","sum","c","totalChunks","event","error","_a","_b","sortedChunks","a","b","totalSize","x","y","offset","loadVisible","visibleRange","buffer","rangeWidth","buffered","chunksToLoad","startIdx","endIdx","i","maxToLoad","nextChunk","getKeepChunkRange","startChunk","endChunk","unloadDistant","unloadedCount","seriesUnloaded","visibleSpan","thresholdChunks","keepStart","keepEnd","toRemove","registerSeries","seriesId","provider","totalPoints","unregisterSeries","loadRange","getLoadingStatus","clear","setDataWindow","opts","span","targets","id","info","api","newConfig","pluginCtx","_c","_d"],"mappings":"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"}

package/dist/plugins/replay/index.d.ts

@@ -0,0 +1,19 @@
+import { ChartPlugin } from '../types';
+
+export interface PluginReplayConfig {
+    /** Series id to replay */
+    seriesId: string;
+    /** Milliseconds between frames at 1x speed */
+    frameMs?: number;
+}
+export interface ReplayAPI {
+    play(speed?: number): void;
+    pause(): void;
+    step(count?: number): void;
+    seek(index: number): void;
+    getIndex(): number;
+    getLength(): number;
+    isPlaying(): boolean;
+}
+export declare function PluginReplay(config: PluginReplayConfig): ChartPlugin<PluginReplayConfig>;
+export default PluginReplay;

package/dist/plugins/virtualization/types.d.ts

@@ -7,6 +7,12 @@ export type VirtualizationStrategy = "lttb" | "minmax";
 export interface PluginVirtualizationConfig {
     /** Enable virtualization (default: true) */
     enabled?: boolean;
+    /**
+     * Data fidelity mode (default: `'lod'`).
+     * - `'lod'`: downsample to canvas budget (recommended for large datasets).
+     * - `'full'`: skip downsampling and send all points to the GPU (opt-out for fidelity-critical views).
+     */
+    precision?: "lod" | "full";
     /** Virtualization mode (default: 'lod') */
     mode?: VirtualizationMode;
     /** Target points or 'auto' (default: 'auto') */
@@ -27,6 +33,12 @@ export interface PluginVirtualizationConfig {
     excludeSeries?: string[];
     /** Debug logging (default: false) */
     debug?: boolean;
+    /** Viewport buffer as fraction of visible x-range when slicing before downsample (default: 0.5) */
+    viewportBuffer?: number;
+    /** Downsample off main thread when Workers are available (default: true) */
+    useWorker?: boolean;
+    /** Point count threshold before using worker path (default: 250000) */
+    workerThreshold?: number;
 }
 export interface VirtualizationStats {
     seriesId: string;

package/dist/plugins/virtualization.js

@@ -1,4 +1,4 @@
-import { P as t, P as l } from "../index-ChgIdk3N.js";
+import { P as t, P as l } from "../index-D7dTq6VB.js";
 export {
   t as PluginVirtualization,
   l as default

package/dist/pool-15HMCNv8.js

@@ -0,0 +1,88 @@
+var c = Object.defineProperty;
+var l = (o, e, r) => e in o ? c(o, e, { enumerable: !0, configurable: !0, writable: !0, value: r }) : o[e] = r;
+var n = (o, e, r) => l(o, typeof e != "symbol" ? e + "" : e, r);
+class d {
+  constructor(e, r = {}) {
+    n(this, "workers", []);
+    n(this, "pending", /* @__PURE__ */ new Map());
+    n(this, "nextWorker", 0);
+    n(this, "poolSize");
+    n(this, "syncFallback");
+    n(this, "workerFactory");
+    n(this, "syncHandler");
+    n(this, "destroyed", !1);
+    if (this.workerFactory = e, this.poolSize = r.poolSize ?? 2, this.syncFallback = r.syncFallback ?? !0, this.syncHandler = r.syncHandler, typeof Worker < "u")
+      for (let s = 0; s < this.poolSize; s++)
+        this.spawnWorker();
+  }
+  removeWorker(e) {
+    const r = this.workers.indexOf(e);
+    r >= 0 && this.workers.splice(r, 1), e.terminate();
+  }
+  workerErrorMessage(e) {
+    const r = e;
+    return typeof r.message == "string" && r.message ? r.message : "Worker error";
+  }
+  rejectPendingWithSyncFallback(e, r) {
+    this.removeWorker(e);
+    const s = this.workerErrorMessage(r), t = [...this.pending.entries()];
+    this.pending.clear();
+    for (const [, i] of t) {
+      if (this.syncFallback && this.syncHandler) {
+        Promise.resolve(this.syncHandler(i.task)).then(i.resolve).catch(i.reject);
+        continue;
+      }
+      i.reject(new Error(s));
+    }
+  }
+  spawnWorker() {
+    const e = this.workerFactory();
+    e.onmessage = (r) => {
+      const s = r.data;
+      if (!(s != null && s.id)) return;
+      const t = this.pending.get(s.id);
+      if (t) {
+        if (this.pending.delete(s.id), s.type === "error" || s.error) {
+          if (this.syncFallback && this.syncHandler) {
+            Promise.resolve(this.syncHandler(t.task)).then(t.resolve).catch(t.reject);
+            return;
+          }
+          t.reject(new Error(s.error ?? "Worker task failed"));
+          return;
+        }
+        t.resolve(s);
+      }
+    }, e.onerror = (r) => {
+      this.rejectPendingWithSyncFallback(e, r);
+    }, this.workers.push(e);
+  }
+  /** Dispatch a task to the pool. Falls back to syncHandler when no workers exist. */
+  run(e) {
+    return this.destroyed ? Promise.reject(new Error("WorkerPool destroyed")) : this.workers.length === 0 ? this.syncFallback && this.syncHandler ? Promise.resolve(this.syncHandler(e)) : Promise.reject(new Error("No workers available and sync fallback disabled")) : new Promise((r, s) => {
+      this.pending.set(e.id, { resolve: r, reject: s, task: e });
+      const t = this.nextWorker;
+      this.nextWorker = (this.nextWorker + 1) % this.workers.length, this.workers[t].postMessage(e);
+    });
+  }
+  size() {
+    return this.workers.length;
+  }
+  pendingCount() {
+    return this.pending.size;
+  }
+  destroy() {
+    this.destroyed = !0;
+    for (const e of this.workers)
+      e.terminate();
+    this.workers = [], this.pending.clear();
+  }
+}
+let a = 0;
+function k(o = "task") {
+  return a += 1, `${o}-${a}-${Date.now()}`;
+}
+export {
+  d as W,
+  k as n
+};
+//# sourceMappingURL=pool-15HMCNv8.js.map

package/dist/pool-15HMCNv8.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pool-15HMCNv8.js","sources":["../src/workers/pool.ts"],"sourcesContent":["/**\n * Generic worker pool with round-robin dispatch and sync fallback.\n * @module workers/pool\n */\n\nexport interface WorkerPoolOptions {\n  /** Number of workers (default: 2) */\n  poolSize?: number;\n  /** Run tasks on main thread when Worker is unavailable */\n  syncFallback?: boolean;\n}\n\nexport class WorkerPool<TMessage extends { id: string }, TResult = unknown> {\n  private workers: Worker[] = [];\n  private pending = new Map<\n    string,\n    {\n      resolve: (value: TResult) => void;\n      reject: (error: Error) => void;\n      task: TMessage;\n    }\n  >();\n  private nextWorker = 0;\n  private readonly poolSize: number;\n  private readonly syncFallback: boolean;\n  private readonly workerFactory: () => Worker;\n  private readonly syncHandler?: (task: TMessage) => TResult | Promise<TResult>;\n  private destroyed = false;\n\n  constructor(\n    workerFactory: () => Worker,\n    options: WorkerPoolOptions & {\n      syncHandler?: (task: TMessage) => TResult | Promise<TResult>;\n    } = {},\n  ) {\n    this.workerFactory = workerFactory;\n    this.poolSize = options.poolSize ?? 2;\n    this.syncFallback = options.syncFallback ?? true;\n    this.syncHandler = options.syncHandler;\n\n    if (typeof Worker !== \"undefined\") {\n      for (let i = 0; i < this.poolSize; i++) {\n        this.spawnWorker();\n      }\n    }\n  }\n\n  private removeWorker(worker: Worker): void {\n    const index = this.workers.indexOf(worker);\n    if (index >= 0) this.workers.splice(index, 1);\n    worker.terminate();\n  }\n\n  private workerErrorMessage(event: Event): string {\n    const maybe = event as { message?: string };\n    if (typeof maybe.message === \"string\" && maybe.message) return maybe.message;\n    return \"Worker error\";\n  }\n\n  private rejectPendingWithSyncFallback(failedWorker: Worker, event: Event): void {\n    this.removeWorker(failedWorker);\n    const message = this.workerErrorMessage(event);\n    const entries = [...this.pending.entries()];\n    this.pending.clear();\n\n    for (const [, entry] of entries) {\n      if (this.syncFallback && this.syncHandler) {\n        Promise.resolve(this.syncHandler(entry.task)).then(entry.resolve).catch(entry.reject);\n        continue;\n      }\n      entry.reject(new Error(message));\n    }\n  }\n\n  private spawnWorker(): void {\n    const worker = this.workerFactory();\n    worker.onmessage = (event: MessageEvent) => {\n      const data = event.data as { id?: string; type?: string; error?: string };\n      if (!data?.id) return;\n\n      const task = this.pending.get(data.id);\n      if (!task) return;\n\n      this.pending.delete(data.id);\n\n      if (data.type === \"error\" || data.error) {\n        if (this.syncFallback && this.syncHandler) {\n          Promise.resolve(this.syncHandler(task.task)).then(task.resolve).catch(task.reject);\n          return;\n        }\n        task.reject(new Error(data.error ?? \"Worker task failed\"));\n        return;\n      }\n\n      task.resolve(data as TResult);\n    };\n\n    worker.onerror = (event) => {\n      this.rejectPendingWithSyncFallback(worker, event);\n    };\n\n    this.workers.push(worker);\n  }\n\n  /** Dispatch a task to the pool. Falls back to syncHandler when no workers exist. */\n  run(task: TMessage): Promise<TResult> {\n    if (this.destroyed) {\n      return Promise.reject(new Error(\"WorkerPool destroyed\"));\n    }\n\n    if (this.workers.length === 0) {\n      if (this.syncFallback && this.syncHandler) {\n        return Promise.resolve(this.syncHandler(task));\n      }\n      return Promise.reject(new Error(\"No workers available and sync fallback disabled\"));\n    }\n\n    return new Promise((resolve, reject) => {\n      this.pending.set(task.id, { resolve, reject, task });\n      const workerIndex = this.nextWorker;\n      this.nextWorker = (this.nextWorker + 1) % this.workers.length;\n      this.workers[workerIndex].postMessage(task);\n    });\n  }\n\n  size(): number {\n    return this.workers.length;\n  }\n\n  pendingCount(): number {\n    return this.pending.size;\n  }\n\n  destroy(): void {\n    this.destroyed = true;\n    for (const worker of this.workers) {\n      worker.terminate();\n    }\n    this.workers = [];\n    this.pending.clear();\n  }\n}\n\nlet taskCounter = 0;\n\n/** Generate a unique task id */\nexport function nextTaskId(prefix = \"task\"): string {\n  taskCounter += 1;\n  return `${prefix}-${taskCounter}-${Date.now()}`;\n}\n"],"names":["WorkerPool","workerFactory","options","__publicField","i","worker","index","event","maybe","failedWorker","message","entries","entry","data","task","resolve","reject","workerIndex","taskCounter","nextTaskId","prefix"],"mappings":"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"}

package/dist/react.js

@@ -1,5 +1,5 @@
-import { c as k } from "./createStackedChart-CjsKcOvX.js";
-import { S as x, u as C } from "./createStackedChart-CjsKcOvX.js";
+import { c as k } from "./createStackedChart-BPooTQ9z.js";
+import { S as x, u as C } from "./createStackedChart-BPooTQ9z.js";
 import { useRef as n, useState as a, useEffect as m, useCallback as f } from "react";
 function A(c) {
   const s = n(null), r = n(null), [i, l] = a(null), [d, u] = a(!1), o = n(c);

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;
 };