velo-plot 1.11.1

package/dist/gpu/backends/webgpu/shaders/heatmap.wgsl.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Heatmap Shader - WGSL for WebGPU
+ *
+ * Renders heatmap cells with colormap texture lookup.
+ * Each vertex has position (x, y) and value (z) for color mapping.
+ */
+export declare const HEATMAP_SHADER_WGSL = "\n// Uniform buffer for transforms and value range\nstruct Uniforms {\n  scale: vec2<f32>,\n  translate: vec2<f32>,\n  minValue: f32,\n  maxValue: f32,\n  _padding: vec2<f32>,\n};\n\n@group(0) @binding(0)\nvar<uniform> uniforms: Uniforms;\n\n@group(0) @binding(1)\nvar colormapSampler: sampler;\n\n@group(0) @binding(2)\nvar colormapTexture: texture_1d<f32>;\n\nstruct VSInput {\n  @location(0) position: vec2<f32>,\n  @location(1) value: f32,\n};\n\nstruct VSOutput {\n  @builtin(position) pos: vec4<f32>,\n  @location(0) value: f32,\n};\n\n@vertex\nfn vs_main(in: VSInput) -> VSOutput {\n  var out: VSOutput;\n  let transformed = in.position * uniforms.scale + uniforms.translate;\n  out.pos = vec4<f32>(transformed, 0.0, 1.0);\n  out.value = in.value;\n  return out;\n}\n\n@fragment\nfn fs_main(in: VSOutput) -> @location(0) vec4<f32> {\n  let range = uniforms.maxValue - uniforms.minValue;\n  var t: f32;\n  if (range != 0.0) {\n    t = (in.value - uniforms.minValue) / range;\n  } else {\n    t = 0.0;\n  }\n  t = clamp(t, 0.0, 1.0);\n  \n  return textureSample(colormapTexture, colormapSampler, t);\n}\n";
+export declare const HEATMAP_VERTEX_STRIDE: number;

package/dist/gpu/backends/webgpu/shaders/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Shader Index - Export all WGSL shaders
+ */
+export { TRIANGLE_SHADER_WGSL } from '../pipelines/triangleShader';
+export { LINE_SHADER_WGSL, LINE_VERTEX_STRIDE } from './line.wgsl';
+export { POINT_SHADER_WGSL, POINT_QUAD_SHADER_WGSL, POINT_VERTEX_STRIDE, } from './point.wgsl';
+export { HEATMAP_SHADER_WGSL, HEATMAP_VERTEX_STRIDE, } from './heatmap.wgsl';
+export { INSTANCED_LINE_SHADER_WGSL, INSTANCED_POINT_SHADER_WGSL, INSTANCED_LINE_VERTEX_STRIDE, INSTANCED_POINT_VERTEX_STRIDE, } from './instanced.wgsl';

