@heojeongbo/fluxion-render 0.2.0

package/dist/chunk-3PK3KDO5.js

@@ -0,0 +1,36 @@
+// src/shared/lib/time-format.ts
+var TOKEN_RE = /HH|SSS|mm|ss|H|m|s|S/g;
+function makeClockFormatter(pattern) {
+  return (epochMs) => formatClock(epochMs, pattern);
+}
+function formatClock(epochMs, pattern) {
+  const d = new Date(epochMs);
+  return pattern.replace(TOKEN_RE, (tok) => {
+    switch (tok) {
+      case "HH":
+        return String(d.getHours()).padStart(2, "0");
+      case "H":
+        return String(d.getHours());
+      case "mm":
+        return String(d.getMinutes()).padStart(2, "0");
+      case "m":
+        return String(d.getMinutes());
+      case "ss":
+        return String(d.getSeconds()).padStart(2, "0");
+      case "s":
+        return String(d.getSeconds());
+      case "SSS":
+        return String(d.getMilliseconds()).padStart(3, "0");
+      case "S":
+        return String(Math.floor(d.getMilliseconds() / 100));
+      default:
+        return tok;
+    }
+  });
+}
+
+export {
+  makeClockFormatter,
+  formatClock
+};
+//# sourceMappingURL=chunk-3PK3KDO5.js.map

