velo-plot 1.11.1

package/dist/gpu/adapter/gpuRenderer.d.ts

@@ -0,0 +1,135 @@
+import { SeriesStyle } from './seriesAdapter';
+
+/**
+ * Bounds interface matching the original
+ */
+export interface Bounds {
+    xMin: number;
+    xMax: number;
+    yMin: number;
+    yMax: number;
+}
+/**
+ * Series render data matching NativeSeriesRenderData
+ */
+export interface GpuSeriesRenderData {
+    id: string;
+    type: "line" | "scatter" | "line+scatter" | "step" | "step+scatter" | "band" | "bar" | "heatmap";
+    visible: boolean;
+    style: SeriesStyle;
+    /** Y-bounds for multi-axis support */
+    yBounds?: {
+        min: number;
+        max: number;
+    };
+    /** Heatmap specific */
+    zBounds?: {
+        min: number;
+        max: number;
+    };
+    colormap?: string;
+}
+/**
+ * Render options matching NativeRenderOptions
+ */
+export interface GpuRenderOptions {
+    bounds: Bounds;
+    backgroundColor?: [number, number, number, number];
+    plotArea?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+}
+/**
+ * Backend preference
+ */
+export type BackendPreference = "webgpu" | "webgl" | "auto";
+/**
+ * GPU Renderer options
+ */
+export interface GpuRendererOptions {
+    backend?: BackendPreference;
+    powerPreference?: "low-power" | "high-performance";
+}
+/**
+ * GPU Renderer - Unified renderer using the GPU abstraction layer
+ */
+export declare class GpuRenderer {
+    private canvas;
+    private options;
+    private backend;
+    private adapter;
+    private dpr;
+    private isInitialized;
+    private backendType;
+    private bufferDataMap;
+    private stepBufferDataMap;
+    private colormapDataMap;
+    constructor(canvas: HTMLCanvasElement, options?: GpuRendererOptions);
+    /**
+     * Initialize the renderer
+     */
+    init(): Promise<boolean>;
+    /**
+     * Check if renderer is available
+     */
+    get available(): boolean;
+    /**
+     * Get the active backend type
+     */
+    get activeBackend(): "webgpu" | "webgl" | null;
+    /**
+     * Set device pixel ratio
+     */
+    setDPR(dpr: number): void;
+    /**
+     * Create or update a buffer
+     */
+    createBuffer(id: string, data: Float32Array): void;
+    /**
+     * Update a buffer partially
+     */
+    updateBuffer(id: string, data: Float32Array, offsetInBytes: number): boolean;
+    /**
+     * Get a buffer's data
+     */
+    getBuffer(id: string): Float32Array | undefined;
+    /**
+     * Delete a buffer
+     */
+    deleteBuffer(id: string): void;
+    /**
+     * Create or update a step buffer
+     */
+    createStepBuffer(id: string, data: Float32Array): void;
+    /**
+     * Create colormap texture
+     */
+    createColormapTexture(id: string, data: Uint8Array): void;
+    /**
+     * Render a frame
+     */
+    render(series: GpuSeriesRenderData[], options: GpuRenderOptions): void;
+    /**
+     * Build draw list from series data
+     */
+    private buildDrawList;
+    /**
+     * Handle canvas resize
+     */
+    resize(): void;
+    /**
+     * Get renderer limits
+     */
+    getLimits(): Record<string, unknown>;
+    /**
+     * Destroy the renderer
+     */
+    destroy(): void;
+}
+/**
+ * Create a GPU renderer (async)
+ */
+export declare function createGpuRenderer(canvas: HTMLCanvasElement, options?: GpuRendererOptions): Promise<GpuRenderer | null>;

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

@@ -0,0 +1,7 @@
+/**
+ * Adapter Index - Export all adapter utilities
+ */
+export { SeriesAdapter, parseColorToRGBA, } from './seriesAdapter';
+export type { SeriesData, SeriesStyle, } from './seriesAdapter';
+export { GpuRenderer, createGpuRenderer, } from './gpuRenderer';
+export type { Bounds, GpuSeriesRenderData, GpuRenderOptions, BackendPreference, GpuRendererOptions, } from './gpuRenderer';