package/dist/gpu/backends/webgpu/shaders/instanced.wgsl.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Instanced Line Shader - For ultra-large datasets
+ *
+ * Uses instancing to render line segments efficiently.
+ * Each instance renders a line segment between two consecutive points.
+ */
+export declare const INSTANCED_LINE_SHADER_WGSL = "\nstruct Uniforms {\n  scale: vec2<f32>,\n  translate: vec2<f32>,\n  color: vec4<f32>,\n  lineWidth: f32,\n  aspectRatio: f32,\n  pointCount: u32,\n  padding: u32,\n}\n\nstruct Point {\n  x: f32,\n  y: f32,\n}\n\n@group(0) @binding(0) var<uniform> uniforms: Uniforms;\n@group(0) @binding(1) var<storage, read> points: array<Point>;\n\nstruct VertexOut {\n  @builtin(position) position: vec4<f32>,\n  @location(0) @interpolate(flat) segment_index: u32,\n}\n\n@vertex\nfn vs_main(\n  @builtin(vertex_index) vertex_index: u32,\n  @builtin(instance_index) instance_index: u32\n) -> VertexOut {\n  var out: VertexOut;\n  out.segment_index = instance_index;\n  \n  // Skip if beyond point count\n  if (instance_index >= uniforms.pointCount - 1u) {\n    out.position = vec4<f32>(0.0, 0.0, 0.0, 1.0);\n    return out;\n  }\n  \n  // Get the two points for this segment\n  let p0 = points[instance_index];\n  let p1 = points[instance_index + 1u];\n  \n  // Transform points to clip space\n  let pos0 = vec2<f32>(p0.x * uniforms.scale.x + uniforms.translate.x,\n                       p0.y * uniforms.scale.y + uniforms.translate.y);\n  let pos1 = vec2<f32>(p1.x * uniforms.scale.x + uniforms.translate.x,\n                       p1.y * uniforms.scale.y + uniforms.translate.y);\n  \n  // Calculate line direction and perpendicular\n  let dir = normalize(pos1 - pos0);\n  let perp = vec2<f32>(-dir.y, dir.x);\n  \n  // Adjust for aspect ratio\n  let width = uniforms.lineWidth / 500.0; // Normalized width\n  let offset = perp * width;\n  \n  // Each segment is a quad (2 triangles, 6 vertices)\n  // vertex_index: 0,1,2 = first triangle, 3,4,5 = second triangle\n  var pos: vec2<f32>;\n  \n  switch (vertex_index % 6u) {\n    case 0u: { pos = pos0 - offset; } // bottom-left of start\n    case 1u: { pos = pos0 + offset; } // top-left of start\n    case 2u: { pos = pos1 - offset; } // bottom-left of end\n    case 3u: { pos = pos1 - offset; } // bottom-left of end\n    case 4u: { pos = pos0 + offset; } // top-left of start\n    case 5u: { pos = pos1 + offset; } // top-left of end\n    default: { pos = pos0; }\n  }\n  \n  out.position = vec4<f32>(pos, 0.0, 1.0);\n  return out;\n}\n\n@fragment\nfn fs_main(in: VertexOut) -> @location(0) vec4<f32> {\n  return uniforms.color;\n}\n";
+/**
+ * Instanced Point Shader - For ultra-large scatter datasets
+ *
+ * Uses instancing with a quad per point.
+ * Supports SDF-based symbols.
+ */
+export declare const INSTANCED_POINT_SHADER_WGSL = "\nstruct Uniforms {\n  scale: vec2<f32>,\n  translate: vec2<f32>,\n  color: vec4<f32>,\n  pointSize: f32,\n  symbolType: i32,\n  viewportWidth: f32,\n  viewportHeight: f32,\n  pointCount: u32,\n  padding: vec3<u32>,\n}\n\nstruct Point {\n  x: f32,\n  y: f32,\n}\n\n@group(0) @binding(0) var<uniform> uniforms: Uniforms;\n@group(0) @binding(1) var<storage, read> points: array<Point>;\n\nstruct VertexOut {\n  @builtin(position) position: vec4<f32>,\n  @location(0) uv: vec2<f32>,\n}\n\n@vertex\nfn vs_main(\n  @builtin(vertex_index) vertex_index: u32,\n  @builtin(instance_index) instance_index: u32\n) -> VertexOut {\n  var out: VertexOut;\n  \n  if (instance_index >= uniforms.pointCount) {\n    out.position = vec4<f32>(0.0, 0.0, 0.0, 1.0);\n    out.uv = vec2<f32>(0.0, 0.0);\n    return out;\n  }\n  \n  let pt = points[instance_index];\n  \n  // Transform point center to clip space\n  let center = vec2<f32>(\n    pt.x * uniforms.scale.x + uniforms.translate.x,\n    pt.y * uniforms.scale.y + uniforms.translate.y\n  );\n  \n  // Calculate point size in clip space\n  let sizeX = uniforms.pointSize / uniforms.viewportWidth * 2.0;\n  let sizeY = uniforms.pointSize / uniforms.viewportHeight * 2.0;\n  \n  // Quad vertices (6 for 2 triangles)\n  var offset: vec2<f32>;\n  var uv: vec2<f32>;\n  \n  switch (vertex_index % 6u) {\n    case 0u: { offset = vec2<f32>(-sizeX, -sizeY); uv = vec2<f32>(-1.0, -1.0); }\n    case 1u: { offset = vec2<f32>( sizeX, -sizeY); uv = vec2<f32>( 1.0, -1.0); }\n    case 2u: { offset = vec2<f32>(-sizeX,  sizeY); uv = vec2<f32>(-1.0,  1.0); }\n    case 3u: { offset = vec2<f32>(-sizeX,  sizeY); uv = vec2<f32>(-1.0,  1.0); }\n    case 4u: { offset = vec2<f32>( sizeX, -sizeY); uv = vec2<f32>( 1.0, -1.0); }\n    case 5u: { offset = vec2<f32>( sizeX,  sizeY); uv = vec2<f32>( 1.0,  1.0); }\n    default: { offset = vec2<f32>(0.0, 0.0); uv = vec2<f32>(0.0, 0.0); }\n  }\n  \n  out.position = vec4<f32>(center + offset, 0.0, 1.0);\n  out.uv = uv;\n  return out;\n}\n\n// SDF functions\nfn sdCircle(p: vec2<f32>) -> f32 {\n  return length(p) - 0.8;\n}\n\nfn sdSquare(p: vec2<f32>) -> f32 {\n  let d = abs(p) - vec2<f32>(0.7);\n  return length(max(d, vec2<f32>(0.0))) + min(max(d.x, d.y), 0.0);\n}\n\nfn sdDiamond(p: vec2<f32>) -> f32 {\n  return (abs(p.x) + abs(p.y)) - 0.8;\n}\n\n@fragment\nfn fs_main(in: VertexOut) -> @location(0) vec4<f32> {\n  var d: f32;\n  \n  switch (uniforms.symbolType) {\n    case 0: { d = sdCircle(in.uv); }  // circle\n    case 1: { d = sdSquare(in.uv); }  // square\n    case 2: { d = sdDiamond(in.uv); } // diamond\n    default: { d = sdCircle(in.uv); }\n  }\n  \n  if (d > 0.05) {\n    discard;\n  }\n  \n  let alpha = 1.0 - smoothstep(0.0, 0.05, d);\n  return vec4<f32>(uniforms.color.rgb, uniforms.color.a * alpha);\n}\n";
+export declare const INSTANCED_LINE_VERTEX_STRIDE = 8;
+export declare const INSTANCED_POINT_VERTEX_STRIDE = 8;

package/dist/gpu/backends/webgpu/shaders/line.wgsl.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Line Shader - WGSL for WebGPU
+ *
+ * Renders simple line strips with uniform color.
+ * Uses uniform buffer for transform (scale + translate).
+ */
+export declare const LINE_SHADER_WGSL = "\n// Uniform buffer for transforms and color\nstruct Uniforms {\n  scale: vec2<f32>,\n  translate: vec2<f32>,\n  color: vec4<f32>,\n};\n\n@group(0) @binding(0)\nvar<uniform> uniforms: Uniforms;\n\nstruct VSInput {\n  @location(0) position: vec2<f32>,\n};\n\nstruct VSOutput {\n  @builtin(position) pos: vec4<f32>,\n};\n\n@vertex\nfn vs_main(in: VSInput) -> VSOutput {\n  var out: VSOutput;\n  let transformed = in.position * uniforms.scale + uniforms.translate;\n  out.pos = vec4<f32>(transformed, 0.0, 1.0);\n  return out;\n}\n\n@fragment\nfn fs_main(in: VSOutput) -> @location(0) vec4<f32> {\n  return uniforms.color;\n}\n";
+export declare const LINE_VERTEX_STRIDE: number;

