@heojeongbo/fluxion-render 0.2.0

package/dist/fluxion-worker.js

@@ -0,0 +1,816 @@
+import {
+  formatClock
+} from "./chunk-3PK3KDO5.js";
+import {
+  Op
+} from "./chunk-R7FLS7BG.js";
+
+// src/shared/lib/math.ts
+function niceStep(range, targetTicks) {
+  const rough = range / Math.max(1, targetTicks);
+  const pow10 = Math.pow(10, Math.floor(Math.log10(rough)));
+  const norm = rough / pow10;
+  let nice;
+  if (norm < 1.5) nice = 1;
+  else if (norm < 3) nice = 2;
+  else if (norm < 7) nice = 5;
+  else nice = 10;
+  return nice * pow10;
+}
+function niceTicks(min, max, targetTicks = 6) {
+  if (!isFinite(min) || !isFinite(max) || max <= min) return [];
+  const step = niceStep(max - min, targetTicks);
+  const start = Math.ceil(min / step) * step;
+  const out = [];
+  for (let v = start; v <= max + step * 1e-6; v += step) {
+    out.push(Number(v.toFixed(12)));
+  }
+  return out;
+}
+
+// src/entities/axis-grid-layer/model/axis-grid-layer.ts
+var AxisGridLayer = class {
+  id;
+  gridColor = "rgba(255,255,255,0.08)";
+  axisColor = "rgba(255,255,255,0.4)";
+  labelColor = "rgba(255,255,255,0.7)";
+  font = "10px sans-serif";
+  targetTicks = 6;
+  bounds = { xMin: -1, xMax: 1, yMin: -1, yMax: 1 };
+  applyToViewport = true;
+  xMode = "fixed";
+  timeWindowMs = 5e3;
+  timeOrigin = null;
+  xTickFormat = "HH:mm:ss";
+  yMode = "fixed";
+  yAutoPadding = 0.1;
+  yAutoMin;
+  yAutoMax;
+  showXGrid = true;
+  showYGrid = true;
+  showAxes = true;
+  showXLabels = true;
+  showYLabels = true;
+  constructor(id) {
+    this.id = id;
+  }
+  setConfig(config) {
+    const c = config;
+    if (c.xRange) {
+      this.bounds.xMin = c.xRange[0];
+      this.bounds.xMax = c.xRange[1];
+    }
+    if (c.yRange) {
+      this.bounds.yMin = c.yRange[0];
+      this.bounds.yMax = c.yRange[1];
+    }
+    if (c.gridColor) this.gridColor = c.gridColor;
+    if (c.axisColor) this.axisColor = c.axisColor;
+    if (c.labelColor) this.labelColor = c.labelColor;
+    if (c.font) this.font = c.font;
+    if (c.targetTicks) this.targetTicks = c.targetTicks;
+    if (c.applyToViewport !== void 0) this.applyToViewport = c.applyToViewport;
+    if (c.xMode !== void 0) this.xMode = c.xMode;
+    if (c.timeWindowMs !== void 0) this.timeWindowMs = c.timeWindowMs;
+    if (c.timeOrigin !== void 0) this.timeOrigin = c.timeOrigin;
+    if (c.xTickFormat !== void 0) this.xTickFormat = c.xTickFormat;
+    if (c.yMode !== void 0) this.yMode = c.yMode;
+    if (c.yAutoPadding !== void 0) this.yAutoPadding = c.yAutoPadding;
+    if (c.yAutoMin !== void 0) this.yAutoMin = c.yAutoMin;
+    if (c.yAutoMax !== void 0) this.yAutoMax = c.yAutoMax;
+    if (c.showXGrid !== void 0) this.showXGrid = c.showXGrid;
+    if (c.showYGrid !== void 0) this.showYGrid = c.showYGrid;
+    if (c.showAxes !== void 0) this.showAxes = c.showAxes;
+    if (c.showXLabels !== void 0) this.showXLabels = c.showXLabels;
+    if (c.showYLabels !== void 0) this.showYLabels = c.showYLabels;
+  }
+  setData(_buffer, _length, _viewport) {
+  }
+  resize(_viewport) {
+  }
+  /**
+   * Orchestration pass: establish x bounds so data layers' `scan` can filter
+   * visible samples correctly. yMode:"auto" is finalized in `draw` after all
+   * line layers have published their observations.
+   */
+  scan(viewport) {
+    if (this.xMode === "time") {
+      const latestT = viewport.latestT;
+      this.bounds.xMin = latestT - this.timeWindowMs;
+      this.bounds.xMax = latestT;
+    }
+    if (this.applyToViewport) {
+      viewport.setBounds(this.bounds);
+    }
+  }
+  draw(ctx, viewport) {
+    if (this.yMode === "auto") {
+      let yMin = viewport.observedYMin;
+      let yMax = viewport.observedYMax;
+      if (!Number.isFinite(yMin) || !Number.isFinite(yMax)) {
+        yMin = this.bounds.yMin;
+        yMax = this.bounds.yMax;
+        if (yMin === yMax) {
+          yMin = -1;
+          yMax = 1;
+        }
+      } else if (yMin === yMax) {
+        yMin -= 0.5;
+        yMax += 0.5;
+      } else {
+        const pad = (yMax - yMin) * this.yAutoPadding;
+        yMin -= pad;
+        yMax += pad;
+      }
+      if (this.yAutoMin !== void 0 && yMin < this.yAutoMin) yMin = this.yAutoMin;
+      if (this.yAutoMax !== void 0 && yMax > this.yAutoMax) yMax = this.yAutoMax;
+      this.bounds.yMin = yMin;
+      this.bounds.yMax = yMax;
+      if (this.applyToViewport) viewport.setBounds(this.bounds);
+    }
+    const { widthPx: w, heightPx: h } = viewport;
+    const xTicks = niceTicks(this.bounds.xMin, this.bounds.xMax, this.targetTicks);
+    const yTicks = niceTicks(this.bounds.yMin, this.bounds.yMax, this.targetTicks);
+    if (this.showXGrid || this.showYGrid) {
+      ctx.strokeStyle = this.gridColor;
+      ctx.lineWidth = 1;
+      ctx.beginPath();
+      if (this.showXGrid) {
+        for (let i = 0; i < xTicks.length; i++) {
+          const x = Math.round(viewport.xToPx(xTicks[i])) + 0.5;
+          ctx.moveTo(x, 0);
+          ctx.lineTo(x, h);
+        }
+      }
+      if (this.showYGrid) {
+        for (let i = 0; i < yTicks.length; i++) {
+          const y = Math.round(viewport.yToPx(yTicks[i])) + 0.5;
+          ctx.moveTo(0, y);
+          ctx.lineTo(w, y);
+        }
+      }
+      ctx.stroke();
+    }
+    if (this.showAxes) {
+      ctx.strokeStyle = this.axisColor;
+      ctx.beginPath();
+      if (this.bounds.xMin < 0 && this.bounds.xMax > 0) {
+        const x0 = Math.round(viewport.xToPx(0)) + 0.5;
+        ctx.moveTo(x0, 0);
+        ctx.lineTo(x0, h);
+      }
+      if (this.bounds.yMin < 0 && this.bounds.yMax > 0) {
+        const y0 = Math.round(viewport.yToPx(0)) + 0.5;
+        ctx.moveTo(0, y0);
+        ctx.lineTo(w, y0);
+      }
+      ctx.stroke();
+    }
+    if (this.showXLabels || this.showYLabels) {
+      ctx.fillStyle = this.labelColor;
+      ctx.font = this.font;
+      if (this.showXLabels) {
+        ctx.textBaseline = "top";
+        for (let i = 0; i < xTicks.length; i++) {
+          const x = viewport.xToPx(xTicks[i]);
+          ctx.fillText(
+            formatTick(xTicks[i], this.xMode, this.timeOrigin, this.xTickFormat),
+            x + 2,
+            h - 12
+          );
+        }
+      }
+      if (this.showYLabels) {
+        ctx.textBaseline = "middle";
+        for (let i = 0; i < yTicks.length; i++) {
+          const y = viewport.yToPx(yTicks[i]);
+          ctx.fillText(String(yTicks[i]), 2, y - 6);
+        }
+      }
+    }
+  }
+  dispose() {
+  }
+};
+function formatTick(value, mode, timeOrigin, pattern) {
+  if (mode === "time") {
+    if (timeOrigin != null) {
+      return formatClock(timeOrigin + value, pattern);
+    }
+    const s = value / 1e3;
+    return `${s.toFixed(1)}s`;
+  }
+  return String(value);
+}
+
+// src/entities/layer-stack/model/layer-stack.ts
+var LayerStack = class {
+  layers = [];
+  byId = /* @__PURE__ */ new Map();
+  add(layer) {
+    this.layers.push(layer);
+    this.byId.set(layer.id, layer);
+  }
+  remove(id) {
+    const layer = this.byId.get(id);
+    if (!layer) return;
+    this.byId.delete(id);
+    const i = this.layers.indexOf(layer);
+    if (i >= 0) this.layers.splice(i, 1);
+    layer.dispose();
+  }
+  get(id) {
+    return this.byId.get(id);
+  }
+  resizeAll(viewport) {
+    for (let i = 0; i < this.layers.length; i++) {
+      this.layers[i].resize(viewport);
+    }
+  }
+  /**
+   * Pre-draw pass. Layers that implement `scan` update shared viewport state
+   * (bounds, observed extents) here so downstream layers' `draw` sees the
+   * correct values. Iterates in insertion order so axis-grid (added first)
+   * writes bounds before data layers read them.
+   */
+  scanAll(viewport) {
+    for (let i = 0; i < this.layers.length; i++) {
+      this.layers[i].scan?.(viewport);
+    }
+  }
+  drawAll(ctx, viewport) {
+    for (let i = 0; i < this.layers.length; i++) {
+      this.layers[i].draw(ctx, viewport);
+    }
+  }
+  disposeAll() {
+    for (let i = 0; i < this.layers.length; i++) {
+      this.layers[i].dispose();
+    }
+    this.layers.length = 0;
+    this.byId.clear();
+  }
+};
+
+// src/shared/lib/color.ts
+var LUT_SIZE = 256;
+var lutR = new Uint8ClampedArray(LUT_SIZE);
+var lutG = new Uint8ClampedArray(LUT_SIZE);
+var lutB = new Uint8ClampedArray(LUT_SIZE);
+function ramp(t) {
+  const stops = [
+    [0, [13, 8, 135]],
+    [0.25, [84, 2, 163]],
+    [0.5, [156, 23, 158]],
+    [0.75, [225, 100, 98]],
+    [1, [240, 249, 33]]
+  ];
+  for (let i = 0; i < stops.length - 1; i++) {
+    const [t0, c0] = stops[i];
+    const [t1, c1] = stops[i + 1];
+    if (t <= t1) {
+      const k = (t - t0) / (t1 - t0);
+      return [
+        c0[0] + (c1[0] - c0[0]) * k,
+        c0[1] + (c1[1] - c0[1]) * k,
+        c0[2] + (c1[2] - c0[2]) * k
+      ];
+    }
+  }
+  return stops[stops.length - 1][1];
+}
+for (let i = 0; i < LUT_SIZE; i++) {
+  const [r, g, b] = ramp(i / (LUT_SIZE - 1));
+  lutR[i] = r;
+  lutG[i] = g;
+  lutB[i] = b;
+}
+var SINGLETON = Object.freeze({
+  r: lutR,
+  g: lutG,
+  b: lutB,
+  size: LUT_SIZE
+});
+function intensityLUT() {
+  return SINGLETON;
+}
+
+// src/entities/lidar-scatter-layer/model/lidar-scatter-layer.ts
+var LUT_BUCKETS = 256;
+var LidarScatterLayer = class {
+  id;
+  stride = 4;
+  pointSize = 2;
+  intensityMax = 1;
+  solidColor = null;
+  data = null;
+  length = 0;
+  // Scratch buffers for counting-sort batching.
+  sortedX = new Float32Array(0);
+  sortedY = new Float32Array(0);
+  bucketCount = new Uint32Array(LUT_BUCKETS);
+  bucketOffset = new Uint32Array(LUT_BUCKETS);
+  scratchCapacity = 0;
+  constructor(id) {
+    this.id = id;
+  }
+  setConfig(config) {
+    const c = config;
+    if (c.stride !== void 0) this.stride = Math.max(2, c.stride | 0);
+    if (c.pointSize !== void 0) this.pointSize = Math.max(1, c.pointSize);
+    if (c.intensityMax !== void 0) this.intensityMax = c.intensityMax;
+    if (c.color !== void 0) this.solidColor = parseColor(c.color);
+  }
+  setData(buffer, length, _viewport) {
+    this.data = new Float32Array(buffer, 0, length);
+    this.length = length;
+  }
+  resize(_viewport) {
+  }
+  draw(ctx, viewport) {
+    const data = this.data;
+    if (!data || this.length < this.stride) return;
+    const stride = this.stride;
+    const size = this.pointSize;
+    const half = size / 2;
+    const count = this.length / stride | 0;
+    if (this.solidColor) {
+      this.drawSolid(ctx, viewport, data, stride, count, size, half);
+      return;
+    }
+    this.ensureScratch(count);
+    this.drawBucketed(ctx, viewport, data, stride, count, size, half);
+  }
+  drawSolid(ctx, viewport, data, stride, count, size, half) {
+    const [r, g, b] = this.solidColor;
+    ctx.fillStyle = `rgb(${r},${g},${b})`;
+    ctx.beginPath();
+    for (let i = 0; i < count; i++) {
+      const o = i * stride;
+      const px = viewport.xToPx(data[o]);
+      const py = viewport.yToPx(data[o + 1]);
+      ctx.rect(px - half, py - half, size, size);
+    }
+    ctx.fill();
+  }
+  drawBucketed(ctx, viewport, data, stride, count, size, half) {
+    const lut = intensityLUT();
+    const invMax = 1 / (this.intensityMax || 1);
+    const sortedX = this.sortedX;
+    const sortedY = this.sortedY;
+    const bucketCount = this.bucketCount;
+    const bucketOffset = this.bucketOffset;
+    bucketCount.fill(0);
+    for (let i = 0; i < count; i++) {
+      const o = i * stride;
+      const intensity = stride >= 4 ? data[o + 3] : 1;
+      let idx = intensity * invMax * (LUT_BUCKETS - 1) | 0;
+      if (idx < 0) idx = 0;
+      else if (idx >= LUT_BUCKETS) idx = LUT_BUCKETS - 1;
+      bucketCount[idx]++;
+    }
+    let acc = 0;
+    for (let b = 0; b < LUT_BUCKETS; b++) {
+      bucketOffset[b] = acc;
+      acc += bucketCount[b];
+    }
+    const writeCursor = bucketCount;
+    for (let b = 0; b < LUT_BUCKETS; b++) writeCursor[b] = 0;
+    for (let i = 0; i < count; i++) {
+      const o = i * stride;
+      const intensity = stride >= 4 ? data[o + 3] : 1;
+      let idx = intensity * invMax * (LUT_BUCKETS - 1) | 0;
+      if (idx < 0) idx = 0;
+      else if (idx >= LUT_BUCKETS) idx = LUT_BUCKETS - 1;
+      const pos = bucketOffset[idx] + writeCursor[idx];
+      writeCursor[idx]++;
+      sortedX[pos] = viewport.xToPx(data[o]);
+      sortedY[pos] = viewport.yToPx(data[o + 1]);
+    }
+    for (let b = 0; b < LUT_BUCKETS; b++) {
+      const n = writeCursor[b];
+      if (n === 0) continue;
+      ctx.fillStyle = `rgb(${lut.r[b]},${lut.g[b]},${lut.b[b]})`;
+      ctx.beginPath();
+      const start = bucketOffset[b];
+      const end = start + n;
+      for (let i = start; i < end; i++) {
+        ctx.rect(sortedX[i] - half, sortedY[i] - half, size, size);
+      }
+      ctx.fill();
+    }
+  }
+  ensureScratch(count) {
+    if (count <= this.scratchCapacity) return;
+    const next = Math.max(count, Math.ceil(this.scratchCapacity * 1.25), 1024);
+    this.sortedX = new Float32Array(next);
+    this.sortedY = new Float32Array(next);
+    this.scratchCapacity = next;
+  }
+  dispose() {
+    this.data = null;
+    this.sortedX = new Float32Array(0);
+    this.sortedY = new Float32Array(0);
+    this.scratchCapacity = 0;
+  }
+};
+function parseColor(css) {
+  if (css.startsWith("#")) {
+    const hex = css.slice(1);
+    if (hex.length === 3) {
+      return [
+        parseInt(hex[0] + hex[0], 16),
+        parseInt(hex[1] + hex[1], 16),
+        parseInt(hex[2] + hex[2], 16)
+      ];
+    }
+    if (hex.length === 6) {
+      return [
+        parseInt(hex.slice(0, 2), 16),
+        parseInt(hex.slice(2, 4), 16),
+        parseInt(hex.slice(4, 6), 16)
+      ];
+    }
+  }
+  return [255, 255, 255];
+}
+
+// src/shared/model/ring-buffer.ts
+var RingBuffer = class {
+  stride;
+  capacity;
+  data;
+  head = 0;
+  count = 0;
+  constructor(capacity, stride) {
+    this.capacity = capacity;
+    this.stride = stride;
+    this.data = new Float32Array(capacity * stride);
+  }
+  get length() {
+    return this.count;
+  }
+  push(record) {
+    const base = this.head * this.stride;
+    for (let i = 0; i < this.stride; i++) {
+      this.data[base + i] = record[i];
+    }
+    this.head = (this.head + 1) % this.capacity;
+    if (this.count < this.capacity) this.count++;
+  }
+  pushMany(records) {
+    const recCount = records.length / this.stride;
+    for (let r = 0; r < recCount; r++) {
+      const base = this.head * this.stride;
+      const src = r * this.stride;
+      for (let i = 0; i < this.stride; i++) {
+        this.data[base + i] = records[src + i];
+      }
+      this.head = (this.head + 1) % this.capacity;
+      if (this.count < this.capacity) this.count++;
+    }
+  }
+  forEach(fn) {
+    const start = this.count < this.capacity ? 0 : this.head;
+    for (let i = 0; i < this.count; i++) {
+      const slot = (start + i) % this.capacity;
+      fn(this.data, slot * this.stride, i);
+    }
+  }
+  clear() {
+    this.head = 0;
+    this.count = 0;
+  }
+};
+
+// src/entities/line-chart-layer/model/line-chart-layer.ts
+var LineChartLayer = class {
+  id;
+  color = "#4fc3f7";
+  lineWidth = 1;
+  ring;
+  constructor(id) {
+    this.id = id;
+    this.ring = new RingBuffer(2048, 2);
+  }
+  setConfig(config) {
+    const c = config;
+    if (c.color !== void 0) this.color = c.color;
+    if (c.lineWidth !== void 0) this.lineWidth = c.lineWidth;
+    if (c.capacity !== void 0 && c.capacity !== this.ring.capacity) {
+      this.ring = new RingBuffer(c.capacity, 2);
+    }
+  }
+  setData(buffer, length, viewport) {
+    if (length < 2) return;
+    const arr = new Float32Array(buffer, 0, length);
+    this.ring.pushMany(arr);
+    const t = arr[length - 2];
+    if (t > viewport.latestT) viewport.latestT = t;
+  }
+  resize(_viewport) {
+  }
+  /**
+   * Pre-draw pass: compute the visible-window min/max of y values in this
+   * layer's ring buffer and merge them into `viewport.observedYMin/Max`.
+   * AxisGridLayer with `yMode: "auto"` reads the aggregate in draw.
+   *
+   * `viewport.bounds.xMin` was already written by AxisGridLayer.scan (which
+   * runs earlier in insertion order), so we can filter stale samples here.
+   */
+  scan(viewport) {
+    if (this.ring.length === 0) return;
+    const xMin = viewport.bounds.xMin;
+    let localMin = viewport.observedYMin;
+    let localMax = viewport.observedYMax;
+    this.ring.forEach((data, off) => {
+      const t = data[off];
+      if (t < xMin) return;
+      const y = data[off + 1];
+      if (y < localMin) localMin = y;
+      if (y > localMax) localMax = y;
+    });
+    viewport.observedYMin = localMin;
+    viewport.observedYMax = localMax;
+  }
+  draw(ctx, viewport) {
+    if (this.ring.length < 2) return;
+    ctx.strokeStyle = this.color;
+    ctx.lineWidth = this.lineWidth;
+    ctx.beginPath();
+    const xMin = viewport.bounds.xMin;
+    let first = true;
+    this.ring.forEach((data, off) => {
+      const t = data[off];
+      if (t < xMin) return;
+      const px = viewport.xToPx(t);
+      const py = viewport.yToPx(data[off + 1]);
+      if (first) {
+        ctx.moveTo(px, py);
+        first = false;
+      } else {
+        ctx.lineTo(px, py);
+      }
+    });
+    ctx.stroke();
+  }
+  dispose() {
+    this.ring.clear();
+  }
+};
+
+// src/entities/line-chart-static-layer/model/line-chart-static-layer.ts
+var LineChartStaticLayer = class {
+  id;
+  color = "#4fc3f7";
+  lineWidth = 1;
+  layout = "xy";
+  data = null;
+  length = 0;
+  constructor(id) {
+    this.id = id;
+  }
+  setConfig(config) {
+    const c = config;
+    if (c.color !== void 0) this.color = c.color;
+    if (c.lineWidth !== void 0) this.lineWidth = c.lineWidth;
+    if (c.layout !== void 0) this.layout = c.layout;
+  }
+  setData(buffer, length, _viewport) {
+    this.data = new Float32Array(buffer, 0, length);
+    this.length = length;
+  }
+  resize(_viewport) {
+  }
+  draw(ctx, viewport) {
+    const data = this.data;
+    if (!data || this.length < 2) return;
+    ctx.strokeStyle = this.color;
+    ctx.lineWidth = this.lineWidth;
+    ctx.beginPath();
+    if (this.layout === "xy") {
+      const n = this.length >> 1;
+      if (n < 2) return;
+      ctx.moveTo(viewport.xToPx(data[0]), viewport.yToPx(data[1]));
+      for (let i = 1; i < n; i++) {
+        const j = i * 2;
+        ctx.lineTo(viewport.xToPx(data[j]), viewport.yToPx(data[j + 1]));
+      }
+    } else {
+      const n = this.length;
+      const xMin = viewport.bounds.xMin;
+      const xMax = viewport.bounds.xMax;
+      const step = (xMax - xMin) / Math.max(1, n - 1);
+      ctx.moveTo(viewport.xToPx(xMin), viewport.yToPx(data[0]));
+      for (let i = 1; i < n; i++) {
+        ctx.lineTo(viewport.xToPx(xMin + i * step), viewport.yToPx(data[i]));
+      }
+    }
+    ctx.stroke();
+  }
+  dispose() {
+    this.data = null;
+  }
+};
+
+// src/shared/model/scheduler.ts
+var Scheduler = class {
+  dirty = false;
+  running = false;
+  raf = null;
+  tick;
+  constructor(tick) {
+    this.tick = tick;
+  }
+  start() {
+    if (this.running) return;
+    this.running = true;
+    this.loop();
+  }
+  stop() {
+    this.running = false;
+    if (this.raf != null) {
+      if (typeof cancelAnimationFrame !== "undefined") {
+        cancelAnimationFrame(this.raf);
+      } else {
+        clearTimeout(this.raf);
+      }
+      this.raf = null;
+    }
+  }
+  markDirty() {
+    this.dirty = true;
+  }
+  loop = () => {
+    if (!this.running) return;
+    if (this.dirty) {
+      this.dirty = false;
+      this.tick();
+    }
+    if (typeof requestAnimationFrame !== "undefined") {
+      this.raf = requestAnimationFrame(this.loop);
+    } else {
+      this.raf = setTimeout(this.loop, 16);
+    }
+  };
+};
+
+// src/shared/model/viewport.ts
+var Viewport = class {
+  widthPx = 0;
+  heightPx = 0;
+  dpr = 1;
+  bounds = { xMin: -1, xMax: 1, yMin: -1, yMax: 1 };
+  /**
+   * Most recent data timestamp (ms, host-relative) seen across all streaming
+   * layers. Streaming `LineChartLayer` updates this on setData; `AxisGridLayer`
+   * in time mode uses it to compute a sliding window.
+   */
+  latestT = 0;
+  /**
+   * Per-frame aggregate of observed y values across all data layers that
+   * currently overlap the visible time window. `AxisGridLayer` in
+   * `yMode: "auto"` reads these in draw to compute bounds.yMin/yMax.
+   *
+   * Initialised to +/-Infinity by `beginScan()` at the top of every frame,
+   * then layers merge their visible-window min/max in via `scan()`.
+   */
+  observedYMin = Number.POSITIVE_INFINITY;
+  observedYMax = Number.NEGATIVE_INFINITY;
+  setSize(width, height, dpr) {
+    this.widthPx = width;
+    this.heightPx = height;
+    this.dpr = dpr;
+  }
+  setBounds(b) {
+    this.bounds = b;
+  }
+  /** Called by Engine at the start of each render frame before scan pass. */
+  beginScan() {
+    this.observedYMin = Number.POSITIVE_INFINITY;
+    this.observedYMax = Number.NEGATIVE_INFINITY;
+  }
+  xToPx(x) {
+    const { xMin, xMax } = this.bounds;
+    return (x - xMin) / (xMax - xMin) * this.widthPx;
+  }
+  yToPx(y) {
+    const { yMin, yMax } = this.bounds;
+    return this.heightPx - (y - yMin) / (yMax - yMin) * this.heightPx;
+  }
+};
+
+// src/features/engine/model/engine.ts
+function createLayer(id, kind) {
+  switch (kind) {
+    case "line":
+      return new LineChartLayer(id);
+    case "line-static":
+      return new LineChartStaticLayer(id);
+    case "lidar":
+      return new LidarScatterLayer(id);
+    case "axis-grid":
+      return new AxisGridLayer(id);
+  }
+}
+var Engine = class {
+  canvas = null;
+  ctx = null;
+  viewport = new Viewport();
+  stack = new LayerStack();
+  scheduler;
+  bgColor = "#0b0d12";
+  constructor() {
+    this.scheduler = new Scheduler(() => this.render());
+  }
+  dispatch(msg) {
+    switch (msg.op) {
+      case Op.INIT:
+        this.init(msg.canvas, msg.width, msg.height, msg.dpr);
+        break;
+      case Op.RESIZE:
+        this.resize(msg.width, msg.height, msg.dpr);
+        break;
+      case Op.ADD_LAYER: {
+        const layer = createLayer(msg.id, msg.kind);
+        if (msg.config !== void 0) layer.setConfig(msg.config);
+        layer.resize(this.viewport);
+        this.stack.add(layer);
+        this.scheduler.markDirty();
+        break;
+      }
+      case Op.REMOVE_LAYER:
+        this.stack.remove(msg.id);
+        this.scheduler.markDirty();
+        break;
+      case Op.CONFIG: {
+        const layer = this.stack.get(msg.id);
+        if (layer) {
+          layer.setConfig(msg.config);
+          this.scheduler.markDirty();
+        }
+        break;
+      }
+      case Op.DATA: {
+        const layer = this.stack.get(msg.id);
+        if (layer) {
+          layer.setData(msg.buffer, msg.length, this.viewport);
+          this.scheduler.markDirty();
+        }
+        break;
+      }
+      case Op.DISPOSE:
+        this.dispose();
+        break;
+    }
+  }
+  init(canvas, width, height, dpr) {
+    this.canvas = canvas;
+    this.ctx = canvas.getContext("2d");
+    this.resize(width, height, dpr);
+    this.scheduler.start();
+    this.scheduler.markDirty();
+  }
+  resize(width, height, dpr) {
+    if (!this.canvas) return;
+    this.canvas.width = Math.max(1, Math.round(width * dpr));
+    this.canvas.height = Math.max(1, Math.round(height * dpr));
+    this.viewport.setSize(width, height, dpr);
+    this.stack.resizeAll(this.viewport);
+    this.scheduler.markDirty();
+  }
+  render() {
+    const ctx = this.ctx;
+    if (!ctx || !this.canvas) return;
+    this.viewport.beginScan();
+    this.stack.scanAll(this.viewport);
+    const { dpr } = this.viewport;
+    ctx.setTransform(dpr, 0, 0, dpr, 0, 0);
+    ctx.fillStyle = this.bgColor;
+    ctx.fillRect(0, 0, this.viewport.widthPx, this.viewport.heightPx);
+    this.stack.drawAll(ctx, this.viewport);
+  }
+  dispose() {
+    this.scheduler.stop();
+    this.stack.disposeAll();
+    this.canvas = null;
+    this.ctx = null;
+  }
+};
+
+// src/app/worker/fluxion-worker.ts
+var engine = new Engine();
+self.onmessage = (e) => {
+  try {
+    engine.dispatch(e.data);
+  } catch (err) {
+    console.error("[fluxion-worker] dispatch error:", err);
+  }
+};
+self.addEventListener("error", (e) => {
+  console.error("[fluxion-worker] uncaught error:", e.message ?? e);
+});
+self.addEventListener("messageerror", (e) => {
+  console.error("[fluxion-worker] message deserialization failed:", e);
+});
+//# sourceMappingURL=fluxion-worker.js.map