package/dist/chunk-3PK3KDO5.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/shared/lib/time-format.ts"],"sourcesContent":["/**\n * Tiny clock pattern formatter. Supports the following tokens (leftmost\n * longest wins):\n *\n *   HH  - hours, zero-padded (00..23)\n *   H   - hours (0..23)\n *   mm  - minutes, zero-padded (00..59)\n *   m   - minutes (0..59)\n *   ss  - seconds, zero-padded (00..59)\n *   s   - seconds (0..59)\n *   SSS - milliseconds, zero-padded (000..999)\n *   S   - tenths of a second (0..9)\n *\n * Anything else is treated as a literal (e.g. \":\", \".\", \" \", \"T\"). The parser\n * is intentionally small: no locale support, no escape syntax. Feed it a\n * wall-clock epoch in ms.\n *\n * Example:\n *   formatClock(Date.now(), \"HH:mm:ss\")       -> \"14:07:32\"\n *   formatClock(Date.now(), \"HH:mm:ss.SSS\")   -> \"14:07:32.481\"\n *   formatClock(Date.now(), \"H:m:s\")          -> \"14:7:32\"\n */\nconst TOKEN_RE = /HH|SSS|mm|ss|H|m|s|S/g;\n\nexport type TickFormatter = (epochMs: number) => string;\n\n/** Build a memoized formatter for a pattern. */\nexport function makeClockFormatter(pattern: string): TickFormatter {\n  return (epochMs: number) => formatClock(epochMs, pattern);\n}\n\nexport function formatClock(epochMs: number, pattern: string): string {\n  const d = new Date(epochMs);\n  return pattern.replace(TOKEN_RE, (tok) => {\n    switch (tok) {\n      case \"HH\":\n        return String(d.getHours()).padStart(2, \"0\");\n      case \"H\":\n        return String(d.getHours());\n      case \"mm\":\n        return String(d.getMinutes()).padStart(2, \"0\");\n      case \"m\":\n        return String(d.getMinutes());\n      case \"ss\":\n        return String(d.getSeconds()).padStart(2, \"0\");\n      case \"s\":\n        return String(d.getSeconds());\n      case \"SSS\":\n        return String(d.getMilliseconds()).padStart(3, \"0\");\n      case \"S\":\n        return String(Math.floor(d.getMilliseconds() / 100));\n      default:\n        return tok;\n    }\n  });\n}\n"],"mappings":";AAsBA,IAAM,WAAW;AAKV,SAAS,mBAAmB,SAAgC;AACjE,SAAO,CAAC,YAAoB,YAAY,SAAS,OAAO;AAC1D;AAEO,SAAS,YAAY,SAAiB,SAAyB;AACpE,QAAM,IAAI,IAAI,KAAK,OAAO;AAC1B,SAAO,QAAQ,QAAQ,UAAU,CAAC,QAAQ;AACxC,YAAQ,KAAK;AAAA,MACX,KAAK;AACH,eAAO,OAAO,EAAE,SAAS,CAAC,EAAE,SAAS,GAAG,GAAG;AAAA,MAC7C,KAAK;AACH,eAAO,OAAO,EAAE,SAAS,CAAC;AAAA,MAC5B,KAAK;AACH,eAAO,OAAO,EAAE,WAAW,CAAC,EAAE,SAAS,GAAG,GAAG;AAAA,MAC/C,KAAK;AACH,eAAO,OAAO,EAAE,WAAW,CAAC;AAAA,MAC9B,KAAK;AACH,eAAO,OAAO,EAAE,WAAW,CAAC,EAAE,SAAS,GAAG,GAAG;AAAA,MAC/C,KAAK;AACH,eAAO,OAAO,EAAE,WAAW,CAAC;AAAA,MAC9B,KAAK;AACH,eAAO,OAAO,EAAE,gBAAgB,CAAC,EAAE,SAAS,GAAG,GAAG;AAAA,MACpD,KAAK;AACH,eAAO,OAAO,KAAK,MAAM,EAAE,gBAAgB,IAAI,GAAG,CAAC;AAAA,MACrD;AACE,eAAO;AAAA,IACX;AAAA,EACF,CAAC;AACH;","names":[]}

package/dist/chunk-56NZ4OEO.js

@@ -0,0 +1,247 @@
+import {
+  Op
+} from "./chunk-R7FLS7BG.js";
+
+// src/features/host/model/layer-handles.ts
+var LineLayerHandle = class {
+  constructor(sink, id) {
+    this.sink = sink;
+    this.id = id;
+  }
+  sink;
+  id;
+  /** Push a single `[t, y]` sample. Allocates a 2-element Float32Array. */
+  push(sample) {
+    const buf = new Float32Array(2);
+    buf[0] = sample.t;
+    buf[1] = sample.y;
+    this.sink.pushData(this.id, buf);
+  }
+  /**
+   * Push an array of samples in one postMessage. Encodes into a single
+   * contiguous Float32Array and transfers ownership. Prefer this over a loop
+   * of `push()` when you already have a batch in hand.
+   */
+  pushBatch(samples) {
+    const n = samples.length;
+    if (n === 0) return;
+    const buf = new Float32Array(n * 2);
+    for (let i = 0; i < n; i++) {
+      const s = samples[i];
+      buf[i * 2] = s.t;
+      buf[i * 2 + 1] = s.y;
+    }
+    this.sink.pushData(this.id, buf);
+  }
+  /**
+   * Escape hatch: push a pre-built `[t, y, t, y, ...]` Float32Array directly.
+   * Use for hot paths where you can avoid the object-to-array encode step.
+   * The TypedArray's byteOffset must be 0 (same rule as `pushData`).
+   */
+  pushRaw(data) {
+    this.sink.pushData(this.id, data);
+  }
+};
+var LineStaticLayerHandle = class {
+  constructor(sink, id) {
+    this.sink = sink;
+    this.id = id;
+  }
+  sink;
+  id;
+  setXY(points) {
+    const n = points.length;
+    const buf = new Float32Array(n * 2);
+    for (let i = 0; i < n; i++) {
+      const p = points[i];
+      buf[i * 2] = p.x;
+      buf[i * 2 + 1] = p.y;
+    }
+    this.sink.pushData(this.id, buf);
+  }
+  setY(values) {
+    const buf = new Float32Array(values.length);
+    for (let i = 0; i < values.length; i++) buf[i] = values[i];
+    this.sink.pushData(this.id, buf);
+  }
+  pushRaw(data) {
+    this.sink.pushData(this.id, data);
+  }
+};
+var LidarLayerHandle = class {
+  constructor(sink, id, stride = 4) {
+    this.sink = sink;
+    this.id = id;
+    this.stride = stride;
+  }
+  sink;
+  id;
+  stride;
+  push(points) {
+    const stride = this.stride;
+    const n = points.length;
+    const buf = new Float32Array(n * stride);
+    for (let i = 0; i < n; i++) {
+      const p = points[i];
+      const o = i * stride;
+      buf[o] = p.x;
+      buf[o + 1] = p.y;
+      if (stride >= 3) buf[o + 2] = p.z ?? 0;
+      if (stride >= 4) buf[o + 3] = p.intensity ?? 0;
+    }
+    this.sink.pushData(this.id, buf);
+  }
+  pushRaw(data) {
+    this.sink.pushData(this.id, data);
+  }
+};
+
+// src/features/host/model/fluxion-host.ts
+function defaultWorkerFactory() {
+  return new Worker(new URL("./fluxion-worker.js", import.meta.url), {
+    type: "module"
+  });
+}
+function dtypeOf(arr) {
+  if (arr instanceof Float32Array) return "f32";
+  if (arr instanceof Uint8Array) return "u8";
+  if (arr instanceof Int16Array) return "i16";
+  if (arr instanceof Uint16Array) return "u16";
+  if (arr instanceof Int32Array) return "i32";
+  throw new Error("fluxion-render: unsupported TypedArray");
+}
+var FluxionHost = class {
+  worker;
+  disposed = false;
+  constructor(canvas, opts = {}) {
+    this.worker = (opts.workerFactory ?? defaultWorkerFactory)();
+    const offscreen = canvas.transferControlToOffscreen();
+    const dpr = typeof devicePixelRatio === "number" ? devicePixelRatio : 1;
+    const rect = canvas.getBoundingClientRect();
+    const width = rect.width || canvas.width || 300;
+    const height = rect.height || canvas.height || 150;
+    this.post(
+      {
+        op: Op.INIT,
+        canvas: offscreen,
+        width,
+        height,
+        dpr
+      },
+      [offscreen]
+    );
+  }
+  addLayer(id, kind, config) {
+    this.post({ op: Op.ADD_LAYER, id, kind, config });
+  }
+  removeLayer(id) {
+    this.post({ op: Op.REMOVE_LAYER, id });
+  }
+  configLayer(id, config) {
+    this.post({ op: Op.CONFIG, id, config });
+  }
+  // ──────────────────────────────────────────────────────────────────────
+  // Typed add-layer helpers: construct + return a typed handle in one call.
+  // ──────────────────────────────────────────────────────────────────────
+  /**
+   * Add a streaming line layer and return a handle that accepts structured
+   * `{ t, y }` samples instead of raw Float32Array interleaved layout.
+   */
+  addLineLayer(id, config) {
+    this.addLayer(id, "line", config);
+    return new LineLayerHandle(this, id);
+  }
+  /**
+   * Add a static xy line layer and return a handle that accepts
+   * `{ x, y }[]` or plain y-only arrays.
+   */
+  addLineStaticLayer(id, config) {
+    this.addLayer(id, "line-static", config);
+    return new LineStaticLayerHandle(this, id);
+  }
+  /**
+   * Add a LiDAR scatter layer and return a handle that accepts
+   * `{ x, y, z?, intensity? }[]`. The handle's stride must match
+   * `config.stride` (default 4).
+   */
+  addLidarLayer(id, config) {
+    this.addLayer(id, "lidar", config);
+    const stride = config?.stride ?? 4;
+    return new LidarLayerHandle(this, id, stride);
+  }
+  /**
+   * Add an axis/grid layer. Axis layers don't take data, so this returns
+   * void — use `configLayer` to retune bounds / time window later.
+   */
+  addAxisLayer(id, config) {
+    this.addLayer(id, "axis-grid", config);
+  }
+  // ──────────────────────────────────────────────────────────────────────
+  // Attach a typed handle to a layer that was added via another API path
+  // (e.g. declaratively through `<FluxionCanvas layers={...}>` or
+  // `useFluxionCanvas({ layers: [...] })`).
+  // ──────────────────────────────────────────────────────────────────────
+  line(id) {
+    return new LineLayerHandle(this, id);
+  }
+  lineStatic(id) {
+    return new LineStaticLayerHandle(this, id);
+  }
+  lidar(id, stride = 4) {
+    return new LidarLayerHandle(this, id, stride);
+  }
+  /**
+   * Push TypedArray data to a layer. Transfers the underlying ArrayBuffer —
+   * the caller MUST NOT use `data` again afterwards.
+   *
+   * The TypedArray must start at byteOffset 0 because the worker reconstructs
+   * the view at offset 0. Subviews would silently read from the wrong offset,
+   * so they're rejected up-front. Use `data.slice()` to get a fresh buffer.
+   */
+  pushData(id, data) {
+    if (data.byteOffset !== 0) {
+      throw new Error(
+        `fluxion-render: TypedArray must start at byteOffset 0 (got ${data.byteOffset}). Call .slice() to copy into a fresh buffer before pushing.`
+      );
+    }
+    const buffer = data.buffer;
+    this.post(
+      {
+        op: Op.DATA,
+        id,
+        buffer,
+        dtype: dtypeOf(data),
+        length: data.length
+      },
+      [buffer]
+    );
+  }
+  resize(width, height, dpr) {
+    this.post({ op: Op.RESIZE, width, height, dpr });
+  }
+  dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    try {
+      this.post({ op: Op.DISPOSE });
+    } catch {
+    }
+    this.worker.terminate();
+  }
+  post(msg, transfer) {
+    if (this.disposed) return;
+    if (transfer && transfer.length) {
+      this.worker.postMessage(msg, transfer);
+    } else {
+      this.worker.postMessage(msg);
+    }
+  }
+};
+
+export {
+  LineLayerHandle,
+  LineStaticLayerHandle,
+  LidarLayerHandle,
+  FluxionHost
+};
+//# sourceMappingURL=chunk-56NZ4OEO.js.map

package/dist/chunk-56NZ4OEO.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/features/host/model/layer-handles.ts","../src/features/host/model/fluxion-host.ts"],"sourcesContent":["/**\n * Type-safe layer handles.\n *\n * These wrap the raw `FluxionHost.pushData(id, Float32Array)` API so callers\n * can work with structured records on the main thread (e.g. after receiving\n * ROS messages or processing sensor frames) without hand-rolling the\n * interleaved Float32Array layout every time.\n *\n * Each handle is a thin encoder: the input shape is type-checked at the call\n * site, encoding to the worker-side layout happens once, and the underlying\n * ArrayBuffer is still transferred zero-copy.\n */\n\n// A minimal surface of `FluxionHost` that handles depend on. Declared here\n// so this module has no circular import with fluxion-host.ts.\nexport interface FluxionDataSink {\n  pushData(id: string, data: Float32Array): void;\n}\n\n// ────────────────────────────────────────────────────────────────────────────\n// Line (streaming) — data layout: [t, y, t, y, ...]\n// ────────────────────────────────────────────────────────────────────────────\n\n/** One streaming sample. `t` is host-relative ms (what `axis-grid` time mode expects). */\nexport interface LineSample {\n  t: number;\n  y: number;\n}\n\nexport class LineLayerHandle {\n  constructor(\n    private readonly sink: FluxionDataSink,\n    readonly id: string,\n  ) {}\n\n  /** Push a single `[t, y]` sample. Allocates a 2-element Float32Array. */\n  push(sample: LineSample): void {\n    const buf = new Float32Array(2);\n    buf[0] = sample.t;\n    buf[1] = sample.y;\n    this.sink.pushData(this.id, buf);\n  }\n\n  /**\n   * Push an array of samples in one postMessage. Encodes into a single\n   * contiguous Float32Array and transfers ownership. Prefer this over a loop\n   * of `push()` when you already have a batch in hand.\n   */\n  pushBatch(samples: readonly LineSample[]): void {\n    const n = samples.length;\n    if (n === 0) return;\n    const buf = new Float32Array(n * 2);\n    for (let i = 0; i < n; i++) {\n      const s = samples[i];\n      buf[i * 2] = s.t;\n      buf[i * 2 + 1] = s.y;\n    }\n    this.sink.pushData(this.id, buf);\n  }\n\n  /**\n   * Escape hatch: push a pre-built `[t, y, t, y, ...]` Float32Array directly.\n   * Use for hot paths where you can avoid the object-to-array encode step.\n   * The TypedArray's byteOffset must be 0 (same rule as `pushData`).\n   */\n  pushRaw(data: Float32Array): void {\n    this.sink.pushData(this.id, data);\n  }\n}\n\n// ────────────────────────────────────────────────────────────────────────────\n// Line-static — data layout: [x, y, x, y, ...] or [y0, y1, ...]\n// ────────────────────────────────────────────────────────────────────────────\n\nexport interface XyPoint {\n  x: number;\n  y: number;\n}\n\n/**\n * Handle for `kind: \"line-static\"` layers. `setXY` replaces the entire series\n * with a new xy array; `setY` does the same with y-only data (x is computed\n * from the layer's configured x range). Use the variant that matches the\n * layer's `layout` config — this is not enforced at the type level since the\n * worker-side layout is a runtime config.\n */\nexport class LineStaticLayerHandle {\n  constructor(\n    private readonly sink: FluxionDataSink,\n    readonly id: string,\n  ) {}\n\n  setXY(points: readonly XyPoint[]): void {\n    const n = points.length;\n    const buf = new Float32Array(n * 2);\n    for (let i = 0; i < n; i++) {\n      const p = points[i];\n      buf[i * 2] = p.x;\n      buf[i * 2 + 1] = p.y;\n    }\n    this.sink.pushData(this.id, buf);\n  }\n\n  setY(values: readonly number[]): void {\n    const buf = new Float32Array(values.length);\n    for (let i = 0; i < values.length; i++) buf[i] = values[i];\n    this.sink.pushData(this.id, buf);\n  }\n\n  pushRaw(data: Float32Array): void {\n    this.sink.pushData(this.id, data);\n  }\n}\n\n// ────────────────────────────────────────────────────────────────────────────\n// Lidar — data layout: [x, y, (z), (intensity), ...] with configurable stride\n// ────────────────────────────────────────────────────────────────────────────\n\nexport interface LidarPoint {\n  x: number;\n  y: number;\n  /** Optional when the layer stride is 2. Defaults to 0 otherwise. */\n  z?: number;\n  /** Optional when the layer stride is <4. Defaults to 0 otherwise. */\n  intensity?: number;\n}\n\nexport type LidarStride = 2 | 3 | 4;\n\n/**\n * Handle for `kind: \"lidar\"` scatter layers. The stride (2 = xy, 3 = xyz,\n * 4 = xyz+intensity) must match the layer's stride config. Passing a\n * mismatched stride will succeed but the worker will read the wrong fields.\n */\nexport class LidarLayerHandle {\n  constructor(\n    private readonly sink: FluxionDataSink,\n    readonly id: string,\n    readonly stride: LidarStride = 4,\n  ) {}\n\n  push(points: readonly LidarPoint[]): void {\n    const stride = this.stride;\n    const n = points.length;\n    const buf = new Float32Array(n * stride);\n    for (let i = 0; i < n; i++) {\n      const p = points[i];\n      const o = i * stride;\n      buf[o] = p.x;\n      buf[o + 1] = p.y;\n      if (stride >= 3) buf[o + 2] = p.z ?? 0;\n      if (stride >= 4) buf[o + 3] = p.intensity ?? 0;\n    }\n    this.sink.pushData(this.id, buf);\n  }\n\n  pushRaw(data: Float32Array): void {\n    this.sink.pushData(this.id, data);\n  }\n}\n","import type { AxisGridConfig } from \"../../../entities/axis-grid-layer\";\nimport type { LidarScatterConfig } from \"../../../entities/lidar-scatter-layer\";\nimport type { LineChartConfig } from \"../../../entities/line-chart-layer\";\nimport type { LineChartStaticConfig } from \"../../../entities/line-chart-static-layer\";\nimport { Op, type DType, type HostMsg, type LayerKind } from \"../../../shared/protocol\";\nimport {\n  LidarLayerHandle,\n  type LidarStride,\n  LineLayerHandle,\n  LineStaticLayerHandle,\n} from \"./layer-handles\";\n\n/**\n * TypedArray flavors that FluxionRender accepts. `ArrayBufferView` is too\n * permissive (includes DataView), so we narrow to the specific types whose\n * layout matches the worker-side `wrapTypedArray` contract.\n */\nexport type FluxionTypedArray =\n  | Float32Array\n  | Uint8Array\n  | Int16Array\n  | Uint16Array\n  | Int32Array;\n\nexport interface FluxionHostOptions {\n  /**\n   * Override the worker URL. Useful when bundlers don't support\n   * `new Worker(new URL('./fluxion-worker.js', import.meta.url))`.\n   * Pass a factory that returns a constructed Worker.\n   */\n  workerFactory?: () => Worker;\n}\n\nfunction defaultWorkerFactory(): Worker {\n  // Vite / modern bundlers resolve this to a separate worker chunk.\n  return new Worker(new URL(\"./fluxion-worker.js\", import.meta.url), {\n    type: \"module\",\n  });\n}\n\nfunction dtypeOf(arr: FluxionTypedArray): DType {\n  if (arr instanceof Float32Array) return \"f32\";\n  if (arr instanceof Uint8Array) return \"u8\";\n  if (arr instanceof Int16Array) return \"i16\";\n  if (arr instanceof Uint16Array) return \"u16\";\n  if (arr instanceof Int32Array) return \"i32\";\n  throw new Error(\"fluxion-render: unsupported TypedArray\");\n}\n\n/**\n * Main-thread handle to a worker-hosted rendering engine.\n *\n * Lifecycle:\n *   const host = new FluxionHost(canvas);\n *   host.addLayer('chart', 'line', { color: '#0ff' });\n *   host.pushData('chart', float32);   // transfers ownership\n *   host.resize(w, h, dpr);\n *   host.dispose();\n */\nexport class FluxionHost {\n  private worker: Worker;\n  private disposed = false;\n\n  constructor(canvas: HTMLCanvasElement, opts: FluxionHostOptions = {}) {\n    this.worker = (opts.workerFactory ?? defaultWorkerFactory)();\n\n    const offscreen = canvas.transferControlToOffscreen();\n    const dpr = typeof devicePixelRatio === \"number\" ? devicePixelRatio : 1;\n    const rect = canvas.getBoundingClientRect();\n    const width = rect.width || canvas.width || 300;\n    const height = rect.height || canvas.height || 150;\n\n    this.post(\n      {\n        op: Op.INIT,\n        canvas: offscreen,\n        width,\n        height,\n        dpr,\n      },\n      [offscreen],\n    );\n  }\n\n  /**\n   * Typed `addLayer` overloads.\n   *\n   * Prefer the kind-specific helpers below (`addLineLayer`, `addAxisLayer`,\n   * etc.) — they both type-check the config AND return a typed handle where\n   * applicable. This overload is retained for cases where the kind is chosen\n   * dynamically.\n   */\n  addLayer(id: string, kind: \"line\", config?: LineChartConfig): void;\n  addLayer(id: string, kind: \"line-static\", config?: LineChartStaticConfig): void;\n  addLayer(id: string, kind: \"lidar\", config?: LidarScatterConfig): void;\n  addLayer(id: string, kind: \"axis-grid\", config?: AxisGridConfig): void;\n  // Dynamic fallback for code paths that pass a runtime `LayerKind` (e.g.\n  // `useFluxionCanvas({ layers: FluxionLayerSpec[] })`).\n  addLayer(id: string, kind: LayerKind, config?: unknown): void;\n  addLayer(id: string, kind: LayerKind, config?: unknown): void {\n    this.post({ op: Op.ADD_LAYER, id, kind, config });\n  }\n\n  removeLayer(id: string): void {\n    this.post({ op: Op.REMOVE_LAYER, id });\n  }\n\n  /**\n   * Typed `configLayer` overloads — pick the config shape from the kind used\n   * when the layer was created. There's no runtime tag check; the caller is\n   * trusted to pass the right config for the right id.\n   */\n  configLayer(id: string, config: LineChartConfig): void;\n  configLayer(id: string, config: LineChartStaticConfig): void;\n  configLayer(id: string, config: LidarScatterConfig): void;\n  configLayer(id: string, config: AxisGridConfig): void;\n  // Dynamic fallback for helpers like `useLayerConfig` that carry an opaque\n  // config alongside the layer id.\n  configLayer(id: string, config: unknown): void;\n  configLayer(id: string, config: unknown): void {\n    this.post({ op: Op.CONFIG, id, config });\n  }\n\n  // ──────────────────────────────────────────────────────────────────────\n  // Typed add-layer helpers: construct + return a typed handle in one call.\n  // ──────────────────────────────────────────────────────────────────────\n\n  /**\n   * Add a streaming line layer and return a handle that accepts structured\n   * `{ t, y }` samples instead of raw Float32Array interleaved layout.\n   */\n  addLineLayer(id: string, config?: LineChartConfig): LineLayerHandle {\n    this.addLayer(id, \"line\", config);\n    return new LineLayerHandle(this, id);\n  }\n\n  /**\n   * Add a static xy line layer and return a handle that accepts\n   * `{ x, y }[]` or plain y-only arrays.\n   */\n  addLineStaticLayer(id: string, config?: LineChartStaticConfig): LineStaticLayerHandle {\n    this.addLayer(id, \"line-static\", config);\n    return new LineStaticLayerHandle(this, id);\n  }\n\n  /**\n   * Add a LiDAR scatter layer and return a handle that accepts\n   * `{ x, y, z?, intensity? }[]`. The handle's stride must match\n   * `config.stride` (default 4).\n   */\n  addLidarLayer(id: string, config?: LidarScatterConfig): LidarLayerHandle {\n    this.addLayer(id, \"lidar\", config);\n    const stride = (config?.stride as LidarStride | undefined) ?? 4;\n    return new LidarLayerHandle(this, id, stride);\n  }\n\n  /**\n   * Add an axis/grid layer. Axis layers don't take data, so this returns\n   * void — use `configLayer` to retune bounds / time window later.\n   */\n  addAxisLayer(id: string, config?: AxisGridConfig): void {\n    this.addLayer(id, \"axis-grid\", config);\n  }\n\n  // ──────────────────────────────────────────────────────────────────────\n  // Attach a typed handle to a layer that was added via another API path\n  // (e.g. declaratively through `<FluxionCanvas layers={...}>` or\n  // `useFluxionCanvas({ layers: [...] })`).\n  // ──────────────────────────────────────────────────────────────────────\n\n  line(id: string): LineLayerHandle {\n    return new LineLayerHandle(this, id);\n  }\n\n  lineStatic(id: string): LineStaticLayerHandle {\n    return new LineStaticLayerHandle(this, id);\n  }\n\n  lidar(id: string, stride: LidarStride = 4): LidarLayerHandle {\n    return new LidarLayerHandle(this, id, stride);\n  }\n\n  /**\n   * Push TypedArray data to a layer. Transfers the underlying ArrayBuffer —\n   * the caller MUST NOT use `data` again afterwards.\n   *\n   * The TypedArray must start at byteOffset 0 because the worker reconstructs\n   * the view at offset 0. Subviews would silently read from the wrong offset,\n   * so they're rejected up-front. Use `data.slice()` to get a fresh buffer.\n   */\n  pushData(id: string, data: FluxionTypedArray): void {\n    if (data.byteOffset !== 0) {\n      throw new Error(\n        `fluxion-render: TypedArray must start at byteOffset 0 (got ${data.byteOffset}). ` +\n          `Call .slice() to copy into a fresh buffer before pushing.`,\n      );\n    }\n    const buffer = data.buffer as ArrayBuffer;\n    this.post(\n      {\n        op: Op.DATA,\n        id,\n        buffer,\n        dtype: dtypeOf(data),\n        length: data.length,\n      },\n      [buffer],\n    );\n  }\n\n  resize(width: number, height: number, dpr: number): void {\n    this.post({ op: Op.RESIZE, width, height, dpr });\n  }\n\n  dispose(): void {\n    if (this.disposed) return;\n    this.disposed = true;\n    try {\n      this.post({ op: Op.DISPOSE });\n    } catch {\n      // worker may already be gone\n    }\n    this.worker.terminate();\n  }\n\n  private post(msg: HostMsg, transfer?: Transferable[]): void {\n    if (this.disposed) return;\n    if (transfer && transfer.length) {\n      this.worker.postMessage(msg, transfer);\n    } else {\n      this.worker.postMessage(msg);\n    }\n  }\n}\n"],"mappings":";;;;;AA6BO,IAAM,kBAAN,MAAsB;AAAA,EAC3B,YACmB,MACR,IACT;AAFiB;AACR;AAAA,EACR;AAAA,EAFgB;AAAA,EACR;AAAA;AAAA,EAIX,KAAK,QAA0B;AAC7B,UAAM,MAAM,IAAI,aAAa,CAAC;AAC9B,QAAI,CAAC,IAAI,OAAO;AAChB,QAAI,CAAC,IAAI,OAAO;AAChB,SAAK,KAAK,SAAS,KAAK,IAAI,GAAG;AAAA,EACjC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,UAAU,SAAsC;AAC9C,UAAM,IAAI,QAAQ;AAClB,QAAI,MAAM,EAAG;AACb,UAAM,MAAM,IAAI,aAAa,IAAI,CAAC;AAClC,aAAS,IAAI,GAAG,IAAI,GAAG,KAAK;AAC1B,YAAM,IAAI,QAAQ,CAAC;AACnB,UAAI,IAAI,CAAC,IAAI,EAAE;AACf,UAAI,IAAI,IAAI,CAAC,IAAI,EAAE;AAAA,IACrB;AACA,SAAK,KAAK,SAAS,KAAK,IAAI,GAAG;AAAA,EACjC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,QAAQ,MAA0B;AAChC,SAAK,KAAK,SAAS,KAAK,IAAI,IAAI;AAAA,EAClC;AACF;AAkBO,IAAM,wBAAN,MAA4B;AAAA,EACjC,YACmB,MACR,IACT;AAFiB;AACR;AAAA,EACR;AAAA,EAFgB;AAAA,EACR;AAAA,EAGX,MAAM,QAAkC;AACtC,UAAM,IAAI,OAAO;AACjB,UAAM,MAAM,IAAI,aAAa,IAAI,CAAC;AAClC,aAAS,IAAI,GAAG,IAAI,GAAG,KAAK;AAC1B,YAAM,IAAI,OAAO,CAAC;AAClB,UAAI,IAAI,CAAC,IAAI,EAAE;AACf,UAAI,IAAI,IAAI,CAAC,IAAI,EAAE;AAAA,IACrB;AACA,SAAK,KAAK,SAAS,KAAK,IAAI,GAAG;AAAA,EACjC;AAAA,EAEA,KAAK,QAAiC;AACpC,UAAM,MAAM,IAAI,aAAa,OAAO,MAAM;AAC1C,aAAS,IAAI,GAAG,IAAI,OAAO,QAAQ,IAAK,KAAI,CAAC,IAAI,OAAO,CAAC;AACzD,SAAK,KAAK,SAAS,KAAK,IAAI,GAAG;AAAA,EACjC;AAAA,EAEA,QAAQ,MAA0B;AAChC,SAAK,KAAK,SAAS,KAAK,IAAI,IAAI;AAAA,EAClC;AACF;AAsBO,IAAM,mBAAN,MAAuB;AAAA,EAC5B,YACmB,MACR,IACA,SAAsB,GAC/B;AAHiB;AACR;AACA;AAAA,EACR;AAAA,EAHgB;AAAA,EACR;AAAA,EACA;AAAA,EAGX,KAAK,QAAqC;AACxC,UAAM,SAAS,KAAK;AACpB,UAAM,IAAI,OAAO;AACjB,UAAM,MAAM,IAAI,aAAa,IAAI,MAAM;AACvC,aAAS,IAAI,GAAG,IAAI,GAAG,KAAK;AAC1B,YAAM,IAAI,OAAO,CAAC;AAClB,YAAM,IAAI,IAAI;AACd,UAAI,CAAC,IAAI,EAAE;AACX,UAAI,IAAI,CAAC,IAAI,EAAE;AACf,UAAI,UAAU,EAAG,KAAI,IAAI,CAAC,IAAI,EAAE,KAAK;AACrC,UAAI,UAAU,EAAG,KAAI,IAAI,CAAC,IAAI,EAAE,aAAa;AAAA,IAC/C;AACA,SAAK,KAAK,SAAS,KAAK,IAAI,GAAG;AAAA,EACjC;AAAA,EAEA,QAAQ,MAA0B;AAChC,SAAK,KAAK,SAAS,KAAK,IAAI,IAAI;AAAA,EAClC;AACF;;;AC9HA,SAAS,uBAA+B;AAEtC,SAAO,IAAI,OAAO,IAAI,IAAI,uBAAuB,YAAY,GAAG,GAAG;AAAA,IACjE,MAAM;AAAA,EACR,CAAC;AACH;AAEA,SAAS,QAAQ,KAA+B;AAC9C,MAAI,eAAe,aAAc,QAAO;AACxC,MAAI,eAAe,WAAY,QAAO;AACtC,MAAI,eAAe,WAAY,QAAO;AACtC,MAAI,eAAe,YAAa,QAAO;AACvC,MAAI,eAAe,WAAY,QAAO;AACtC,QAAM,IAAI,MAAM,wCAAwC;AAC1D;AAYO,IAAM,cAAN,MAAkB;AAAA,EACf;AAAA,EACA,WAAW;AAAA,EAEnB,YAAY,QAA2B,OAA2B,CAAC,GAAG;AACpE,SAAK,UAAU,KAAK,iBAAiB,sBAAsB;AAE3D,UAAM,YAAY,OAAO,2BAA2B;AACpD,UAAM,MAAM,OAAO,qBAAqB,WAAW,mBAAmB;AACtE,UAAM,OAAO,OAAO,sBAAsB;AAC1C,UAAM,QAAQ,KAAK,SAAS,OAAO,SAAS;AAC5C,UAAM,SAAS,KAAK,UAAU,OAAO,UAAU;AAE/C,SAAK;AAAA,MACH;AAAA,QACE,IAAI,GAAG;AAAA,QACP,QAAQ;AAAA,QACR;AAAA,QACA;AAAA,QACA;AAAA,MACF;AAAA,MACA,CAAC,SAAS;AAAA,IACZ;AAAA,EACF;AAAA,EAiBA,SAAS,IAAY,MAAiB,QAAwB;AAC5D,SAAK,KAAK,EAAE,IAAI,GAAG,WAAW,IAAI,MAAM,OAAO,CAAC;AAAA,EAClD;AAAA,EAEA,YAAY,IAAkB;AAC5B,SAAK,KAAK,EAAE,IAAI,GAAG,cAAc,GAAG,CAAC;AAAA,EACvC;AAAA,EAcA,YAAY,IAAY,QAAuB;AAC7C,SAAK,KAAK,EAAE,IAAI,GAAG,QAAQ,IAAI,OAAO,CAAC;AAAA,EACzC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUA,aAAa,IAAY,QAA2C;AAClE,SAAK,SAAS,IAAI,QAAQ,MAAM;AAChC,WAAO,IAAI,gBAAgB,MAAM,EAAE;AAAA,EACrC;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,mBAAmB,IAAY,QAAuD;AACpF,SAAK,SAAS,IAAI,eAAe,MAAM;AACvC,WAAO,IAAI,sBAAsB,MAAM,EAAE;AAAA,EAC3C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,cAAc,IAAY,QAA+C;AACvE,SAAK,SAAS,IAAI,SAAS,MAAM;AACjC,UAAM,SAAU,QAAQ,UAAsC;AAC9D,WAAO,IAAI,iBAAiB,MAAM,IAAI,MAAM;AAAA,EAC9C;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,aAAa,IAAY,QAA+B;AACtD,SAAK,SAAS,IAAI,aAAa,MAAM;AAAA,EACvC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,KAAK,IAA6B;AAChC,WAAO,IAAI,gBAAgB,MAAM,EAAE;AAAA,EACrC;AAAA,EAEA,WAAW,IAAmC;AAC5C,WAAO,IAAI,sBAAsB,MAAM,EAAE;AAAA,EAC3C;AAAA,EAEA,MAAM,IAAY,SAAsB,GAAqB;AAC3D,WAAO,IAAI,iBAAiB,MAAM,IAAI,MAAM;AAAA,EAC9C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUA,SAAS,IAAY,MAA+B;AAClD,QAAI,KAAK,eAAe,GAAG;AACzB,YAAM,IAAI;AAAA,QACR,8DAA8D,KAAK,UAAU;AAAA,MAE/E;AAAA,IACF;AACA,UAAM,SAAS,KAAK;AACpB,SAAK;AAAA,MACH;AAAA,QACE,IAAI,GAAG;AAAA,QACP;AAAA,QACA;AAAA,QACA,OAAO,QAAQ,IAAI;AAAA,QACnB,QAAQ,KAAK;AAAA,MACf;AAAA,MACA,CAAC,MAAM;AAAA,IACT;AAAA,EACF;AAAA,EAEA,OAAO,OAAe,QAAgB,KAAmB;AACvD,SAAK,KAAK,EAAE,IAAI,GAAG,QAAQ,OAAO,QAAQ,IAAI,CAAC;AAAA,EACjD;AAAA,EAEA,UAAgB;AACd,QAAI,KAAK,SAAU;AACnB,SAAK,WAAW;AAChB,QAAI;AACF,WAAK,KAAK,EAAE,IAAI,GAAG,QAAQ,CAAC;AAAA,IAC9B,QAAQ;AAAA,IAER;AACA,SAAK,OAAO,UAAU;AAAA,EACxB;AAAA,EAEQ,KAAK,KAAc,UAAiC;AAC1D,QAAI,KAAK,SAAU;AACnB,QAAI,YAAY,SAAS,QAAQ;AAC/B,WAAK,OAAO,YAAY,KAAK,QAAQ;AAAA,IACvC,OAAO;AACL,WAAK,OAAO,YAAY,GAAG;AAAA,IAC7B;AAAA,EACF;AACF;","names":[]}

package/dist/chunk-R7FLS7BG.js

@@ -0,0 +1,15 @@
+// src/shared/protocol/protocol.ts
+var Op = {
+  INIT: 1,
+  RESIZE: 2,
+  ADD_LAYER: 3,
+  REMOVE_LAYER: 4,
+  CONFIG: 5,
+  DATA: 6,
+  DISPOSE: 7
+};
+
+export {
+  Op
+};
+//# sourceMappingURL=chunk-R7FLS7BG.js.map

package/dist/chunk-R7FLS7BG.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/shared/protocol/protocol.ts"],"sourcesContent":["/**\n * Binary message protocol between main-thread `FluxionHost` and worker `Engine`.\n * Uses a plain const object (not const enum) so consumers with\n * `isolatedModules` can import types safely from the published package.\n */\nexport const Op = {\n  INIT: 1,\n  RESIZE: 2,\n  ADD_LAYER: 3,\n  REMOVE_LAYER: 4,\n  CONFIG: 5,\n  DATA: 6,\n  DISPOSE: 7,\n} as const;\nexport type Op = (typeof Op)[keyof typeof Op];\n\nexport type LayerKind = \"line\" | \"line-static\" | \"lidar\" | \"axis-grid\";\n\nexport type DType = \"f32\" | \"u8\" | \"i16\" | \"u16\" | \"i32\";\n\nexport interface InitMsg {\n  op: typeof Op.INIT;\n  canvas: OffscreenCanvas;\n  width: number;\n  height: number;\n  dpr: number;\n}\n\nexport interface ResizeMsg {\n  op: typeof Op.RESIZE;\n  width: number;\n  height: number;\n  dpr: number;\n}\n\nexport interface AddLayerMsg {\n  op: typeof Op.ADD_LAYER;\n  id: string;\n  kind: LayerKind;\n  config?: unknown;\n}\n\nexport interface RemoveLayerMsg {\n  op: typeof Op.REMOVE_LAYER;\n  id: string;\n}\n\nexport interface ConfigMsg {\n  op: typeof Op.CONFIG;\n  id: string;\n  config: unknown;\n}\n\nexport interface DataMsg {\n  op: typeof Op.DATA;\n  id: string;\n  buffer: ArrayBuffer;\n  dtype: DType;\n  length: number;\n}\n\nexport interface DisposeMsg {\n  op: typeof Op.DISPOSE;\n}\n\nexport type HostMsg =\n  | InitMsg\n  | ResizeMsg\n  | AddLayerMsg\n  | RemoveLayerMsg\n  | ConfigMsg\n  | DataMsg\n  | DisposeMsg;\n"],"mappings":";AAKO,IAAM,KAAK;AAAA,EAChB,MAAM;AAAA,EACN,QAAQ;AAAA,EACR,WAAW;AAAA,EACX,cAAc;AAAA,EACd,QAAQ;AAAA,EACR,MAAM;AAAA,EACN,SAAS;AACX;","names":[]}