package/dist/gpu/backends/webgpu/shaders/point.wgsl.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Point Shader - WGSL for WebGPU
+ *
+ * Renders scatter points with SDF-based symbols.
+ * Supports: circle, square, diamond, triangle, triangleDown, cross, x, star
+ */
+export declare const POINT_SHADER_WGSL = "\n// Uniform buffer for transforms, color, point properties\nstruct Uniforms {\n  scale: vec2<f32>,\n  translate: vec2<f32>,\n  color: vec4<f32>,\n  pointSize: f32,\n  symbol: i32, // 0=circle, 1=square, 2=diamond, 3=triangle, 4=triangleDown, 5=cross, 6=x, 7=star\n  _padding: vec2<f32>,\n};\n\n@group(0) @binding(0)\nvar<uniform> uniforms: Uniforms;\n\nstruct VSInput {\n  @location(0) position: vec2<f32>,\n};\n\nstruct VSOutput {\n  @builtin(position) pos: vec4<f32>,\n  @location(0) @interpolate(flat) pointSize: f32,\n  @location(1) @interpolate(flat) symbol: i32,\n};\n\n@vertex\nfn vs_main(in: VSInput, @builtin(vertex_index) vertexIndex: u32) -> VSOutput {\n  var out: VSOutput;\n  let transformed = in.position * uniforms.scale + uniforms.translate;\n  out.pos = vec4<f32>(transformed, 0.0, 1.0);\n  out.pointSize = uniforms.pointSize;\n  out.symbol = uniforms.symbol;\n  return out;\n}\n\n// SDF functions for symbols\nfn sdCircle(p: vec2<f32>, r: f32) -> f32 {\n  return length(p) - r;\n}\n\nfn sdBox(p: vec2<f32>, b: vec2<f32>) -> f32 {\n  let d = abs(p) - b;\n  return length(max(d, vec2<f32>(0.0))) + min(max(d.x, d.y), 0.0);\n}\n\nfn sdDiamond(p: vec2<f32>, r: f32) -> f32 {\n  return (abs(p.x) + abs(p.y)) - r;\n}\n\nfn sdTriangle(p_in: vec2<f32>, r: f32) -> f32 {\n  let k = sqrt(3.0);\n  var p = p_in;\n  p.x = abs(p.x) - r;\n  p.y = p.y + r / k;\n  if (p.x + k * p.y > 0.0) {\n    p = vec2<f32>(p.x - k * p.y, -k * p.x - p.y) / 2.0;\n  }\n  p.x = p.x - clamp(p.x, -2.0 * r, 0.0);\n  return -length(p) * sign(p.y);\n}\n\nfn sdCross(p: vec2<f32>, r: f32, thickness: f32) -> f32 {\n  let d = abs(p);\n  let s1 = sdBox(d, vec2<f32>(r, thickness));\n  let s2 = sdBox(d, vec2<f32>(thickness, r));\n  return min(s1, s2);\n}\n\nfn sdX(p: vec2<f32>, r: f32, thickness: f32) -> f32 {\n  let c = cos(0.785398);\n  let s = sin(0.785398);\n  let m = mat2x2<f32>(c, -s, s, c);\n  return sdCross(m * p, r, thickness);\n}\n\nfn sdStar(p_in: vec2<f32>, r: f32, rf: f32) -> f32 {\n  let k1 = vec2<f32>(0.80901699, -0.58778525);\n  let k2 = vec2<f32>(-k1.x, k1.y);\n  var p = p_in;\n  p.x = abs(p.x);\n  p = p - 2.0 * max(dot(k1, p), 0.0) * k1;\n  p = p - 2.0 * max(dot(k2, p), 0.0) * k2;\n  p.x = abs(p.x);\n  p.y = p.y - r;\n  let ba = rf * vec2<f32>(-k1.y, k1.x) - vec2<f32>(0.0, 1.0);\n  let h = clamp(dot(p, ba) / dot(ba, ba), 0.0, r);\n  return length(p - ba * h) * sign(p.y * ba.x - p.x * ba.y);\n}\n\n@fragment\nfn fs_main(in: VSOutput) -> @location(0) vec4<f32> {\n  // Note: WebGPU doesn't have gl_PointCoord directly\n  // Points in WebGPU require rendering quads instead\n  // This shader needs instanced rendering with quads for proper point rendering\n  // For now, return the color directly\n  return uniforms.color;\n}\n";
+export declare const POINT_QUAD_SHADER_WGSL = "\n// Uniform buffer for transforms, color, point properties\nstruct Uniforms {\n  scale: vec2<f32>,\n  translate: vec2<f32>,\n  color: vec4<f32>,\n  pointSize: f32,\n  symbol: i32,\n  viewport: vec2<f32>, // viewport dimensions for proper sizing\n};\n\n@group(0) @binding(0)\nvar<uniform> uniforms: Uniforms;\n\nstruct VSInput {\n  @location(0) position: vec2<f32>,  // point center position\n  @location(1) quadOffset: vec2<f32>, // quad vertex offset (-1 to 1)\n};\n\nstruct VSOutput {\n  @builtin(position) pos: vec4<f32>,\n  @location(0) uv: vec2<f32>, // -0.5 to 0.5 for SDF\n};\n\n@vertex\nfn vs_main(in: VSInput) -> VSOutput {\n  var out: VSOutput;\n  \n  // Transform point position to NDC\n  let transformed = in.position * uniforms.scale + uniforms.translate;\n  \n  // Calculate point size in NDC\n  let pointSizeNDC = vec2<f32>(\n    uniforms.pointSize / uniforms.viewport.x * 2.0,\n    uniforms.pointSize / uniforms.viewport.y * 2.0\n  );\n  \n  // Apply quad offset\n  let offset = in.quadOffset * pointSizeNDC * 0.5;\n  \n  out.pos = vec4<f32>(transformed + offset, 0.0, 1.0);\n  out.uv = in.quadOffset * 0.5; // -0.5 to 0.5\n  \n  return out;\n}\n\n// SDF functions\nfn sdCircle(p: vec2<f32>, r: f32) -> f32 {\n  return length(p) - r;\n}\n\nfn sdBox(p: vec2<f32>, b: vec2<f32>) -> f32 {\n  let d = abs(p) - b;\n  return length(max(d, vec2<f32>(0.0))) + min(max(d.x, d.y), 0.0);\n}\n\nfn sdDiamond(p: vec2<f32>, r: f32) -> f32 {\n  return (abs(p.x) + abs(p.y)) - r;\n}\n\nfn sdTriangle(p_in: vec2<f32>, r: f32) -> f32 {\n  let k = sqrt(3.0);\n  var p = p_in;\n  p.x = abs(p.x) - r;\n  p.y = p.y + r / k;\n  if (p.x + k * p.y > 0.0) {\n    p = vec2<f32>(p.x - k * p.y, -k * p.x - p.y) / 2.0;\n  }\n  p.x = p.x - clamp(p.x, -2.0 * r, 0.0);\n  return -length(p) * sign(p.y);\n}\n\nfn sdCross(p: vec2<f32>, r: f32, thickness: f32) -> f32 {\n  let d = abs(p);\n  let s1 = sdBox(d, vec2<f32>(r, thickness));\n  let s2 = sdBox(d, vec2<f32>(thickness, r));\n  return min(s1, s2);\n}\n\nfn sdX(p: vec2<f32>, r: f32, thickness: f32) -> f32 {\n  let c = cos(0.785398);\n  let s = sin(0.785398);\n  let m = mat2x2<f32>(c, -s, s, c);\n  return sdCross(m * p, r, thickness);\n}\n\nfn sdStar(p_in: vec2<f32>, r: f32, rf: f32) -> f32 {\n  let k1 = vec2<f32>(0.80901699, -0.58778525);\n  let k2 = vec2<f32>(-k1.x, k1.y);\n  var p = p_in;\n  p.x = abs(p.x);\n  p = p - 2.0 * max(dot(k1, p), 0.0) * k1;\n  p = p - 2.0 * max(dot(k2, p), 0.0) * k2;\n  p.x = abs(p.x);\n  p.y = p.y - r;\n  let ba = rf * vec2<f32>(-k1.y, k1.x) - vec2<f32>(0.0, 1.0);\n  let h = clamp(dot(p, ba) / dot(ba, ba), 0.0, r);\n  return length(p - ba * h) * sign(p.y * ba.x - p.x * ba.y);\n}\n\n@fragment\nfn fs_main(in: VSOutput) -> @location(0) vec4<f32> {\n  var d: f32 = 0.0;\n  \n  if (uniforms.symbol == 0) {\n    d = sdCircle(in.uv, 0.45);\n  } else if (uniforms.symbol == 1) {\n    d = sdBox(in.uv, vec2<f32>(0.35));\n  } else if (uniforms.symbol == 2) {\n    d = sdDiamond(in.uv, 0.45);\n  } else if (uniforms.symbol == 3) {\n    d = sdTriangle(vec2<f32>(in.uv.x, in.uv.y + 0.1), 0.4);\n  } else if (uniforms.symbol == 4) {\n    d = sdTriangle(vec2<f32>(in.uv.x, -in.uv.y + 0.1), 0.4);\n  } else if (uniforms.symbol == 5) {\n    d = sdCross(in.uv, 0.45, 0.15);\n  } else if (uniforms.symbol == 6) {\n    d = sdX(in.uv, 0.45, 0.15);\n  } else if (uniforms.symbol == 7) {\n    d = sdStar(in.uv, 0.45, 0.4);\n  }\n  \n  if (d > 0.02) {\n    discard;\n  }\n  \n  let alpha = 1.0 - smoothstep(0.0, 0.02, d);\n  return vec4<f32>(uniforms.color.rgb, uniforms.color.a * alpha);\n}\n";
+export declare const POINT_VERTEX_STRIDE: number;