package/dist/gpu/adapter/seriesAdapter.d.ts

@@ -0,0 +1,88 @@
+import { DrawList } from '../drawList';
+import { GpuBackend, RGBA } from '../types';
+
+/**
+ * Series style from the original renderer
+ */
+export interface SeriesStyle {
+    color?: string | RGBA;
+    opacity?: number;
+    lineWidth?: number;
+    pointSize?: number;
+    symbol?: string;
+}
+/**
+ * Series render data from the chart system
+ */
+export interface SeriesData {
+    id: string;
+    type: "line" | "scatter" | "line+scatter" | "step" | "step+scatter" | "band" | "bar" | "heatmap";
+    visible: boolean;
+    /** Main vertex data */
+    data: Float32Array;
+    /** Style properties */
+    style: SeriesStyle;
+    /** For step charts */
+    stepData?: Float32Array;
+    /** Y-axis bounds for multi-axis support */
+    yBounds?: {
+        min: number;
+        max: number;
+    };
+    /** For heatmaps */
+    zBounds?: {
+        min: number;
+        max: number;
+    };
+    colormapData?: Uint8Array;
+    colormap?: string;
+}
+/**
+ * Mutable color tuple for internal use
+ */
+type MutableRGBA = [number, number, number, number];
+/**
+ * Parse color from various formats to RGBA
+ */
+export declare function parseColorToRGBA(color: string | RGBA | undefined): MutableRGBA;
+/**
+ * Series Adapter class
+ *
+ * Manages the conversion of chart series to GPU resources and draw calls.
+ */
+export declare class SeriesAdapter {
+    private backend;
+    private seriesBufferMap;
+    private seriesStepBufferMap;
+    private seriesTextureMap;
+    constructor(backend: GpuBackend);
+    /**
+     * Get buffer ID for a series
+     */
+    private getBufferId;
+    /**
+     * Get step buffer ID for a series
+     */
+    private getStepBufferId;
+    /**
+     * Get texture ID for a series
+     */
+    private getTextureId;
+    /**
+     * Update series data in GPU buffers
+     */
+    updateSeries(series: SeriesData): void;
+    /**
+     * Remove a series from GPU resources
+     */
+    removeSeries(seriesId: string): void;
+    /**
+     * Build draw list from series array
+     */
+    buildDrawList(seriesArray: SeriesData[]): DrawList;
+    /**
+     * Cleanup all resources
+     */
+    destroy(): void;
+}
+export {};

package/dist/gpu/backends/webgl/WebGLBackend.d.ts

@@ -0,0 +1,42 @@
+import { BufferDescriptor, BufferId, GpuBackend, GpuBackendInfo, GpuViewport, Texture1DDescriptor, TextureId } from '../../types';
+import { DrawList } from '../../drawList';
+import { FrameUniforms } from '../../frame';
+
+export interface WebGLBackendOptions {
+    antialias?: boolean;
+    preserveDrawingBuffer?: boolean;
+    powerPreference?: "default" | "low-power" | "high-performance";
+}
+export declare class WebGLBackend implements GpuBackend {
+    readonly info: GpuBackendInfo;
+    private canvas;
+    private opts;
+    private gl;
+    private viewport;
+    private dpr;
+    private programs;
+    private buffers;
+    private textures;
+    constructor(canvas: HTMLCanvasElement, opts?: WebGLBackendOptions);
+    static isSupported(): boolean;
+    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;
+    renderWithBounds(drawList: DrawList, frame: FrameUniforms, bounds: {
+        xMin: number;
+        xMax: number;
+        yMin: number;
+        yMax: number;
+    }): void;
+    private renderDrawCall;
+    private renderLine;
+    private renderPoints;
+    private renderBand;
+    private renderTriangles;
+    private renderHeatmap;
+    destroy(): void;
+}

package/dist/gpu/backends/webgl/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * WebGL Backend Index
+ */
+export { WebGLBackend } from './WebGLBackend';
+export type { WebGLBackendOptions } from './WebGLBackend';

package/dist/gpu/backends/webgl/programFactory.d.ts