package/dist/fluxion-host-C_n0cGQO.d.ts

@@ -0,0 +1,319 @@
+interface AxisGridConfig {
+    /** Fixed x-range. Used when `xMode` is "fixed" (default). */
+    xRange?: [number, number];
+    yRange?: [number, number];
+    gridColor?: string;
+    axisColor?: string;
+    labelColor?: string;
+    font?: string;
+    targetTicks?: number;
+    /** If true (default), writes this layer's bounds into `viewport` so data layers share them. */
+    applyToViewport?: boolean;
+    /**
+     * "fixed": xRange is literal world units (default).
+     * "time": bounds follow the streaming `viewport.latestT` as a trailing
+     * sliding window `[latestT - timeWindowMs, latestT]`. yRange is still fixed.
+     */
+    xMode?: "fixed" | "time";
+    /** Width of the sliding window in ms when xMode="time". Default 5000. */
+    timeWindowMs?: number;
+    /**
+     * Absolute wall-clock epoch (ms) corresponding to data timestamp `0`. When
+     * set together with `xMode: "time"`, tick labels render as wall clock
+     * instead of elapsed seconds. Typically set once at host creation:
+     * `timeOrigin: Date.now()` on the main thread.
+     */
+    timeOrigin?: number;
+    /**
+     * Clock-pattern string used to render x tick labels when `xMode: "time"`
+     * AND `timeOrigin` is set. Default `"HH:mm:ss"`. Supported tokens:
+     * `HH / H / mm / m / ss / s / SSS / S`. Anything else is a literal.
+     *
+     * Ignored when `timeOrigin` is not provided — elapsed-seconds fallback
+     * (`"X.Xs"`) is used instead.
+     */
+    xTickFormat?: string;
+    /**
+     * "fixed" (default): use configured `yRange`.
+     * "auto": data-driven. Reads `viewport.observedYMin/Max` during draw,
+     * applies padding and clamps, updates `bounds.yMin/yMax`. Requires at
+     * least one data layer (e.g. `LineChartLayer`) in the stack to publish
+     * observations via its `scan()` pass.
+     */
+    yMode?: "fixed" | "auto";
+    /** Padding ratio applied above/below the observed range. Default 0.1 (10%). */
+    yAutoPadding?: number;
+    /** Absolute lower clamp after padding. */
+    yAutoMin?: number;
+    /** Absolute upper clamp after padding. */
+    yAutoMax?: number;
+    /** Show vertical grid lines at x ticks. */
+    showXGrid?: boolean;
+    /** Show horizontal grid lines at y ticks. */
+    showYGrid?: boolean;
+    /** Show the x=0 / y=0 axis lines when 0 is inside the range. */
+    showAxes?: boolean;
+    /** Show tick labels along the x axis. */
+    showXLabels?: boolean;
+    /** Show tick labels along the y axis. */
+    showYLabels?: boolean;
+}
+
+interface LidarScatterConfig {
+    /** Floats per point. Default 4 (x,y,z,intensity). Minimum 2 (x,y). */
+    stride?: number;
+    /** Point size in pixels. */
+    pointSize?: number;
+    /** Max intensity value for normalization (0..1). Default 1.0. */
+    intensityMax?: number;
+    /** Solid color override. When set, intensity LUT is ignored. */
+    color?: string;
+}
+
+interface LineChartConfig {
+    color?: string;
+    lineWidth?: number;
+    /** Ring buffer capacity (number of [t,y] samples retained). Default 2048. */
+    capacity?: number;
+}
+
+interface LineChartStaticConfig {
+    color?: string;
+    lineWidth?: number;
+    /**
+     * Data layout:
+     * - "xy" (default): interleaved [x,y,x,y,...] stride=2
+     * - "y": [y0,y1,...] with implicit x = linear sweep across `viewport.bounds.x`
+     */
+    layout?: "xy" | "y";
+}
+
+/**
+ * Binary message protocol between main-thread `FluxionHost` and worker `Engine`.
+ * Uses a plain const object (not const enum) so consumers with
+ * `isolatedModules` can import types safely from the published package.
+ */
+declare const Op: {
+    readonly INIT: 1;
+    readonly RESIZE: 2;
+    readonly ADD_LAYER: 3;
+    readonly REMOVE_LAYER: 4;
+    readonly CONFIG: 5;
+    readonly DATA: 6;
+    readonly DISPOSE: 7;
+};
+type Op = (typeof Op)[keyof typeof Op];
+type LayerKind = "line" | "line-static" | "lidar" | "axis-grid";
+type DType = "f32" | "u8" | "i16" | "u16" | "i32";
+interface InitMsg {
+    op: typeof Op.INIT;
+    canvas: OffscreenCanvas;
+    width: number;
+    height: number;
+    dpr: number;
+}
+interface ResizeMsg {
+    op: typeof Op.RESIZE;
+    width: number;
+    height: number;
+    dpr: number;
+}
+interface AddLayerMsg {
+    op: typeof Op.ADD_LAYER;
+    id: string;
+    kind: LayerKind;
+    config?: unknown;
+}
+interface RemoveLayerMsg {
+    op: typeof Op.REMOVE_LAYER;
+    id: string;
+}
+interface ConfigMsg {
+    op: typeof Op.CONFIG;
+    id: string;
+    config: unknown;
+}
+interface DataMsg {
+    op: typeof Op.DATA;
+    id: string;
+    buffer: ArrayBuffer;
+    dtype: DType;
+    length: number;
+}
+interface DisposeMsg {
+    op: typeof Op.DISPOSE;
+}
+type HostMsg = InitMsg | ResizeMsg | AddLayerMsg | RemoveLayerMsg | ConfigMsg | DataMsg | DisposeMsg;
+
+/**
+ * Type-safe layer handles.
+ *
+ * These wrap the raw `FluxionHost.pushData(id, Float32Array)` API so callers
+ * can work with structured records on the main thread (e.g. after receiving
+ * ROS messages or processing sensor frames) without hand-rolling the
+ * interleaved Float32Array layout every time.
+ *
+ * Each handle is a thin encoder: the input shape is type-checked at the call
+ * site, encoding to the worker-side layout happens once, and the underlying
+ * ArrayBuffer is still transferred zero-copy.
+ */
+interface FluxionDataSink {
+    pushData(id: string, data: Float32Array): void;
+}
+/** One streaming sample. `t` is host-relative ms (what `axis-grid` time mode expects). */
+interface LineSample {
+    t: number;
+    y: number;
+}
+declare class LineLayerHandle {
+    private readonly sink;
+    readonly id: string;
+    constructor(sink: FluxionDataSink, id: string);
+    /** Push a single `[t, y]` sample. Allocates a 2-element Float32Array. */
+    push(sample: LineSample): void;
+    /**
+     * Push an array of samples in one postMessage. Encodes into a single
+     * contiguous Float32Array and transfers ownership. Prefer this over a loop
+     * of `push()` when you already have a batch in hand.
+     */
+    pushBatch(samples: readonly LineSample[]): void;
+    /**
+     * Escape hatch: push a pre-built `[t, y, t, y, ...]` Float32Array directly.
+     * Use for hot paths where you can avoid the object-to-array encode step.
+     * The TypedArray's byteOffset must be 0 (same rule as `pushData`).
+     */
+    pushRaw(data: Float32Array): void;
+}
+interface XyPoint {
+    x: number;
+    y: number;
+}
+/**
+ * Handle for `kind: "line-static"` layers. `setXY` replaces the entire series
+ * with a new xy array; `setY` does the same with y-only data (x is computed
+ * from the layer's configured x range). Use the variant that matches the
+ * layer's `layout` config — this is not enforced at the type level since the
+ * worker-side layout is a runtime config.
+ */
+declare class LineStaticLayerHandle {
+    private readonly sink;
+    readonly id: string;
+    constructor(sink: FluxionDataSink, id: string);
+    setXY(points: readonly XyPoint[]): void;
+    setY(values: readonly number[]): void;
+    pushRaw(data: Float32Array): void;
+}
+interface LidarPoint {
+    x: number;
+    y: number;
+    /** Optional when the layer stride is 2. Defaults to 0 otherwise. */
+    z?: number;
+    /** Optional when the layer stride is <4. Defaults to 0 otherwise. */
+    intensity?: number;
+}
+type LidarStride = 2 | 3 | 4;
+/**
+ * Handle for `kind: "lidar"` scatter layers. The stride (2 = xy, 3 = xyz,
+ * 4 = xyz+intensity) must match the layer's stride config. Passing a
+ * mismatched stride will succeed but the worker will read the wrong fields.
+ */
+declare class LidarLayerHandle {
+    private readonly sink;
+    readonly id: string;
+    readonly stride: LidarStride;
+    constructor(sink: FluxionDataSink, id: string, stride?: LidarStride);
+    push(points: readonly LidarPoint[]): void;
+    pushRaw(data: Float32Array): void;
+}
+
+/**
+ * TypedArray flavors that FluxionRender accepts. `ArrayBufferView` is too
+ * permissive (includes DataView), so we narrow to the specific types whose
+ * layout matches the worker-side `wrapTypedArray` contract.
+ */
+type FluxionTypedArray = Float32Array | Uint8Array | Int16Array | Uint16Array | Int32Array;
+interface FluxionHostOptions {
+    /**
+     * Override the worker URL. Useful when bundlers don't support
+     * `new Worker(new URL('./fluxion-worker.js', import.meta.url))`.
+     * Pass a factory that returns a constructed Worker.
+     */
+    workerFactory?: () => Worker;
+}
+/**
+ * Main-thread handle to a worker-hosted rendering engine.
+ *
+ * Lifecycle:
+ *   const host = new FluxionHost(canvas);
+ *   host.addLayer('chart', 'line', { color: '#0ff' });
+ *   host.pushData('chart', float32);   // transfers ownership
+ *   host.resize(w, h, dpr);
+ *   host.dispose();
+ */
+declare class FluxionHost {
+    private worker;
+    private disposed;
+    constructor(canvas: HTMLCanvasElement, opts?: FluxionHostOptions);
+    /**
+     * Typed `addLayer` overloads.
+     *
+     * Prefer the kind-specific helpers below (`addLineLayer`, `addAxisLayer`,
+     * etc.) — they both type-check the config AND return a typed handle where
+     * applicable. This overload is retained for cases where the kind is chosen
+     * dynamically.
+     */
+    addLayer(id: string, kind: "line", config?: LineChartConfig): void;
+    addLayer(id: string, kind: "line-static", config?: LineChartStaticConfig): void;
+    addLayer(id: string, kind: "lidar", config?: LidarScatterConfig): void;
+    addLayer(id: string, kind: "axis-grid", config?: AxisGridConfig): void;
+    addLayer(id: string, kind: LayerKind, config?: unknown): void;
+    removeLayer(id: string): void;
+    /**
+     * Typed `configLayer` overloads — pick the config shape from the kind used
+     * when the layer was created. There's no runtime tag check; the caller is
+     * trusted to pass the right config for the right id.
+     */
+    configLayer(id: string, config: LineChartConfig): void;
+    configLayer(id: string, config: LineChartStaticConfig): void;
+    configLayer(id: string, config: LidarScatterConfig): void;
+    configLayer(id: string, config: AxisGridConfig): void;
+    configLayer(id: string, config: unknown): void;
+    /**
+     * Add a streaming line layer and return a handle that accepts structured
+     * `{ t, y }` samples instead of raw Float32Array interleaved layout.
+     */
+    addLineLayer(id: string, config?: LineChartConfig): LineLayerHandle;
+    /**
+     * Add a static xy line layer and return a handle that accepts
+     * `{ x, y }[]` or plain y-only arrays.
+     */
+    addLineStaticLayer(id: string, config?: LineChartStaticConfig): LineStaticLayerHandle;
+    /**
+     * Add a LiDAR scatter layer and return a handle that accepts
+     * `{ x, y, z?, intensity? }[]`. The handle's stride must match
+     * `config.stride` (default 4).
+     */
+    addLidarLayer(id: string, config?: LidarScatterConfig): LidarLayerHandle;
+    /**
+     * Add an axis/grid layer. Axis layers don't take data, so this returns
+     * void — use `configLayer` to retune bounds / time window later.
+     */
+    addAxisLayer(id: string, config?: AxisGridConfig): void;
+    line(id: string): LineLayerHandle;
+    lineStatic(id: string): LineStaticLayerHandle;
+    lidar(id: string, stride?: LidarStride): LidarLayerHandle;
+    /**
+     * Push TypedArray data to a layer. Transfers the underlying ArrayBuffer —
+     * the caller MUST NOT use `data` again afterwards.
+     *
+     * The TypedArray must start at byteOffset 0 because the worker reconstructs
+     * the view at offset 0. Subviews would silently read from the wrong offset,
+     * so they're rejected up-front. Use `data.slice()` to get a fresh buffer.
+     */
+    pushData(id: string, data: FluxionTypedArray): void;
+    resize(width: number, height: number, dpr: number): void;
+    dispose(): void;
+    private post;
+}
+
+export { type AxisGridConfig as A, type DType as D, type FluxionDataSink as F, type HostMsg as H, type LayerKind as L, type XyPoint as X, FluxionHost as a, type FluxionHostOptions as b, type FluxionTypedArray as c, LidarLayerHandle as d, type LidarPoint as e, type LidarScatterConfig as f, type LidarStride as g, type LineChartConfig as h, type LineChartStaticConfig as i, LineLayerHandle as j, type LineSample as k, LineStaticLayerHandle as l };

package/dist/fluxion-worker.d.ts

@@ -0,0 +1,2 @@
+
+export {  }