blazeplot 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 BlazePlot contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,206 @@
+# BlazePlot
+
+[![npm version](https://img.shields.io/npm/v/blazeplot.svg)](https://www.npmjs.com/package/blazeplot)
+[![npm downloads](https://img.shields.io/npm/dt/blazeplot.svg)](https://www.npmjs.com/package/blazeplot)
+[![license](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
+[![build](https://img.shields.io/github/actions/workflow/status/Federicocervelli/blazeplot/release.yml?branch=master)](https://github.com/Federicocervelli/blazeplot/actions)
+
+Real-time LOD time series rendering engine for the browser.
+
+BlazePlot is GPU-native plotting engineered for high-frequency streaming data where standard charting libraries (Chart.js, ECharts, uPlot) fall over. Instead of drawing every sample, it keeps a resident ring buffer of millions of points, builds a min/max LOD pyramid, and renders only what each pixel needs — so frame cost is `O(pixels)`, not `O(samples)`.
+
+Built on WebGL2 + [regl](https://github.com/regl-project/regl). No Canvas2D, no SVG, no DOM layout.
+
+## Target
+
+- **10M+** resident points per series
+- **60 Hz** smooth append + render
+- **Zero allocations** in the frame loop
+- **Multi-series** with independent buffers and LOD
+
+## Installation
+
+```bash
+bun install blazeplot
+```
+
+## Quick start
+
+```html
+<canvas id="chart" style="width:100%;height:400px"></canvas>
+```
+
+```js
+import { Chart } from "blazeplot";
+
+const canvas = document.getElementById("chart");
+const chart = new Chart(canvas);
+
+const series = chart.addSeries(
+  { mode: "line", capacity: 1_000_000, downsample: "minmax" },
+  { color: [0.3, 0.6, 1.0, 1.0] },
+);
+
+chart.setViewport({ xMin: 0, xMax: 1000, yMin: -2, yMax: 2 });
+chart.start();
+
+// Append data periodically
+function push() {
+  const n = 256;
+  const xs = new Float64Array(n);
+  const ys = new Float32Array(n);
+  for (let i = 0; i < n; i++) {
+    xs[i] = t++;
+    ys[i] = Math.sin(t * 0.01) * 0.5 + Math.random() * 0.01;
+  }
+  series.append(xs, ys);
+  requestAnimationFrame(push);
+}
+let t = 0;
+push();
+```
+
+## Features
+
+| | |
+|---|---|
+| **LOD downsampling** | Min/max pyramid automatically selects the right detail level for the visible range — sparse viewports show raw points, dense viewports show vertical min/max segments. |
+| **Streaming append** | Fixed-capacity ring buffer wraps silently. No re-allocation. No memory growth. |
+| **Pan & zoom** | Pointer/touch pan and wheel zoom via `Camera2D`. Customizable viewport policies (e.g. live-follow X while Y is free). |
+| **Grid lines** | Data-anchored grid rendered as WebGL line lists. |
+| **Multi-series** | Independent buffers, styles, and visibility per series. |
+| **No DOM** | No axis DOM elements, no SVG overlay. The canvas owns everything. |
+| **ResizeObserver** | Automatic DPR-aware canvas sizing. |
+
+## API
+
+### `Chart`
+
+| Signature | Description |
+|---|---|
+| `new Chart(canvas, options?)` | Create a chart from an HTML canvas element. |
+| `chart.addSeries(config, style?)` | Add a data series. Returns `SeriesStore`. |
+| `chart.removeSeries(series)` | Remove a previously added series. |
+| `chart.setViewport({ xMin, xMax, yMin, yMax })` | Set the visible data range. |
+| `chart.resize(dpr?)` | Resize the canvas to match its CSS size × DPR. |
+| `chart.start()` | Start the render loop (rAF). |
+| `chart.stop()` | Stop the render loop. |
+| `chart.getFrameStats(target?)` | Copy per-frame benchmark counters into a reusable object. |
+| `chart.dispose()` | Dispose GPU resources, observers, and input handlers. |
+
+### `ChartOptions`
+
+| Property | Default | Description |
+|---|---|---|
+| `viewportPolicy?` | — | Custom pan/zoom/viewport behavior hooks. |
+| `grid?` | `true` | Show grid lines. |
+| `gridStyle?` | `{ color: [0.22,0.30,0.44,0.45] }` | Grid line color and width. |
+
+### `ChartFrameStats`
+
+| Field | Description |
+|---|---|
+| `fps` | Instantaneous render-loop FPS. |
+| `frameMs` | Milliseconds spent in `render()`. |
+| `pointsRendered` | Number of vertices drawn this frame. |
+| `drawCalls` | Number of GPU draw calls this frame. |
+| `uploadBytes` | Bytes uploaded to GPU this frame. |
+| `renderMode` | `"none"` / `"raw"` / `"minmax"` / `"mixed"`. |
+
+### `SeriesStore`
+
+| Signature | Description |
+|---|---|
+| `series.append(xs, ys)` | Append typed arrays of X (Float64) and Y (Float32) values. |
+| `series.clear()` | Clear all data and reset LOD state. |
+| `series.setVisible(v)` | Toggle visibility. |
+| `series.visible` | Current visibility state. |
+| `series.length` | Number of samples buffered. |
+
+### `SeriesConfig`
+
+| Property | Description |
+|---|---|
+| `mode` | `"line"` / `"envelope"` / `"scatter"` (envelope and scatter roadmap-only). |
+| `capacity` | Ring buffer capacity (samples). |
+| `downsample` | `"minmax"` (the only LOD strategy). |
+
+### `SeriesStyle`
+
+| Property | Default | Description |
+|---|---|---|
+| `color` | `[0.3, 0.6, 1.0, 1.0]` | RGBA float color. |
+| `lineWidth` | `1` | Line width in pixels. |
+
+### `ViewportPolicy`
+
+```ts
+interface ViewportPolicy {
+  beforePan?(camera: Camera2D, intent: PanIntent): PanIntent | null;
+  beforeZoom?(camera: Camera2D, intent: ZoomIntent): ZoomIntent | null;
+  beforeRender?(camera: Camera2D): void;
+}
+```
+
+Built-in data types: `Viewport`, `PanIntent`, `ZoomIntent`, `ZoomAxis`.
+
+### Lower-level primitives
+
+`Camera2D`, `RingBuffer`, `MinMaxPyramid`, `AxisController` are exported for advanced use cases (custom pipelines, worker threads, offscreen rendering).
+
+## How it works
+
+```
+Data stream ──► RingBuffer (resident, wraps at capacity)
+                   │
+                   ▼
+              MinMaxPyramid (full rebuild today, incremental roadmap)
+                   │
+                   ▼
+              SeriesStore.query() ──► LODView (buckets for visible range)
+                                    │
+                                    ▼
+                              Renderer (regl / WebGL2)
+```
+
+The render loop decides per-frame:
+- **Few visible samples** → raw line strip from ring buffer
+- **Many visible samples** → min/max vertical segments from the pyramid
+
+## Architecture
+
+```
+src/
+  core/          # Data engine — no UI, no GPU
+  render/        # GPU abstraction + regl backend
+  interaction/   # Camera, input, axis ticks
+  ui/            # Orchestrator (Chart)
+```
+
+## Development
+
+```bash
+bun install
+bun run dev          # Vite dev server → preview/
+bun run build        # Package build (JS + declarations)
+bun run build:js     # JS-only build
+bun test             # Core data-structure tests
+bun run typecheck    # TypeScript strict check
+```
+
+## Package build
+
+```bash
+bun run build
+```
+
+Output:
+
+```
+dist/index.js        ES module
+dist/index.d.ts      TypeScript declarations
+dist/index.js.map    Source map
+dist/*.d.ts.map      Declaration maps
+```
+
+

package/ROADMAP.md

@@ -0,0 +1,263 @@
+# BlazePlot — Roadmap
+
+**BlazePlot is a real-time LOD time series rendering engine, not a plotting library.**
+
+Target: 10M points resident, 60 Hz append/update, pan/zoom fluid, render O(pixel) not O(samples), zero allocations in frame loop, multi-series, line/envelope/scatter.
+
+---
+
+## Architecture
+
+```
+src/
+  core/          # Data engine — no UI, no GPU
+  render/        # GPU abstraction + regl V1 backend
+  interaction/   # Camera, input, axis ticks
+  ui/            # Orchestrator (Chart)
+tests/           # bun test — RingBuffer, MinMaxPyramid, Camera2D
+preview/         # Dev preview harness, detached from package build
+```
+
+The core split: **data engine** and **renderer** are separate. A `SeriesStore` owns a `RingBuffer` + `MinMaxPyramid`. The renderer reads LOD views, never raw data.
+
+```
+interface GpuBackend { … }     # abstract GPU
+class ReglBackend { … }        # V1 implementation
+class FutureWebGPUBackend { …} # V3
+```
+
+**Camera2D** is the canonical viewport model (data-space xMin/xMax/yMin/yMax). Scale/offset for shader uniforms are derived getters. `ViewportPlanner` was removed — its pan/zoom live on `Camera2D` directly.
+
+Package output is detached from the preview app:
+- `bun run dev` serves `preview/`.
+- `bun run build` emits `dist/index.js` and `dist/index.d.ts` from `src/index.ts`.
+- `preview/` is excluded from npm package contents.
+
+---
+
+## Phase 1 — Vertical slice: line on screen
+
+**Status: in progress**
+
+Get one end-to-end path working: append → visible raw extraction → GPU upload → draw.
+
+- [x] WebGL2 context + regl init
+- [x] Canvas resize + DPR handling
+- [x] Streaming append with debug overlay
+- [x] `ReglBackend` — createBuffer, updateBuffer, createProgram, cached draw commands
+- [x] Raw line strip draw via regl
+- [x] Wire `Chart.render()`: clear → copy visible raw range → upload → draw
+- [x] **Benchmark overlay**: fps, ms/frame, points rendered, draw calls, upload bytes
+
+This is the shortest path to seeing data on screen. Benchmarking the full pipeline comes after.
+
+---
+
+## Phase 2 — Core data engine
+
+**Status: basic scaffold implemented, correctness tests passing**
+
+- [x] `RingBuffer` — append-only, Float64Array x / Float32Array y, logical index access, ring-wrap aware search
+- [x] `MinMaxPyramid` — min/max per level (bucket size 2), correct higher-level aggregation, ring-wrap aware builds, `query()` returns `LODView`
+- [x] `SeriesStore` — buffer + pyramid + style, dirty tracking
+- [x] `Camera2D` — viewport model with pan, zoom, setViewport, clip/screen transforms
+- [x] `DataCursor` — binary search by timestamp
+- [x] Tests for `RingBuffer`, `MinMaxPyramid`, and `Camera2D` (bun test runner)
+- [ ] **Incremental pyramid update** — current: full rebuild on every `build()`. Target: O(log N) per append, updating only closed buckets in the chain. This is the core competitive advantage — must be designed before release.
+
+---
+
+## Phase 2.5 — Worker pipeline
+
+**Status: not started**
+
+```
+producer thread / worker ──► SharedArrayBuffer ──► downsampling worker ──► main thread
+```
+
+- [ ] Ingest worker — receives data, writes to ring buffer via SharedArrayBuffer
+- [ ] Downsample worker — incremental pyramid update off main thread
+- [ ] Main thread — reads coherent snapshot, uploads visible range to GPU
+- [ ] `OffscreenCanvas` optional path
+
+Data structures have correctness coverage, but the incremental pyramid API must be finalized before moving them off main thread.
+
+---
+
+## Phase 3 — regl renderer (full)
+
+**Status: not started**
+
+- [x] `ReglBackend` — createBuffer, updateBuffer (subdata), createProgram, draw command cache
+- [ ] Persistent buffer pool (no Float32Array allocs per frame)
+- [x] Raw line strip for few visible points
+- [x] `MinMaxSegmentRenderer` — vertical min/max segments for dense viewports
+- [ ] Instanced draw for segment mode
+- [x] Camera transform as uniforms (scale/offset getters on Camera2D)
+- [ ] Two shader modes: `line.vert/frag` and `segment.vert/frag`
+- [x] `Renderer.drawMinMaxSegments`
+- [ ] Draw call batching per shader mode
+
+---
+
+## Phase 4 — Interaction
+
+**Status: implemented (camera + input)**
+
+- [x] `Camera2D` — viewport model with pan, zoom, setViewport
+- [x] `InputController` — pointer pan, wheel zoom, touch via Pointer Events
+- [x] `ViewportPolicy` — transforms pan/zoom intents and can update camera before render
+- [x] Preview synced-X policy — X stays live-followed while wheel zoom/pan affect Y only
+- [x] Camera uniforms propagated to shaders per frame
+- [ ] LOD re-query on pan/zoom (viewport change → new LODView)
+- [x] `AxisController` — smart tick generation and label formatting
+- [ ] Axis tick rendering (smart tick count, label formatting)
+- [x] Grid line rendering
+
+Camera modifies `Camera2D`, renderer reads it. No direct data access from interaction layer.
+
+---
+
+## Phase 5 — Multi-series
+
+**Status: data model ready**
+
+- [x] `Chart.addSeries()` supports multiple stores
+- [x] Each `SeriesStore` has independent buffer + pyramid + style
+- [ ] Batched draw calls (same shader → one draw per series group)
+- [ ] Shared X axis optional, independent Y per series
+- [x] Color/style per-series
+- [x] Series visibility toggle
+
+Limit: solid lines only, no markers, no antialias, no spline, no fill.
+
+---
+
+## Phase 6 — Public API
+
+**Status: basic shape exists**
+
+- [x] `new Chart(canvas)`
+- [x] `new Chart(canvas, { viewportPolicy })`
+- [x] `chart.addSeries(config, style)`
+- [x] `chart.setViewport({ xMin, xMax, yMin, yMax })`
+- [x] `chart.start()` / `chart.stop()`
+- [x] `chart.resize()` — handle container resize with DPR
+- [x] `series.append(x, y)` — accepts typed arrays
+- [x] `series.clear()`
+- [x] `chart.removeSeries(series)`
+- [ ] Axis labels / tick rendering
+- [x] Grid
+- [ ] Legend
+- [ ] Tooltip / hit testing
+- [ ] Export image
+- [ ] Theme system
+- [x] ResizeObserver integration
+
+Package status:
+- [x] `exports`, `main`, `module`, and `types` point at `dist/`
+- [x] Vite library build from `src/index.ts`
+- [x] Declaration emit from `src/` only via Vite d.ts plugin
+- [x] `bun pm pack --dry-run` includes package files only
+
+---
+
+## Downsampler — LOD engine
+
+**Status: basic pyramid built, not incremental**
+
+Current: `MinMaxPyramid.build()` does a full bottom-up rebuild. Target:
+
+```
+raw level:    x: Float64Array, y: Float32Array
+level 1:      minY/maxY per bucket of 2
+level 2:      minY/maxY per bucket of 4
+level 3:      minY/maxY per bucket of 8
+…
+```
+
+**Incremental append**: each append updates only the chain of closed buckets. Query is O(buckets in viewport).
+
+Planned incremental design:
+- Raw samples are addressed by monotonically increasing logical sample index, not physical ring position.
+- Level `n` bucket width is `bucketSize ** (n + 1)` raw samples.
+- Appending a sample updates only level 0 while its bucket is open.
+- When a bucket closes, its min/max pair is propagated upward as one input sample for the next level.
+- Higher levels never read raw Y values; they combine child min/max pairs.
+- Ring wrap invalidates buckets whose covered logical index range was overwritten.
+- Query receives a visible logical index range from x-search and maps that range to bucket indices using the selected level width.
+
+**Query**: `samples_per_pixel = visible_samples / plotWidthPx`, pick `level = max(0, ceil(log2(samples_per_pixel)) - 1)`, return min/max pairs.
+
+**Render decision**:
+- few points → raw line strip
+- many points → vertical min/max segments
+- very many → envelope mesh
+
+---
+
+## Backend strategy
+
+```
+V1:  WebGL2 + regl             ← CURRENT
+V2:  Backend abstraction          ← In place (GpuBackend interface)
+V3:  WebGPU backend               ← Future
+```
+
+regl is the V1 backend, not the architecture. The `GpuBackend` interface decouples core from GPU.
+
+regl rules for V1:
+- Persistent buffers (no re-create per frame)
+- Precompiled regl commands
+- `subdata` on small ranges
+- Batched draw calls
+- Simple shaders, camera in uniforms
+- WebGL2 required (no fallback)
+
+---
+
+## Overflow semantics
+
+**Status: undecided**
+
+`RingBuffer` wraps silently at capacity. For streaming this is usually correct, but it should be explicit. Options:
+- Ring-buffer with wrap notification
+- Fixed capacity with error on overflow
+- Auto-growing buffer (breaks streaming contract)
+
+Deferred until we have a concrete use case.
+
+---
+
+## What we're NOT doing (V1)
+
+- SVG / Canvas2D fallback
+- Spline interpolation
+- Complex fill (gradient, area below)
+- Markers / point symbols
+- Antialias perfection
+- Recalculating axes in render loop
+- Per-series draw call without batching
+
+---
+
+## Competitive advantage
+
+Not WebGL. The core differentiator:
+
+> Incremental min/max pyramid + zero-allocation render loop + Camera2D viewport model
+
+Never render 10M points. Render `plotWidthPx * 2` (2k–8k vertices).
+
+---
+
+## Future / difficult
+
+- Multi-chart sync
+- Multiple Y axes
+- Spectrogram / heatmap
+- Large scatter ( > 1M points )
+- OHLC / candlestick
+- FFT / waterfall
+- Out-of-core data ( > RAM)
+- WebGPU backend

package/dist/core/DataCursor.d.ts

@@ -0,0 +1,9 @@
+import { RingBuffer } from './RingBuffer.js';
+export declare class DataCursor {
+    private _index;
+    private _buffer;
+    bind(buffer: RingBuffer): void;
+    get index(): number;
+    seekTimestamp(x: number): number;
+}
+//# sourceMappingURL=DataCursor.d.ts.map

package/dist/core/DataCursor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DataCursor.d.ts","sourceRoot":"","sources":["../../src/core/DataCursor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAElD,qBAAa,UAAU;IACrB,OAAO,CAAC,MAAM,CAAc;IAC5B,OAAO,CAAC,OAAO,CAA2B;IAE1C,IAAI,CAAC,MAAM,EAAE,UAAU,GAAG,IAAI;IAK9B,IAAI,KAAK,IAAI,MAAM,CAElB;IAED,aAAa,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM;CAYjC"}

package/dist/core/MinMaxPyramid.d.ts

@@ -0,0 +1,15 @@
+import { LODView, Viewport } from './types.js';
+import { RingBuffer } from './RingBuffer.js';
+export declare class MinMaxPyramid {
+    readonly bucketSize: number;
+    private levels;
+    private levelLengths;
+    private levelSampleWidths;
+    constructor(bucketSize?: number);
+    build(source: RingBuffer): void;
+    query(_viewport: Viewport, pixelWidth: number, xRange: {
+        start: number;
+        length: number;
+    }): LODView;
+}
+//# sourceMappingURL=MinMaxPyramid.d.ts.map

package/dist/core/MinMaxPyramid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MinMaxPyramid.d.ts","sourceRoot":"","sources":["../../src/core/MinMaxPyramid.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACpD,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAI7C,qBAAa,aAAa;IAKZ,QAAQ,CAAC,UAAU,EAAE,MAAM;IAJvC,OAAO,CAAC,MAAM,CAAsB;IACpC,OAAO,CAAC,YAAY,CAAc;IAClC,OAAO,CAAC,iBAAiB,CAAc;gBAElB,UAAU,GAAE,MAAU;IAS3C,KAAK,CAAC,MAAM,EAAE,UAAU,GAAG,IAAI;IAgD/B,KAAK,CAAC,SAAS,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO;CAsCnG"}

package/dist/core/RingBuffer.d.ts

@@ -0,0 +1,24 @@
+import { TimeRange } from './types.js';
+export declare class RingBuffer {
+    readonly capacity: number;
+    private _length;
+    private _head;
+    private readonly xData;
+    private readonly yData;
+    constructor(capacity: number);
+    get length(): number;
+    get range(): TimeRange | null;
+    push(x: number, y: number): void;
+    get(index: number): {
+        x: number;
+        y: number;
+    } | null;
+    getX(index: number): number;
+    getY(index: number): number;
+    lowerBoundX(x: number): number;
+    upperBoundX(x: number): number;
+    clear(): void;
+    private logicalToPhysical;
+    private assertValidIndex;
+}
+//# sourceMappingURL=RingBuffer.d.ts.map

package/dist/core/RingBuffer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RingBuffer.d.ts","sourceRoot":"","sources":["../../src/core/RingBuffer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAE5C,qBAAa,UAAU;IACrB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,OAAO,CAAC,OAAO,CAAa;IAC5B,OAAO,CAAC,KAAK,CAAa;IAE1B,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAe;IACrC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAe;gBAEzB,QAAQ,EAAE,MAAM;IAU5B,IAAI,MAAM,IAAI,MAAM,CAEnB;IAED,IAAI,KAAK,IAAI,SAAS,GAAG,IAAI,CAG5B;IAED,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI;IAOhC,GAAG,CAAC,KAAK,EAAE,MAAM,GAAG;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI;IAKnD,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IAK3B,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IAK3B,WAAW,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM;IAW9B,WAAW,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM;IAW9B,KAAK,IAAI,IAAI;IAKb,OAAO,CAAC,iBAAiB;IAIzB,OAAO,CAAC,gBAAgB;CAKzB"}

package/dist/core/SeriesStore.d.ts

@@ -0,0 +1,22 @@
+import { SeriesConfig, SeriesStyle, LODView, Viewport } from './types.js';
+export declare class SeriesStore {
+    readonly config: SeriesConfig;
+    readonly style: SeriesStyle;
+    private readonly buffer;
+    private readonly pyramid;
+    private _dirty;
+    private _visible;
+    constructor(config: SeriesConfig, style: SeriesStyle);
+    get dirty(): boolean;
+    get length(): number;
+    get visible(): boolean;
+    setVisible(visible: boolean): void;
+    append(x: ArrayLike<number>, y: ArrayLike<number>): void;
+    clear(): void;
+    rebuildPyramid(): void;
+    query(viewport: Viewport, pixelWidth: number): LODView;
+    visibleSampleCount(viewport: Viewport): number;
+    copyRawVisible(viewport: Viewport, target: Float32Array, maxPoints: number): number;
+    copyMinMaxVisible(viewport: Viewport, target: Float32Array, maxSegments: number): number;
+}
+//# sourceMappingURL=SeriesStore.d.ts.map

package/dist/core/SeriesStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SeriesStore.d.ts","sourceRoot":"","sources":["../../src/core/SeriesStore.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAI/E,qBAAa,WAAW;IACtB,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;IAC9B,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC;IAC5B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAa;IACpC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAgB;IAExC,OAAO,CAAC,MAAM,CAAkB;IAChC,OAAO,CAAC,QAAQ,CAAiB;gBAErB,MAAM,EAAE,YAAY,EAAE,KAAK,EAAE,WAAW;IAOpD,IAAI,KAAK,IAAI,OAAO,CAEnB;IAED,IAAI,MAAM,IAAI,MAAM,CAEnB;IAED,IAAI,OAAO,IAAI,OAAO,CAErB;IAED,UAAU,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI;IAIlC,MAAM,CAAC,CAAC,EAAE,SAAS,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE,SAAS,CAAC,MAAM,CAAC,GAAG,IAAI;IAQxD,KAAK,IAAI,IAAI;IAMb,cAAc,IAAI,IAAI;IAMtB,KAAK,CAAC,QAAQ,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO;IAetD,kBAAkB,CAAC,QAAQ,EAAE,QAAQ,GAAG,MAAM;IAM9C,cAAc,CAAC,QAAQ,EAAE,QAAQ,EAAE,MAAM,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM;IAmBnF,iBAAiB,CAAC,QAAQ,EAAE,QAAQ,EAAE,MAAM,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM;CAqCzF"}

package/dist/core/index.d.ts

@@ -0,0 +1,6 @@
+export type { Viewport, LODBucket, LODView, TimeRange, SeriesStyle, SeriesMode, SeriesConfig } from './types.js';
+export { RingBuffer } from './RingBuffer.js';
+export { MinMaxPyramid } from './MinMaxPyramid.js';
+export { SeriesStore } from './SeriesStore.js';
+export { DataCursor } from './DataCursor.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,QAAQ,EAAE,SAAS,EAAE,OAAO,EAAE,SAAS,EAAE,WAAW,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAEjH,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/core/types.d.ts

@@ -0,0 +1,33 @@
+export interface Viewport {
+    readonly xMin: number;
+    readonly xMax: number;
+    readonly yMin: number;
+    readonly yMax: number;
+}
+export interface LODBucket {
+    readonly xStart: number;
+    readonly xEnd: number;
+    readonly minY: number;
+    readonly maxY: number;
+}
+export interface LODView {
+    readonly buckets: Float32Array;
+    readonly bucketCount: number;
+    readonly level: number;
+    readonly samplesPerPixel: number;
+}
+export interface TimeRange {
+    readonly start: number;
+    readonly end: number;
+}
+export interface SeriesStyle {
+    readonly color: readonly [number, number, number, number];
+    readonly lineWidth: number;
+}
+export type SeriesMode = "line" | "envelope" | "scatter";
+export interface SeriesConfig {
+    readonly mode: SeriesMode;
+    readonly capacity: number;
+    readonly downsample: "minmax";
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/core/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/core/types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,OAAO;IACtB,QAAQ,CAAC,OAAO,EAAE,YAAY,CAAC;IAC/B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;CAClC;AAED,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IAC1D,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B;AAED,MAAM,MAAM,UAAU,GAAG,MAAM,GAAG,UAAU,GAAG,SAAS,CAAC;AAEzD,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,UAAU,EAAE,QAAQ,CAAC;CAC/B"}

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export { Chart } from './ui/Chart.js';
+export type { ChartFrameStats, ChartOptions } from './ui/Chart.js';
+export { SeriesStore } from './core/SeriesStore.js';
+export { RingBuffer } from './core/RingBuffer.js';
+export { MinMaxPyramid } from './core/MinMaxPyramid.js';
+export { Camera2D } from './interaction/Camera2D.js';
+export { AxisController } from './interaction/AxisController.js';
+export type { Viewport, LODBucket, LODView, TimeRange, SeriesStyle, SeriesMode, SeriesConfig } from './core/types.js';
+export type { PanIntent, ZoomAxis, ZoomIntent, ViewportPolicy } from './interaction/types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AACtC,YAAY,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AACnE,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACpD,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAClD,OAAO,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AACxD,OAAO,EAAE,QAAQ,EAAE,MAAM,2BAA2B,CAAC;AACrD,OAAO,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAC;AACjE,YAAY,EAAE,QAAQ,EAAE,SAAS,EAAE,OAAO,EAAE,SAAS,EAAE,WAAW,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AACtH,YAAY,EAAE,SAAS,EAAE,QAAQ,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC"}