Apply LOD. Returns the source arrays when the level is `raw`. Source data is never mutated.
(x: Float64Array, y: Float64Array, viewportPx: number, level?: LodLevel) => DownsampleResult & { level: LodLevel; }Options for viewport-aware LOD.
interface ApplyLodOptions| x | Float64Array<ArrayBufferLike> |
| y | Float64Array<ArrayBufferLike> |
| viewportPx | number |
| xMin? | number | undefined |
| xMax? | number | undefined |
| level? | LodLevel | undefined |
Window to the visible x-range, then downsample. Source arrays are never mutated. The returned `x`/`y` may alias the source when the view is `raw` and covers the full series.
(options: ApplyLodOptions) => LodResultReusable ArrayBuffer pool. Acquire/release is O(1) amortized. Released buffers must not be written after {@link BufferPool.release}. A second release of the same buffer is a documented no-op (no use-after-free of the pool's free list).
class BufferPool() => booleanCPU-side series storage on the TypedArray → GPUBuffer path. Source arrays are retained; render views may be downsampled copies. Allocations go through {@link BufferPool} so repeated `setData` / `replace` of similar sizes reuse backing stores.
class DataBufferShared process-wide pool for typed-array reuse.
BufferPooltype DownsampleAlgorithm = DownsampleAlgorithmAverage each bin to a single sample.
(x: Float64Array, y: Float64Array, bins: number) => DownsampleResultMin/max envelope. Each bin emits the min and max Y samples (order preserved).
(x: Float64Array, y: Float64Array, bins: number) => DownsampleResultFirst and last sample of each bin.
(x: Float64Array, y: Float64Array, bins: number) => DownsampleResultLargest-Triangle-Three-Buckets. Preserves visual shape better than naive stride.
(x: Float64Array, y: Float64Array, threshold: number) => DownsampleResultDownsample on a worker when available; otherwise run synchronously. Source arrays are never mutated. Transferable copies are sent to the worker so the caller retains ownership of `x` / `y`.
(x: Float64Array, y: Float64Array, options: DownsampleOffThreadOptions) => Promise<DownsampleResult>interface DownsampleOffThreadOptions| algorithm? | DownsampleAlgorithm | undefined |
| threshold | number |
| preferWorker? | boolean | undefined |
Pixel-aware downsample using LTTB when the source exceeds ~2 samples/pixel.
(x: Float64Array, y: Float64Array, viewportPx: number) => DownsampleResultDownsampling is a *render* optimization. Callers must keep source arrays.
interface DownsampleResult| x | Float64Array<ArrayBufferLike> |
| y | Float64Array<ArrayBufferLike> |
type DType = DTypeinterface HudSample| frameMs | number |
| points | number |
| drawCalls | number |
| bufferBytes | number |
| updates? | number | undefined |
| lodLevel? | string | undefined |
| seriesCount? | number | undefined |
| vertexCount? | number | undefined |
| cpuBytes? | number | undefined |
| gpuBytes? | number | undefined |
Measured-only performance snapshot. Never invent values.
interface HudSnapshot| fps | number |
| frameMs | number |
| points | number |
| drawCalls | number |
| bufferBytes | number |
| updatesPerSec | number |
| lodLevel | string |
| seriesCount | number |
| vertexCount | number |
| cpuBytes | number |
| gpuBytes | number |
`true` when `x` is non-decreasing.
(x: Float64Array) => booleanConvenience: pick LOD then downsample.
(x: Float64Array, y: Float64Array, viewportPx: number) => DownsampleResult & { level: LodLevel; }Level-of-detail buckets (PRD §16).
type LodLevel = LodLevelLOD result plus bookkeeping for HUD / events.
interface LodResult| level | LodLevel |
| sourceCount | number |
| renderCount | number |
| windowStart | number |
| windowEnd | number |
| x | Float64Array<ArrayBufferLike> |
| y | Float64Array<ArrayBufferLike> |
First index `i` such that `x[i] >= value`. Assumes non-decreasing `x`.
(x: Float64Array, value: number) => numberRolling performance monitor. HUD is **off** unless explicitly enabled.
class PerformanceMonitorChoose a target count from the viewport width (typically 1–2 samples/pixel).
(pointCount: number, viewportPx: number) => numberChoose a LOD from *visible* sample count vs viewport width. Zoomed-in views have fewer visible samples and stay `raw`. Zoomed-out views of large series become `aggressive`.
(pointCount: number, viewportPx: number) => LodLevelSlice samples whose x-values fall in `[xMin, xMax]`. When `x` is monotonic the result aliases the source via `subarray`. Unsorted series return the full source so downsampling still runs.
(x: Float64Array, y: Float64Array, xMin: number, xMax: number, padding?: number) => VisibleWindowFirst index `i` such that `x[i] > value`. Assumes non-decreasing `x`.
(x: Float64Array, value: number) => numberVisible-window helpers. Used by LOD so zoomed-in views only process samples that can appear on screen.
interface VisibleWindow| x | Float64Array<ArrayBufferLike> |
| y | Float64Array<ArrayBufferLike> |
| start | number |
| end | number |
| aliased | boolean |
Got any questions? I'm happy to help with products, licensing, and examples.