@@ -0,0 +1,30 @@
+/**
+ * WebGL Program Factory
+ *
+ * Utilities for compiling and linking WebGL shader programs.
+ */
+export interface ShaderProgram {
+    program: WebGLProgram;
+    attributes: Record<string, number>;
+    uniforms: Record<string, WebGLUniformLocation | null>;
+}
+/**
+ * Create a shader program from source
+ */
+export declare function createProgram(gl: WebGLRenderingContext, vertSource: string, fragSource: string, attributeNames: string[], uniformNames: string[]): ShaderProgram;
+/**
+ * All programs used by the WebGL backend
+ */
+export interface ProgramBundle {
+    line: ShaderProgram;
+    point: ShaderProgram;
+    heatmap: ShaderProgram;
+}
+/**
+ * Create all shader programs
+ */
+export declare function createAllPrograms(gl: WebGLRenderingContext): ProgramBundle;
+/**
+ * Destroy all programs
+ */
+export declare function destroyPrograms(gl: WebGLRenderingContext, bundle: ProgramBundle): void;

package/dist/gpu/backends/webgl/shaders.d.ts

@@ -0,0 +1,14 @@
+/**
+ * WebGL Shader Sources
+ *
+ * GLSL shaders for the WebGL backend.
+ * These match the functionality of the WebGPU WGSL shaders.
+ */
+export declare const LINE_VERT_GLSL = "\nprecision highp float;\nattribute vec2 aPosition;\nuniform vec2 uScale;\nuniform vec2 uTranslate;\n\nvoid main() {\n  vec2 pos = aPosition * uScale + uTranslate;\n  gl_Position = vec4(pos, 0.0, 1.0);\n}\n";
+export declare const LINE_FRAG_GLSL = "\nprecision highp float;\nuniform vec4 uColor;\n\nvoid main() {\n  gl_FragColor = uColor;\n}\n";
+export declare const POINT_VERT_GLSL = "\nprecision highp float;\nattribute vec2 aPosition;\nuniform vec2 uScale;\nuniform vec2 uTranslate;\nuniform float uPointSize;\n\nvoid main() {\n  vec2 pos = aPosition * uScale + uTranslate;\n  gl_Position = vec4(pos, 0.0, 1.0);\n  gl_PointSize = uPointSize;\n}\n";
+export declare const POINT_FRAG_GLSL = "\nprecision highp float;\nuniform vec4 uColor;\nuniform int uSymbol;\n\nfloat sdCircle(vec2 p, float r) {\n  return length(p) - r;\n}\n\nfloat sdBox(vec2 p, vec2 b) {\n  vec2 d = abs(p) - b;\n  return length(max(d, 0.0)) + min(max(d.x, d.y), 0.0);\n}\n\nfloat sdTriangle(vec2 p, float r) {\n  const float k = sqrt(3.0);\n  p.x = abs(p.x) - r;\n  p.y = p.y + r / k;\n  if (p.x + k * p.y > 0.0) p = vec2(p.x - k * p.y, -k * p.x - p.y) / 2.0;\n  p.x -= clamp(p.x, -2.0 * r, 0.0);\n  return -length(p) * sign(p.y);\n}\n\nfloat sdDiamond(vec2 p, float r) {\n  return (abs(p.x) + abs(p.y)) - r;\n}\n\nfloat sdCross(vec2 p, float r, float thickness) {\n  vec2 d = abs(p);\n  float s1 = sdBox(d, vec2(r, thickness));\n  float s2 = sdBox(d, vec2(thickness, r));\n  return min(s1, s2);\n}\n\nfloat sdX(vec2 p, float r, float thickness) {\n  float c = cos(0.785398);\n  float s = sin(0.785398);\n  mat2 m = mat2(c, -s, s, c);\n  return sdCross(m * p, r, thickness);\n}\n\nfloat sdStar(vec2 p, float r, float rf) {\n  const vec2 k1 = vec2(0.80901699, -0.58778525);\n  const vec2 k2 = vec2(-k1.x, k1.y);\n  p.x = abs(p.x);\n  p -= 2.0 * max(dot(k1, p), 0.0) * k1;\n  p -= 2.0 * max(dot(k2, p), 0.0) * k2;\n  p.x = abs(p.x);\n  p.y -= r;\n  vec2 ba = rf * vec2(-k1.y, k1.x) - vec2(0, 1);\n  float 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\nvoid main() {\n  vec2 p = gl_PointCoord - vec2(0.5);\n  float d = 0.0;\n\n  if (uSymbol == 0) {\n    d = sdCircle(p, 0.45);\n  } else if (uSymbol == 1) {\n    d = sdBox(p, vec2(0.35));\n  } else if (uSymbol == 2) {\n    d = sdDiamond(p, 0.45);\n  } else if (uSymbol == 3) {\n    d = sdTriangle(vec2(p.x, p.y + 0.1), 0.4);\n  } else if (uSymbol == 4) {\n    d = sdTriangle(vec2(p.x, -p.y + 0.1), 0.4);\n  } else if (uSymbol == 5) {\n    d = sdCross(p, 0.45, 0.15);\n  } else if (uSymbol == 6) {\n    d = sdX(p, 0.45, 0.15);\n  } else if (uSymbol == 7) {\n    d = sdStar(p, 0.45, 0.4);\n  }\n\n  if (d > 0.02) discard;\n\n  float alpha = 1.0 - smoothstep(0.0, 0.02, d);\n  gl_FragColor = vec4(uColor.rgb, uColor.a * alpha);\n}\n";
+export declare const HEATMAP_VERT_GLSL = "\nprecision highp float;\nattribute vec2 aPosition;\nattribute float aValue;\nuniform vec2 uScale;\nuniform vec2 uTranslate;\nvarying float vValue;\n\nvoid main() {\n  gl_Position = vec4(aPosition * uScale + uTranslate, 0.0, 1.0);\n  vValue = aValue;\n}\n";
+export declare const HEATMAP_FRAG_GLSL = "\nprecision highp float;\nvarying float vValue;\nuniform float uMinValue;\nuniform float uMaxValue;\nuniform sampler2D uColormap;\n\nvoid main() {\n  float range = uMaxValue - uMinValue;\n  float t = (vValue - uMinValue) / (range != 0.0 ? range : 1.0);\n  t = clamp(t, 0.0, 1.0);\n  gl_FragColor = texture2D(uColormap, vec2(t, 0.5));\n}\n";
+export declare const TRIANGLE_VERT_GLSL = "\nprecision highp float;\nattribute vec2 aPosition;\nattribute vec4 aColor;\nuniform vec2 uScale;\nuniform vec2 uTranslate;\nvarying vec4 vColor;\n\nvoid main() {\n  vec2 pos = aPosition * uScale + uTranslate;\n  gl_Position = vec4(pos, 0.0, 1.0);\n  vColor = aColor;\n}\n";
+export declare const TRIANGLE_FRAG_GLSL = "\nprecision highp float;\nvarying vec4 vColor;\n\nvoid main() {\n  gl_FragColor = vColor;\n}\n";