package/dist/gpu/benchmark/benchmark.d.ts

@@ -0,0 +1,74 @@
+/**
+ * GPU Benchmark Utilities
+ *
+ * Provides tools for measuring rendering performance across backends.
+ */
+export interface BenchmarkResult {
+    backend: "webgpu" | "webgl" | "unknown";
+    pointCount: number;
+    fps: number;
+    avgFrameTime: number;
+    minFrameTime: number;
+    maxFrameTime: number;
+    totalFrames: number;
+    duration: number;
+}
+export interface BenchmarkOptions {
+    /** Number of points to render */
+    pointCount?: number;
+    /** Duration of benchmark in milliseconds */
+    durationMs?: number;
+    /** Warm-up frames before measuring */
+    warmupFrames?: number;
+    /** Callback for progress updates */
+    onProgress?: (progress: number) => void;
+}
+/**
+ * Benchmark runner for GPU backends
+ */
+export declare class GpuBenchmark {
+    private canvas;
+    private results;
+    constructor(canvas?: HTMLCanvasElement);
+    /**
+     * Generate random line data
+     */
+    private generateLineData;
+    /**
+     * Measure frame times
+     */
+    private measureFrameTimes;
+    /**
+     * Run benchmark with WebGPU backend
+     */
+    benchmarkWebGPU(options?: BenchmarkOptions): Promise<BenchmarkResult | null>;
+    /**
+     * Run benchmark with WebGL backend
+     */
+    benchmarkWebGL(options?: BenchmarkOptions): Promise<BenchmarkResult | null>;
+    /**
+     * Calculate benchmark result from frame times
+     */
+    private calculateResult;
+    /**
+     * Run comparative benchmark
+     */
+    runComparison(options?: BenchmarkOptions): Promise<{
+        webgpu: BenchmarkResult | null;
+        webgl: BenchmarkResult | null;
+        winner: "webgpu" | "webgl" | "tie" | "unknown";
+        speedup: number;
+    }>;
+    /**
+     * Get all results
+     */
+    getResults(): BenchmarkResult[];
+    /**
+     * Clear results
+     */
+    clearResults(): void;
+    /**
+     * Format result as string
+     */
+    static formatResult(result: BenchmarkResult): string;
+}

package/dist/gpu/benchmark/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Benchmark Index
+ */
+export { GpuBenchmark } from './benchmark';
+export type { BenchmarkResult, BenchmarkOptions } from './benchmark';

package/dist/gpu/compute/gpuCompute.d.ts

