scichart-engine 0.4.1

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

package/dist/index.d.ts

@@ -0,0 +1,34 @@
+/**
+ * SciChart Engine - High-Performance Scientific Charting
+ *
+ * A WebGL-based charting engine designed for scientific data visualization
+ * and high-performance rendering of large datasets.
+ *
+ * Features:
+ * - 10⁵–10⁶ points at 60 FPS
+ * - Zoom/pan via GPU uniforms (no buffer recreation)
+ * - Scientific precision with Float32/Float64 arrays
+ * - Data analysis utilities (peak detection, cycle detection, etc.)
+ *
+ * @packageDocumentation
+ */
+export { createChart } from './core/Chart';
+export { Series } from './core/Series';
+export { EventEmitter } from './core/EventEmitter';
+export type { Chart, ChartOptions, ExportOptions } from './core/Chart';
+export { AnnotationManager } from './core/annotations';
+export type { Annotation, AnnotationType, HorizontalLineAnnotation, VerticalLineAnnotation, RectangleAnnotation, BandAnnotation, TextAnnotation, ArrowAnnotation, } from './core/annotations';
+export type { AxisOptions, SeriesOptions, SeriesData, SeriesStyle, SeriesUpdateData, ZoomOptions, CursorOptions, ChartEventMap, Point, Bounds, Range, ScaleType, SeriesType, StepMode, ErrorBarStyle, ErrorBarDirection, ScatterSymbol, } from './types';
+export { LinearScale, LogScale, createScale, type Scale } from './scales';
+export { NativeWebGLRenderer, interleaveData, parseColor, createRenderer, createNativeRenderer, WebGPURenderer, type WebGPURendererOptions, type IWebGLRenderer, type SeriesRenderData, type RenderOptions, } from './renderer';
+export { DARK_THEME, LIGHT_THEME, MIDNIGHT_THEME, ELECTROCHEM_THEME, DEFAULT_THEME, createTheme, getThemeByName, type ChartTheme, type GridTheme, type AxisTheme, type LegendTheme, type CursorTheme, } from './theme';
+export { OverlayRenderer, } from './core/OverlayRenderer';
+export type { PlotArea, CursorState, } from './types';
+export { TooltipManager, TOOLTIP_THEMES, getTooltipThemeForChartTheme, } from './core/tooltip';
+export type { TooltipData, TooltipType, TooltipTheme, TooltipOptions, TooltipTemplate, DataPointTooltip, CrosshairTooltip, HeatmapTooltip, } from './core/tooltip';
+export { lttbDownsample, minMaxDownsample, calculateTargetPoints, } from './workers/downsample';
+export { formatWithPrefix, formatValue, formatScientific, getBestPrefix, detectCycles, generateCycleColors, detectPeaks, validateData, calculateStats, movingAverage, downsampleLTTB, type CycleInfo, type Peak, type PrefixInfo, type ValidationResult, type DataStats, } from './analysis';
+export { createWebSocketStream, connectStreamToChart, createMessageParser, createMockStream, type WebSocketStream, type WebSocketStreamConfig, type DataPoint, type StreamStats, type WebSocketState, } from './streaming';
+export { SciChart, useSciChart, type SciChartProps, type SciChartRef, type SciChartSeries, type UseSciChartOptions, type UseSciChartReturn, } from './react';
+export { WebGPUBackend, WebGLBackend, GpuRenderer, createGpuRenderer, SeriesAdapter, parseColorToRGBA, PipelineCache, BaseBufferStore, BaseTextureStore, GpuBenchmark, GpuCompute, } from './gpu';
+export type { GpuBackendType, RGBA, GpuViewport, GpuBackend, BufferId, TextureId, FrameUniforms, DrawKind, DrawCall, DrawList, PointSymbol, SeriesData as GpuSeriesData, Bounds as GpuBounds, GpuRenderOptions, GpuRendererOptions, BackendPreference, WebGPUBackendOptions, BenchmarkResult, BenchmarkOptions, DataStats as GpuDataStats, DataBounds as GpuDataBounds, Peak as GpuPeak, GpuComputeOptions, } from './gpu';

package/dist/overlay/CanvasOverlay.d.ts

@@ -0,0 +1,102 @@
+import { Bounds } from '../types';
+import { Scale } from '../scales';
+
+export interface OverlayTheme {
+    /** Background color (usually transparent) */
+    background: string;
+    /** Axis line color */
+    axisColor: string;
+    /** Tick mark color */
+    tickColor: string;
+    /** Label text color */
+    labelColor: string;
+    /** Grid line color */
+    gridColor: string;
+    /** Cursor line color */
+    cursorColor: string;
+    /** Font family */
+    fontFamily: string;
+    /** Base font size */
+    fontSize: number;
+}
+export declare const DEFAULT_THEME: OverlayTheme;
+export interface AxisConfig {
+    /** Axis label (e.g., 'E / V') */
+    label?: string;
+    /** Tick values to draw */
+    ticks?: number[];
+    /** Format function for tick labels */
+    tickFormat?: (value: number) => string;
+    /** Show grid lines */
+    showGrid?: boolean;
+}
+export interface CursorState {
+    /** Cursor enabled */
+    enabled: boolean;
+    /** Cursor X position in pixels */
+    x: number;
+    /** Cursor Y position in pixels */
+    y: number;
+    /** Show crosshair */
+    crosshair: boolean;
+    /** Tooltip text */
+    tooltip?: string;
+}
+/**
+ * Canvas Overlay manages the 2D rendering layer
+ */
+export declare class CanvasOverlay {
+    private canvas;
+    private ctx;
+    private dpr;
+    private theme;
+    private readonly MARGIN;
+    constructor(parentElement: HTMLElement, theme?: Partial<OverlayTheme>);
+    /**
+     * Resize the overlay canvas
+     */
+    resize(): void;
+    /**
+     * Get the plot area (excluding margins)
+     */
+    getPlotArea(): {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    /**
+     * Clear the overlay
+     */
+    clear(): void;
+    /**
+     * Render axes
+     */
+    renderAxes(bounds: Bounds, xAxis?: AxisConfig, yAxis?: AxisConfig, xScale?: Scale, yScale?: Scale): void;
+    private renderGrid;
+    private renderXAxis;
+    private renderYAxis;
+    private renderXAxisLabel;
+    private renderYAxisLabel;
+    /**
+     * Render cursor/crosshair
+     */
+    renderCursor(cursor: CursorState): void;
+    /**
+     * Render tooltip
+     */
+    renderTooltip(x: number, y: number, text: string): void;
+    /**
+     * Render FPS counter (debug)
+     */
+    renderFPS(fps: number, frameTime: number): void;
+    private dataToPixelX;
+    private dataToPixelY;
+    private generateTicks;
+    private formatNumber;
+    private formatScientific;
+    /**
+     * Destroy the overlay
+     */
+    destroy(): void;
+}

package/dist/overlay/index.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Overlay module exports
+ */
+export { CanvasOverlay, DEFAULT_THEME, type OverlayTheme, type AxisConfig, type CursorState, } from './CanvasOverlay';