package/dist/gpu/backends/webgpu/MassiveDataRenderer.d.ts

@@ -0,0 +1,111 @@
+/**
+ * MassiveDataRenderer - Optimized renderer for 100M+ points
+ *
+ * Features:
+ * - Chunked buffer upload with progress
+ * - Batched draw calls to avoid GPU timeout
+ * - LOD (Level of Detail) with GPU downsampling
+ * - Storage buffers for instanced rendering
+ * - Streaming data generation
+ */
+export interface MassiveDataConfig {
+    maxPointsPerBatch: number;
+    chunkSizeBytes: number;
+    enableLOD: boolean;
+    lodLevels: number;
+    onProgress?: (phase: string, progress: number) => void;
+    onStats?: (stats: RenderStats) => void;
+}
+export interface RenderStats {
+    totalPoints: number;
+    renderedPoints: number;
+    bufferSizeMB: number;
+    uploadTimeMs: number;
+    frameTimeMs: number;
+    fps: number;
+    lodLevel: number;
+    batchCount: number;
+}
+export interface LODLevel {
+    buffer: any;
+    pointCount: number;
+    factor: number;
+}
+export declare class MassiveDataRenderer {
+    private device;
+    private context;
+    private format;
+    private config;
+    private linePipeline;
+    private lineBindGroupLayout;
+    private uniformBuffer;
+    private storageBuffer;
+    private bindGroup;
+    private totalPoints;
+    private lodLevels;
+    private currentLOD;
+    private lastFrameTime;
+    private frameCount;
+    private lastFpsTime;
+    private currentFps;
+    private viewport;
+    constructor(device: any, // GPUDevice
+    context: any, // GPUCanvasContext
+    format: any, // GPUTextureFormat
+    config?: Partial<MassiveDataConfig>);
+    /**
+     * Initialize render pipelines
+     */
+    init(): Promise<void>;
+    /**
+     * Set viewport dimensions
+     */
+    setViewport(width: number, height: number): void;
+    /**
+     * Upload data with chunked progress
+     */
+    uploadData(data: Float32Array): Promise<void>;
+    /**
+     * Build LOD levels using GPU downsampling
+     */
+    private buildLOD;
+    /**
+     * Select appropriate LOD level based on visible range
+     */
+    selectLOD(visibleRange: number, totalRange: number): number;
+    /**
+     * Render frame with batching
+     */
+    render(options: {
+        bounds: {
+            xMin: number;
+            xMax: number;
+            yMin: number;
+            yMax: number;
+        };
+        color?: [number, number, number, number];
+        lineWidth?: number;
+        time?: number;
+        lodLevel?: number;
+    }): void;
+    /**
+     * Generate streaming sine wave data
+     */
+    static generateSineWaveData(pointCount: number, onProgress?: (progress: number) => void): Promise<Float32Array>;
+    /**
+     * Get current stats
+     */
+    getStats(): RenderStats;
+    /**
+     * Get available LOD levels
+     */
+    getLODLevels(): {
+        level: number;
+        pointCount: number;
+        factor: number;
+    }[];
+    /**
+     * Cleanup resources
+     */
+    destroy(): void;
+}