@@ -0,0 +1,72 @@
+/**
+ * GPU Compute Engine
+ *
+ * Provides GPU-accelerated data analysis using WebGPU compute shaders.
+ * Includes statistics calculation, bounds computation, downsampling, and peak detection.
+ */
+export interface DataStats {
+    min: number;
+    max: number;
+    mean: number;
+    std: number;
+    count: number;
+}
+export interface DataBounds {
+    xMin: number;
+    xMax: number;
+    yMin: number;
+    yMax: number;
+}
+export interface Peak {
+    index: number;
+    value: number;
+}
+export interface GpuComputeOptions {
+    /** WebGPU device (if already available) */
+    device?: any;
+}
+/**
+ * GPU Compute Engine for data analysis
+ */
+export declare class GpuCompute {
+    private options;
+    private device;
+    private statsPipeline;
+    private minmaxPipeline;
+    private downsamplePipeline;
+    private peaksPipeline;
+    private isInitialized;
+    constructor(options?: GpuComputeOptions);
+    /**
+     * Check if GPU compute is available
+     */
+    static isSupported(): boolean;
+    /**
+     * Initialize the compute engine
+     */
+    init(): Promise<void>;
+    private createPipelines;
+    /**
+     * Calculate statistics for a 1D array of values
+     */
+    calculateStats(data: Float32Array): Promise<DataStats>;
+    /**
+     * Calculate bounds for 2D point data
+     */
+    calculateBounds(points: Float32Array): Promise<DataBounds>;
+    /**
+     * Downsample point data using min-max algorithm
+     */
+    downsample(points: Float32Array, targetCount: number): Promise<Float32Array>;
+    /**
+     * Detect peaks in 1D data
+     */
+    detectPeaks(data: Float32Array, options?: {
+        threshold?: number;
+        minDistance?: number;
+    }): Promise<Peak[]>;
+    /**
+     * Cleanup resources
+     */
+    destroy(): void;
+}

package/dist/gpu/compute/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * GPU Compute Index
+ */
+export { GpuCompute } from './gpuCompute';
+export type { DataStats, DataBounds, Peak, GpuComputeOptions, } from './gpuCompute';
+export { STATS_COMPUTE_WGSL, MINMAX_COMPUTE_WGSL, DOWNSAMPLE_COMPUTE_WGSL, PEAK_DETECT_COMPUTE_WGSL, } from './shaders';

package/dist/gpu/compute/shaders.d.ts

