@camstack/addon-pipeline 0.1.19 → 0.2.0

package/dist/pipeline-runner/index.js

@@ -1,1860 +1,2060 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+const require_dist = require("../dist-7ewQjTle.js");
+let _camstack_shm_ring = require("@camstack/shm-ring");
+//#region src/pipeline-runner/frame-queue.ts
+/**
+* Latest-frame-only buffer. Keeps only the most recent item, dropping all
+* older items immediately. This ensures inference always runs on the
+* freshest available frame, never accumulating a backlog regardless of
+* inference latency.
+*
+* ## Buffer ownership (Phase 5 / D9 Task 7b)
+*
+* Frames arrive from the shm frame plane via a `FrameRingReader`, whose
+* `FrameRead.pixels` is **borrowed** — a view onto the reader's reusable
+* scratch buffer, valid only until that reader's next read (see
+* `@camstack/shm-ring`'s `FrameRead` contract). Both queue consumers retain
+* the frame PAST the next read:
+*
+*   - the **motion** queue is drained by the scheduler's `tick`, not by the
+*     poller that read the frame — and the poller drains a burst of handles
+*     per poll, so even handle #2's read would clobber handle #1's pixels;
+*   - the **detection** queue is drained asynchronously after a semaphore wait
+*     and a 10s–100s ms inference.
+*
+* In both cases holding the borrowed buffer is silent corruption. So
+* `enqueue` runs the queue's injected `clone` function which copies the
+* pixels into queue-owned storage at the retention boundary. The queue is
+* latest-only (capacity 1), so this is exactly one allocation per *queued*
+* frame — bounded by the scheduler/inference cadence, NOT per *read* frame.
+* The high-frequency per-read allocation that failed the D9 perf gate is
+* eliminated; this bounded copy-on-retain is the correct cost.
+*
+* The generic parameter `T` lets the detection path queue a
+* `{ frame, handle }` entry (Task 7 — propagating the `FrameHandle`
+* through to the inference-result event), while the motion path keeps
+* queueing bare `DecodedFrame`s. Each instance provides its own
+* `clone` so the inner pixel buffer is detached at the same retention
+* boundary regardless of the wrapping entry shape.
+*/
+var FrameQueue = class {
+	maxSize;
+	latest = null;
+	_droppedFrames = 0;
+	clone;
+	/**
+	* `clone` runs on every {@link enqueue} to detach a queue-owned copy from
+	* the (possibly borrowed) source — required by the D9 Task 7b ownership
+	* contract above. Motion call sites pass {@link ownFrame}; the detection
+	* path passes a clone that copies its inner frame's pixel buffer.
+	*/
+	constructor(maxSize, clone) {
+		this.maxSize = maxSize;
+		this.clone = clone;
+	}
+	enqueue(item) {
+		if (this.latest !== null) this._droppedFrames++;
+		this.latest = this.clone(item);
+	}
+	dequeue() {
+		const item = this.latest ?? void 0;
+		this.latest = null;
+		return item;
+	}
+	get size() {
+		return this.latest !== null ? 1 : 0;
+	}
+	get droppedFrames() {
+		return this._droppedFrames;
+	}
+	clear() {
+		this.latest = null;
+	}
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
-const index = require("../index-BbPPvoCx.js");
-const shmRing = require("@camstack/shm-ring");
-class FrameQueue {
-  /**
-   * `clone` runs on every {@link enqueue} to detach a queue-owned copy from
-   * the (possibly borrowed) source — required by the D9 Task 7b ownership
-   * contract above. Motion call sites pass {@link ownFrame}; the detection
-   * path passes a clone that copies its inner frame's pixel buffer.
-   */
-  constructor(maxSize, clone) {
-    this.maxSize = maxSize;
-    this.clone = clone;
-  }
-  latest = null;
-  _droppedFrames = 0;
-  clone;
-  enqueue(item) {
-    if (this.latest !== null) {
-      this._droppedFrames++;
-    }
-    this.latest = this.clone(item);
-  }
-  dequeue() {
-    const item = this.latest ?? void 0;
-    this.latest = null;
-    return item;
-  }
-  get size() {
-    return this.latest !== null ? 1 : 0;
-  }
-  get droppedFrames() {
-    return this._droppedFrames;
-  }
-  clear() {
-    this.latest = null;
-  }
-}
+/**
+* Return a copy of `frame` whose `data` is queue-owned — a detached
+* `Buffer.from` of the (possibly borrowed) source pixels. Every other field is
+* a plain value and is carried through unchanged; any extra non-`DecodedFrame`
+* property the runner pins on a frame (e.g. `_enqueuedAt`) is preserved by the
+* spread so downstream timing accounting is unaffected.
+*/
 function ownFrame(frame) {
-  return { ...frame, data: Buffer.from(frame.data) };
-}
-class Semaphore {
-  _concurrency;
-  _available;
-  waiters = [];
-  constructor(concurrency) {
-    this._concurrency = concurrency;
-    this._available = concurrency;
-  }
-  get concurrency() {
-    return this._concurrency;
-  }
-  get available() {
-    return this._available;
-  }
-  /**
-   * Change the concurrency limit at runtime. Growing wakes as many
-   * pending waiters as possible without exceeding the new headroom;
-   * shrinking simply caps `_available` to `max(0, _available + delta)`.
-   * In-flight permits are never revoked — the excess will drain
-   * naturally as existing callers release.
-   */
-  resize(newConcurrency) {
-    if (newConcurrency < 1) throw new Error("Semaphore: concurrency must be >= 1");
-    const delta = newConcurrency - this._concurrency;
-    this._concurrency = newConcurrency;
-    this._available = Math.max(0, this._available + delta);
-    while (this._available > 0 && this.waiters.length > 0) {
-      const next = this.waiters.shift();
-      if (next) next();
-    }
-  }
-  async acquire() {
-    if (this._available > 0) {
-      this._available--;
-      return () => this.release();
-    }
-    return new Promise((resolve) => {
-      this.waiters.push(() => {
-        this._available--;
-        resolve(() => this.release());
-      });
-    });
-  }
-  release() {
-    this._available++;
-    const next = this.waiters.shift();
-    if (next) next();
-  }
-}
-const REPORT_INTERVAL_MS = 1e4;
-class PipelineTimingSampler {
-  detSamples = /* @__PURE__ */ new Map();
-  motSamples = /* @__PURE__ */ new Map();
-  audioSamples = /* @__PURE__ */ new Map();
-  droppedFrames = 0;
-  reportTimer = null;
-  log = null;
-  runtimeInfo = {};
-  setLogger(logger) {
-    this.log = logger;
-  }
-  start() {
-    if (this.reportTimer) return;
-    this.reportTimer = setInterval(() => this.report(), REPORT_INTERVAL_MS);
-  }
-  stop() {
-    if (this.reportTimer) {
-      clearInterval(this.reportTimer);
-      this.reportTimer = null;
-    }
-  }
-  addSample(deviceId, s) {
-    if (!this.detSamples.has(deviceId)) this.detSamples.set(deviceId, []);
-    this.detSamples.get(deviceId).push(s);
-  }
-  addMotionSample(deviceId, ms, frameAge = -1) {
-    if (!this.motSamples.has(deviceId)) this.motSamples.set(deviceId, []);
-    this.motSamples.get(deviceId).push({ ms, frameAge });
-  }
-  addAudioSample(deviceId, s) {
-    if (!this.audioSamples.has(deviceId)) this.audioSamples.set(deviceId, []);
-    this.audioSamples.get(deviceId).push(s);
-  }
-  addDrop() {
-    this.droppedFrames++;
-  }
-  report() {
-    if (!this.log) return;
-    const dropped = this.droppedFrames;
-    this.droppedFrames = 0;
-    const avg = (arr) => arr.length > 0 ? Math.round(arr.reduce((a, b) => a + b, 0) / arr.length) : 0;
-    const max = (arr) => arr.length > 0 ? Math.round(Math.max(...arr)) : 0;
-    const p95 = (arr) => {
-      if (arr.length === 0) return 0;
-      const sorted = [...arr].sort((a, b) => a - b);
-      return Math.round(sorted[Math.floor(sorted.length * 0.95)] ?? sorted[sorted.length - 1]);
-    };
-    const rt = this.runtimeInfo;
-    for (const [deviceId, det] of this.detSamples) {
-      if (det.length === 0) continue;
-      const e2e = det.map((s) => s.endToEnd);
-      const inf = det.map((s) => s.inference);
-      const frameAge = det.map((s) => s.frameAge).filter((v) => v >= 0);
-      const totalDet = det.reduce((s, d) => s + d.detections, 0);
-      this.log.info(
-        "pipeline stats",
-        {
-          tags: { deviceId },
-          meta: {
-            frames: det.length,
-            intervalSec: REPORT_INTERVAL_MS / 1e3,
-            // enqueue → emit, in ms. Stage breakdown (avg) exposes WHERE the
-            // latency sits: queue backlog vs semaphore contention vs inference
-            // vs result-emit. inference is usually the floor (model chain).
-            e2e: { avg: avg(e2e), p95: p95(e2e), max: max(e2e) },
-            // Frame age (capture→inference-pick): if large, the analyzed frame is
-            // already stale (decoder/ring behind), which delays the overlay
-            // regardless of how fast the result is delivered.
-            frameAge: { avg: avg(frameAge), p95: p95(frameAge), max: max(frameAge) },
-            stagesMs: {
-              queueWait: avg(det.map((s) => s.queueWait)),
-              semaphoreWait: avg(det.map((s) => s.semaphoreWait)),
-              inference: avg(inf),
-              resultToEmit: avg(det.map((s) => s.resultToEmit))
-            },
-            inference: { avg: avg(inf), p95: p95(inf) },
-            detections: totalDet,
-            dropped,
-            pipelineRuntime: rt.pipelineRuntime ?? null,
-            pipelineModels: rt.pipelineModels ?? null
-          }
-        }
-      );
-    }
-    this.detSamples.clear();
-    for (const [deviceId, mot] of this.motSamples) {
-      if (mot.length === 0) continue;
-      const ms = mot.map((s) => s.ms);
-      const frameAge = mot.map((s) => s.frameAge).filter((v) => v >= 0);
-      this.log.info(
-        "motion stats",
-        {
-          tags: { deviceId },
-          meta: {
-            frames: mot.length,
-            intervalSec: REPORT_INTERVAL_MS / 1e3,
-            avg: avg(ms),
-            p95: p95(ms),
-            max: max(ms),
-            // Frame age at motion analysis (capture→analysis). Large = stale
-            // input frame (decoder/ring behind) → motion box lags real movement.
-            frameAge: { avg: avg(frameAge), p95: p95(frameAge), max: max(frameAge) }
-          }
-        }
-      );
-    }
-    this.motSamples.clear();
-    for (const [deviceId, aud] of this.audioSamples) {
-      if (aud.length === 0) continue;
-      const classifyTimes = aud.filter((a) => a.classifyMs > 0).map((a) => a.classifyMs);
-      const classified = aud.filter((a) => a.topLabel !== null);
-      const topLabels = /* @__PURE__ */ new Map();
-      for (const a of classified) {
-        if (a.topLabel) topLabels.set(a.topLabel, (topLabels.get(a.topLabel) ?? 0) + 1);
-      }
-      const topSummary = [...topLabels.entries()].sort((a, b) => b[1] - a[1]).slice(0, 3).map(([l, c]) => `${l}×${c}`).join(", ");
-      const avgDbfs = avg(aud.map((a) => Math.round(a.dbfs)));
-      this.log.info(
-        "audio stats",
-        {
-          tags: { deviceId },
-          meta: {
-            chunks: aud.length,
-            intervalSec: REPORT_INTERVAL_MS / 1e3,
-            classified: classified.length,
-            classifyAvgMs: classifyTimes.length > 0 ? avg(classifyTimes) : 0,
-            avgDbfs,
-            topLabels: topSummary,
-            audioEngine: rt.audioEngine ?? null
-          }
-        }
-      );
-    }
-    this.audioSamples.clear();
-  }
+	return {
+		...frame,
+		data: Buffer.from(frame.data)
+	};
 }
+//#endregion
+//#region src/pipeline-runner/semaphore.ts
+/**
+* Counting semaphore with FIFO waiter queue. Used by the runner to bound
+* concurrent inference invocations across all attached cameras.
+*
+* The concurrency limit is **mutable** via `resize()` so the
+* pipeline-runner addon can hot-reload `maxConcurrentInferences` without
+* tearing down and restarting the runner. In-flight permits are
+* preserved: shrinking the limit just lowers the headroom until existing
+* releases catch up; growing it wakes pending waiters immediately.
+*/
+var Semaphore = class {
+	_concurrency;
+	_available;
+	waiters = [];
+	constructor(concurrency) {
+		this._concurrency = concurrency;
+		this._available = concurrency;
+	}
+	get concurrency() {
+		return this._concurrency;
+	}
+	get available() {
+		return this._available;
+	}
+	/**
+	* Change the concurrency limit at runtime. Growing wakes as many
+	* pending waiters as possible without exceeding the new headroom;
+	* shrinking simply caps `_available` to `max(0, _available + delta)`.
+	* In-flight permits are never revoked — the excess will drain
+	* naturally as existing callers release.
+	*/
+	resize(newConcurrency) {
+		if (newConcurrency < 1) throw new Error("Semaphore: concurrency must be >= 1");
+		const delta = newConcurrency - this._concurrency;
+		this._concurrency = newConcurrency;
+		this._available = Math.max(0, this._available + delta);
+		while (this._available > 0 && this.waiters.length > 0) {
+			const next = this.waiters.shift();
+			if (next) next();
+		}
+	}
+	async acquire() {
+		if (this._available > 0) {
+			this._available--;
+			return () => this.release();
+		}
+		return new Promise((resolve) => {
+			this.waiters.push(() => {
+				this._available--;
+				resolve(() => this.release());
+			});
+		});
+	}
+	release() {
+		this._available++;
+		const next = this.waiters.shift();
+		if (next) next();
+	}
+};
+//#endregion
+//#region src/pipeline-runner/timing-sampler.ts
+var REPORT_INTERVAL_MS = 1e4;
+/**
+* Periodic timing-stats sampler. Accumulates per-camera samples for the
+* detection pipeline (capture → enqueue → semaphore → inference → emit),
+* motion analysis, and audio classification, and logs aggregated stats
+* every REPORT_INTERVAL_MS.
+*/
+var PipelineTimingSampler = class {
+	detSamples = /* @__PURE__ */ new Map();
+	motSamples = /* @__PURE__ */ new Map();
+	audioSamples = /* @__PURE__ */ new Map();
+	droppedFrames = 0;
+	reportTimer = null;
+	log = null;
+	runtimeInfo = {};
+	setLogger(logger) {
+		this.log = logger;
+	}
+	start() {
+		if (this.reportTimer) return;
+		this.reportTimer = setInterval(() => this.report(), REPORT_INTERVAL_MS);
+	}
+	stop() {
+		if (this.reportTimer) {
+			clearInterval(this.reportTimer);
+			this.reportTimer = null;
+		}
+	}
+	addSample(deviceId, s) {
+		if (!this.detSamples.has(deviceId)) this.detSamples.set(deviceId, []);
+		this.detSamples.get(deviceId).push(s);
+	}
+	addMotionSample(deviceId, ms, frameAge = -1) {
+		if (!this.motSamples.has(deviceId)) this.motSamples.set(deviceId, []);
+		this.motSamples.get(deviceId).push({
+			ms,
+			frameAge
+		});
+	}
+	addAudioSample(deviceId, s) {
+		if (!this.audioSamples.has(deviceId)) this.audioSamples.set(deviceId, []);
+		this.audioSamples.get(deviceId).push(s);
+	}
+	addDrop() {
+		this.droppedFrames++;
+	}
+	report() {
+		if (!this.log) return;
+		const dropped = this.droppedFrames;
+		this.droppedFrames = 0;
+		const avg = (arr) => arr.length > 0 ? Math.round(arr.reduce((a, b) => a + b, 0) / arr.length) : 0;
+		const max = (arr) => arr.length > 0 ? Math.round(Math.max(...arr)) : 0;
+		const p95 = (arr) => {
+			if (arr.length === 0) return 0;
+			const sorted = [...arr].toSorted((a, b) => a - b);
+			return Math.round(sorted[Math.floor(sorted.length * .95)] ?? sorted[sorted.length - 1]);
+		};
+		const rt = this.runtimeInfo;
+		for (const [deviceId, det] of this.detSamples) {
+			if (det.length === 0) continue;
+			const e2e = det.map((s) => s.endToEnd);
+			const inf = det.map((s) => s.inference);
+			const frameAge = det.map((s) => s.frameAge).filter((v) => v >= 0);
+			const totalDet = det.reduce((s, d) => s + d.detections, 0);
+			this.log.info("pipeline stats", {
+				tags: { deviceId },
+				meta: {
+					frames: det.length,
+					intervalSec: REPORT_INTERVAL_MS / 1e3,
+					e2e: {
+						avg: avg(e2e),
+						p95: p95(e2e),
+						max: max(e2e)
+					},
+					frameAge: {
+						avg: avg(frameAge),
+						p95: p95(frameAge),
+						max: max(frameAge)
+					},
+					stagesMs: {
+						queueWait: avg(det.map((s) => s.queueWait)),
+						semaphoreWait: avg(det.map((s) => s.semaphoreWait)),
+						inference: avg(inf),
+						resultToEmit: avg(det.map((s) => s.resultToEmit))
+					},
+					inference: {
+						avg: avg(inf),
+						p95: p95(inf)
+					},
+					detections: totalDet,
+					dropped,
+					pipelineRuntime: rt.pipelineRuntime ?? null,
+					pipelineModels: rt.pipelineModels ?? null
+				}
+			});
+		}
+		this.detSamples.clear();
+		for (const [deviceId, mot] of this.motSamples) {
+			if (mot.length === 0) continue;
+			const ms = mot.map((s) => s.ms);
+			const frameAge = mot.map((s) => s.frameAge).filter((v) => v >= 0);
+			this.log.info("motion stats", {
+				tags: { deviceId },
+				meta: {
+					frames: mot.length,
+					intervalSec: REPORT_INTERVAL_MS / 1e3,
+					avg: avg(ms),
+					p95: p95(ms),
+					max: max(ms),
+					frameAge: {
+						avg: avg(frameAge),
+						p95: p95(frameAge),
+						max: max(frameAge)
+					}
+				}
+			});
+		}
+		this.motSamples.clear();
+		for (const [deviceId, aud] of this.audioSamples) {
+			if (aud.length === 0) continue;
+			const classifyTimes = aud.filter((a) => a.classifyMs > 0).map((a) => a.classifyMs);
+			const classified = aud.filter((a) => a.topLabel !== null);
+			const topLabels = /* @__PURE__ */ new Map();
+			for (const a of classified) if (a.topLabel) topLabels.set(a.topLabel, (topLabels.get(a.topLabel) ?? 0) + 1);
+			const topSummary = [...topLabels.entries()].toSorted((a, b) => b[1] - a[1]).slice(0, 3).map(([l, c]) => `${l}×${c}`).join(", ");
+			const avgDbfs = avg(aud.map((a) => Math.round(a.dbfs)));
+			this.log.info("audio stats", {
+				tags: { deviceId },
+				meta: {
+					chunks: aud.length,
+					intervalSec: REPORT_INTERVAL_MS / 1e3,
+					classified: classified.length,
+					classifyAvgMs: classifyTimes.length > 0 ? avg(classifyTimes) : 0,
+					avgDbfs,
+					topLabels: topSummary,
+					audioEngine: rt.audioEngine ?? null
+				}
+			});
+		}
+		this.audioSamples.clear();
+	}
+};
+//#endregion
+//#region src/pipeline-runner/runner.ts
+/**
+* Clone a {@link DetectionQueueEntry} for the queue's copy-on-retain
+* boundary: the inner frame's pixel buffer is detached via
+* {@link ownFrame}, the `FrameHandle` is carried through unchanged (it's
+* a plain serialisable record with no borrowed buffers).
+*/
 function ownDetectionEntry(entry) {
-  return { frame: ownFrame(entry.frame), handle: entry.handle };
+	return {
+		frame: ownFrame(entry.frame),
+		handle: entry.handle
+	};
 }
-const DEFAULT_MOTION_COOLDOWN_MS = 3e4;
+var DEFAULT_MOTION_COOLDOWN_MS = 3e4;
 function toFrameInput$1(frame) {
-  return {
-    data: frame.data,
-    width: frame.width,
-    height: frame.height,
-    format: frame.format,
-    timestamp: frame.timestamp
-  };
+	return {
+		data: frame.data,
+		width: frame.width,
+		height: frame.height,
+		format: frame.format,
+		timestamp: frame.timestamp
+	};
 }
-class PipelineRunner {
-  // Config is mutable (not `readonly`) because `updateLimits()` hot-reloads
-  // the four tuning fields when the pipeline-runner addon's
-  // `updateAddonSettings` is invoked via the new three-level settings API.
-  // The callbacks (`processFrame`, `analyzeMotion`) are invariants captured
-  // at construction and never changed.
-  config;
-  cameras = /* @__PURE__ */ new Map();
-  semaphore;
-  resultCallbacks = [];
-  defaultRoundRobinKeys = [];
-  defaultRoundRobinIndex = 0;
-  intervalHandle = null;
-  detectionStreamHandler = null;
-  logger;
-  timingSampler = new PipelineTimingSampler();
-  constructor(config) {
-    this.config = config;
-    this.logger = config.logger;
-    this.semaphore = new Semaphore(config.maxConcurrentInferences);
-  }
-  /**
-   * Hot-reload the four tuning fields without tearing down the runner.
-   * - `maxConcurrentInferences`: resized on the live semaphore; in-flight
-   *   permits are preserved, new capacity is available immediately.
-   * - `maxQueueDepth`: new `FrameQueue`s created from this point on use
-   *   the updated ceiling. Existing per-camera queues are not resized
-   *   (the FrameQueue implementation is latest-only and ignores maxSize
-   *   anyway — see `frame-queue.ts` — so the field is effectively a
-   *   metadata hint for observability).
-   * - `targetLoadPercent` / `minThrottledFps`: stored for future
-   *   throttling logic (not yet consumed in the current runner body).
-   *
-   * Only keys present in the patch are overwritten; unspecified keys
-   * retain their current value. Any illegal combination (e.g.
-   * concurrency < 1) throws and leaves the runner unchanged.
-   */
-  updateLimits(patch) {
-    const next = {
-      ...this.config,
-      maxQueueDepth: patch.maxQueueDepth ?? this.config.maxQueueDepth,
-      maxConcurrentInferences: patch.maxConcurrentInferences ?? this.config.maxConcurrentInferences,
-      targetLoadPercent: patch.targetLoadPercent ?? this.config.targetLoadPercent,
-      minThrottledFps: patch.minThrottledFps ?? this.config.minThrottledFps
-    };
-    if (next.maxConcurrentInferences !== this.config.maxConcurrentInferences) {
-      this.semaphore.resize(next.maxConcurrentInferences);
-    }
-    this.config = next;
-  }
-  /** Read the current tuning fields for diagnostics / tests. */
-  getLimits() {
-    return {
-      maxQueueDepth: this.config.maxQueueDepth,
-      maxConcurrentInferences: this.config.maxConcurrentInferences,
-      targetLoadPercent: this.config.targetLoadPercent,
-      minThrottledFps: this.config.minThrottledFps
-    };
-  }
-  /** Set a handler called when the runner needs to subscribe/unsubscribe the detection stream. */
-  onDetectionStreamChange(handler) {
-    this.detectionStreamHandler = handler;
-  }
-  registerCamera(deviceId, registration) {
-    const motionQueue = new FrameQueue(this.config.maxQueueDepth, ownFrame);
-    const detectionQueue = new FrameQueue(
-      this.config.maxQueueDepth,
-      ownDetectionEntry
-    );
-    const initialPhase = registration.detectionMode === "disabled" ? "idle" : registration.detectionMode === "always-on" ? "active" : "watching";
-    const state = {
-      registration,
-      motionQueue,
-      detectionQueue,
-      inferenceTimes: [],
-      processedCount: 0,
-      startTime: Date.now(),
-      phase: initialPhase,
-      motionCooldownTimer: null,
-      lastArmedSource: null,
-      lastArmedRegions: void 0
-    };
-    this.cameras.set(deviceId, state);
-    if (registration.detectionMode === "on-motion") {
-      this.defaultRoundRobinKeys.push(deviceId);
-    }
-    if (initialPhase === "active") {
-      this.detectionStreamHandler?.(deviceId, "subscribe");
-      const cooldownMs = registration.motionCooldownMs ?? DEFAULT_MOTION_COOLDOWN_MS;
-      this.config.onPhaseChanged?.(deviceId, "active", {
-        source: "analyzer",
-        regions: void 0,
-        timestamp: Date.now(),
-        cooldownMs
-      });
-    }
-  }
-  unregisterCamera(deviceId) {
-    const state = this.cameras.get(deviceId);
-    if (!state) return;
-    if (state.motionCooldownTimer !== null) {
-      clearTimeout(state.motionCooldownTimer);
-      state.motionCooldownTimer = null;
-    }
-    if (state.phase === "active") {
-      this.detectionStreamHandler?.(deviceId, "unsubscribe");
-    }
-    state.motionQueue.clear();
-    state.detectionQueue.clear();
-    this.cameras.delete(deviceId);
-    const idx = this.defaultRoundRobinKeys.indexOf(deviceId);
-    if (idx !== -1) {
-      this.defaultRoundRobinKeys.splice(idx, 1);
-      if (this.defaultRoundRobinIndex >= this.defaultRoundRobinKeys.length) {
-        this.defaultRoundRobinIndex = 0;
-      }
-    }
-  }
-  enqueueMotionFrame(deviceId, frame) {
-    const state = this.cameras.get(deviceId);
-    if (!state) return;
-    state.motionQueue.enqueue(frame);
-  }
-  enqueueDetectionFrame(deviceId, frame, handle) {
-    const state = this.cameras.get(deviceId);
-    if (!state) return;
-    if (state.phase !== "active") return;
-    frame._enqueuedAt = Date.now();
-    state.detectionQueue.enqueue({ frame, handle });
-  }
-  /**
-   * Report a motion event for a camera. Drives the unified phase
-   * machine for both motion sources (analyzer + onboard):
-   *
-   *   - Every `detected: true` (any source) clears + rearms the
-   *     cooldown timer and transitions watching → active. The same
-   *     timer applies regardless of which source(s) are configured;
-   *     concurrent sources just keep refreshing the same window.
-   *   - `detected: false` is a no-op. Onboard sources never send an
-   *     explicit clear, and the analyzer's "false" pulses would
-   *     otherwise fight the cooldown when motion paused briefly
-   *     during a scene. The timer is the single closure path.
-   *   - Timer expiry transitions active → watching.
-   *
-   * Always-on cameras silently ignore reportMotion calls — they're
-   * already in `active` and have no cooldown.
-   *
-   * `source` and `regions` propagate into the phase-transition event
-   * so the wrapping addon can attach them to the cap-state slice +
-   * bus event.
-   */
-  reportMotion(deviceId, detected, source = "analyzer", regions = void 0) {
-    const state = this.cameras.get(deviceId);
-    if (!state) return;
-    if (state.registration.detectionMode !== "on-motion") return;
-    if (!detected) return;
-    state.lastArmedSource = source;
-    state.lastArmedRegions = regions;
-    const cooldownMs = state.registration.motionCooldownMs ?? DEFAULT_MOTION_COOLDOWN_MS;
-    if (state.motionCooldownTimer !== null) {
-      clearTimeout(state.motionCooldownTimer);
-      state.motionCooldownTimer = null;
-    }
-    if (state.phase === "watching") {
-      this.transitionToActive(deviceId, state, source, regions, cooldownMs);
-    }
-    state.motionCooldownTimer = setTimeout(() => {
-      state.motionCooldownTimer = null;
-      this.transitionToWatching(deviceId, state, cooldownMs);
-    }, cooldownMs);
-  }
-  getPhase(deviceId) {
-    return this.cameras.get(deviceId)?.phase;
-  }
-  onResult(callback) {
-    this.resultCallbacks.push(callback);
-  }
-  start() {
-    if (this.intervalHandle !== null) return;
-    this.intervalHandle = setInterval(() => this.tick(), 10);
-    this.timingSampler.start();
-  }
-  stop() {
-    if (this.intervalHandle !== null) {
-      clearInterval(this.intervalHandle);
-      this.intervalHandle = null;
-    }
-    this.timingSampler.stop();
-    for (const state of this.cameras.values()) {
-      if (state.motionCooldownTimer !== null) {
-        clearTimeout(state.motionCooldownTimer);
-        state.motionCooldownTimer = null;
-      }
-    }
-  }
-  getMetrics() {
-    let totalQueueDepth = 0;
-    let totalInferenceTime = 0;
-    let totalInferenceCount = 0;
-    for (const state of this.cameras.values()) {
-      totalQueueDepth += state.motionQueue.size + state.detectionQueue.size;
-      for (const t of state.inferenceTimes) {
-        totalInferenceTime += t;
-        totalInferenceCount++;
-      }
-    }
-    return {
-      activeCameras: this.cameras.size,
-      throttledCameras: 0,
-      avgInferenceTimeMs: totalInferenceCount > 0 ? totalInferenceTime / totalInferenceCount : 0,
-      queueDepth: totalQueueDepth
-    };
-  }
-  getCameraMetrics(deviceId) {
-    const state = this.cameras.get(deviceId);
-    if (!state) return void 0;
-    const elapsedMs = Date.now() - state.startTime;
-    const elapsedSec = elapsedMs / 1e3;
-    const actualFps = elapsedSec > 0 ? state.processedCount / elapsedSec : 0;
-    const times = state.inferenceTimes;
-    const avgInference = times.length > 0 ? times.reduce((a, b) => a + b, 0) / times.length : 0;
-    return {
-      detectionMode: state.registration.detectionMode,
-      configuredFps: state.registration.fps,
-      actualFps,
-      queueDepth: state.motionQueue.size + state.detectionQueue.size,
-      avgInferenceTimeMs: avgInference,
-      droppedFrames: state.motionQueue.droppedFrames + state.detectionQueue.droppedFrames,
-      phase: state.phase
-    };
-  }
-  getAllCameraMetrics() {
-    const results = [];
-    for (const [deviceId] of this.cameras) {
-      const metrics = this.getCameraMetrics(deviceId);
-      if (metrics) {
-        results.push({ deviceId, ...metrics });
-      }
-    }
-    return results;
-  }
-  getAttachedCameras() {
-    return [...this.cameras.keys()];
-  }
-  transitionToActive(deviceId, state, source, regions, cooldownMs) {
-    state.phase = "active";
-    this.logger?.info("motion gate opened — phase=active", {
-      tags: { deviceId },
-      meta: { detectionMode: state.registration.detectionMode, source }
-    });
-    this.detectionStreamHandler?.(deviceId, "subscribe");
-    this.config.onPhaseChanged?.(deviceId, "active", {
-      source,
-      regions,
-      timestamp: Date.now(),
-      cooldownMs
-    });
-  }
-  transitionToWatching(deviceId, state, cooldownMs) {
-    state.phase = "watching";
-    state.detectionQueue.clear();
-    this.logger?.info("motion gate closed — phase=watching", {
-      tags: { deviceId },
-      meta: { lastSource: state.lastArmedSource }
-    });
-    this.detectionStreamHandler?.(deviceId, "unsubscribe");
-    const source = state.lastArmedSource ?? "analyzer";
-    this.config.onPhaseChanged?.(deviceId, "watching", {
-      source,
-      regions: void 0,
-      timestamp: Date.now(),
-      cooldownMs
-    });
-    state.lastArmedSource = null;
-    state.lastArmedRegions = void 0;
-  }
-  tick() {
-    this.drainMotionQueues();
-    if (this.semaphore.available <= 0) return;
-    const picked = this.pickNextDetectionFrame();
-    if (!picked) return;
-    const { deviceId, entry, state } = picked;
-    const frameInput = toFrameInput$1(entry.frame);
-    void this.processWithSemaphore(deviceId, entry, frameInput, state, "detection");
-  }
-  drainMotionQueues() {
-    for (const [deviceId, state] of this.cameras) {
-      while (state.motionQueue.size > 0) {
-        const frame = state.motionQueue.dequeue();
-        if (frame) {
-          void this.config.analyzeMotion(deviceId, frame);
-        }
-      }
-    }
-  }
-  async processWithSemaphore(deviceId, entry, frameInput, state, streamType) {
-    const pickedAt = Date.now();
-    const { frame, handle } = entry;
-    const enqueuedAt = frame._enqueuedAt ?? pickedAt;
-    const release = await this.semaphore.acquire();
-    const semAcquiredAt = Date.now();
-    try {
-      const result = await this.config.processFrame(deviceId, frameInput);
-      const inferDoneAt = Date.now();
-      const inferenceMs = inferDoneAt - semAcquiredAt;
-      state.inferenceTimes.push(inferenceMs);
-      if (state.inferenceTimes.length > 100) {
-        state.inferenceTimes.shift();
-      }
-      state.processedCount++;
-      if (result) {
-        await this.notifyCallbacks(deviceId, frame, result, streamType, handle);
-        const emittedAt = Date.now();
-        const capturedAt = frame.capturedAt;
-        this.timingSampler.addSample(deviceId, {
-          queueWait: pickedAt - enqueuedAt,
-          semaphoreWait: semAcquiredAt - pickedAt,
-          inference: inferenceMs,
-          resultToEmit: emittedAt - inferDoneAt,
-          // capturedAt is the shm-ring commit wall-clock; pickedAt − capturedAt
-          // is how stale the frame was when inference started. <0/absent → unknown.
-          frameAge: typeof capturedAt === "number" && capturedAt > 0 ? pickedAt - capturedAt : -1,
-          // Wall-clock pipeline latency: enqueue → result emitted. (Capture →
-          // enqueue, i.e. RTSP decode + shm-ring write, is not measured here —
-          // the shm frame carries only a PTS, no wall-clock capture stamp.)
-          endToEnd: emittedAt - enqueuedAt,
-          detections: result.detections?.length ?? 0
-        });
-      }
-    } finally {
-      release();
-    }
-  }
-  async notifyCallbacks(deviceId, frame, result, streamType, handle) {
-    for (const callback of this.resultCallbacks) {
-      try {
-        await callback(deviceId, frame, result, streamType, handle);
-      } catch {
-      }
-    }
-  }
-  pickNextDetectionFrame() {
-    for (const [deviceId, state] of this.cameras) {
-      if (state.registration.detectionMode === "always-on" && state.detectionQueue.size > 0) {
-        const entry = state.detectionQueue.dequeue();
-        return { deviceId, entry, state };
-      }
-    }
-    if (this.defaultRoundRobinKeys.length === 0) return null;
-    const startIndex = this.defaultRoundRobinIndex;
-    for (let i = 0; i < this.defaultRoundRobinKeys.length; i++) {
-      const idx = (startIndex + i) % this.defaultRoundRobinKeys.length;
-      const deviceId = this.defaultRoundRobinKeys[idx];
-      if (!deviceId) continue;
-      const state = this.cameras.get(deviceId);
-      if (!state) continue;
-      if (state.phase === "active" && state.detectionQueue.size > 0) {
-        this.defaultRoundRobinIndex = (idx + 1) % this.defaultRoundRobinKeys.length;
-        const entry = state.detectionQueue.dequeue();
-        if (!entry) continue;
-        return { deviceId, entry, state };
-      }
-    }
-    return null;
-  }
-}
-const PULL_MAX_COUNT = 4;
-const MIN_POLL_INTERVAL_MS = 20;
-const FALLBACK_POLL_INTERVAL_MS = 200;
+/**
+* Pipeline runner scheduler — the per-node detection scheduler.
+*
+* Owns per-camera frame queues, the inference semaphore, the round-robin
+* scheduler, and the motion → detection phase machine. Inference and
+* motion analysis are delegated to caller-provided callbacks injected at
+* construction time so the scheduler stays decoupled from the surrounding
+* addon ecosystem (the addon class wrapping this scheduler injects
+* callbacks that resolve to the local pipeline-executor / motion-detection
+* caps when running in production).
+*
+* This class is intentionally framework-agnostic and side-effect-free
+* outside the callbacks — it can be unit tested with mock callbacks
+* without spinning up Moleculer or the addon framework.
+*/
+var PipelineRunner = class {
+	config;
+	cameras = /* @__PURE__ */ new Map();
+	semaphore;
+	resultCallbacks = [];
+	defaultRoundRobinKeys = [];
+	defaultRoundRobinIndex = 0;
+	intervalHandle = null;
+	detectionStreamHandler = null;
+	logger;
+	timingSampler = new PipelineTimingSampler();
+	constructor(config) {
+		this.config = config;
+		this.logger = config.logger;
+		this.semaphore = new Semaphore(config.maxConcurrentInferences);
+	}
+	/**
+	* Hot-reload the four tuning fields without tearing down the runner.
+	* - `maxConcurrentInferences`: resized on the live semaphore; in-flight
+	*   permits are preserved, new capacity is available immediately.
+	* - `maxQueueDepth`: new `FrameQueue`s created from this point on use
+	*   the updated ceiling. Existing per-camera queues are not resized
+	*   (the FrameQueue implementation is latest-only and ignores maxSize
+	*   anyway — see `frame-queue.ts` — so the field is effectively a
+	*   metadata hint for observability).
+	* - `targetLoadPercent` / `minThrottledFps`: stored for future
+	*   throttling logic (not yet consumed in the current runner body).
+	*
+	* Only keys present in the patch are overwritten; unspecified keys
+	* retain their current value. Any illegal combination (e.g.
+	* concurrency < 1) throws and leaves the runner unchanged.
+	*/
+	updateLimits(patch) {
+		const next = {
+			...this.config,
+			maxQueueDepth: patch.maxQueueDepth ?? this.config.maxQueueDepth,
+			maxConcurrentInferences: patch.maxConcurrentInferences ?? this.config.maxConcurrentInferences,
+			targetLoadPercent: patch.targetLoadPercent ?? this.config.targetLoadPercent,
+			minThrottledFps: patch.minThrottledFps ?? this.config.minThrottledFps
+		};
+		if (next.maxConcurrentInferences !== this.config.maxConcurrentInferences) this.semaphore.resize(next.maxConcurrentInferences);
+		this.config = next;
+	}
+	/** Read the current tuning fields for diagnostics / tests. */
+	getLimits() {
+		return {
+			maxQueueDepth: this.config.maxQueueDepth,
+			maxConcurrentInferences: this.config.maxConcurrentInferences,
+			targetLoadPercent: this.config.targetLoadPercent,
+			minThrottledFps: this.config.minThrottledFps
+		};
+	}
+	/** Set a handler called when the runner needs to subscribe/unsubscribe the detection stream. */
+	onDetectionStreamChange(handler) {
+		this.detectionStreamHandler = handler;
+	}
+	registerCamera(deviceId, registration) {
+		const motionQueue = new FrameQueue(this.config.maxQueueDepth, ownFrame);
+		const detectionQueue = new FrameQueue(this.config.maxQueueDepth, ownDetectionEntry);
+		const initialPhase = registration.detectionMode === "disabled" ? "idle" : registration.detectionMode === "always-on" ? "active" : "watching";
+		const state = {
+			registration,
+			motionQueue,
+			detectionQueue,
+			inferenceTimes: [],
+			processedCount: 0,
+			startTime: Date.now(),
+			phase: initialPhase,
+			motionCooldownTimer: null,
+			lastArmedSource: null,
+			lastArmedRegions: void 0,
+			occupancyTimer: null
+		};
+		this.cameras.set(deviceId, state);
+		if (registration.detectionMode === "on-motion") this.defaultRoundRobinKeys.push(deviceId);
+		if (registration.detectionMode === "on-motion" && (registration.occupancyRecheckSec ?? 0) > 0) state.occupancyTimer = setInterval(() => {
+			if (state.phase === "watching") this.config.onOccupancyRecheck?.(deviceId, registration.occupancyRecheckFrames ?? 4);
+		}, (registration.occupancyRecheckSec ?? 0) * 1e3);
+		if (initialPhase === "active") {
+			this.detectionStreamHandler?.(deviceId, "subscribe");
+			const cooldownMs = registration.motionCooldownMs ?? DEFAULT_MOTION_COOLDOWN_MS;
+			this.config.onPhaseChanged?.(deviceId, "active", {
+				source: "analyzer",
+				regions: void 0,
+				timestamp: Date.now(),
+				cooldownMs
+			});
+		}
+	}
+	unregisterCamera(deviceId) {
+		const state = this.cameras.get(deviceId);
+		if (!state) return;
+		if (state.motionCooldownTimer !== null) {
+			clearTimeout(state.motionCooldownTimer);
+			state.motionCooldownTimer = null;
+		}
+		if (state.occupancyTimer !== null) {
+			clearInterval(state.occupancyTimer);
+			state.occupancyTimer = null;
+		}
+		if (state.phase === "active") this.detectionStreamHandler?.(deviceId, "unsubscribe");
+		state.motionQueue.clear();
+		state.detectionQueue.clear();
+		this.cameras.delete(deviceId);
+		const idx = this.defaultRoundRobinKeys.indexOf(deviceId);
+		if (idx !== -1) {
+			this.defaultRoundRobinKeys.splice(idx, 1);
+			if (this.defaultRoundRobinIndex >= this.defaultRoundRobinKeys.length) this.defaultRoundRobinIndex = 0;
+		}
+	}
+	enqueueMotionFrame(deviceId, frame) {
+		const state = this.cameras.get(deviceId);
+		if (!state) return;
+		state.motionQueue.enqueue(frame);
+	}
+	enqueueDetectionFrame(deviceId, frame, handle) {
+		const state = this.cameras.get(deviceId);
+		if (!state) return;
+		if (state.phase !== "active") return;
+		frame._enqueuedAt = Date.now();
+		state.detectionQueue.enqueue({
+			frame,
+			handle
+		});
+	}
+	enqueueOccupancyFrame(deviceId, frame, handle) {
+		const state = this.cameras.get(deviceId);
+		if (!state) return;
+		if (state.phase !== "watching") return;
+		frame._enqueuedAt = Date.now();
+		state.detectionQueue.enqueue({
+			frame,
+			handle
+		});
+	}
+	/**
+	* Report a motion event for a camera. Drives the unified phase
+	* machine for both motion sources (analyzer + onboard):
+	*
+	*   - Every `detected: true` (any source) clears + rearms the
+	*     cooldown timer and transitions watching → active. The same
+	*     timer applies regardless of which source(s) are configured;
+	*     concurrent sources just keep refreshing the same window.
+	*   - `detected: false` is a no-op. Onboard sources never send an
+	*     explicit clear, and the analyzer's "false" pulses would
+	*     otherwise fight the cooldown when motion paused briefly
+	*     during a scene. The timer is the single closure path.
+	*   - Timer expiry transitions active → watching.
+	*
+	* Always-on cameras silently ignore reportMotion calls — they're
+	* already in `active` and have no cooldown.
+	*
+	* `source` and `regions` propagate into the phase-transition event
+	* so the wrapping addon can attach them to the cap-state slice +
+	* bus event.
+	*/
+	reportMotion(deviceId, detected, source = "analyzer", regions = void 0) {
+		const state = this.cameras.get(deviceId);
+		if (!state) return;
+		if (state.registration.detectionMode !== "on-motion") return;
+		if (!detected) return;
+		state.lastArmedSource = source;
+		state.lastArmedRegions = regions;
+		const cooldownMs = state.registration.motionCooldownMs ?? DEFAULT_MOTION_COOLDOWN_MS;
+		if (state.motionCooldownTimer !== null) {
+			clearTimeout(state.motionCooldownTimer);
+			state.motionCooldownTimer = null;
+		}
+		if (state.phase === "watching") this.transitionToActive(deviceId, state, source, regions, cooldownMs);
+		state.motionCooldownTimer = setTimeout(() => {
+			state.motionCooldownTimer = null;
+			this.transitionToWatching(deviceId, state, cooldownMs);
+		}, cooldownMs);
+	}
+	getPhase(deviceId) {
+		return this.cameras.get(deviceId)?.phase;
+	}
+	onResult(callback) {
+		this.resultCallbacks.push(callback);
+	}
+	start() {
+		if (this.intervalHandle !== null) return;
+		this.intervalHandle = setInterval(() => this.tick(), 10);
+		this.timingSampler.start();
+	}
+	stop() {
+		if (this.intervalHandle !== null) {
+			clearInterval(this.intervalHandle);
+			this.intervalHandle = null;
+		}
+		this.timingSampler.stop();
+		for (const state of this.cameras.values()) {
+			if (state.motionCooldownTimer !== null) {
+				clearTimeout(state.motionCooldownTimer);
+				state.motionCooldownTimer = null;
+			}
+			if (state.occupancyTimer !== null) {
+				clearInterval(state.occupancyTimer);
+				state.occupancyTimer = null;
+			}
+		}
+	}
+	getMetrics() {
+		let totalQueueDepth = 0;
+		let totalInferenceTime = 0;
+		let totalInferenceCount = 0;
+		for (const state of this.cameras.values()) {
+			totalQueueDepth += state.motionQueue.size + state.detectionQueue.size;
+			for (const t of state.inferenceTimes) {
+				totalInferenceTime += t;
+				totalInferenceCount++;
+			}
+		}
+		return {
+			activeCameras: this.cameras.size,
+			throttledCameras: 0,
+			avgInferenceTimeMs: totalInferenceCount > 0 ? totalInferenceTime / totalInferenceCount : 0,
+			queueDepth: totalQueueDepth
+		};
+	}
+	getCameraMetrics(deviceId) {
+		const state = this.cameras.get(deviceId);
+		if (!state) return void 0;
+		const elapsedSec = (Date.now() - state.startTime) / 1e3;
+		const actualFps = elapsedSec > 0 ? state.processedCount / elapsedSec : 0;
+		const times = state.inferenceTimes;
+		const avgInference = times.length > 0 ? times.reduce((a, b) => a + b, 0) / times.length : 0;
+		return {
+			detectionMode: state.registration.detectionMode,
+			configuredFps: state.registration.fps,
+			actualFps,
+			queueDepth: state.motionQueue.size + state.detectionQueue.size,
+			avgInferenceTimeMs: avgInference,
+			droppedFrames: state.motionQueue.droppedFrames + state.detectionQueue.droppedFrames,
+			phase: state.phase
+		};
+	}
+	getAllCameraMetrics() {
+		const results = [];
+		for (const [deviceId] of this.cameras) {
+			const metrics = this.getCameraMetrics(deviceId);
+			if (metrics) results.push({
+				deviceId,
+				...metrics
+			});
+		}
+		return results;
+	}
+	getAttachedCameras() {
+		return [...this.cameras.keys()];
+	}
+	transitionToActive(deviceId, state, source, regions, cooldownMs) {
+		state.phase = "active";
+		this.logger?.info("motion gate opened — phase=active", {
+			tags: { deviceId },
+			meta: {
+				detectionMode: state.registration.detectionMode,
+				source
+			}
+		});
+		this.detectionStreamHandler?.(deviceId, "subscribe");
+		this.config.onPhaseChanged?.(deviceId, "active", {
+			source,
+			regions,
+			timestamp: Date.now(),
+			cooldownMs
+		});
+	}
+	transitionToWatching(deviceId, state, cooldownMs) {
+		state.phase = "watching";
+		state.detectionQueue.clear();
+		this.logger?.info("motion gate closed — phase=watching", {
+			tags: { deviceId },
+			meta: { lastSource: state.lastArmedSource }
+		});
+		this.detectionStreamHandler?.(deviceId, "unsubscribe");
+		const source = state.lastArmedSource ?? "analyzer";
+		this.config.onPhaseChanged?.(deviceId, "watching", {
+			source,
+			regions: void 0,
+			timestamp: Date.now(),
+			cooldownMs
+		});
+		state.lastArmedSource = null;
+		state.lastArmedRegions = void 0;
+	}
+	tick() {
+		this.drainMotionQueues();
+		if (this.semaphore.available <= 0) return;
+		const picked = this.pickNextDetectionFrame();
+		if (!picked) return;
+		const { deviceId, entry, state } = picked;
+		const frameInput = toFrameInput$1(entry.frame);
+		this.processWithSemaphore(deviceId, entry, frameInput, state, "detection");
+	}
+	drainMotionQueues() {
+		for (const [deviceId, state] of this.cameras) while (state.motionQueue.size > 0) {
+			const frame = state.motionQueue.dequeue();
+			if (frame) this.config.analyzeMotion(deviceId, frame);
+		}
+	}
+	async processWithSemaphore(deviceId, entry, frameInput, state, streamType) {
+		const pickedAt = Date.now();
+		const { frame, handle } = entry;
+		const enqueuedAt = frame._enqueuedAt ?? pickedAt;
+		const release = await this.semaphore.acquire();
+		const semAcquiredAt = Date.now();
+		try {
+			const result = await this.config.processFrame(deviceId, frameInput);
+			const inferDoneAt = Date.now();
+			const inferenceMs = inferDoneAt - semAcquiredAt;
+			state.inferenceTimes.push(inferenceMs);
+			if (state.inferenceTimes.length > 100) state.inferenceTimes.shift();
+			state.processedCount++;
+			if (result) {
+				await this.notifyCallbacks(deviceId, frame, result, streamType, handle);
+				const emittedAt = Date.now();
+				const capturedAt = frame.capturedAt;
+				this.timingSampler.addSample(deviceId, {
+					queueWait: pickedAt - enqueuedAt,
+					semaphoreWait: semAcquiredAt - pickedAt,
+					inference: inferenceMs,
+					resultToEmit: emittedAt - inferDoneAt,
+					frameAge: typeof capturedAt === "number" && capturedAt > 0 ? pickedAt - capturedAt : -1,
+					endToEnd: emittedAt - enqueuedAt,
+					detections: result.detections?.length ?? 0
+				});
+			}
+		} finally {
+			release();
+		}
+	}
+	async notifyCallbacks(deviceId, frame, result, streamType, handle) {
+		for (const callback of this.resultCallbacks) try {
+			await callback(deviceId, frame, result, streamType, handle);
+		} catch {}
+	}
+	pickNextDetectionFrame() {
+		for (const [deviceId, state] of this.cameras) if (state.registration.detectionMode === "always-on" && state.detectionQueue.size > 0) return {
+			deviceId,
+			entry: state.detectionQueue.dequeue(),
+			state
+		};
+		if (this.defaultRoundRobinKeys.length === 0) return null;
+		const startIndex = this.defaultRoundRobinIndex;
+		for (let i = 0; i < this.defaultRoundRobinKeys.length; i++) {
+			const idx = (startIndex + i) % this.defaultRoundRobinKeys.length;
+			const deviceId = this.defaultRoundRobinKeys[idx];
+			if (!deviceId) continue;
+			const state = this.cameras.get(deviceId);
+			if (!state) continue;
+			if (state.phase === "active" && state.detectionQueue.size > 0) {
+				this.defaultRoundRobinIndex = (idx + 1) % this.defaultRoundRobinKeys.length;
+				const entry = state.detectionQueue.dequeue();
+				if (!entry) continue;
+				return {
+					deviceId,
+					entry,
+					state
+				};
+			}
+		}
+		return null;
+	}
+};
+//#endregion
+//#region src/pipeline-runner/frame-handle-poller.ts
+/** How many handles to drain per poll — a small burst absorbs jitter. */
+var PULL_MAX_COUNT = 4;
+/** Floor on the poll period so a 0/absurd `maxFps` can't busy-spin. */
+var MIN_POLL_INTERVAL_MS = 20;
+/** Poll period when the broker reports a non-positive cadence hint. */
+var FALLBACK_POLL_INTERVAL_MS = 200;
+/** First subscribe-retry delay, doubled on every subsequent failure. */
+var INITIAL_SUBSCRIBE_RETRY_BACKOFF_MS = 250;
+/**
+* Subscribe-retry backoff ceiling. 5 s is fast enough to recover within a
+* single roster refresh of the consuming UI and slow enough that a
+* misconfigured camStream costs ~12 op/min, not 50/s.
+*/
+var MAX_SUBSCRIBE_RETRY_BACKOFF_MS = 5e3;
+/**
+* Subscribe to a broker's shm frame stream and start the poll loop. Always
+* resolves to a teardown closure — when the broker is not yet registered the
+* closure cancels the ongoing retry loop; when polling is active it stops the
+* loop, releases the broker subscription, and closes every shm segment the
+* reader cache opened.
+*/
 async function startFrameHandlePoller(options) {
-  const { api, brokerId, format, maxFps, tag, onFrame, logger } = options;
-  let result;
-  try {
-    result = await api.streamBroker.subscribeFrames.mutate({
-      brokerId,
-      format,
-      maxFps,
-      tag
-    });
-  } catch (err) {
-    logger.warn("frame-handle poller: subscribeFrames failed", {
-      meta: { brokerId, format, tag, error: index.errMsg(err) }
-    });
-    return null;
-  }
-  const { subscriptionId } = result;
-  const readers = new shmRing.FrameRingReaderCache(logger);
-  const pollIntervalMs = result.maxFps > 0 ? Math.max(MIN_POLL_INTERVAL_MS, Math.round(1e3 / result.maxFps)) : FALLBACK_POLL_INTERVAL_MS;
-  let stopped = false;
-  let timer;
-  const tick = async () => {
-    if (stopped) return;
-    try {
-      const handles = await api.streamBroker.pullFrameHandles.query({
-        subscriptionId,
-        maxCount: PULL_MAX_COUNT
-      });
-      for (const handle of handles) {
-        if (stopped) break;
-        const frame = readers.read(handle);
-        if (frame) onFrame(frame, handle);
-      }
-    } catch (err) {
-      logger.warn("frame-handle poller: pullFrameHandles failed", {
-        meta: { brokerId, subscriptionId, error: index.errMsg(err) }
-      });
-    }
-    if (!stopped) {
-      timer = setTimeout(() => void tick(), pollIntervalMs);
-    }
-  };
-  void tick();
-  return () => {
-    if (stopped) return;
-    stopped = true;
-    if (timer) {
-      clearTimeout(timer);
-      timer = void 0;
-    }
-    readers.close();
-    api.streamBroker.unsubscribeFrames.mutate({ subscriptionId }).catch((err) => {
-      logger.warn("frame-handle poller: unsubscribeFrames failed", {
-        meta: { brokerId, subscriptionId, error: index.errMsg(err) }
-      });
-    });
-  };
+	const lifecycle = {
+		stopped: false,
+		retryTimer: void 0,
+		activeTeardown: null
+	};
+	const teardown = () => {
+		if (lifecycle.stopped) return;
+		lifecycle.stopped = true;
+		if (lifecycle.retryTimer) {
+			clearTimeout(lifecycle.retryTimer);
+			lifecycle.retryTimer = void 0;
+		}
+		lifecycle.activeTeardown?.();
+	};
+	subscribeWithRetry(options, lifecycle);
+	return teardown;
 }
-const BenchEngineChoiceSchema = index.object({
-  runtime: index._enum(["node", "python"]),
-  backend: index.string(),
-  format: index._enum(["onnx", "coreml", "openvino", "tflite", "pt"]),
-  device: index.string().optional()
+/**
+* Run the subscribe → poll handshake with exponential backoff on subscribe
+* failures. Resolves once the subscription is acquired (and the poll loop has
+* been started) or once `lifecycle.stopped` flips, whichever comes first.
+*/
+async function subscribeWithRetry(options, lifecycle) {
+	const { api, brokerId, format, maxFps, tag, logger } = options;
+	let backoffMs = INITIAL_SUBSCRIBE_RETRY_BACKOFF_MS;
+	let attempt = 0;
+	while (!lifecycle.stopped) {
+		attempt += 1;
+		try {
+			const result = await api.streamBroker.subscribeFrames.mutate({
+				brokerId,
+				format,
+				maxFps,
+				tag
+			});
+			if (lifecycle.stopped) {
+				await api.streamBroker.unsubscribeFrames.mutate({ subscriptionId: result.subscriptionId }).catch((err) => {
+					logger.warn("frame-handle poller: late unsubscribe failed", { meta: {
+						brokerId,
+						subscriptionId: result.subscriptionId,
+						error: require_dist.errMsg(err)
+					} });
+				});
+				return;
+			}
+			lifecycle.activeTeardown = startPolling(options, result.subscriptionId, result.maxFps, lifecycle);
+			return;
+		} catch (err) {
+			if (lifecycle.stopped) return;
+			if (attempt === 1) logger.warn("frame-handle poller: subscribeFrames failed, retrying", { meta: {
+				brokerId,
+				format,
+				tag,
+				error: require_dist.errMsg(err),
+				nextRetryInMs: backoffMs
+			} });
+			else logger.debug("frame-handle poller: subscribeFrames still failing", { meta: {
+				brokerId,
+				format,
+				tag,
+				attempt,
+				error: require_dist.errMsg(err),
+				nextRetryInMs: backoffMs
+			} });
+			await sleep(backoffMs, lifecycle);
+			backoffMs = Math.min(MAX_SUBSCRIBE_RETRY_BACKOFF_MS, backoffMs * 2);
+		}
+	}
+}
+/**
+* Sleep `ms` milliseconds, but resolve early when `lifecycle.stopped` flips so
+* a teardown during a retry pause doesn't have to wait out the full backoff.
+*/
+function sleep(ms, lifecycle) {
+	return new Promise((resolve) => {
+		lifecycle.retryTimer = setTimeout(() => {
+			lifecycle.retryTimer = void 0;
+			resolve();
+		}, ms);
+	});
+}
+/**
+* Run the steady-state poll loop for a successfully-acquired subscription.
+* Returns the teardown closure that stops the loop and releases the
+* subscription.
+*/
+function startPolling(options, subscriptionId, resolvedMaxFps, lifecycle) {
+	const { api, brokerId, onFrame, logger } = options;
+	const readers = new _camstack_shm_ring.FrameRingReaderCache(logger);
+	const pollIntervalMs = resolvedMaxFps > 0 ? Math.max(MIN_POLL_INTERVAL_MS, Math.round(1e3 / resolvedMaxFps)) : FALLBACK_POLL_INTERVAL_MS;
+	let timer;
+	const tick = async () => {
+		if (lifecycle.stopped) return;
+		try {
+			const handles = await api.streamBroker.pullFrameHandles.query({
+				subscriptionId,
+				maxCount: PULL_MAX_COUNT
+			});
+			for (const handle of handles) {
+				if (lifecycle.stopped) break;
+				const frame = readers.read(handle);
+				if (frame) onFrame(frame, handle);
+			}
+		} catch (err) {
+			logger.warn("frame-handle poller: pullFrameHandles failed", { meta: {
+				brokerId,
+				subscriptionId,
+				error: require_dist.errMsg(err)
+			} });
+		}
+		if (!lifecycle.stopped) timer = setTimeout(() => void tick(), pollIntervalMs);
+	};
+	tick();
+	return () => {
+		if (timer) {
+			clearTimeout(timer);
+			timer = void 0;
+		}
+		readers.close();
+		api.streamBroker.unsubscribeFrames.mutate({ subscriptionId }).catch((err) => {
+			logger.warn("frame-handle poller: unsubscribeFrames failed", { meta: {
+				brokerId,
+				subscriptionId,
+				error: require_dist.errMsg(err)
+			} });
+		});
+	};
+}
+//#endregion
+//#region src/pipeline-runner/bench-actions.ts
+/**
+* Synthetic-bench custom actions for pipeline-runner.
+*
+* Lets the admin UI drive a production-realistic detection benchmark:
+* the runner — already co-located with detection-pipeline in the
+* `pipeline` group — invokes `api.pipelineExecutor.runPipeline` directly
+* (in-process via localProviderLink, no Moleculer hop), N workers
+* concurrent × M iterations. Returns aggregate stats.
+*
+* Why this exists: the older bench path (UI → benchmark addon → pipeline
+* addon) crosses TWO Moleculer process boundaries that the production
+* camera path does NOT have (broker / runner / detection-pipeline are
+* all in the same group). Running the loop from inside the runner gives
+* fps numbers that match what real cameras achieve.
+*/
+var BenchEngineChoiceSchema = require_dist.object({
+	runtime: require_dist._enum(["node", "python"]),
+	backend: require_dist.string(),
+	format: require_dist._enum([
+		"onnx",
+		"coreml",
+		"openvino",
+		"tflite",
+		"pt"
+	]),
+	device: require_dist.string().optional()
 });
-const BenchStepSchema = index.lazy(() => index.object({
-  addonId: index.string(),
-  modelId: index.string(),
-  enabled: index.boolean(),
-  children: index.array(BenchStepSchema).optional()
+var BenchStepSchema = require_dist.lazy(() => require_dist.object({
+	addonId: require_dist.string(),
+	modelId: require_dist.string(),
+	enabled: require_dist.boolean(),
+	children: require_dist.array(BenchStepSchema).optional()
 }));
-const CacheBenchFrameInputSchema = index.object({
-  imageBase64: index.string(),
-  ttlSeconds: index.number().int().positive().optional()
-});
-const CacheBenchFrameResultSchema = index.object({
-  frameId: index.string(),
-  width: index.number(),
-  height: index.number(),
-  expiresAt: index.number()
+var CacheBenchFrameInputSchema = require_dist.object({
+	imageBase64: require_dist.string(),
+	ttlSeconds: require_dist.number().int().positive().optional()
 });
-const ReleaseBenchFrameInputSchema = index.object({
-  frameId: index.string()
+var CacheBenchFrameResultSchema = require_dist.object({
+	frameId: require_dist.string(),
+	width: require_dist.number(),
+	height: require_dist.number(),
+	expiresAt: require_dist.number()
 });
-const ReleaseBenchFrameResultSchema = index.object({
-  released: index.boolean()
+var ReleaseBenchFrameInputSchema = require_dist.object({ frameId: require_dist.string() });
+var ReleaseBenchFrameResultSchema = require_dist.object({ released: require_dist.boolean() });
+var RunSyntheticBenchInputSchema = require_dist.object({
+	frameId: require_dist.string(),
+	steps: require_dist.array(BenchStepSchema).min(1),
+	parallel: require_dist.number().int().min(1).max(32),
+	iterations: require_dist.number().int().min(1).max(1e4),
+	warmup: require_dist.number().int().min(0).max(100).optional(),
+	sessionId: require_dist.string().optional(),
+	simulatePipeline: require_dist.boolean().optional(),
+	engine: BenchEngineChoiceSchema.optional()
 });
-const RunSyntheticBenchInputSchema = index.object({
-  frameId: index.string(),
-  steps: index.array(BenchStepSchema).min(1),
-  parallel: index.number().int().min(1).max(32),
-  iterations: index.number().int().min(1).max(1e4),
-  warmup: index.number().int().min(0).max(100).optional(),
-  sessionId: index.string().optional(),
-  simulatePipeline: index.boolean().optional(),
-  engine: BenchEngineChoiceSchema.optional()
+var TimingSplitSchema = require_dist.object({
+	mean: require_dist.number(),
+	p50: require_dist.number(),
+	p95: require_dist.number(),
+	p99: require_dist.number()
 });
-const TimingSplitSchema = index.object({
-  mean: index.number(),
-  p50: index.number(),
-  p95: index.number(),
-  p99: index.number()
+var RunSyntheticBenchResultSchema = require_dist.object({
+	runs: require_dist.number(),
+	wallSec: require_dist.number(),
+	fps: require_dist.number(),
+	detectionsPerSec: require_dist.number(),
+	avgDetections: require_dist.number(),
+	callMs: TimingSplitSchema,
+	inferMs: require_dist.number(),
+	preprocessMs: require_dist.number(),
+	predictMs: require_dist.number(),
+	batchSizeMean: require_dist.number(),
+	batchSizeMax: require_dist.number(),
+	engine: require_dist.object({
+		runtime: require_dist.string(),
+		backend: require_dist.string(),
+		device: require_dist.string().optional()
+	}).optional(),
+	tuning: require_dist.object({
+		batchMode: require_dist.string(),
+		windowMs: require_dist.number(),
+		maxBatchSize: require_dist.number(),
+		concurrency: require_dist.number()
+	}).optional(),
+	path: require_dist.string().optional()
 });
-const RunSyntheticBenchResultSchema = index.object({
-  runs: index.number(),
-  wallSec: index.number(),
-  fps: index.number(),
-  detectionsPerSec: index.number(),
-  avgDetections: index.number(),
-  callMs: TimingSplitSchema,
-  inferMs: index.number(),
-  preprocessMs: index.number(),
-  predictMs: index.number(),
-  batchSizeMean: index.number(),
-  batchSizeMax: index.number(),
-  engine: index.object({ runtime: index.string(), backend: index.string(), device: index.string().optional() }).optional(),
-  tuning: index.object({ batchMode: index.string(), windowMs: index.number(), maxBatchSize: index.number(), concurrency: index.number() }).optional(),
-  path: index.string().optional()
+var pipelineRunnerBenchActions = require_dist.defineCustomActions({
+	cacheBenchFrame: require_dist.customAction(CacheBenchFrameInputSchema, CacheBenchFrameResultSchema, { kind: "mutation" }),
+	releaseBenchFrame: require_dist.customAction(ReleaseBenchFrameInputSchema, ReleaseBenchFrameResultSchema, { kind: "mutation" }),
+	runSyntheticBench: require_dist.customAction(RunSyntheticBenchInputSchema, RunSyntheticBenchResultSchema, { kind: "mutation" })
 });
-const pipelineRunnerBenchActions = index.defineCustomActions({
-  cacheBenchFrame: index.customAction(
-    CacheBenchFrameInputSchema,
-    CacheBenchFrameResultSchema,
-    { kind: "mutation" }
-  ),
-  releaseBenchFrame: index.customAction(
-    ReleaseBenchFrameInputSchema,
-    ReleaseBenchFrameResultSchema,
-    { kind: "mutation" }
-  ),
-  runSyntheticBench: index.customAction(
-    RunSyntheticBenchInputSchema,
-    RunSyntheticBenchResultSchema,
-    { kind: "mutation" }
-  )
-});
-const DEFAULT_CONFIG = {
-  maxQueueDepth: 30,
-  // CoreML window accumulator coalesces concurrent calls into a single
-  // model.predict([list]) — the more in-flight, the larger the batch and
-  // the higher the per-frame throughput. With concurrency=2 the window
-  // never fills past batch=2, capping the pool at ~50 fps single-node.
-  // 16 matches the slider ceiling and lines up with bench numbers
-  // (parallel=16 hits batch=7-8/8, sustaining ~140 fps full path).
-  maxConcurrentInferences: 16,
-  targetLoadPercent: 80,
-  minThrottledFps: 1
+//#endregion
+//#region src/pipeline-runner/index.ts
+var DEFAULT_CONFIG = {
+	maxQueueDepth: 30,
+	maxConcurrentInferences: 16,
+	targetLoadPercent: 80,
+	minThrottledFps: 1
 };
+/**
+* Pure decision helper: returns `true` when a dynamic frame-diff analyzer
+* subscription should be opened for an onboard-motion camera.
+*
+* Conditions (all must hold):
+* - `onboardMotionDrivesAnalyzer` flag is enabled on the config.
+* - `motionSources` does NOT already include `'analyzer'` — if it does,
+*   the analyzer runs continuously and there is nothing to gate.
+*
+* Extracted as a pure function so the unit suite can exercise the decision
+* logic without instantiating the full addon.
+*/
 function shouldStartOnboardAnalyzer(config) {
-  if (!config.onboardMotionDrivesAnalyzer) return false;
-  if (config.motionSources.includes("analyzer")) return false;
-  return true;
+	if (!config.onboardMotionDrivesAnalyzer) return false;
+	if (config.motionSources.includes("analyzer")) return false;
+	return true;
 }
 function toFrameInput(frame) {
-  return {
-    data: frame.data,
-    width: frame.width,
-    height: frame.height,
-    format: frame.format,
-    timestamp: frame.timestamp
-  };
-}
-const STEP_LOG_INTERVAL_MS = 3e4;
-const METRICS_SNAPSHOT_INTERVAL_MS = 1e3;
-const METRICS_HEARTBEAT_MS = 3e4;
-class PipelineRunnerAddon extends index.BaseAddon {
-  runner = null;
-  attached = /* @__PURE__ */ new Map();
-  nodeId = "unknown";
-  stepLogTimer = null;
-  metricsSnapshotTimer = null;
-  unsubMotionEvents = null;
-  /** Last analyzer-detected state per device — gates the
-   *  `MotionOnMotionChanged` emit in `runMotionAnalysis` to transitions
-   *  only (otherwise we'd emit on every analyzer frame). */
-  lastAnalyzerDetected = /* @__PURE__ */ new Map();
-  /**
-   * Last positive motion timestamp per device — preserved across the
-   * OFF transition so the motion runtime-state slice keeps a stable
-   * `lastDetectedAt` after the cooldown closes the phase. Cleared on
-   * detach.
-   */
-  lastMotionAt = /* @__PURE__ */ new Map();
-  /**
-   * Dynamic analyzer subscriptions opened on `MotionOnMotionChanged
-   * source:'onboard'` when `onboardMotionDrivesAnalyzer === true`. Each
-   * entry is the unsubscribe handle returned by `subscribeMotionFrames`.
-   * Cleared on teardown timer fire, detach, and shutdown.
-   */
-  onboardAnalyzerSubs = /* @__PURE__ */ new Map();
-  /**
-   * Teardown timers that close the dynamic analyzer subscription after
-   * `motionCooldownMs` without a new motion event. Re-armed on every
-   * `MotionOnMotionChanged source:'onboard'` call so the sub stays open
-   * while motion persists.
-   */
-  onboardAnalyzerTeardownTimers = /* @__PURE__ */ new Map();
-  /**
-   * Snapshot-equality cache for metrics-snapshot defer. The runner
-   * fires per-camera metrics every `METRICS_SNAPSHOT_INTERVAL_MS`;
-   * for an idle camera (no inference, queue empty, fps=0) every tick
-   * carries an identical payload. We skip the bus emit when the
-   * payload deep-equals the previous one so the events tab + remote
-   * subscribers stop seeing 60 metrics-snapshots/min/camera that
-   * convey nothing. A periodic heartbeat re-emits every
-   * METRICS_HEARTBEAT_MS so consumers know the runner is still
-   * alive.
-   */
-  lastEmittedCameraMetrics = /* @__PURE__ */ new Map();
-  lastEmittedRunnerLoad = null;
-  /**
-   * In-memory bench-frame cache (decoded JPEG bytes). Populated by the
-   * `cacheBenchFrame` custom action. Fed into the synthetic-bench loop
-   * via the `frame: FrameInput` shape that mirrors what stream-broker
-   * delivers to this very addon during real camera detection.
-   */
-  benchFrameCache = /* @__PURE__ */ new Map();
-  benchFrameSweeper = null;
-  constructor() {
-    super({ ...DEFAULT_CONFIG });
-  }
-  async onInitialize() {
-    const raw = this.ctx.kernel.localNodeId ?? this.ctx.id;
-    this.nodeId = raw.includes("/") ? raw.split("/")[0] : raw;
-    this.runner = new PipelineRunner({
-      maxQueueDepth: this.config.maxQueueDepth,
-      maxConcurrentInferences: this.config.maxConcurrentInferences,
-      targetLoadPercent: this.config.targetLoadPercent,
-      minThrottledFps: this.config.minThrottledFps,
-      processFrame: (deviceId, frame) => this.runInference(deviceId, frame),
-      analyzeMotion: (deviceId, frame) => this.runMotionAnalysis(deviceId, frame),
-      onPhaseChanged: (deviceId, phase, meta) => this.handlePhaseChanged(deviceId, phase, meta),
-      logger: this.ctx.logger
-    });
-    this.runner.timingSampler.setLogger(this.ctx.logger.child("timing"));
-    this.runner.onDetectionStreamChange((deviceId, action) => {
-      this.handleDetectionStreamChange(deviceId, action);
-    });
-    this.runner.onResult(async (deviceId, frame, result, _streamType, handle) => {
-      this.emitInferenceResult(deviceId, frame, result, handle);
-    });
-    this.runner.start();
-    this.ctx.logger.info(
-      "Pipeline runner started",
-      {
-        tags: { nodeId: this.nodeId },
-        meta: {
-          maxConcurrent: this.config.maxConcurrentInferences,
-          queueDepth: this.config.maxQueueDepth
-        }
-      }
-    );
-    if (this.ctx.eventBus) {
-      this.unsubMotionEvents = this.ctx.eventBus.subscribe(
-        { category: index.EventCategory.MotionOnMotionChanged },
-        (event) => {
-          const data = event.data;
-          const deviceId = data.deviceId;
-          const attachment = this.attached.get(deviceId);
-          if (!attachment) return;
-          const source = data.source;
-          if (source === "onboard") {
-            void this.handleOnboardMotionAnalyzer(deviceId, data.detected);
-          }
-          if (!attachment.config.motionSources.includes(source)) return;
-          this.runner?.reportMotion(
-            deviceId,
-            data.detected,
-            source,
-            data.regions ? [...data.regions] : void 0
-          );
-        }
-      );
-    }
-    this.stepLogTimer = setInterval(() => this.logAttachedSteps(), STEP_LOG_INTERVAL_MS);
-    this.metricsSnapshotTimer = setInterval(
-      () => this.emitMetricsSnapshot(),
-      METRICS_SNAPSHOT_INTERVAL_MS
-    );
-    return {
-      providers: [{ capability: index.pipelineRunnerCapability, provider: this }],
-      customActions: pipelineRunnerBenchActions,
-      actionHandlers: {
-        cacheBenchFrame: async (input) => this.cacheBenchFrame(input),
-        releaseBenchFrame: async (input) => this.releaseBenchFrame(input),
-        runSyntheticBench: async (input) => this.runSyntheticBench(input)
-      }
-    };
-  }
-  async onShutdown() {
-    if (this.metricsSnapshotTimer) {
-      clearInterval(this.metricsSnapshotTimer);
-      this.metricsSnapshotTimer = null;
-    }
-    if (this.stepLogTimer) {
-      clearInterval(this.stepLogTimer);
-      this.stepLogTimer = null;
-    }
-    if (this.benchFrameSweeper) {
-      clearInterval(this.benchFrameSweeper);
-      this.benchFrameSweeper = null;
-    }
-    this.benchFrameCache.clear();
-    if (this.unsubMotionEvents) {
-      this.unsubMotionEvents();
-      this.unsubMotionEvents = null;
-    }
-    this.lastAnalyzerDetected.clear();
-    for (const deviceId of [...this.onboardAnalyzerTeardownTimers.keys(), ...this.onboardAnalyzerSubs.keys()]) {
-      this.clearOnboardAnalyzer(deviceId);
-    }
-    if (this.runner) {
-      this.runner.stop();
-      this.runner = null;
-    }
-    for (const attachment of this.attached.values()) {
-      attachment.motionUnsubscribe?.();
-      attachment.detectionUnsubscribe?.();
-    }
-    this.attached.clear();
-  }
-  // ── Synthetic bench (production-equivalent measurement) ───────────────
-  async cacheBenchFrame(input) {
-    const sharp = (await import("sharp")).default;
-    const jpeg = Buffer.from(input.imageBase64, "base64");
-    const { data, info } = await sharp(jpeg).raw().toBuffer({ resolveWithObject: true });
-    if (info.channels !== 3) {
-      throw new Error(`cacheBenchFrame: expected 3 channels (rgb), got ${info.channels}`);
-    }
-    const rgb = new Uint8Array(data);
-    const ttlMs = Math.max(6e4, (input.ttlSeconds ?? 600) * 1e3);
-    const frameId = `runner-bench-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
-    const expiresAt = Date.now() + ttlMs;
-    this.benchFrameCache.set(frameId, { data: rgb, width: info.width, height: info.height, format: "rgb", expiresAt });
-    if (!this.benchFrameSweeper) {
-      this.benchFrameSweeper = setInterval(() => this.sweepBenchFrameCache(), 6e4);
-      this.benchFrameSweeper.unref?.();
-    }
-    this.ctx.logger.info("cached bench frame", {
-      meta: { frameId, width: info.width, height: info.height, bytes: rgb.length, ttlMs }
-    });
-    return { frameId, width: info.width, height: info.height, expiresAt };
-  }
-  async releaseBenchFrame(input) {
-    return { released: this.benchFrameCache.delete(input.frameId) };
-  }
-  sweepBenchFrameCache() {
-    const now = Date.now();
-    for (const [id, entry] of this.benchFrameCache) {
-      if (entry.expiresAt < now) this.benchFrameCache.delete(id);
-    }
-  }
-  async runSyntheticBench(input) {
-    const ctx = this.ctx;
-    const api = ctx.api;
-    if (!api) throw new Error("runSyntheticBench: ctx.api unavailable");
-    ctx.logger.info("runSyntheticBench input", {
-      meta: { frameId: input.frameId, parallel: input.parallel, iterations: input.iterations }
-    });
-    const cached = this.benchFrameCache.get(input.frameId);
-    if (!cached) {
-      throw new Error(`runSyntheticBench: frameId ${input.frameId} not cached (call cacheBenchFrame first)`);
-    }
-    const stepsToRun = input.steps.map((s) => ({
-      addonId: s.addonId,
-      modelId: s.modelId,
-      enabled: s.enabled,
-      children: s.children ?? []
-    }));
-    const enabledSteps = stepsToRun.filter((s) => s.enabled);
-    const isSingleStep = enabledSteps.length === 1 && (!enabledSteps[0].children || enabledSteps[0].children.filter((c) => c.enabled).length === 0);
-    const useFastPath = isSingleStep && !input.simulatePipeline;
-    const rootStep = enabledSteps[0];
-    const sharedFrame = {
-      data: cached.data,
-      format: cached.format,
-      width: cached.width,
-      height: cached.height,
-      timestamp: Date.now()
-    };
-    let poolFrameId = null;
-    if (useFastPath && rootStep) {
-      ctx.logger.info("synthetic bench: using Python cache path", {
-        meta: { step: rootStep.addonId, model: rootStep.modelId }
-      });
-      const cacheResult = await api.pipelineExecutor.cacheFrameInPool.mutate({
-        data: new Uint8Array(cached.data.slice().buffer),
-        width: cached.width,
-        height: cached.height,
-        format: cached.format
-      });
-      poolFrameId = cacheResult.frameId;
-      await api.pipelineExecutor.runPipeline.mutate({
-        steps: stepsToRun,
-        frame: sharedFrame,
-        ...input.engine ? { engine: input.engine } : {}
-      });
-      const warmupCount2 = input.warmup ?? 1;
-      for (let w = 0; w < warmupCount2; w++) {
-        await api.pipelineExecutor.inferCached.mutate({
-          stepId: rootStep.addonId,
-          frameId: poolFrameId
-        });
-      }
-      const wallTimings2 = [];
-      const inferTimings2 = [];
-      const preprocessTimings2 = [];
-      const predictTimings2 = [];
-      const batchSizes2 = [];
-      const detCounts2 = [];
-      let _n = 0;
-      const sessionId2 = input.sessionId ?? `synth-${Date.now().toString(36)}`;
-      const totalRuns2 = input.parallel * input.iterations;
-      const wallStart2 = performance.now();
-      const worker2 = async () => {
-        for (let i = 0; i < input.iterations; i++) {
-          const t0 = performance.now();
-          const result = await api.pipelineExecutor.inferCached.mutate({
-            stepId: rootStep.addonId,
-            frameId: poolFrameId
-          });
-          const wallMs = performance.now() - t0;
-          const r = result;
-          const inferMs = typeof r["inferenceMs"] === "number" ? r["inferenceMs"] : wallMs;
-          const preMs = typeof r["preprocessMs"] === "number" ? r["preprocessMs"] : 0;
-          const predMs = typeof r["predictMs"] === "number" ? r["predictMs"] : 0;
-          const bs = typeof r["batchSize"] === "number" ? r["batchSize"] : 1;
-          const dets = Array.isArray(r["detections"]) ? r["detections"].length : 0;
-          wallTimings2.push(wallMs);
-          inferTimings2.push(inferMs);
-          preprocessTimings2.push(preMs);
-          predictTimings2.push(predMs);
-          batchSizes2.push(bs);
-          detCounts2.push(dets);
-          const n = ++_n;
-          if (n <= 20) {
-            ctx.logger.info("bench call trace (cached)", {
-              meta: { n, wallMs: Math.round(wallMs), inferMs: Math.round(inferMs), preMs: Math.round(preMs * 10) / 10, predMs: Math.round(predMs * 10) / 10, bs }
-            });
-          }
-          if (n % Math.max(1, input.parallel) === 0) {
-            const elapsed = (performance.now() - wallStart2) / 1e3;
-            const fps = elapsed > 0 ? n / elapsed : 0;
-            const meanCallMs = wallTimings2.reduce((s, v) => s + v, 0) / wallTimings2.length;
-            const sorted = [...wallTimings2].sort((a, b) => a - b);
-            const p95 = sorted[Math.min(sorted.length - 1, Math.floor(0.95 * sorted.length))] ?? 0;
-            const totalDet = detCounts2.reduce((s, v) => s + v, 0);
-            const avgDet = detCounts2.length > 0 ? totalDet / detCounts2.length : 0;
-            const bsMean = batchSizes2.reduce((s, v) => s + v, 0) / batchSizes2.length;
-            const msg = `runs ${n}/${totalRuns2} · ${fps.toFixed(1)} fps · call ${meanCallMs.toFixed(1)}ms · batch ${bsMean.toFixed(1)}`;
-            if (ctx.eventBus) {
-              ctx.eventBus.emit({
-                id: `bench-${n}`,
-                timestamp: /* @__PURE__ */ new Date(),
-                source: { type: "pipeline", id: "synthetic-bench" },
-                category: index.EventCategory.PipelineProgress,
-                data: {
-                  nodeId: "hub",
-                  sessionId: sessionId2,
-                  step: "synthetic-bench",
-                  message: msg,
-                  benchProgress: true,
-                  runs: n,
-                  totalRuns: totalRuns2,
-                  fps: Math.round(fps * 100) / 100,
-                  meanMs: Math.round(meanCallMs * 100) / 100,
-                  p95Ms: Math.round(p95 * 100) / 100,
-                  inferMeanMs: Math.round(inferTimings2.reduce((s, v) => s + v, 0) / inferTimings2.length * 100) / 100,
-                  preprocessMeanMs: Math.round(preprocessTimings2.reduce((s, v) => s + v, 0) / preprocessTimings2.length * 100) / 100,
-                  predictMeanMs: Math.round(predictTimings2.reduce((s, v) => s + v, 0) / predictTimings2.length * 100) / 100,
-                  batchSizeMean: Math.round(bsMean * 100) / 100,
-                  detPerSec: elapsed > 0 ? Math.round(totalDet / elapsed * 100) / 100 : 0,
-                  avgDetections: Math.round(avgDet * 100) / 100
-                }
-              });
-            } else {
-              ctx.logger.warn("emitProgress: NO eventBus");
-            }
-          }
-        }
-      };
-      await Promise.all(Array.from({ length: input.parallel }, () => worker2()));
-      const wallSec2 = (performance.now() - wallStart2) / 1e3;
-      await api.pipelineExecutor.uncacheFrame.mutate({ frameId: poolFrameId }).catch(() => {
-      });
-      return this.buildBenchResult(wallTimings2, inferTimings2, preprocessTimings2, predictTimings2, batchSizes2, detCounts2, wallSec2, "cached");
-    }
-    ctx.logger.info("synthetic bench: using full runPipeline path", {
-      meta: { steps: enabledSteps.length, simulatePipeline: !!input.simulatePipeline }
-    });
-    let _callCount = 0;
-    const callOnce = async () => {
-      const t0 = performance.now();
-      const result = await api.pipelineExecutor.runPipeline.mutate({
-        steps: stepsToRun,
-        frame: sharedFrame,
-        ...input.engine ? { engine: input.engine } : {}
-      });
-      const wallMs = performance.now() - t0;
-      const n = ++_callCount;
-      if (n <= 20) {
-        ctx.logger.info("bench call trace", {
-          meta: {
-            n,
-            wallMs: Math.round(wallMs),
-            totalInferenceMs: Math.round(result.debug?.totalInferenceMs ?? 0),
-            predictMs: Math.round((result.debug?.predictMs ?? 0) * 10) / 10,
-            preprocessMs: Math.round((result.debug?.preprocessMs ?? 0) * 10) / 10,
-            batchSize: result.debug?.batchSize ?? 1
-          }
-        });
-      }
-      return { wallMs, result };
-    };
-    const warmupCount = input.warmup ?? 1;
-    for (let i = 0; i < warmupCount; i++) {
-      await callOnce();
-    }
-    const wallTimings = [];
-    const serverWallTimings = [];
-    const inferTimings = [];
-    const preprocessTimings = [];
-    const predictTimings = [];
-    const batchSizes = [];
-    const detCounts = [];
-    const sessionId = input.sessionId ?? `synth-${Date.now().toString(36)}`;
-    const totalRuns = input.parallel * input.iterations;
-    const wallStart = performance.now();
-    const worker = async () => {
-      for (let i = 0; i < input.iterations; i++) {
-        const { wallMs, result } = await callOnce();
-        wallTimings.push(wallMs);
-        serverWallTimings.push(result.debug?.wallMs ?? 0);
-        inferTimings.push(result.debug?.totalInferenceMs ?? 0);
-        preprocessTimings.push(result.debug?.preprocessMs ?? 0);
-        predictTimings.push(result.debug?.predictMs ?? 0);
-        batchSizes.push(result.debug?.batchSize ?? 1);
-        detCounts.push(result.detections?.length ?? 0);
-        const n = wallTimings.length;
-        if (n % Math.max(1, input.parallel) === 0 && ctx.eventBus) {
-          const elapsed = (performance.now() - wallStart) / 1e3;
-          const fps = elapsed > 0 ? n / elapsed : 0;
-          const meanMs = wallTimings.reduce((s, v) => s + v, 0) / n;
-          const sorted = [...wallTimings].sort((a, b) => a - b);
-          const p95 = sorted[Math.min(sorted.length - 1, Math.floor(0.95 * sorted.length))] ?? 0;
-          const totalDet = detCounts.reduce((s, v) => s + v, 0);
-          const bsMean = batchSizes.reduce((s, v) => s + v, 0) / n;
-          ctx.eventBus.emit({
-            id: `bench-${n}`,
-            timestamp: /* @__PURE__ */ new Date(),
-            source: { type: "pipeline", id: "synthetic-bench" },
-            category: index.EventCategory.PipelineProgress,
-            data: {
-              nodeId: "hub",
-              sessionId,
-              step: "synthetic-bench",
-              message: `runs ${n}/${totalRuns} · ${fps.toFixed(1)} fps · call ${meanMs.toFixed(1)}ms · batch ${bsMean.toFixed(1)}`,
-              benchProgress: true,
-              runs: n,
-              totalRuns,
-              fps: Math.round(fps * 100) / 100,
-              meanMs: Math.round(meanMs * 100) / 100,
-              p95Ms: Math.round(p95 * 100) / 100,
-              inferMeanMs: Math.round(inferTimings.reduce((s, v) => s + v, 0) / n * 100) / 100,
-              preprocessMeanMs: Math.round(preprocessTimings.reduce((s, v) => s + v, 0) / n * 100) / 100,
-              predictMeanMs: Math.round(predictTimings.reduce((s, v) => s + v, 0) / n * 100) / 100,
-              batchSizeMean: Math.round(bsMean * 100) / 100,
-              detPerSec: elapsed > 0 ? Math.round(totalDet / elapsed * 100) / 100 : 0,
-              avgDetections: n > 0 ? Math.round(totalDet / n * 100) / 100 : 0
-            }
-          });
-        }
-      }
-    };
-    await Promise.all(Array.from({ length: input.parallel }, () => worker()));
-    const wallSec = (performance.now() - wallStart) / 1e3;
-    return this.buildBenchResult(wallTimings, inferTimings, preprocessTimings, predictTimings, batchSizes, detCounts, wallSec, "pipeline");
-  }
-  async buildBenchResult(wallTimings, inferTimings, preprocessTimings, predictTimings, batchSizes, detCounts, wallSec, path) {
-    const meanOfArr = (xs) => xs.length > 0 ? xs.reduce((s, v) => s + v, 0) / xs.length : 0;
-    this.ctx.logger.info("synthetic bench summary", {
-      meta: {
-        runs: wallTimings.length,
-        wallSec: Math.round(wallSec * 100) / 100,
-        fps: Math.round(wallTimings.length / wallSec * 100) / 100,
-        callMeanMs: Math.round(meanOfArr(wallTimings)),
-        inferMeanMs: Math.round(meanOfArr(inferTimings)),
-        preprocessMeanMs: Math.round(meanOfArr(preprocessTimings)),
-        predictMeanMs: Math.round(meanOfArr(predictTimings)),
-        batchSizeMean: Math.round(meanOfArr(batchSizes) * 100) / 100,
-        batchSizeMax: batchSizes.length > 0 ? Math.max(...batchSizes) : 0
-      }
-    });
-    const sorted = [...wallTimings].sort((a, b) => a - b);
-    const pick = (q) => sorted.length > 0 ? sorted[Math.min(sorted.length - 1, Math.floor(q * sorted.length))] : 0;
-    const meanOf = (xs) => xs.length > 0 ? xs.reduce((s, v) => s + v, 0) / xs.length : 0;
-    const totalRuns = wallTimings.length;
-    const totalDet = detCounts.reduce((s, v) => s + v, 0);
-    return {
-      runs: totalRuns,
-      wallSec: Math.round(wallSec * 1e3) / 1e3,
-      fps: wallSec > 0 ? Math.round(totalRuns / wallSec * 100) / 100 : 0,
-      detectionsPerSec: wallSec > 0 ? Math.round(totalDet / wallSec * 100) / 100 : 0,
-      avgDetections: totalRuns > 0 ? Math.round(totalDet / totalRuns * 100) / 100 : 0,
-      callMs: {
-        mean: Math.round(meanOf(wallTimings) * 100) / 100,
-        p50: Math.round(pick(0.5) * 100) / 100,
-        p95: Math.round(pick(0.95) * 100) / 100,
-        p99: Math.round(pick(0.99) * 100) / 100
-      },
-      inferMs: Math.round(meanOf(inferTimings) * 100) / 100,
-      preprocessMs: Math.round(meanOf(preprocessTimings) * 100) / 100,
-      predictMs: Math.round(meanOf(predictTimings) * 100) / 100,
-      batchSizeMean: Math.round(meanOf(batchSizes) * 100) / 100,
-      batchSizeMax: batchSizes.length > 0 ? Math.max(...batchSizes) : 0,
-      path,
-      ...await this.getEngineAndTuning()
-    };
-  }
-  async getEngineAndTuning() {
-    try {
-      const api = this.ctx.api;
-      if (!api) return {};
-      const [eng, tuning] = await Promise.all([
-        api.pipelineExecutor.getSelectedEngine.query(),
-        api.pipelineExecutor.getEffectiveTuning.query()
-      ]);
-      return {
-        engine: eng ? { runtime: eng.runtime, backend: eng.backend, device: eng.device } : void 0,
-        tuning: tuning ?? void 0
-      };
-    } catch {
-      return {};
-    }
-  }
-  // ── IPipelineRunnerProvider implementation ────────────────────────────
-  async attachCamera(config) {
-    const runner = this.runner;
-    const ctx = this.ctx;
-    if (!runner || !ctx) {
-      throw new Error("PipelineRunnerAddon: attachCamera called before initialize completed");
-    }
-    this.ctx.logger.info("attachCamera received config", {
-      tags: { deviceId: config.deviceId },
-      meta: {
-        motionSources: config.motionSources,
-        motionSourcesType: Array.isArray(config.motionSources) ? `array(${config.motionSources.length})` : typeof config.motionSources,
-        motionStreamId: config.motionStreamId,
-        detectionStreamId: config.detectionStreamId,
-        keys: Object.keys(config)
-      }
-    });
-    if (this.attached.has(config.deviceId)) {
-      this.detachInternal(config.deviceId);
-    }
-    runner.registerCamera(config.deviceId, {
-      detectionMode: config.detectionMode,
-      fps: config.detectionFps,
-      motionCooldownMs: config.motionCooldownMs
-    });
-    const attachment = {
-      config,
-      motionUnsubscribe: null,
-      detectionUnsubscribe: null
-    };
-    this.attached.set(config.deviceId, attachment);
-    if (config.motionSources.includes("analyzer")) {
-      attachment.motionUnsubscribe = await this.subscribeMotionFrames(config);
-    }
-    const stepsCount = config.steps?.length ?? 0;
-    const dispatch = stepsCount > 0 ? `runPipeline(${stepsCount}step${stepsCount === 1 ? "" : "s"})` : config.steps !== void 0 ? "skip(0steps)" : "runFrame(legacy)";
-    const engineLabel = config.engine ? `${config.engine.runtime}+${config.engine.backend}/${config.engine.format}` : "default";
-    this.ctx.logger.info(
-      "attachCamera",
-      {
-        tags: { deviceId: config.deviceId },
-        meta: {
-          detectionMode: config.detectionMode,
-          audioMode: config.audioMode,
-          motionFps: config.motionFps,
-          detectionFps: config.detectionFps,
-          motionSources: config.motionSources,
-          dispatch,
-          engine: engineLabel
-        }
-      }
-    );
-    return { success: true };
-  }
-  async detachCamera(input) {
-    this.detachInternal(input.deviceId);
-    return { success: true };
-  }
-  async reportMotion(input) {
-    this.runner?.reportMotion(input.deviceId, input.detected, input.source, input.regions);
-    return { success: true };
-  }
-  /**
-   * Periodic per-camera step roster dump. Once every
-   * STEP_LOG_INTERVAL_MS (30s) emits one log line per attached camera
-   * with the configured detection step tree + audio classifier branch
-   * so an operator looking at the agent log can quickly see what each
-   * camera is currently running without crossing tRPC. Skips when no
-   * cameras are attached so quiet dev runs stay silent.
-   */
-  logAttachedSteps() {
-    if (this.attached.size === 0) return;
-    for (const [deviceId, attachment] of this.attached) {
-      const cfg = attachment.config;
-      const detectionSteps = cfg.steps && cfg.steps.length > 0 ? this.flattenSteps(cfg.steps).filter((s) => s.enabled) : [];
-      const detectionLabel = detectionSteps.length > 0 ? detectionSteps.map((s) => `${s.addonId}/${s.modelId}`).join(" → ") : "<none>";
-      const audioLabel = cfg.audio && cfg.audio.enabled ? `${cfg.audio.engine.runtime}/${cfg.audio.engine.backend}/${cfg.audio.modelId}` : "<off>";
-      const engineLabel = cfg.engine ? `${cfg.engine.runtime}/${cfg.engine.backend}${cfg.engine.device ? `/${cfg.engine.device}` : ""}` : "<unset>";
-      this.ctx.logger.info("Camera pipeline roster", {
-        tags: { deviceId },
-        meta: {
-          phase: "roster",
-          intervalSec: STEP_LOG_INTERVAL_MS / 1e3,
-          pipelineEnabled: cfg.pipelineEnabled,
-          motionSources: cfg.motionSources,
-          motionFps: cfg.motionFps,
-          detectionFps: cfg.detectionFps,
-          engine: engineLabel,
-          videoSteps: detectionLabel,
-          videoStepCount: detectionSteps.length,
-          audio: audioLabel
-        }
-      });
-    }
-  }
-  /** Recursively flatten the step tree → ordered list of every node. */
-  flattenSteps(steps) {
-    const out = [];
-    const walk = (s) => {
-      out.push(s);
-      if (s.children) {
-        for (const c of s.children) walk(c);
-      }
-    };
-    for (const s of steps) walk(s);
-    return out;
-  }
-  detachInternal(deviceId) {
-    const attachment = this.attached.get(deviceId);
-    if (!attachment) return;
-    this.clearOnboardAnalyzer(deviceId);
-    attachment.motionUnsubscribe?.();
-    attachment.detectionUnsubscribe?.();
-    this.attached.delete(deviceId);
-    this.lastMotionAt.delete(deviceId);
-    this.lastEmittedCameraMetrics.delete(deviceId);
-    this.runner?.unregisterCamera(deviceId);
-    this.ctx?.logger.info("detachCamera", { tags: { deviceId } });
-  }
-  /**
-   * Synchronously cancel the teardown timer and call the unsubscribe
-   * handle for the dynamic onboard analyzer, if one is open. Safe to
-   * call when no subscription exists.
-   */
-  clearOnboardAnalyzer(deviceId) {
-    const timer = this.onboardAnalyzerTeardownTimers.get(deviceId);
-    if (timer !== void 0) {
-      clearTimeout(timer);
-      this.onboardAnalyzerTeardownTimers.delete(deviceId);
-    }
-    const unsub = this.onboardAnalyzerSubs.get(deviceId);
-    if (unsub !== void 0) {
-      try {
-        unsub();
-      } catch {
-      }
-      this.onboardAnalyzerSubs.delete(deviceId);
-    }
-  }
-  /**
-   * Dynamic analyzer gate for onboard-motion cameras.
-   *
-   * Called from the `MotionOnMotionChanged` subscriber whenever
-   * `source === 'onboard'`. Opens a `subscribeMotionFrames` subscription
-   * the first time motion is detected (idempotent — a second `detected:true`
-   * while the sub is already open is a no-op). Always re-arms the teardown
-   * timer so the subscription stays open as long as motion events keep
-   * arriving and tears down `motionCooldownMs` after the last event.
-   *
-   * No-op when:
-   * - The camera is not currently attached.
-   * - `shouldStartOnboardAnalyzer(config)` returns false (flag off or
-   *   `motionSources` already includes `'analyzer'`).
-   */
-  async handleOnboardMotionAnalyzer(deviceId, detected) {
-    const attachment = this.attached.get(deviceId);
-    if (!attachment) return;
-    const config = attachment.config;
-    if (!shouldStartOnboardAnalyzer(config)) return;
-    const log = this.ctx.logger.withTags({ deviceId });
-    if (detected && !this.onboardAnalyzerSubs.has(deviceId)) {
-      const unsub = await this.subscribeMotionFrames(config);
-      if (unsub) {
-        this.onboardAnalyzerSubs.set(deviceId, unsub);
-        log.debug("onboard-analyzer: opened motion-frame subscription");
-      }
-    }
-    const existing = this.onboardAnalyzerTeardownTimers.get(deviceId);
-    if (existing !== void 0) clearTimeout(existing);
-    const cooldownMs = config.motionCooldownMs;
-    const timer = setTimeout(() => {
-      this.onboardAnalyzerTeardownTimers.delete(deviceId);
-      const unsub = this.onboardAnalyzerSubs.get(deviceId);
-      if (!unsub) return;
-      try {
-        unsub();
-      } catch {
-      }
-      this.onboardAnalyzerSubs.delete(deviceId);
-      log.debug("onboard-analyzer: closed after motion cooldown", { meta: { cooldownMs } });
-    }, cooldownMs);
-    this.onboardAnalyzerTeardownTimers.set(deviceId, timer);
-  }
-  async getLocalLoad() {
-    const metrics = this.runner?.getMetrics() ?? { avgInferenceTimeMs: 0, queueDepth: 0 };
-    const allCameraMetrics = this.runner?.getAllCameraMetrics() ?? [];
-    let activeCameras = 0;
-    let totalActualFps = 0;
-    for (const cm of allCameraMetrics) {
-      if (cm.phase === "active") activeCameras++;
-      totalActualFps += cm.actualFps;
-    }
-    return {
-      nodeId: this.nodeId,
-      attachedCameras: this.attached.size,
-      activeCameras,
-      avgInferenceFps: totalActualFps,
-      avgInferenceTimeMs: metrics.avgInferenceTimeMs,
-      queueDepthTotal: metrics.queueDepth,
-      hardware: {
-        hasGpu: false,
-        inferenceBackend: void 0
-      }
-    };
-  }
-  async getLocalMetrics() {
-    const m = this.runner?.getMetrics() ?? { activeCameras: 0, throttledCameras: 0, avgInferenceTimeMs: 0, queueDepth: 0 };
-    return { nodeId: this.nodeId, ...m };
-  }
-  async getCameraMetrics(input) {
-    return this.runner?.getCameraMetrics(input.deviceId) ?? null;
-  }
-  getAllCameraMetrics() {
-    return this.runner?.getAllCameraMetrics() ?? [];
-  }
-  getLocalCameras() {
-    return [...this.attached.keys()];
-  }
-  // ── Internal: broker subscription wiring ─────────────────────────────
-  async subscribeMotionFrames(config) {
-    const ctx = this.ctx;
-    const runner = this.runner;
-    if (!ctx || !runner) return null;
-    const log = this.ctx.logger.withTags({ deviceId: config.deviceId });
-    const api = this.ctx.api;
-    if (!api) {
-      log.warn("subscribeMotionFrames: this.ctx.api not available");
-      return null;
-    }
-    return startFrameHandlePoller({
-      api,
-      brokerId: `${config.deviceId}/${config.motionStreamId}`,
-      format: "gray",
-      maxFps: config.motionFps,
-      tag: "motion",
-      logger: log,
-      // Motion analysis is intra-process and never propagates beyond
-      // the runner; the handle is intentionally ignored here.
-      onFrame: (frame, _handle) => {
-        runner.enqueueMotionFrame(config.deviceId, frame);
-      }
-    });
-  }
-  handleDetectionStreamChange(deviceId, action) {
-    const attachment = this.attached.get(deviceId);
-    if (!attachment) return;
-    if (action === "subscribe") {
-      void this.subscribeDetectionFrames(attachment.config).then((unsub) => {
-        attachment.detectionUnsubscribe = unsub;
-      });
-    } else {
-      attachment.detectionUnsubscribe?.();
-      attachment.detectionUnsubscribe = null;
-    }
-  }
-  /**
-   * Bridge runner phase transitions to the device's `motion` runtime
-   * state + the bus. Single ownership point — every motion source
-   * (analyzer, onboard, future variants) funnels through the runner's
-   * phase machine and lands here.
-   *
-   * - Cap-state via the unified `device-state.setCapSlice` API.
-   *   `autoClearAfterMs = cooldownMs` on ON, `null` on OFF.
-   *   `lastDetectedAt` is preserved across OFF using `lastMotionAt`.
-   * - Bus event `MotionOnMotionChanged` fires alongside for consumers
-   *   that prefer event-driven over runtime-state polling.
-   */
-  handlePhaseChanged(deviceId, phase, meta) {
-    const detected = phase === "active";
-    if (detected) this.lastMotionAt.set(deviceId, meta.timestamp);
-    const lastDetectedAt = this.lastMotionAt.get(deviceId) ?? null;
-    const slice = {
-      detected,
-      lastDetectedAt,
-      autoClearAfterMs: detected ? meta.cooldownMs : null
-    };
-    void (async () => {
-      const dev = await this.ctx.fetchDevice(deviceId);
-      await dev.deviceState.setCapSlice({ capName: "motion", slice });
-    })().catch((err) => {
-      this.ctx.logger.debug("motion cap-state write failed", {
-        tags: { deviceId },
-        meta: { error: index.errMsg(err) }
-      });
-    });
-    if (this.ctx.eventBus) {
-      const from = detected ? "watching" : "active";
-      const to = detected ? "active" : "watching";
-      const reason = detected ? "motion_detected" : "cooldown_expired";
-      const payload = {
-        deviceId,
-        from,
-        to,
-        reason,
-        source: meta.source,
-        cooldownMs: meta.cooldownMs,
-        timestamp: meta.timestamp
-      };
-      this.ctx.eventBus.emit(index.createEvent(
-        index.EventCategory.DetectionPhaseTransition,
-        { type: "device", id: deviceId, addonId: this.ctx.id, deviceId, nodeId: this.nodeId },
-        payload
-      ));
-    }
-  }
-  async subscribeDetectionFrames(config) {
-    const ctx = this.ctx;
-    const runner = this.runner;
-    if (!ctx || !runner) return null;
-    const log = this.ctx.logger.withTags({ deviceId: config.deviceId });
-    const api = this.ctx.api;
-    if (!api) {
-      log.warn("subscribeDetectionFrames: this.ctx.api not available");
-      return null;
-    }
-    return startFrameHandlePoller({
-      api,
-      brokerId: `${config.deviceId}/${config.detectionStreamId}`,
-      format: "rgb",
-      maxFps: config.detectionFps,
-      tag: "detection",
-      logger: log,
-      // Detection threads the `FrameHandle` through the runner so the
-      // emitted `PipelineInferenceResultPayload` can name the shm slot
-      // post-analysis (Task 8) reads pixels back from.
-      onFrame: (frame, handle) => {
-        runner.enqueueDetectionFrame(config.deviceId, frame, handle);
-      }
-    });
-  }
-  // ── Internal: inference + motion callbacks ───────────────────────────
-  async runInference(deviceId, frame) {
-    const ctx = this.ctx;
-    if (!ctx) return null;
-    const log = this.ctx.logger.withTags({ deviceId });
-    const api = this.ctx.api;
-    if (!api) {
-      log.error("runInference: this.ctx.api not available");
-      return null;
-    }
-    const attachment = this.attached.get(deviceId);
-    const camConfig = attachment?.config;
-    const steps = camConfig?.steps;
-    const engine = camConfig?.engine;
-    if (!steps) {
-      log.warn("runInference: no steps in attach config — skipping frame (legacy attach?)");
-      return null;
-    }
-    if (steps.length === 0) {
-      return null;
-    }
-    try {
-      return await api.pipelineExecutor.runPipeline.mutate({
-        // tRPC input is a mutable array; the attach payload holds it
-        // as readonly. One spread copy at the cap boundary is cheap
-        // (pipeline step trees are tiny) and keeps the type surface
-        // clean without casting.
-        steps: [...steps],
-        frame,
-        deviceId,
-        ...engine ? { engine } : {}
-      });
-    } catch (err) {
-      const msg = index.errMsg(err);
-      log.error("runInference failed", { meta: { error: msg } });
-      return null;
-    }
-  }
-  async runMotionAnalysis(deviceId, frame) {
-    const ctx = this.ctx;
-    const runner = this.runner;
-    if (!ctx || !runner) return;
-    const log = this.ctx.logger.withTags({ deviceId });
-    const motionStart = Date.now();
-    try {
-      const api = this.ctx.api;
-      if (!api) {
-        log.warn("runMotionAnalysis: this.ctx.api not available");
-        return;
-      }
-      const result = await api.motionDetection.analyze.mutate({ deviceId, frame: toFrameInput(frame) });
-      if (!result) return;
-      const detected = result.regions.length > 0;
-      const prevDetected = this.lastAnalyzerDetected.get(deviceId) ?? false;
-      if (detected !== prevDetected) {
-        this.lastAnalyzerDetected.set(deviceId, detected);
-        if (this.ctx.eventBus) {
-          this.ctx.eventBus.emit(index.createEvent(
-            index.EventCategory.MotionOnMotionChanged,
-            // EventSource wrapper kept symmetric with the onboard
-            // emit (Reolink/ONVIF/etc.) so consumers grouping by
-            // addonId / deviceId see consistent provenance. `nodeId`
-            // identifies which cluster node ran the analyzer.
-            { type: "device", id: deviceId, addonId: this.ctx.id, deviceId, nodeId: this.nodeId },
-            {
-              deviceId,
-              detected,
-              timestamp: frame.timestamp,
-              source: "analyzer",
-              ...detected ? { regions: result.regions } : {}
-            }
-          ));
-        }
-      }
-      if (this.ctx.eventBus) {
-        const motionPayload = {
-          detected,
-          regionCount: result.regions.length,
-          regions: result.regions.map((r) => ({
-            bbox: { x: r.bbox.x, y: r.bbox.y, w: r.bbox.w, h: r.bbox.h },
-            pixelCount: r.pixelCount,
-            intensity: r.intensity
-          })),
-          frameWidth: frame.width,
-          frameHeight: frame.height,
-          analysisMs: result.analysisMs
-        };
-        const analyzerSource = { type: "device", id: deviceId, addonId: this.ctx.id, deviceId, nodeId: this.nodeId };
-        this.ctx.eventBus.emit(index.createEvent(
-          index.EventCategory.MotionAnalysis,
-          analyzerSource,
-          motionPayload
-        ));
-        const zonesPayload = {
-          deviceId,
-          timestamp: frame.timestamp,
-          zones: result.rawRegions.map((r) => ({
-            bbox: [r.bbox.x, r.bbox.y, r.bbox.x + r.bbox.w, r.bbox.y + r.bbox.h],
-            pixelCount: r.pixelCount,
-            changeScore: r.intensity / 255
-          })),
-          frameSize: { width: frame.width, height: frame.height }
-        };
-        this.ctx.eventBus.emit(index.createEvent(
-          index.EventCategory.MotionZonesRaw,
-          analyzerSource,
-          zonesPayload
-        ));
-      }
-      const capturedAt = frame.capturedAt;
-      const motionFrameAge = typeof capturedAt === "number" && capturedAt > 0 ? motionStart - capturedAt : -1;
-      runner.timingSampler.addMotionSample(deviceId, Date.now() - motionStart, motionFrameAge);
-    } catch (error) {
-      const msg = index.errMsg(error);
-      log.error("runMotionAnalysis failed", { meta: { error: msg } });
-    }
-  }
-  emitInferenceResult(deviceId, frame, result, handle) {
-    const ctx = this.ctx;
-    if (!ctx?.eventBus) return;
-    const capturedAt = frame.capturedAt;
-    const payload = {
-      deviceId,
-      frame: result,
-      nodeId: this.nodeId,
-      frameHandle: handle,
-      ...typeof capturedAt === "number" && capturedAt > 0 ? { capturedAt } : {}
-    };
-    this.ctx.eventBus.emit(index.createEvent(
-      index.EventCategory.PipelineInferenceResult,
-      { type: "device", id: deviceId, nodeId: this.nodeId },
-      payload
-    ));
-  }
-  /**
-   * Emit periodic metric snapshots: one runner-load event for the
-   * node + one camera-metrics event per attached camera. Subscribed
-   * by admin-ui dashboards (LiveLoadPanel, NodeDetailHeader,
-   * CameraStreamPanel) to drive live overlays without polling.
-   *
-   * Skipped when there are no cameras attached so quiet dev runs
-   * don't emit needless bus traffic. The runner-load event is still
-   * emitted in that case because the dashboards rely on it to see
-   * "agent reachable, idle".
-   */
-  emitMetricsSnapshot() {
-    const ctx = this.ctx;
-    const runner = this.runner;
-    if (!ctx?.eventBus || !runner) return;
-    const timestamp = Date.now();
-    void this.getLocalLoad().then((load) => {
-      if (!ctx.eventBus) return;
-      const json = JSON.stringify(load);
-      const prev = this.lastEmittedRunnerLoad;
-      const heartbeatDue = !prev || timestamp - prev.emittedAt >= METRICS_HEARTBEAT_MS;
-      if (prev && prev.json === json && !heartbeatDue) return;
-      this.lastEmittedRunnerLoad = { json, emittedAt: timestamp };
-      ctx.eventBus.emit(index.createEvent(
-        index.EventCategory.PipelineRunnerLoadSnapshot,
-        { type: "node", id: this.nodeId, nodeId: this.nodeId },
-        { nodeId: this.nodeId, load, timestamp }
-      ));
-    }).catch(() => {
-    });
-    if (this.attached.size === 0) return;
-    for (const deviceId of this.attached.keys()) {
-      const metrics = runner.getCameraMetrics(deviceId);
-      if (!metrics) continue;
-      const json = JSON.stringify(metrics);
-      const prev = this.lastEmittedCameraMetrics.get(deviceId);
-      const heartbeatDue = !prev || timestamp - prev.emittedAt >= METRICS_HEARTBEAT_MS;
-      if (prev && prev.json === json && !heartbeatDue) continue;
-      this.lastEmittedCameraMetrics.set(deviceId, { json, emittedAt: timestamp });
-      ctx.eventBus.emit(index.createEvent(
-        index.EventCategory.PipelineCameraMetricsSnapshot,
-        { type: "device", id: deviceId, nodeId: this.nodeId },
-        { deviceId, nodeId: this.nodeId, metrics, timestamp }
-      ));
-    }
-  }
-  // ── Standard ICamstackAddon — three-level settings API (Phase 3) ─────
-  //
-  // The runner is a per-node addon with only ADDON-LEVEL settings (no
-  // per-device overrides, no cluster-wide tunables). All four tuning
-  // fields live in `getAddonSettings()`. When the UI surface moves in
-  // Phase 9 these will be rendered under Pipeline -> node -> Settings.
-  globalSettingsSchema() {
-    return this.schema({
-      sections: [
-        {
-          id: "pipeline-runner-tuning",
-          title: "Pipeline Runner",
-          tab: "scheduler",
-          description: "Per-node detection scheduler tuning. Change only if you understand the pipeline internals.",
-          columns: 2,
-          fields: [
-            {
-              type: "slider",
-              key: "maxConcurrentInferences",
-              label: "Scheduler concurrency",
-              description: 'Max parallel inferences the runner scheduler allows across all cameras on this node. Distinct from the detection-pipeline inference-pool worker count (Pipeline tab → "Worker concurrency"), which controls Python-side thread pool sizing inside a single inference job.',
-              min: 1,
-              max: 16,
-              step: 1,
-              default: DEFAULT_CONFIG.maxConcurrentInferences,
-              showValue: true
-            },
-            {
-              type: "slider",
-              key: "maxQueueDepth",
-              label: "Max queue depth",
-              description: "Maximum frames held per camera before dropping.",
-              min: 5,
-              max: 100,
-              step: 5,
-              default: DEFAULT_CONFIG.maxQueueDepth,
-              showValue: true
-            },
-            {
-              type: "slider",
-              key: "targetLoadPercent",
-              label: "Target load",
-              description: "Percentage of inference capacity to target before throttling FPS.",
-              min: 50,
-              max: 100,
-              step: 5,
-              default: DEFAULT_CONFIG.targetLoadPercent,
-              unit: "%",
-              showValue: true
-            },
-            {
-              type: "slider",
-              key: "minThrottledFps",
-              label: "Min throttled FPS",
-              description: "Lowest FPS the runner will allow when load-shedding.",
-              min: 1,
-              max: 10,
-              step: 1,
-              default: DEFAULT_CONFIG.minThrottledFps,
-              showValue: true
-            }
-          ]
-        }
-      ]
-    });
-  }
-  async onConfigChanged() {
-    this.runner?.updateLimits(this.config);
-    this.ctx.logger.info(
-      "pipeline-runner tuning updated",
-      {
-        meta: {
-          maxQueueDepth: this.config.maxQueueDepth,
-          maxConcurrentInferences: this.config.maxConcurrentInferences,
-          targetLoadPercent: this.config.targetLoadPercent,
-          minThrottledFps: this.config.minThrottledFps
-        }
-      }
-    );
-  }
+	return {
+		data: frame.data,
+		width: frame.width,
+		height: frame.height,
+		format: frame.format,
+		timestamp: frame.timestamp
+	};
 }
+/**
+* Interval for periodic metric snapshot emission. ~1 Hz strikes the
+* balance between UI freshness (overlay phase / fps numbers feel live)
+* and bus traffic (one snapshot per attached camera + one per node
+* load is well under 100 events/s even at 50 cameras).
+*/
+var METRICS_SNAPSHOT_INTERVAL_MS = 1e3;
+/**
+* Force a metrics-snapshot emit at least every 30s even when the
+* payload hasn't changed — gives the UI's "agent reachable" chip a
+* heartbeat without the per-tick spam an unconditional emit
+* produces. Picked so a 5-minute idle window emits ~10 events
+* instead of ~300.
+*/
+var METRICS_HEARTBEAT_MS = 3e4;
+var PipelineRunnerAddon = class extends require_dist.BaseAddon {
+	runner = null;
+	attached = /* @__PURE__ */ new Map();
+	nodeId = "unknown";
+	metricsSnapshotTimer = null;
+	unsubMotionEvents = null;
+	/** Last analyzer-detected state per device — gates the
+	*  `MotionOnMotionChanged` emit in `runMotionAnalysis` to transitions
+	*  only (otherwise we'd emit on every analyzer frame). */
+	lastAnalyzerDetected = /* @__PURE__ */ new Map();
+	/**
+	* Last positive motion timestamp per device — preserved across the
+	* OFF transition so the motion runtime-state slice keeps a stable
+	* `lastDetectedAt` after the cooldown closes the phase. Cleared on
+	* detach.
+	*/
+	lastMotionAt = /* @__PURE__ */ new Map();
+	/**
+	* Dynamic analyzer subscriptions opened on `MotionOnMotionChanged
+	* source:'onboard'` when `onboardMotionDrivesAnalyzer === true`. Each
+	* entry is the unsubscribe handle returned by `subscribeMotionFrames`.
+	* Cleared on teardown timer fire, detach, and shutdown.
+	*/
+	onboardAnalyzerSubs = /* @__PURE__ */ new Map();
+	/**
+	* Teardown timers that close the dynamic analyzer subscription after
+	* `motionCooldownMs` without a new motion event. Re-armed on every
+	* `MotionOnMotionChanged source:'onboard'` call so the sub stays open
+	* while motion persists.
+	*/
+	onboardAnalyzerTeardownTimers = /* @__PURE__ */ new Map();
+	/**
+	* Snapshot-equality cache for metrics-snapshot defer. The runner
+	* fires per-camera metrics every `METRICS_SNAPSHOT_INTERVAL_MS`;
+	* for an idle camera (no inference, queue empty, fps=0) every tick
+	* carries an identical payload. We skip the bus emit when the
+	* payload deep-equals the previous one so the events tab + remote
+	* subscribers stop seeing 60 metrics-snapshots/min/camera that
+	* convey nothing. A periodic heartbeat re-emits every
+	* METRICS_HEARTBEAT_MS so consumers know the runner is still
+	* alive.
+	*/
+	lastEmittedCameraMetrics = /* @__PURE__ */ new Map();
+	lastEmittedRunnerLoad = null;
+	/**
+	* In-memory bench-frame cache (decoded JPEG bytes). Populated by the
+	* `cacheBenchFrame` custom action. Fed into the synthetic-bench loop
+	* via the `frame: FrameInput` shape that mirrors what stream-broker
+	* delivers to this very addon during real camera detection.
+	*/
+	benchFrameCache = /* @__PURE__ */ new Map();
+	benchFrameSweeper = null;
+	occupancyBurstInFlight = /* @__PURE__ */ new Set();
+	constructor() {
+		super({ ...DEFAULT_CONFIG });
+	}
+	async onInitialize() {
+		const raw = this.ctx.kernel.localNodeId ?? this.ctx.id;
+		this.nodeId = raw.includes("/") ? raw.split("/")[0] : raw;
+		this.runner = new PipelineRunner({
+			maxQueueDepth: this.config.maxQueueDepth,
+			maxConcurrentInferences: this.config.maxConcurrentInferences,
+			targetLoadPercent: this.config.targetLoadPercent,
+			minThrottledFps: this.config.minThrottledFps,
+			processFrame: (deviceId, frame) => this.runInference(deviceId, frame),
+			analyzeMotion: (deviceId, frame) => this.runMotionAnalysis(deviceId, frame),
+			onPhaseChanged: (deviceId, phase, meta) => this.handlePhaseChanged(deviceId, phase, meta),
+			logger: this.ctx.logger,
+			onOccupancyRecheck: (deviceId, frames) => {
+				this.runOccupancyBurst(deviceId, frames);
+			}
+		});
+		this.runner.timingSampler.setLogger(this.ctx.logger.child("timing"));
+		this.runner.onDetectionStreamChange((deviceId, action) => {
+			this.handleDetectionStreamChange(deviceId, action);
+		});
+		this.runner.onResult(async (deviceId, frame, result, _streamType, handle) => {
+			this.emitInferenceResult(deviceId, frame, result, handle);
+		});
+		this.runner.start();
+		this.ctx.logger.info("Pipeline runner started", {
+			tags: { nodeId: this.nodeId },
+			meta: {
+				maxConcurrent: this.config.maxConcurrentInferences,
+				queueDepth: this.config.maxQueueDepth
+			}
+		});
+		if (this.ctx.eventBus) this.unsubMotionEvents = this.ctx.eventBus.subscribe({ category: require_dist.EventCategory.MotionOnMotionChanged }, (event) => {
+			const data = event.data;
+			const deviceId = data.deviceId;
+			const attachment = this.attached.get(deviceId);
+			if (!attachment) return;
+			const source = data.source;
+			if (source === "onboard") this.handleOnboardMotionAnalyzer(deviceId, data.detected);
+			if (!attachment.config.motionSources.includes(source)) return;
+			this.runner?.reportMotion(deviceId, data.detected, source, data.regions ? [...data.regions] : void 0);
+		});
+		this.metricsSnapshotTimer = setInterval(() => this.emitMetricsSnapshot(), METRICS_SNAPSHOT_INTERVAL_MS);
+		return {
+			providers: [{
+				capability: require_dist.pipelineRunnerCapability,
+				provider: this
+			}],
+			customActions: pipelineRunnerBenchActions,
+			actionHandlers: {
+				cacheBenchFrame: async (input) => this.cacheBenchFrame(input),
+				releaseBenchFrame: async (input) => this.releaseBenchFrame(input),
+				runSyntheticBench: async (input) => this.runSyntheticBench(input)
+			}
+		};
+	}
+	async onShutdown() {
+		if (this.metricsSnapshotTimer) {
+			clearInterval(this.metricsSnapshotTimer);
+			this.metricsSnapshotTimer = null;
+		}
+		if (this.benchFrameSweeper) {
+			clearInterval(this.benchFrameSweeper);
+			this.benchFrameSweeper = null;
+		}
+		this.benchFrameCache.clear();
+		if (this.unsubMotionEvents) {
+			this.unsubMotionEvents();
+			this.unsubMotionEvents = null;
+		}
+		this.lastAnalyzerDetected.clear();
+		for (const deviceId of [...this.onboardAnalyzerTeardownTimers.keys(), ...this.onboardAnalyzerSubs.keys()]) this.clearOnboardAnalyzer(deviceId);
+		if (this.runner) {
+			this.runner.stop();
+			this.runner = null;
+		}
+		for (const attachment of this.attached.values()) {
+			attachment.motionUnsubscribe?.();
+			attachment.detectionUnsubscribe?.();
+		}
+		this.attached.clear();
+	}
+	async cacheBenchFrame(input) {
+		const sharp = (await import("sharp")).default;
+		const { data, info } = await sharp(Buffer.from(input.imageBase64, "base64")).raw().toBuffer({ resolveWithObject: true });
+		if (info.channels !== 3) throw new Error(`cacheBenchFrame: expected 3 channels (rgb), got ${info.channels}`);
+		const rgb = new Uint8Array(data);
+		const ttlMs = Math.max(6e4, (input.ttlSeconds ?? 600) * 1e3);
+		const frameId = `runner-bench-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+		const expiresAt = Date.now() + ttlMs;
+		this.benchFrameCache.set(frameId, {
+			data: rgb,
+			width: info.width,
+			height: info.height,
+			format: "rgb",
+			expiresAt
+		});
+		if (!this.benchFrameSweeper) {
+			this.benchFrameSweeper = setInterval(() => this.sweepBenchFrameCache(), 6e4);
+			this.benchFrameSweeper.unref?.();
+		}
+		this.ctx.logger.info("cached bench frame", { meta: {
+			frameId,
+			width: info.width,
+			height: info.height,
+			bytes: rgb.length,
+			ttlMs
+		} });
+		return {
+			frameId,
+			width: info.width,
+			height: info.height,
+			expiresAt
+		};
+	}
+	async releaseBenchFrame(input) {
+		return { released: this.benchFrameCache.delete(input.frameId) };
+	}
+	sweepBenchFrameCache() {
+		const now = Date.now();
+		for (const [id, entry] of this.benchFrameCache) if (entry.expiresAt < now) this.benchFrameCache.delete(id);
+	}
+	async runSyntheticBench(input) {
+		const ctx = this.ctx;
+		const api = ctx.api;
+		if (!api) throw new Error("runSyntheticBench: ctx.api unavailable");
+		ctx.logger.info("runSyntheticBench input", { meta: {
+			frameId: input.frameId,
+			parallel: input.parallel,
+			iterations: input.iterations
+		} });
+		const cached = this.benchFrameCache.get(input.frameId);
+		if (!cached) throw new Error(`runSyntheticBench: frameId ${input.frameId} not cached (call cacheBenchFrame first)`);
+		const stepsToRun = input.steps.map((s) => ({
+			addonId: s.addonId,
+			modelId: s.modelId,
+			enabled: s.enabled,
+			children: s.children ?? []
+		}));
+		const enabledSteps = stepsToRun.filter((s) => s.enabled);
+		const useFastPath = enabledSteps.length === 1 && (!enabledSteps[0].children || enabledSteps[0].children.filter((c) => c.enabled).length === 0) && !input.simulatePipeline;
+		const rootStep = enabledSteps[0];
+		const sharedFrame = {
+			data: cached.data,
+			format: cached.format,
+			width: cached.width,
+			height: cached.height,
+			timestamp: Date.now()
+		};
+		let poolFrameId = null;
+		if (useFastPath && rootStep) {
+			ctx.logger.info("synthetic bench: using Python cache path", { meta: {
+				step: rootStep.addonId,
+				model: rootStep.modelId
+			} });
+			poolFrameId = (await api.pipelineExecutor.cacheFrameInPool.mutate({
+				data: new Uint8Array(cached.data.slice().buffer),
+				width: cached.width,
+				height: cached.height,
+				format: cached.format
+			})).frameId;
+			await api.pipelineExecutor.runPipeline.mutate({
+				steps: stepsToRun,
+				frame: sharedFrame,
+				...input.engine ? { engine: input.engine } : {}
+			});
+			const warmupCount = input.warmup ?? 1;
+			for (let w = 0; w < warmupCount; w++) await api.pipelineExecutor.inferCached.mutate({
+				stepId: rootStep.addonId,
+				frameId: poolFrameId
+			});
+			const wallTimings = [];
+			const inferTimings = [];
+			const preprocessTimings = [];
+			const predictTimings = [];
+			const batchSizes = [];
+			const detCounts = [];
+			let _n = 0;
+			const sessionId = input.sessionId ?? `synth-${Date.now().toString(36)}`;
+			const totalRuns = input.parallel * input.iterations;
+			const wallStart = performance.now();
+			const worker = async () => {
+				for (let i = 0; i < input.iterations; i++) {
+					const t0 = performance.now();
+					const result = await api.pipelineExecutor.inferCached.mutate({
+						stepId: rootStep.addonId,
+						frameId: poolFrameId
+					});
+					const wallMs = performance.now() - t0;
+					const r = result;
+					const inferMs = typeof r["inferenceMs"] === "number" ? r["inferenceMs"] : wallMs;
+					const preMs = typeof r["preprocessMs"] === "number" ? r["preprocessMs"] : 0;
+					const predMs = typeof r["predictMs"] === "number" ? r["predictMs"] : 0;
+					const bs = typeof r["batchSize"] === "number" ? r["batchSize"] : 1;
+					const dets = Array.isArray(r["detections"]) ? r["detections"].length : 0;
+					wallTimings.push(wallMs);
+					inferTimings.push(inferMs);
+					preprocessTimings.push(preMs);
+					predictTimings.push(predMs);
+					batchSizes.push(bs);
+					detCounts.push(dets);
+					const n = ++_n;
+					if (n <= 20) ctx.logger.info("bench call trace (cached)", { meta: {
+						n,
+						wallMs: Math.round(wallMs),
+						inferMs: Math.round(inferMs),
+						preMs: Math.round(preMs * 10) / 10,
+						predMs: Math.round(predMs * 10) / 10,
+						bs
+					} });
+					if (n % Math.max(1, input.parallel) === 0) {
+						const elapsed = (performance.now() - wallStart) / 1e3;
+						const fps = elapsed > 0 ? n / elapsed : 0;
+						const meanCallMs = wallTimings.reduce((s, v) => s + v, 0) / wallTimings.length;
+						const sorted = [...wallTimings].toSorted((a, b) => a - b);
+						const p95 = sorted[Math.min(sorted.length - 1, Math.floor(.95 * sorted.length))] ?? 0;
+						const totalDet = detCounts.reduce((s, v) => s + v, 0);
+						const avgDet = detCounts.length > 0 ? totalDet / detCounts.length : 0;
+						const bsMean = batchSizes.reduce((s, v) => s + v, 0) / batchSizes.length;
+						const msg = `runs ${n}/${totalRuns} \u00b7 ${fps.toFixed(1)} fps \u00b7 call ${meanCallMs.toFixed(1)}ms \u00b7 batch ${bsMean.toFixed(1)}`;
+						if (ctx.eventBus) ctx.eventBus.emit({
+							id: `bench-${n}`,
+							timestamp: /* @__PURE__ */ new Date(),
+							source: {
+								type: "pipeline",
+								id: "synthetic-bench"
+							},
+							category: require_dist.EventCategory.PipelineProgress,
+							data: {
+								nodeId: "hub",
+								sessionId,
+								step: "synthetic-bench",
+								message: msg,
+								benchProgress: true,
+								runs: n,
+								totalRuns,
+								fps: Math.round(fps * 100) / 100,
+								meanMs: Math.round(meanCallMs * 100) / 100,
+								p95Ms: Math.round(p95 * 100) / 100,
+								inferMeanMs: Math.round(inferTimings.reduce((s, v) => s + v, 0) / inferTimings.length * 100) / 100,
+								preprocessMeanMs: Math.round(preprocessTimings.reduce((s, v) => s + v, 0) / preprocessTimings.length * 100) / 100,
+								predictMeanMs: Math.round(predictTimings.reduce((s, v) => s + v, 0) / predictTimings.length * 100) / 100,
+								batchSizeMean: Math.round(bsMean * 100) / 100,
+								detPerSec: elapsed > 0 ? Math.round(totalDet / elapsed * 100) / 100 : 0,
+								avgDetections: Math.round(avgDet * 100) / 100
+							}
+						});
+						else ctx.logger.warn("emitProgress: NO eventBus");
+					}
+				}
+			};
+			await Promise.all(Array.from({ length: input.parallel }, () => worker()));
+			const wallSec = (performance.now() - wallStart) / 1e3;
+			await api.pipelineExecutor.uncacheFrame.mutate({ frameId: poolFrameId }).catch(() => {});
+			return this.buildBenchResult(wallTimings, inferTimings, preprocessTimings, predictTimings, batchSizes, detCounts, wallSec, "cached");
+		}
+		ctx.logger.info("synthetic bench: using full runPipeline path", { meta: {
+			steps: enabledSteps.length,
+			simulatePipeline: !!input.simulatePipeline
+		} });
+		let _callCount = 0;
+		const callOnce = async () => {
+			const t0 = performance.now();
+			const result = await api.pipelineExecutor.runPipeline.mutate({
+				steps: stepsToRun,
+				frame: sharedFrame,
+				...input.engine ? { engine: input.engine } : {}
+			});
+			const wallMs = performance.now() - t0;
+			const n = ++_callCount;
+			if (n <= 20) ctx.logger.info("bench call trace", { meta: {
+				n,
+				wallMs: Math.round(wallMs),
+				totalInferenceMs: Math.round(result.debug?.totalInferenceMs ?? 0),
+				predictMs: Math.round((result.debug?.predictMs ?? 0) * 10) / 10,
+				preprocessMs: Math.round((result.debug?.preprocessMs ?? 0) * 10) / 10,
+				batchSize: result.debug?.batchSize ?? 1
+			} });
+			return {
+				wallMs,
+				result
+			};
+		};
+		const warmupCount = input.warmup ?? 1;
+		for (let i = 0; i < warmupCount; i++) await callOnce();
+		const wallTimings = [];
+		const serverWallTimings = [];
+		const inferTimings = [];
+		const preprocessTimings = [];
+		const predictTimings = [];
+		const batchSizes = [];
+		const detCounts = [];
+		const sessionId = input.sessionId ?? `synth-${Date.now().toString(36)}`;
+		const totalRuns = input.parallel * input.iterations;
+		const wallStart = performance.now();
+		const worker = async () => {
+			for (let i = 0; i < input.iterations; i++) {
+				const { wallMs, result } = await callOnce();
+				wallTimings.push(wallMs);
+				serverWallTimings.push(result.debug?.wallMs ?? 0);
+				inferTimings.push(result.debug?.totalInferenceMs ?? 0);
+				preprocessTimings.push(result.debug?.preprocessMs ?? 0);
+				predictTimings.push(result.debug?.predictMs ?? 0);
+				batchSizes.push(result.debug?.batchSize ?? 1);
+				detCounts.push(result.detections?.length ?? 0);
+				const n = wallTimings.length;
+				if (n % Math.max(1, input.parallel) === 0 && ctx.eventBus) {
+					const elapsed = (performance.now() - wallStart) / 1e3;
+					const fps = elapsed > 0 ? n / elapsed : 0;
+					const meanMs = wallTimings.reduce((s, v) => s + v, 0) / n;
+					const sorted = [...wallTimings].toSorted((a, b) => a - b);
+					const p95 = sorted[Math.min(sorted.length - 1, Math.floor(.95 * sorted.length))] ?? 0;
+					const totalDet = detCounts.reduce((s, v) => s + v, 0);
+					const bsMean = batchSizes.reduce((s, v) => s + v, 0) / n;
+					ctx.eventBus.emit({
+						id: `bench-${n}`,
+						timestamp: /* @__PURE__ */ new Date(),
+						source: {
+							type: "pipeline",
+							id: "synthetic-bench"
+						},
+						category: require_dist.EventCategory.PipelineProgress,
+						data: {
+							nodeId: "hub",
+							sessionId,
+							step: "synthetic-bench",
+							message: `runs ${n}/${totalRuns} \u00b7 ${fps.toFixed(1)} fps \u00b7 call ${meanMs.toFixed(1)}ms \u00b7 batch ${bsMean.toFixed(1)}`,
+							benchProgress: true,
+							runs: n,
+							totalRuns,
+							fps: Math.round(fps * 100) / 100,
+							meanMs: Math.round(meanMs * 100) / 100,
+							p95Ms: Math.round(p95 * 100) / 100,
+							inferMeanMs: Math.round(inferTimings.reduce((s, v) => s + v, 0) / n * 100) / 100,
+							preprocessMeanMs: Math.round(preprocessTimings.reduce((s, v) => s + v, 0) / n * 100) / 100,
+							predictMeanMs: Math.round(predictTimings.reduce((s, v) => s + v, 0) / n * 100) / 100,
+							batchSizeMean: Math.round(bsMean * 100) / 100,
+							detPerSec: elapsed > 0 ? Math.round(totalDet / elapsed * 100) / 100 : 0,
+							avgDetections: n > 0 ? Math.round(totalDet / n * 100) / 100 : 0
+						}
+					});
+				}
+			}
+		};
+		await Promise.all(Array.from({ length: input.parallel }, () => worker()));
+		const wallSec = (performance.now() - wallStart) / 1e3;
+		return this.buildBenchResult(wallTimings, inferTimings, preprocessTimings, predictTimings, batchSizes, detCounts, wallSec, "pipeline");
+	}
+	async buildBenchResult(wallTimings, inferTimings, preprocessTimings, predictTimings, batchSizes, detCounts, wallSec, path) {
+		const meanOfArr = (xs) => xs.length > 0 ? xs.reduce((s, v) => s + v, 0) / xs.length : 0;
+		this.ctx.logger.info("synthetic bench summary", { meta: {
+			runs: wallTimings.length,
+			wallSec: Math.round(wallSec * 100) / 100,
+			fps: Math.round(wallTimings.length / wallSec * 100) / 100,
+			callMeanMs: Math.round(meanOfArr(wallTimings)),
+			inferMeanMs: Math.round(meanOfArr(inferTimings)),
+			preprocessMeanMs: Math.round(meanOfArr(preprocessTimings)),
+			predictMeanMs: Math.round(meanOfArr(predictTimings)),
+			batchSizeMean: Math.round(meanOfArr(batchSizes) * 100) / 100,
+			batchSizeMax: batchSizes.length > 0 ? Math.max(...batchSizes) : 0
+		} });
+		const sorted = [...wallTimings].toSorted((a, b) => a - b);
+		const pick = (q) => sorted.length > 0 ? sorted[Math.min(sorted.length - 1, Math.floor(q * sorted.length))] : 0;
+		const meanOf = (xs) => xs.length > 0 ? xs.reduce((s, v) => s + v, 0) / xs.length : 0;
+		const totalRuns = wallTimings.length;
+		const totalDet = detCounts.reduce((s, v) => s + v, 0);
+		return {
+			runs: totalRuns,
+			wallSec: Math.round(wallSec * 1e3) / 1e3,
+			fps: wallSec > 0 ? Math.round(totalRuns / wallSec * 100) / 100 : 0,
+			detectionsPerSec: wallSec > 0 ? Math.round(totalDet / wallSec * 100) / 100 : 0,
+			avgDetections: totalRuns > 0 ? Math.round(totalDet / totalRuns * 100) / 100 : 0,
+			callMs: {
+				mean: Math.round(meanOf(wallTimings) * 100) / 100,
+				p50: Math.round(pick(.5) * 100) / 100,
+				p95: Math.round(pick(.95) * 100) / 100,
+				p99: Math.round(pick(.99) * 100) / 100
+			},
+			inferMs: Math.round(meanOf(inferTimings) * 100) / 100,
+			preprocessMs: Math.round(meanOf(preprocessTimings) * 100) / 100,
+			predictMs: Math.round(meanOf(predictTimings) * 100) / 100,
+			batchSizeMean: Math.round(meanOf(batchSizes) * 100) / 100,
+			batchSizeMax: batchSizes.length > 0 ? Math.max(...batchSizes) : 0,
+			path,
+			...await this.getEngineAndTuning()
+		};
+	}
+	async getEngineAndTuning() {
+		try {
+			const api = this.ctx.api;
+			if (!api) return {};
+			const [eng, tuning] = await Promise.all([api.pipelineExecutor.getSelectedEngine.query(), api.pipelineExecutor.getEffectiveTuning.query()]);
+			return {
+				engine: eng ? {
+					runtime: eng.runtime,
+					backend: eng.backend,
+					device: eng.device
+				} : void 0,
+				tuning: tuning ?? void 0
+			};
+		} catch {
+			return {};
+		}
+	}
+	async attachCamera(config) {
+		const runner = this.runner;
+		const ctx = this.ctx;
+		if (!runner || !ctx) throw new Error("PipelineRunnerAddon: attachCamera called before initialize completed");
+		this.ctx.logger.info("attachCamera received config", {
+			tags: { deviceId: config.deviceId },
+			meta: {
+				motionSources: config.motionSources,
+				motionSourcesType: Array.isArray(config.motionSources) ? `array(${config.motionSources.length})` : typeof config.motionSources,
+				motionStreamId: config.motionStreamId,
+				detectionStreamId: config.detectionStreamId,
+				keys: Object.keys(config)
+			}
+		});
+		if (this.attached.has(config.deviceId)) this.detachInternal(config.deviceId);
+		runner.registerCamera(config.deviceId, {
+			detectionMode: config.detectionMode,
+			fps: config.detectionFps,
+			motionCooldownMs: config.motionCooldownMs,
+			occupancyRecheckSec: config.occupancyRecheckSec,
+			occupancyRecheckFrames: config.occupancyRecheckFrames
+		});
+		const attachment = {
+			config,
+			motionUnsubscribe: null,
+			detectionUnsubscribe: null
+		};
+		this.attached.set(config.deviceId, attachment);
+		if (config.motionSources.includes("analyzer")) attachment.motionUnsubscribe = await this.subscribeMotionFrames(config);
+		const stepsCount = config.steps?.length ?? 0;
+		const dispatch = stepsCount > 0 ? `runPipeline(${stepsCount}step${stepsCount === 1 ? "" : "s"})` : config.steps !== void 0 ? "skip(0steps)" : "runFrame(legacy)";
+		const engineLabel = config.engine ? `${config.engine.runtime}+${config.engine.backend}/${config.engine.format}` : "default";
+		this.ctx.logger.info("attachCamera", {
+			tags: { deviceId: config.deviceId },
+			meta: {
+				detectionMode: config.detectionMode,
+				audioMode: config.audioMode,
+				motionFps: config.motionFps,
+				detectionFps: config.detectionFps,
+				motionSources: config.motionSources,
+				dispatch,
+				engine: engineLabel
+			}
+		});
+		return { success: true };
+	}
+	async detachCamera(input) {
+		this.detachInternal(input.deviceId);
+		return { success: true };
+	}
+	async reportMotion(input) {
+		this.runner?.reportMotion(input.deviceId, input.detected, input.source, input.regions);
+		return { success: true };
+	}
+	detachInternal(deviceId) {
+		const attachment = this.attached.get(deviceId);
+		if (!attachment) return;
+		this.clearOnboardAnalyzer(deviceId);
+		attachment.motionUnsubscribe?.();
+		attachment.detectionUnsubscribe?.();
+		this.attached.delete(deviceId);
+		this.lastMotionAt.delete(deviceId);
+		this.lastEmittedCameraMetrics.delete(deviceId);
+		this.runner?.unregisterCamera(deviceId);
+		this.ctx?.logger.info("detachCamera", { tags: { deviceId } });
+	}
+	/**
+	* Synchronously cancel the teardown timer and call the unsubscribe
+	* handle for the dynamic onboard analyzer, if one is open. Safe to
+	* call when no subscription exists.
+	*/
+	clearOnboardAnalyzer(deviceId) {
+		const timer = this.onboardAnalyzerTeardownTimers.get(deviceId);
+		if (timer !== void 0) {
+			clearTimeout(timer);
+			this.onboardAnalyzerTeardownTimers.delete(deviceId);
+		}
+		const unsub = this.onboardAnalyzerSubs.get(deviceId);
+		if (unsub !== void 0) {
+			try {
+				unsub();
+			} catch {}
+			this.onboardAnalyzerSubs.delete(deviceId);
+		}
+	}
+	/**
+	* Dynamic analyzer gate for onboard-motion cameras.
+	*
+	* Called from the `MotionOnMotionChanged` subscriber whenever
+	* `source === 'onboard'`. Opens a `subscribeMotionFrames` subscription
+	* the first time motion is detected (idempotent — a second `detected:true`
+	* while the sub is already open is a no-op). Always re-arms the teardown
+	* timer so the subscription stays open as long as motion events keep
+	* arriving and tears down `motionCooldownMs` after the last event.
+	*
+	* No-op when:
+	* - The camera is not currently attached.
+	* - `shouldStartOnboardAnalyzer(config)` returns false (flag off or
+	*   `motionSources` already includes `'analyzer'`).
+	*/
+	async handleOnboardMotionAnalyzer(deviceId, detected) {
+		const attachment = this.attached.get(deviceId);
+		if (!attachment) return;
+		const config = attachment.config;
+		if (!shouldStartOnboardAnalyzer(config)) return;
+		const log = this.ctx.logger.withTags({ deviceId });
+		if (detected && !this.onboardAnalyzerSubs.has(deviceId)) {
+			const unsub = await this.subscribeMotionFrames(config);
+			if (unsub) {
+				this.onboardAnalyzerSubs.set(deviceId, unsub);
+				log.debug("onboard-analyzer: opened motion-frame subscription");
+			}
+		}
+		const existing = this.onboardAnalyzerTeardownTimers.get(deviceId);
+		if (existing !== void 0) clearTimeout(existing);
+		const cooldownMs = config.motionCooldownMs;
+		const timer = setTimeout(() => {
+			this.onboardAnalyzerTeardownTimers.delete(deviceId);
+			const unsub = this.onboardAnalyzerSubs.get(deviceId);
+			if (!unsub) return;
+			try {
+				unsub();
+			} catch {}
+			this.onboardAnalyzerSubs.delete(deviceId);
+			log.debug("onboard-analyzer: closed after motion cooldown", { meta: { cooldownMs } });
+		}, cooldownMs);
+		this.onboardAnalyzerTeardownTimers.set(deviceId, timer);
+	}
+	async getLocalLoad() {
+		const metrics = this.runner?.getMetrics() ?? {
+			activeCameras: 0,
+			throttledCameras: 0,
+			avgInferenceTimeMs: 0,
+			queueDepth: 0
+		};
+		const allCameraMetrics = this.runner?.getAllCameraMetrics() ?? [];
+		let activeCameras = 0;
+		let totalActualFps = 0;
+		for (const cm of allCameraMetrics) {
+			if (cm.phase === "active") activeCameras++;
+			totalActualFps += cm.actualFps;
+		}
+		return {
+			nodeId: this.nodeId,
+			attachedCameras: this.attached.size,
+			activeCameras,
+			avgInferenceFps: totalActualFps,
+			avgInferenceTimeMs: metrics.avgInferenceTimeMs,
+			queueDepthTotal: metrics.queueDepth,
+			hardware: {
+				hasGpu: false,
+				inferenceBackend: void 0
+			}
+		};
+	}
+	async getLocalMetrics() {
+		const m = this.runner?.getMetrics() ?? {
+			activeCameras: 0,
+			throttledCameras: 0,
+			avgInferenceTimeMs: 0,
+			queueDepth: 0
+		};
+		return {
+			nodeId: this.nodeId,
+			...m
+		};
+	}
+	async getCameraMetrics(input) {
+		return this.runner?.getCameraMetrics(input.deviceId) ?? null;
+	}
+	getAllCameraMetrics() {
+		return this.runner?.getAllCameraMetrics() ?? [];
+	}
+	getLocalCameras() {
+		return [...this.attached.keys()];
+	}
+	async subscribeMotionFrames(config) {
+		const ctx = this.ctx;
+		const runner = this.runner;
+		if (!ctx || !runner) return null;
+		const log = this.ctx.logger.withTags({ deviceId: config.deviceId });
+		const api = this.ctx.api;
+		if (!api) {
+			log.warn("subscribeMotionFrames: this.ctx.api not available");
+			return null;
+		}
+		return startFrameHandlePoller({
+			api,
+			brokerId: require_dist.makeSourceBrokerId(config.deviceId, config.motionStreamId),
+			format: "gray",
+			maxFps: config.motionFps,
+			tag: "motion",
+			logger: log,
+			onFrame: (frame, _handle) => {
+				runner.enqueueMotionFrame(config.deviceId, frame);
+			}
+		});
+	}
+	handleDetectionStreamChange(deviceId, action) {
+		const attachment = this.attached.get(deviceId);
+		if (!attachment) return;
+		if (action === "subscribe") this.subscribeDetectionFrames(attachment.config).then((unsub) => {
+			attachment.detectionUnsubscribe = unsub;
+		});
+		else {
+			attachment.detectionUnsubscribe?.();
+			attachment.detectionUnsubscribe = null;
+		}
+	}
+	/**
+	* Bridge runner phase transitions to the device's `motion` runtime
+	* state + the bus. Single ownership point — every motion source
+	* (analyzer, onboard, future variants) funnels through the runner's
+	* phase machine and lands here.
+	*
+	* - Cap-state via the unified `device-state.setCapSlice` API.
+	*   `autoClearAfterMs = cooldownMs` on ON, `null` on OFF.
+	*   `lastDetectedAt` is preserved across OFF using `lastMotionAt`.
+	* - Bus event `MotionOnMotionChanged` fires alongside for consumers
+	*   that prefer event-driven over runtime-state polling.
+	*/
+	handlePhaseChanged(deviceId, phase, meta) {
+		const detected = phase === "active";
+		if (detected) this.lastMotionAt.set(deviceId, meta.timestamp);
+		const slice = {
+			detected,
+			lastDetectedAt: this.lastMotionAt.get(deviceId) ?? null,
+			autoClearAfterMs: detected ? meta.cooldownMs : null
+		};
+		(async () => {
+			await (await this.ctx.fetchDevice(deviceId)).deviceState.setCapSlice({
+				capName: "motion",
+				slice
+			});
+		})().catch((err) => {
+			this.ctx.logger.debug("motion cap-state write failed", {
+				tags: { deviceId },
+				meta: { error: require_dist.errMsg(err) }
+			});
+		});
+		if (this.ctx.eventBus) {
+			const payload = {
+				deviceId,
+				from: detected ? "watching" : "active",
+				to: detected ? "active" : "watching",
+				reason: detected ? "motion_detected" : "cooldown_expired",
+				source: meta.source,
+				cooldownMs: meta.cooldownMs,
+				timestamp: meta.timestamp
+			};
+			this.ctx.eventBus.emit(require_dist.createEvent(require_dist.EventCategory.DetectionPhaseTransition, {
+				type: "device",
+				id: deviceId,
+				addonId: this.ctx.id,
+				deviceId,
+				nodeId: this.nodeId
+			}, payload));
+		}
+	}
+	async subscribeDetectionFrames(config) {
+		const ctx = this.ctx;
+		const runner = this.runner;
+		if (!ctx || !runner) return null;
+		const log = this.ctx.logger.withTags({ deviceId: config.deviceId });
+		const api = this.ctx.api;
+		if (!api) {
+			log.warn("subscribeDetectionFrames: this.ctx.api not available");
+			return null;
+		}
+		return startFrameHandlePoller({
+			api,
+			brokerId: require_dist.makeSourceBrokerId(config.deviceId, config.detectionStreamId),
+			format: "rgb",
+			maxFps: config.detectionFps,
+			tag: "detection",
+			logger: log,
+			onFrame: (frame, handle) => {
+				runner.enqueueDetectionFrame(config.deviceId, frame, handle);
+			}
+		});
+	}
+	async runInference(deviceId, frame) {
+		if (!this.ctx) return null;
+		const log = this.ctx.logger.withTags({ deviceId });
+		const api = this.ctx.api;
+		if (!api) {
+			log.error("runInference: this.ctx.api not available");
+			return null;
+		}
+		const camConfig = this.attached.get(deviceId)?.config;
+		const steps = camConfig?.steps;
+		const engine = camConfig?.engine;
+		if (!steps) {
+			log.warn("runInference: no steps in attach config — skipping frame (legacy attach?)");
+			return null;
+		}
+		if (steps.length === 0) return null;
+		try {
+			return await api.pipelineExecutor.runPipeline.mutate({
+				steps: [...steps],
+				frame,
+				deviceId,
+				...engine ? { engine } : {}
+			});
+		} catch (err) {
+			const msg = require_dist.errMsg(err);
+			log.error("runInference failed", { meta: { error: msg } });
+			return null;
+		}
+	}
+	async runMotionAnalysis(deviceId, frame) {
+		const ctx = this.ctx;
+		const runner = this.runner;
+		if (!ctx || !runner) return;
+		const log = this.ctx.logger.withTags({ deviceId });
+		const motionStart = Date.now();
+		try {
+			const api = this.ctx.api;
+			if (!api) {
+				log.warn("runMotionAnalysis: this.ctx.api not available");
+				return;
+			}
+			const result = await api.motionDetection.analyze.mutate({
+				deviceId,
+				frame: toFrameInput(frame)
+			});
+			if (!result) return;
+			const detected = result.regions.length > 0;
+			if (detected !== (this.lastAnalyzerDetected.get(deviceId) ?? false)) {
+				this.lastAnalyzerDetected.set(deviceId, detected);
+				if (this.ctx.eventBus) this.ctx.eventBus.emit(require_dist.createEvent(require_dist.EventCategory.MotionOnMotionChanged, {
+					type: "device",
+					id: deviceId,
+					addonId: this.ctx.id,
+					deviceId,
+					nodeId: this.nodeId
+				}, {
+					deviceId,
+					detected,
+					timestamp: frame.timestamp,
+					source: "analyzer",
+					...detected ? { regions: result.regions } : {}
+				}));
+			}
+			if (this.ctx.eventBus) {
+				const motionPayload = {
+					detected,
+					regionCount: result.regions.length,
+					regions: result.regions.map((r) => ({
+						bbox: {
+							x: r.bbox.x,
+							y: r.bbox.y,
+							w: r.bbox.w,
+							h: r.bbox.h
+						},
+						pixelCount: r.pixelCount,
+						intensity: r.intensity
+					})),
+					frameWidth: frame.width,
+					frameHeight: frame.height,
+					analysisMs: result.analysisMs
+				};
+				const analyzerSource = {
+					type: "device",
+					id: deviceId,
+					addonId: this.ctx.id,
+					deviceId,
+					nodeId: this.nodeId
+				};
+				this.ctx.eventBus.emit(require_dist.createEvent(require_dist.EventCategory.MotionAnalysis, analyzerSource, motionPayload));
+				const zonesPayload = {
+					deviceId,
+					timestamp: frame.timestamp,
+					zones: result.rawRegions.map((r) => ({
+						bbox: [
+							r.bbox.x,
+							r.bbox.y,
+							r.bbox.x + r.bbox.w,
+							r.bbox.y + r.bbox.h
+						],
+						pixelCount: r.pixelCount,
+						changeScore: r.intensity / 255
+					})),
+					frameSize: {
+						width: frame.width,
+						height: frame.height
+					}
+				};
+				this.ctx.eventBus.emit(require_dist.createEvent(require_dist.EventCategory.MotionZonesRaw, analyzerSource, zonesPayload));
+			}
+			const capturedAt = frame.capturedAt;
+			const motionFrameAge = typeof capturedAt === "number" && capturedAt > 0 ? motionStart - capturedAt : -1;
+			runner.timingSampler.addMotionSample(deviceId, Date.now() - motionStart, motionFrameAge);
+		} catch (error) {
+			const msg = require_dist.errMsg(error);
+			log.error("runMotionAnalysis failed", { meta: { error: msg } });
+		}
+	}
+	async runOccupancyBurst(deviceId, frames) {
+		if (this.occupancyBurstInFlight.has(deviceId)) return;
+		const attachment = this.attached.get(deviceId);
+		if (!attachment) return;
+		const config = attachment.config;
+		const runner = this.runner;
+		if (!runner) return;
+		const log = this.ctx.logger.withTags({ deviceId });
+		const api = this.ctx.api;
+		if (!api) {
+			log.debug("runOccupancyBurst: ctx.api not available");
+			return;
+		}
+		this.occupancyBurstInFlight.add(deviceId);
+		log.debug("occupancy re-check: starting burst", { meta: { frames } });
+		let count = 0;
+		let unsubscribe = null;
+		let unsubbed = false;
+		let settled = false;
+		const doUnsub = () => {
+			if (!unsubbed && unsubscribe) {
+				unsubbed = true;
+				unsubscribe();
+			}
+		};
+		const cleanup = () => {
+			if (settled) return;
+			settled = true;
+			doUnsub();
+			this.occupancyBurstInFlight.delete(deviceId);
+			log.debug("occupancy re-check: burst complete", { meta: { collected: count } });
+		};
+		const safetyTimer = setTimeout(() => {
+			log.debug("occupancy re-check: safety timeout reached", { meta: { collected: count } });
+			cleanup();
+		}, 8e3);
+		try {
+			unsubscribe = await startFrameHandlePoller({
+				api,
+				brokerId: require_dist.makeSourceBrokerId(config.deviceId, config.detectionStreamId),
+				format: "rgb",
+				maxFps: config.detectionFps,
+				tag: "occupancy",
+				logger: log,
+				onFrame: (frame, handle) => {
+					if (settled) return;
+					runner.enqueueOccupancyFrame(deviceId, frame, handle);
+					count++;
+					if (count >= frames) {
+						clearTimeout(safetyTimer);
+						cleanup();
+					}
+				}
+			});
+		} catch (err) {
+			clearTimeout(safetyTimer);
+			this.occupancyBurstInFlight.delete(deviceId);
+			log.debug("occupancy re-check: poller start failed", { meta: { error: require_dist.errMsg(err) } });
+			return;
+		}
+		if (settled) {
+			clearTimeout(safetyTimer);
+			doUnsub();
+		}
+	}
+	emitInferenceResult(deviceId, frame, result, handle) {
+		if (!this.ctx?.eventBus) return;
+		const capturedAt = frame.capturedAt;
+		const payload = {
+			deviceId,
+			frame: result,
+			nodeId: this.nodeId,
+			frameHandle: handle,
+			...typeof capturedAt === "number" && capturedAt > 0 ? { capturedAt } : {}
+		};
+		this.ctx.eventBus.emit(require_dist.createEvent(require_dist.EventCategory.PipelineInferenceResult, {
+			type: "device",
+			id: deviceId,
+			nodeId: this.nodeId
+		}, payload));
+	}
+	/**
+	* Emit periodic metric snapshots: one runner-load event for the
+	* node + one camera-metrics event per attached camera. Subscribed
+	* by admin-ui dashboards (LiveLoadPanel, NodeDetailHeader,
+	* CameraStreamPanel) to drive live overlays without polling.
+	*
+	* Skipped when there are no cameras attached so quiet dev runs
+	* don't emit needless bus traffic. The runner-load event is still
+	* emitted in that case because the dashboards rely on it to see
+	* "agent reachable, idle".
+	*/
+	emitMetricsSnapshot() {
+		const ctx = this.ctx;
+		const runner = this.runner;
+		if (!ctx?.eventBus || !runner) return;
+		const timestamp = Date.now();
+		this.getLocalLoad().then((load) => {
+			if (!ctx.eventBus) return;
+			const json = JSON.stringify(load);
+			const prev = this.lastEmittedRunnerLoad;
+			const heartbeatDue = !prev || timestamp - prev.emittedAt >= METRICS_HEARTBEAT_MS;
+			if (prev && prev.json === json && !heartbeatDue) return;
+			this.lastEmittedRunnerLoad = {
+				json,
+				emittedAt: timestamp
+			};
+			ctx.eventBus.emit(require_dist.createEvent(require_dist.EventCategory.PipelineRunnerLoadSnapshot, {
+				type: "node",
+				id: this.nodeId,
+				nodeId: this.nodeId
+			}, {
+				nodeId: this.nodeId,
+				load,
+				timestamp
+			}));
+		}).catch(() => {});
+		if (this.attached.size === 0) return;
+		for (const deviceId of this.attached.keys()) {
+			const metrics = runner.getCameraMetrics(deviceId);
+			if (!metrics) continue;
+			const json = JSON.stringify(metrics);
+			const prev = this.lastEmittedCameraMetrics.get(deviceId);
+			const heartbeatDue = !prev || timestamp - prev.emittedAt >= METRICS_HEARTBEAT_MS;
+			if (prev && prev.json === json && !heartbeatDue) continue;
+			this.lastEmittedCameraMetrics.set(deviceId, {
+				json,
+				emittedAt: timestamp
+			});
+			ctx.eventBus.emit(require_dist.createEvent(require_dist.EventCategory.PipelineCameraMetricsSnapshot, {
+				type: "device",
+				id: deviceId,
+				nodeId: this.nodeId
+			}, {
+				deviceId,
+				nodeId: this.nodeId,
+				metrics,
+				timestamp
+			}));
+		}
+	}
+	globalSettingsSchema() {
+		return this.schema({ sections: [{
+			id: "pipeline-runner-tuning",
+			title: "Pipeline Runner",
+			tab: "scheduler",
+			description: "Per-node detection scheduler tuning. Change only if you understand the pipeline internals.",
+			columns: 2,
+			fields: [
+				{
+					type: "slider",
+					key: "maxConcurrentInferences",
+					label: "Scheduler concurrency",
+					description: "Max parallel inferences the runner scheduler allows across all cameras on this node. Distinct from the detection-pipeline inference-pool worker count (Pipeline tab → \"Worker concurrency\"), which controls Python-side thread pool sizing inside a single inference job.",
+					min: 1,
+					max: 16,
+					step: 1,
+					default: DEFAULT_CONFIG.maxConcurrentInferences,
+					showValue: true
+				},
+				{
+					type: "slider",
+					key: "maxQueueDepth",
+					label: "Max queue depth",
+					description: "Maximum frames held per camera before dropping.",
+					min: 5,
+					max: 100,
+					step: 5,
+					default: DEFAULT_CONFIG.maxQueueDepth,
+					showValue: true
+				},
+				{
+					type: "slider",
+					key: "targetLoadPercent",
+					label: "Target load",
+					description: "Percentage of inference capacity to target before throttling FPS.",
+					min: 50,
+					max: 100,
+					step: 5,
+					default: DEFAULT_CONFIG.targetLoadPercent,
+					unit: "%",
+					showValue: true
+				},
+				{
+					type: "slider",
+					key: "minThrottledFps",
+					label: "Min throttled FPS",
+					description: "Lowest FPS the runner will allow when load-shedding.",
+					min: 1,
+					max: 10,
+					step: 1,
+					default: DEFAULT_CONFIG.minThrottledFps,
+					showValue: true
+				}
+			]
+		}] });
+	}
+	async onConfigChanged() {
+		this.runner?.updateLimits(this.config);
+		this.ctx.logger.info("pipeline-runner tuning updated", { meta: {
+			maxQueueDepth: this.config.maxQueueDepth,
+			maxConcurrentInferences: this.config.maxConcurrentInferences,
+			targetLoadPercent: this.config.targetLoadPercent,
+			minThrottledFps: this.config.minThrottledFps
+		} });
+	}
+};
+//#endregion
 exports.FrameQueue = FrameQueue;
 exports.PipelineRunner = PipelineRunner;
 exports.PipelineTimingSampler = PipelineTimingSampler;
@@ -1862,4 +2062,3 @@ exports.Semaphore = Semaphore;
 exports.customActions = pipelineRunnerBenchActions;
 exports.default = PipelineRunnerAddon;
 exports.shouldStartOnboardAnalyzer = shouldStartOnboardAnalyzer;
-//# sourceMappingURL=index.js.map