package/dist/gpu/backends/webgpu/WebGPUBackend.d.ts

@@ -0,0 +1,58 @@
+import { BufferDescriptor, BufferId, GpuBackend, GpuBackendInfo, GpuViewport, Texture1DDescriptor, TextureId } from '../../types';
+import { DrawList } from '../../drawList';
+import { FrameUniforms } from '../../frame';
+
+export interface WebGPUBackendOptions {
+    powerPreference?: "low-power" | "high-performance";
+    preferredFormat?: string;
+}
+export declare class WebGPUBackend implements GpuBackend {
+    readonly info: GpuBackendInfo;
+    private canvas;
+    private opts;
+    private viewport;
+    private adapter;
+    private device;
+    private context;
+    private format;
+    private buffers;
+    private textures;
+    private trianglePipeline;
+    private linePipeline;
+    private pointPipeline;
+    private bandPipeline;
+    private heatmapPipeline;
+    private heatmapBindGroups;
+    constructor(canvas: HTMLCanvasElement, opts?: WebGPUBackendOptions);
+    static isSupported(): boolean;
+    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;
+    /**
+     * Initialize all pipelines lazily
+     */
+    private ensurePipelines;
+    render(drawList: DrawList, frame: FrameUniforms): void;
+    /**
+     * Render with explicit bounds (for integration with chart system)
+     */
+    renderWithBounds(drawList: DrawList, frame: FrameUniforms, bounds: {
+        xMin: number;
+        xMax: number;
+        yMin: number;
+        yMax: number;
+    }): void;
+    /**
+     * Render a single draw call
+     */
+    private renderDrawCall;
+    private renderTriangles;
+    private renderLine;
+    private renderPoints;
+    private renderBand;
+    private renderHeatmap;
+    destroy(): void;
+}