@@ -0,0 +1,9 @@
+/**
+ * GPU Compute - Compute shader infrastructure for WebGPU
+ *
+ * Provides GPU-accelerated data analysis capabilities.
+ */
+export declare const STATS_COMPUTE_WGSL = "\nstruct StatsResult {\n  min_val: f32,\n  max_val: f32,\n  sum: f32,\n  sum_sq: f32,\n  count: u32,\n  padding: vec3<u32>,\n}\n\n@group(0) @binding(0) var<storage, read> input_data: array<f32>;\n@group(0) @binding(1) var<storage, read_write> result: StatsResult;\n\nvar<workgroup> local_min: array<f32, 256>;\nvar<workgroup> local_max: array<f32, 256>;\nvar<workgroup> local_sum: array<f32, 256>;\nvar<workgroup> local_sum_sq: array<f32, 256>;\nvar<workgroup> local_count: array<u32, 256>;\n\n@compute @workgroup_size(256)\nfn main(\n  @builtin(global_invocation_id) global_id: vec3<u32>,\n  @builtin(local_invocation_id) local_id: vec3<u32>,\n  @builtin(workgroup_id) workgroup_id: vec3<u32>\n) {\n  let idx = global_id.x;\n  let lid = local_id.x;\n  let data_len = arrayLength(&input_data);\n  \n  // Initialize local values\n  if (idx < data_len) {\n    let val = input_data[idx];\n    local_min[lid] = val;\n    local_max[lid] = val;\n    local_sum[lid] = val;\n    local_sum_sq[lid] = val * val;\n    local_count[lid] = 1u;\n  } else {\n    local_min[lid] = 3.402823e+38; // f32 max\n    local_max[lid] = -3.402823e+38; // f32 min\n    local_sum[lid] = 0.0;\n    local_sum_sq[lid] = 0.0;\n    local_count[lid] = 0u;\n  }\n  \n  workgroupBarrier();\n  \n  // Parallel reduction\n  for (var stride: u32 = 128u; stride > 0u; stride = stride >> 1u) {\n    if (lid < stride) {\n      local_min[lid] = min(local_min[lid], local_min[lid + stride]);\n      local_max[lid] = max(local_max[lid], local_max[lid + stride]);\n      local_sum[lid] = local_sum[lid] + local_sum[lid + stride];\n      local_sum_sq[lid] = local_sum_sq[lid] + local_sum_sq[lid + stride];\n      local_count[lid] = local_count[lid] + local_count[lid + stride];\n    }\n    workgroupBarrier();\n  }\n  \n  // First thread writes result (atomic for multi-workgroup)\n  if (lid == 0u) {\n    // Use atomics for multi-workgroup reduction\n    // For now, we assume single workgroup or post-process on CPU\n    result.min_val = local_min[0];\n    result.max_val = local_max[0];\n    result.sum = local_sum[0];\n    result.sum_sq = local_sum_sq[0];\n    result.count = local_count[0];\n  }\n}\n";
+export declare const MINMAX_COMPUTE_WGSL = "\nstruct MinMax {\n  min_x: f32,\n  max_x: f32,\n  min_y: f32,\n  max_y: f32,\n}\n\n@group(0) @binding(0) var<storage, read> points: array<vec2<f32>>;\n@group(0) @binding(1) var<storage, read_write> result: MinMax;\n\nvar<workgroup> local_min_x: array<f32, 256>;\nvar<workgroup> local_max_x: array<f32, 256>;\nvar<workgroup> local_min_y: array<f32, 256>;\nvar<workgroup> local_max_y: array<f32, 256>;\n\n@compute @workgroup_size(256)\nfn main(\n  @builtin(global_invocation_id) global_id: vec3<u32>,\n  @builtin(local_invocation_id) local_id: vec3<u32>\n) {\n  let idx = global_id.x;\n  let lid = local_id.x;\n  let data_len = arrayLength(&points);\n  \n  if (idx < data_len) {\n    let pt = points[idx];\n    local_min_x[lid] = pt.x;\n    local_max_x[lid] = pt.x;\n    local_min_y[lid] = pt.y;\n    local_max_y[lid] = pt.y;\n  } else {\n    local_min_x[lid] = 3.402823e+38;\n    local_max_x[lid] = -3.402823e+38;\n    local_min_y[lid] = 3.402823e+38;\n    local_max_y[lid] = -3.402823e+38;\n  }\n  \n  workgroupBarrier();\n  \n  for (var stride: u32 = 128u; stride > 0u; stride = stride >> 1u) {\n    if (lid < stride) {\n      local_min_x[lid] = min(local_min_x[lid], local_min_x[lid + stride]);\n      local_max_x[lid] = max(local_max_x[lid], local_max_x[lid + stride]);\n      local_min_y[lid] = min(local_min_y[lid], local_min_y[lid + stride]);\n      local_max_y[lid] = max(local_max_y[lid], local_max_y[lid + stride]);\n    }\n    workgroupBarrier();\n  }\n  \n  if (lid == 0u) {\n    result.min_x = local_min_x[0];\n    result.max_x = local_max_x[0];\n    result.min_y = local_min_y[0];\n    result.max_y = local_max_y[0];\n  }\n}\n";
+export declare const DOWNSAMPLE_COMPUTE_WGSL = "\nstruct Params {\n  input_count: u32,\n  output_count: u32,\n  bucket_size: u32,\n  padding: u32,\n}\n\n@group(0) @binding(0) var<uniform> params: Params;\n@group(0) @binding(1) var<storage, read> input_points: array<vec2<f32>>;\n@group(0) @binding(2) var<storage, read_write> output_points: array<vec2<f32>>;\n\n@compute @workgroup_size(64)\nfn main(@builtin(global_invocation_id) global_id: vec3<u32>) {\n  let bucket_idx = global_id.x;\n  \n  if (bucket_idx >= params.output_count / 2u) {\n    return;\n  }\n  \n  let start = bucket_idx * params.bucket_size;\n  let end = min(start + params.bucket_size, params.input_count);\n  \n  if (start >= params.input_count) {\n    return;\n  }\n  \n  var min_y = input_points[start].y;\n  var max_y = input_points[start].y;\n  var min_idx = start;\n  var max_idx = start;\n  \n  for (var i = start; i < end; i = i + 1u) {\n    let y = input_points[i].y;\n    if (y < min_y) {\n      min_y = y;\n      min_idx = i;\n    }\n    if (y > max_y) {\n      max_y = y;\n      max_idx = i;\n    }\n  }\n  \n  // Output min and max points (preserving x,y pairs)\n  let out_base = bucket_idx * 2u;\n  \n  // Ensure min comes before max in x order\n  if (min_idx <= max_idx) {\n    output_points[out_base] = input_points[min_idx];\n    output_points[out_base + 1u] = input_points[max_idx];\n  } else {\n    output_points[out_base] = input_points[max_idx];\n    output_points[out_base + 1u] = input_points[min_idx];\n  }\n}\n";
+export declare const PEAK_DETECT_COMPUTE_WGSL = "\nstruct Params {\n  data_count: u32,\n  threshold: f32,\n  min_distance: u32,\n  padding: u32,\n}\n\nstruct Peak {\n  index: u32,\n  value: f32,\n  is_peak: u32,\n  padding: u32,\n}\n\n@group(0) @binding(0) var<uniform> params: Params;\n@group(0) @binding(1) var<storage, read> data: array<f32>;\n@group(0) @binding(2) var<storage, read_write> peaks: array<Peak>;\n\n@compute @workgroup_size(64)\nfn main(@builtin(global_invocation_id) global_id: vec3<u32>) {\n  let idx = global_id.x;\n  \n  if (idx >= params.data_count) {\n    return;\n  }\n  \n  peaks[idx].index = idx;\n  peaks[idx].value = data[idx];\n  peaks[idx].is_peak = 0u;\n  \n  // Skip edges\n  if (idx < params.min_distance || idx >= params.data_count - params.min_distance) {\n    return;\n  }\n  \n  let val = data[idx];\n  \n  // Check if above threshold\n  if (val < params.threshold) {\n    return;\n  }\n  \n  // Check if local maximum\n  var is_max = true;\n  for (var i = 1u; i <= params.min_distance; i = i + 1u) {\n    if (data[idx - i] >= val || data[idx + i] >= val) {\n      is_max = false;\n      break;\n    }\n  }\n  \n  if (is_max) {\n    peaks[idx].is_peak = 1u;\n  }\n}\n";

package/dist/gpu/drawList.d.ts

@@ -0,0 +1,77 @@
+import { BufferId, TextureId, RGBA } from './types';
+
+/**
+ * Draw kinds matching the original NativeWebGLRenderer series types
+ */
+export type DrawKind = "triangles" | "line" | "points" | "scatter" | "line+scatter" | "step" | "step+scatter" | "band" | "bar" | "heatmap";
+/**
+ * Common style properties for all draw calls
+ */
+export interface CommonStyle {
+    color?: RGBA;
+    opacity?: number;
+}
+/**
+ * Style for line-type series
+ */
+export interface LineStyle extends CommonStyle {
+    lineWidth?: number;
+}
+/**
+ * Point symbol types matching the original implementation
+ */
+export type PointSymbol = "circle" | "square" | "diamond" | "triangle" | "triangleDown" | "cross" | "x" | "star";
+/**
+ * Style for point/scatter-type series
+ */
+export interface PointStyle extends CommonStyle {
+    pointSize?: number;
+    symbol?: PointSymbol;
+}
+/**
+ * Style for heatmap-type series
+ */
+export interface HeatmapStyle {
+    zBounds?: {
+        min: number;
+        max: number;
+    };
+    colormap?: string;
+}
+/**
+ * Combined style type
+ */
+export type DrawStyle = CommonStyle | LineStyle | PointStyle | HeatmapStyle;
+/**
+ * A single draw call in the draw list
+ */
+export interface DrawCall {
+    /** Unique identifier for this draw call */
+    id: string;
+    /** Type of primitive to draw */
+    kind: DrawKind;
+    /** Reference to the vertex buffer */
+    bufferId: BufferId;
+    /** Number of vertices/instances to draw */
+    count: number;
+    /** Whether this draw call should be rendered */
+    visible: boolean;
+    /** Styling properties */
+    style?: DrawStyle;
+    /** Reference to texture (for heatmaps) */
+    textureId?: TextureId;
+    /** Step buffer for step charts */
+    stepBufferId?: BufferId;
+    stepCount?: number;
+    /** Optional Y-bounds override for multi-axis support */
+    yBounds?: {
+        min: number;
+        max: number;
+    };
+}
+/**
+ * The draw list contains all draw calls for a frame
+ */
+export interface DrawList {
+    items: DrawCall[];
+}

package/dist/gpu/examples/gallery.d.ts

@@ -0,0 +1,20 @@
+export interface GpuDemo {
+    name: string;
+    description: string;
+    init: (canvas: HTMLCanvasElement) => Promise<{
+        render: () => void;
+        destroy: () => void;
+    }>;
+}
+/**
+ * 1M Line Demo
+ */
+export declare const LinePerformanceDemo: GpuDemo;
+/**
+ * Instanced Scatter Demo
+ */
+export declare const ScatterInstancedDemo: GpuDemo;
+/**
+ * Dynamic Heatmap Demo
+ */
+export declare const DynamicHeatmapDemo: GpuDemo;

package/dist/gpu/examples/index.d.ts

@@ -0,0 +1,3 @@
+export * from './gallery';
+export * from './webgpu-line-demo';
+export * from './webgpu-triangle';

package/dist/gpu/examples/webgpu-line-demo.d.ts

@@ -0,0 +1,8 @@
+/**
+ * WebGPU Line Demo - Demonstrates line rendering with the GPU abstraction layer
+ */
+export declare function runWebGPULineDemo(container: HTMLElement): Promise<() => void>;
+/**
+ * WebGPU Chart Demo - Demonstrates multiple series types
+ */
+export declare function runWebGPUChartDemo(container: HTMLElement): Promise<() => void>;

package/dist/gpu/examples/webgpu-triangle.d.ts

@@ -0,0 +1 @@
+export declare function runWebGPUTriangleDemo(container: HTMLElement): Promise<() => void>;

package/dist/gpu/frame.d.ts

@@ -0,0 +1,25 @@
+import { GpuViewport, RGBA } from './types';
+
+/**
+ * Frame uniforms passed to each render call
+ */
+export interface FrameUniforms {
+    /** Viewport dimensions */
+    viewport: GpuViewport;
+    /** Background/clear color */
+    clearColor: RGBA;
+    /** Optional bounds for coordinate transforms */
+    bounds?: {
+        xMin: number;
+        xMax: number;
+        yMin: number;
+        yMax: number;
+    };
+    /** Optional plot area for clipping */
+    plotArea?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+}

package/dist/gpu/index.d.ts

@@ -0,0 +1,24 @@
+/**
+ * GPU Abstraction Layer - Backend-agnostic GPU API
+ *
+ * This module provides a unified interface for GPU rendering
+ * that can work with WebGPU (primary) or WebGL (fallback).
+ */
+export type { GpuBackendType, RGBA, GpuViewport, GpuLimits, GpuBackendInfo, BufferId, TextureId, BufferUsage, BufferDescriptor, TextureFormat, Texture1DDescriptor, Dispose, GpuBackend, } from './types';
+export type { FrameUniforms } from './frame';
+export type { DrawKind, CommonStyle, LineStyle, PointStyle, PointSymbol, HeatmapStyle, DrawStyle, DrawCall, DrawList, } from './drawList';
+export type { BufferEntry, IBufferStore, TextureEntry, ITextureStore, PipelineKind, PipelineKey, IPipelineCache, } from './resources';
+export { BaseBufferStore, BaseTextureStore, PipelineCache } from './resources';
+export { SeriesAdapter, parseColorToRGBA, GpuRenderer, createGpuRenderer, } from './adapter';
+export type { SeriesData, SeriesStyle, Bounds, GpuSeriesRenderData, GpuRenderOptions, BackendPreference, GpuRendererOptions, } from './adapter';
+export { WebGPUBackend } from './backends/webgpu/WebGPUBackend';
+export type { WebGPUBackendOptions } from './backends/webgpu/WebGPUBackend';
+export { WebGLBackend } from './backends/webgl/WebGLBackend';
+export type { WebGLBackendOptions } from './backends/webgl/WebGLBackend';
+export { runWebGPUTriangleDemo, runWebGPULineDemo, runWebGPUChartDemo, } from './examples';
+export { GpuBenchmark } from './benchmark';
+export type { BenchmarkResult, BenchmarkOptions } from './benchmark';
+export { GpuCompute } from './compute';
+export type { DataStats, DataBounds, Peak, GpuComputeOptions, } from './compute';
+export { MassiveDataRenderer } from './backends/webgpu/MassiveDataRenderer';
+export type { MassiveDataConfig, RenderStats, LODLevel, } from './backends/webgpu/MassiveDataRenderer';

package/dist/gpu/resources/bufferStore.d.ts