package/dist/gpu/backends/webgpu/pipelines/bandPipeline.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Band Pipeline - WebGPU pipeline for rendering band/area fills
+ *
+ * Uses triangle-strip topology for efficient area rendering.
+ * Reuses the line shader with different primitive topology.
+ * Uses `any` types for WebGPU objects to avoid requiring @webgpu/types.
+ */
+export interface BandPipelineBundle {
+    pipeline: any;
+    bindGroupLayout: any;
+    uniformBuffer: any;
+    bindGroup: any;
+    vertexStride: number;
+}
+export interface BandUniforms {
+    scale: [number, number];
+    translate: [number, number];
+    color: [number, number, number, number];
+}
+export declare function createBandPipeline(device: any, // GPUDevice
+format: string): BandPipelineBundle;
+export declare function updateBandUniforms(device: any, // GPUDevice
+uniformBuffer: any, // GPUBuffer
+uniforms: BandUniforms): void;

package/dist/gpu/backends/webgpu/pipelines/heatmapPipeline.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Heatmap Pipeline - WebGPU pipeline for rendering heatmaps with colormap textures
+ *
+ * Uses `any` types for WebGPU objects to avoid requiring @webgpu/types.
+ */
+export interface HeatmapPipelineBundle {
+    pipeline: any;
+    bindGroupLayout: any;
+    uniformBuffer: any;
+    sampler: any;
+    vertexStride: number;
+}
+export interface HeatmapUniforms {
+    scale: [number, number];
+    translate: [number, number];
+    minValue: number;
+    maxValue: number;
+}
+export declare function createHeatmapPipeline(device: any, // GPUDevice
+format: string): HeatmapPipelineBundle;
+export declare function createHeatmapBindGroup(device: any, // GPUDevice
+layout: any, // GPUBindGroupLayout
+uniformBuffer: any, // GPUBuffer
+sampler: any, // GPUSampler
+colormapTexture: any): any;
+export declare function updateHeatmapUniforms(device: any, // GPUDevice
+uniformBuffer: any, // GPUBuffer
+uniforms: HeatmapUniforms): void;

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

@@ -0,0 +1,10 @@
+/**
+ * Pipeline Index - Export all WebGPU pipelines
+ */
+export { createTrianglePipeline, type TrianglePipelineBundle, } from './trianglePipeline';
+export { createLinePipeline, updateLineUniforms, type LinePipelineBundle, type LineUniforms, } from './linePipeline';
+export { createPointPipeline, updatePointUniforms, SYMBOL_MAP, type PointPipelineBundle, type PointUniforms, } from './pointPipeline';
+export { createHeatmapPipeline, createHeatmapBindGroup, updateHeatmapUniforms, type HeatmapPipelineBundle, type HeatmapUniforms, } from './heatmapPipeline';
+export { createBandPipeline, updateBandUniforms, type BandPipelineBundle, type BandUniforms, } from './bandPipeline';
+export { createInstancedLinePipeline, createInstancedLineBindGroup, updateInstancedLineUniforms, type InstancedLinePipelineBundle, type InstancedLineUniforms, } from './instancedLinePipeline';
+export { createInstancedPointPipeline, createInstancedPointBindGroup, updateInstancedPointUniforms, SYMBOL_TYPE_MAP, type InstancedPointPipelineBundle, type InstancedPointUniforms, } from './instancedPointPipeline';

package/dist/gpu/backends/webgpu/pipelines/instancedLinePipeline.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Instanced Line Pipeline - For rendering large datasets efficiently
+ *
+ * Uses storage buffers and instancing to render millions of line segments.
+ * Each instance represents one line segment between consecutive points.
+ */
+export interface InstancedLinePipelineBundle {
+    pipeline: any;
+    bindGroupLayout: any;
+    uniformBuffer: any;
+    vertexStride: number;
+}
+export interface InstancedLineUniforms {
+    scale: [number, number];
+    translate: [number, number];
+    color: [number, number, number, number];
+    lineWidth: number;
+    aspectRatio: number;
+    pointCount: number;
+}
+export declare function createInstancedLinePipeline(device: any, format: string): InstancedLinePipelineBundle;
+export declare function createInstancedLineBindGroup(device: any, layout: any, uniformBuffer: any, pointBuffer: any): any;
+export declare function updateInstancedLineUniforms(device: any, uniformBuffer: any, uniforms: InstancedLineUniforms): void;