@@ -0,0 +1,40 @@
+import { BufferId, BufferUsage } from '../types';
+
+export interface BufferEntry {
+    id: BufferId;
+    usage: BufferUsage;
+    byteLength: number;
+    lastUpdated: number;
+}
+export interface IBufferStore {
+    /** Create or update a buffer with new data */
+    createOrUpdate(id: BufferId, data: ArrayBufferView, usage?: BufferUsage): void;
+    /** Partially update a buffer at an offset */
+    partialUpdate(id: BufferId, data: ArrayBufferView, offsetBytes: number): boolean;
+    /** Get buffer metadata */
+    getInfo(id: BufferId): BufferEntry | undefined;
+    /** Check if buffer exists */
+    has(id: BufferId): boolean;
+    /** Delete a buffer */
+    delete(id: BufferId): void;
+    /** Get all buffer IDs */
+    keys(): IterableIterator<BufferId>;
+    /** Get buffer count */
+    readonly size: number;
+    /** Cleanup all buffers */
+    destroy(): void;
+}
+/**
+ * Abstract base class for buffer stores
+ */
+export declare abstract class BaseBufferStore implements IBufferStore {
+    protected entries: Map<string, BufferEntry>;
+    abstract createOrUpdate(id: BufferId, data: ArrayBufferView, usage?: BufferUsage): void;
+    abstract partialUpdate(id: BufferId, data: ArrayBufferView, offsetBytes: number): boolean;
+    abstract delete(id: BufferId): void;
+    abstract destroy(): void;
+    getInfo(id: BufferId): BufferEntry | undefined;
+    has(id: BufferId): boolean;
+    keys(): IterableIterator<BufferId>;
+    get size(): number;
+}

package/dist/gpu/resources/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Resources Index - Export all resource management utilities
+ */
+export type { BufferEntry, IBufferStore } from './bufferStore';
+export { BaseBufferStore } from './bufferStore';
+export type { TextureEntry, ITextureStore } from './textureStore';
+export { BaseTextureStore } from './textureStore';
+export type { PipelineKind, PipelineKey, IPipelineCache } from './pipelineCache';
+export { PipelineCache } from './pipelineCache';

package/dist/gpu/resources/pipelineCache.d.ts

@@ -0,0 +1,33 @@
+/**
+ * PipelineCache - Manages GPU pipeline lifecycle
+ *
+ * Caches compiled pipelines to avoid recompilation overhead.
+ */
+export type PipelineKind = "triangle" | "line" | "point" | "band" | "heatmap";
+export interface PipelineKey {
+    kind: PipelineKind;
+    variant?: string;
+}
+export interface IPipelineCache {
+    /** Get or create a pipeline */
+    getOrCreate<T>(key: PipelineKey, factory: () => T): T;
+    /** Check if pipeline exists */
+    has(key: PipelineKey): boolean;
+    /** Delete a pipeline */
+    delete(key: PipelineKey): void;
+    /** Get pipeline count */
+    readonly size: number;
+    /** Cleanup all pipelines */
+    destroy(): void;
+}
+/**
+ * Generic pipeline cache implementation
+ */
+export declare class PipelineCache implements IPipelineCache {
+    private pipelines;
+    getOrCreate<T>(key: PipelineKey, factory: () => T): T;
+    has(key: PipelineKey): boolean;
+    delete(key: PipelineKey): void;
+    get size(): number;
+    destroy(): void;
+}

package/dist/gpu/resources/textureStore.d.ts

@@ -0,0 +1,41 @@
+import { TextureId, TextureFormat } from '../types';
+
+export interface TextureEntry {
+    id: TextureId;
+    format: TextureFormat;
+    width: number;
+    height: number;
+    lastUpdated: number;
+}
+export interface ITextureStore {
+    /** Create or update a 1D texture (for colormaps) */
+    createOrUpdate1D(id: TextureId, data: Uint8Array, width?: number): void;
+    /** Create or update a 2D texture */
+    createOrUpdate2D(id: TextureId, data: Uint8Array, width: number, height: number): void;
+    /** Get texture metadata */
+    getInfo(id: TextureId): TextureEntry | undefined;
+    /** Check if texture exists */
+    has(id: TextureId): boolean;
+    /** Delete a texture */
+    delete(id: TextureId): void;
+    /** Get all texture IDs */
+    keys(): IterableIterator<TextureId>;
+    /** Get texture count */
+    readonly size: number;
+    /** Cleanup all textures */
+    destroy(): void;
+}
+/**
+ * Abstract base class for texture stores
+ */
+export declare abstract class BaseTextureStore implements ITextureStore {
+    protected entries: Map<string, TextureEntry>;
+    abstract createOrUpdate1D(id: TextureId, data: Uint8Array, width?: number): void;
+    abstract createOrUpdate2D(id: TextureId, data: Uint8Array, width: number, height: number): void;
+    abstract delete(id: TextureId): void;
+    abstract destroy(): void;
+    getInfo(id: TextureId): TextureEntry | undefined;
+    has(id: TextureId): boolean;
+    keys(): IterableIterator<TextureId>;
+    get size(): number;
+}

package/dist/gpu/types.d.ts

@@ -0,0 +1,47 @@
+import { DrawList } from './drawList';
+import { FrameUniforms } from './frame';
+
+export type GpuBackendType = "webgpu" | "webgl";
+export type RGBA = readonly [number, number, number, number];
+export interface GpuViewport {
+    width: number;
+    height: number;
+    dpr: number;
+}
+export interface GpuLimits {
+    maxTextureDimension2D?: number;
+    maxBufferSize?: number;
+    [key: string]: unknown;
+}
+export interface GpuBackendInfo {
+    type: GpuBackendType;
+    available: boolean;
+    limits?: GpuLimits;
+}
+export type BufferId = string;
+export type TextureId = string;
+export type BufferUsage = "vertex" | "index" | "uniform";
+export interface BufferDescriptor {
+    id: BufferId;
+    usage: BufferUsage;
+    byteStride?: number;
+}
+export type TextureFormat = "rgba8unorm" | "bgra8unorm";
+export interface Texture1DDescriptor {
+    id: TextureId;
+    format: TextureFormat;
+    width: number;
+}
+export interface Dispose {
+    destroy(): void;
+}
+export interface GpuBackend extends Dispose {
+    readonly info: GpuBackendInfo;
+    init(): Promise<void>;
+    setViewport(viewport: GpuViewport): void;
+    createOrUpdateBuffer(id: BufferId, data: ArrayBufferView, desc?: Partial<BufferDescriptor>): void;
+    deleteBuffer(id: BufferId): void;
+    createOrUpdateTexture1D(id: TextureId, data: Uint8Array, desc?: Partial<Texture1DDescriptor>): void;
+    deleteTexture(id: TextureId): void;
+    render(drawList: DrawList, frame: FrameUniforms): void;
+}