package/dist/gpu/backends/webgpu/pipelines/instancedPointPipeline.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Instanced Point Pipeline - For rendering large scatter datasets
+ *
+ * Uses storage buffers and instancing to render millions of points.
+ */
+export interface InstancedPointPipelineBundle {
+    pipeline: any;
+    bindGroupLayout: any;
+    uniformBuffer: any;
+    vertexStride: number;
+}
+export interface InstancedPointUniforms {
+    scale: [number, number];
+    translate: [number, number];
+    color: [number, number, number, number];
+    pointSize: number;
+    symbolType: number;
+    viewportWidth: number;
+    viewportHeight: number;
+    pointCount: number;
+}
+export declare function createInstancedPointPipeline(device: any, format: string): InstancedPointPipelineBundle;
+export declare function createInstancedPointBindGroup(device: any, layout: any, uniformBuffer: any, pointBuffer: any): any;
+export declare function updateInstancedPointUniforms(device: any, uniformBuffer: any, uniforms: InstancedPointUniforms): void;
+export declare const SYMBOL_TYPE_MAP: Record<string, number>;

package/dist/gpu/backends/webgpu/pipelines/linePipeline.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Line Pipeline - WebGPU pipeline for rendering lines with uniform buffer
+ *
+ * Uses `any` types for WebGPU objects to avoid requiring @webgpu/types
+ * (following the pattern of the original WebGPUBackend.ts)
+ */
+export interface LinePipelineBundle {
+    pipeline: any;
+    bindGroupLayout: any;
+    uniformBuffer: any;
+    bindGroup: any;
+    vertexStride: number;
+}
+export interface LineUniforms {
+    scale: [number, number];
+    translate: [number, number];
+    color: [number, number, number, number];
+}
+export declare function createLinePipeline(device: any, // GPUDevice
+format: string): LinePipelineBundle;
+export declare function updateLineUniforms(device: any, // GPUDevice
+uniformBuffer: any, // GPUBuffer
+uniforms: LineUniforms): void;

package/dist/gpu/backends/webgpu/pipelines/pointPipeline.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Point Pipeline - WebGPU pipeline for rendering scatter points with SDF symbols
+ *
+ * Uses instanced rendering where each point is rendered as a quad (2 triangles).
+ * Uses `any` types for WebGPU objects to avoid requiring @webgpu/types.
+ */
+export interface PointPipelineBundle {
+    pipeline: any;
+    bindGroupLayout: any;
+    uniformBuffer: any;
+    bindGroup: any;
+    quadBuffer: any;
+    vertexStride: number;
+}
+export interface PointUniforms {
+    scale: [number, number];
+    translate: [number, number];
+    color: [number, number, number, number];
+    pointSize: number;
+    symbol: number;
+    viewport: [number, number];
+}
+export declare function createPointPipeline(device: any, // GPUDevice
+format: string): PointPipelineBundle;
+export declare function updatePointUniforms(device: any, // GPUDevice
+uniformBuffer: any, // GPUBuffer
+uniforms: PointUniforms): void;
+export declare const SYMBOL_MAP: Record<string, number>;

package/dist/gpu/backends/webgpu/pipelines/trianglePipeline.d.ts

@@ -0,0 +1,5 @@
+export interface TrianglePipelineBundle {
+    pipeline: any;
+    vertexStride: number;
+}
+export declare function createTrianglePipeline(device: any, format: string): TrianglePipelineBundle;

package/dist/gpu/backends/webgpu/pipelines/triangleShader.d.ts

@@ -0,0 +1 @@
+export declare const TRIANGLE_SHADER_WGSL = "\nstruct VSOut {\n  @builtin(position) pos: vec4<f32>,\n  @location(0) color: vec4<f32>,\n};\n\n@vertex\nfn vs_main(\n  @location(0) position: vec2<f32>,\n  @location(1) color: vec4<f32>\n) -> VSOut {\n  var out: VSOut;\n  out.pos = vec4<f32>(position, 0.0, 1.0);\n  out.color = color;\n  return out;\n}\n\n@fragment\nfn fs_main(in: VSOut) -> @location(0) vec4<f32> {\n  return in.color;\n}\n";