@camstack/addon-pipeline 1.2.213 → 1.2.215

package/dist/pipeline-runner/index.mjs

@@ -1,17 +1,17 @@
-import { $ as failureContributionCapability, It as errMsg, Qt as nodePin, R as customAction, U as deriveDetailCropRect, Ut as BaseAddon, V as defineCustomActions, _ as FailureCounters, _t as pickDetailCropConvention, an as boolean, bt as pipelineRunnerCapability, cn as literal, hn as EventCategory, in as array, it as loadContributionCapability, ln as number, m as DEVICE_BACKEND_TO_FORMAT, p as DEFAULT_NATIVE_LEASE_SETTINGS, pn as string, qt as createEvent, rn as _enum, sn as lazy, u as DEFAULT_DETAIL_CROP_CONVENTION, un as object, vt as pickNativeLeaseOverride } from "../dist-CsI90TVi.mjs";
-import { i as NO_COST_CLAIM, t as ChildCostRegistry } from "../node-6Pb_t1Fm.mjs";
-import { i as resolveFrameViewGeometry, l as getStepDefinition, r as localFrameRegistry } from "../default-detection-model-B-PccVsO.mjs";
-import { a as nativeLeaseSettingEnv, t as isWorkerReply } from "../worker-protocol-DNqdtZzZ.mjs";
+import { $ as failureContributionCapability, It as errMsg, Qt as nodePin, R as customAction, U as deriveDetailCropRect, Ut as BaseAddon, V as defineCustomActions, _ as FailureCounters, _t as pickDetailCropConvention, an as boolean, bt as pipelineRunnerCapability, cn as literal, hn as EventCategory, in as array, it as loadContributionCapability, ln as number, m as DEVICE_BACKEND_TO_FORMAT, p as DEFAULT_NATIVE_LEASE_SETTINGS, pn as string, qt as createEvent, rn as _enum, sn as lazy, u as DEFAULT_DETAIL_CROP_CONVENTION, un as object, vt as pickNativeLeaseOverride } from "../dist-DttqKvsQ.mjs";
+import { i as NO_COST_CLAIM, t as ChildCostRegistry } from "../node-NtM7__8q.mjs";
+import { i as resolveFrameViewGeometry, l as getStepDefinition, r as localFrameRegistry } from "../default-detection-model-C2vYSX3O.mjs";
+import { a as nativeLeaseSettingEnv, t as isWorkerReply } from "../worker-protocol-BKwkLZWT.mjs";
 import { t as resolveHubHostname } from "../hub-hostname-cCknRYKj.mjs";
 import { t as getSharp } from "../lazy-sharp-DXsqwpph.mjs";
 import { a as preRollRequestOf, o as withDetectionIntent, t as DETECTION_PRE_ROLL_REQUEST_MS } from "../restream-intent-DWe2kInY.mjs";
-import { t as attributeStall } from "../event-loop-stall-monitor-DXLNBMkY.mjs";
 import { n as profileForStreamId, t as isRemoteRestream } from "../remote-restream-BeHi78PZ.mjs";
 import * as os from "node:os";
 import { fork } from "node:child_process";
 import sharp from "sharp";
 import { fileURLToPath } from "node:url";
 import { PerformanceObserver } from "node:perf_hooks";
+import { attributeStall } from "@camstack/system/addon-utils";
 //#region src/session-decode/fork-decode-worker.ts
 /** Absolute path to the built decode-worker child entry (a vite build entry). */
 var CHILD_ENTRY_PATH = fileURLToPath(new URL("../session-decode/decode-worker-child.js", import.meta.url));
@@ -1004,6 +1004,7 @@ var SessionDecodeSession = class {
 	frameTimeoutMs;
 	firstFrameMaxWaitMs;
 	onDialTiming;
+	onPreRollReport;
 	pendingPull = null;
 	pendingToBuffers = /* @__PURE__ */ new Map();
 	/** Outstanding `nativeCrop` requests, keyed by the monotonic `requestId`. */
@@ -1017,7 +1018,7 @@ var SessionDecodeSession = class {
 	firstFrameReceived = false;
 	/** `Date.now()` of the FIRST `pull` — the origin of the cold-start ceiling. */
 	firstPullAt = 0;
-	constructor(child, logger, deviceId, firstFrameTimeoutMs, frameTimeoutMs, firstFrameMaxWaitMs, onDialTiming) {
+	constructor(child, logger, deviceId, firstFrameTimeoutMs, frameTimeoutMs, firstFrameMaxWaitMs, onDialTiming, onPreRollReport) {
 		this.child = child;
 		this.logger = logger;
 		this.deviceId = deviceId;
@@ -1025,6 +1026,7 @@ var SessionDecodeSession = class {
 		this.frameTimeoutMs = frameTimeoutMs;
 		this.firstFrameMaxWaitMs = firstFrameMaxWaitMs;
 		this.onDialTiming = onDialTiming;
+		this.onPreRollReport = onPreRollReport;
 		this.child.on("message", (m) => this.handleMessage(m));
 		this.child.on("exit", (m) => this.handleExit(toWorkerExitInfo(m)));
 	}
@@ -1215,6 +1217,17 @@ var SessionDecodeSession = class {
 					streamInfoProbed: raw.streamInfoProbed
 				});
 				return;
+			case "preRollReport":
+				this.onPreRollReport?.({
+					offered: raw.offered,
+					inferred: raw.inferred,
+					dropped: raw.dropped,
+					droppedByReason: raw.droppedByReason,
+					strideMs: raw.strideMs,
+					subsampled: raw.subsampled,
+					spanMs: raw.spanMs
+				});
+				return;
 		}
 	}
 	handleExit(info) {
@@ -1439,7 +1452,7 @@ function createSessionDecodeCoordinator(deps) {
 	const frameTimeoutMs = deps.frameTimeoutMs ?? DEFAULT_FRAME_TIMEOUT_MS;
 	const firstFrameMaxWaitMs = Math.max(deps.firstFrameMaxWaitMs ?? DEFAULT_FIRST_FRAME_MAX_WAIT_MS, firstFrameTimeoutMs);
 	return { async *generateVideoFrames(source, opts) {
-		const session = new SessionDecodeSession(deps.fork(source), deps.logger, source.deviceId, firstFrameTimeoutMs, frameTimeoutMs, firstFrameMaxWaitMs, deps.onDialTiming);
+		const session = new SessionDecodeSession(deps.fork(source), deps.logger, source.deviceId, firstFrameTimeoutMs, frameTimeoutMs, firstFrameMaxWaitMs, deps.onDialTiming, deps.onPreRollReport);
 		session.start(source, opts);
 		try {
 			while (true) {
@@ -1448,7 +1461,9 @@ function createSessionDecodeCoordinator(deps) {
 				const { reply } = outcome;
 				yield {
 					timestamp: reply.timestamp,
-					image: buildFrameImage(session, reply)
+					image: buildFrameImage(session, reply),
+					...reply.capturedAt !== void 0 ? { capturedAt: reply.capturedAt } : {},
+					...reply.preRoll === true ? { preRoll: true } : {}
 				};
 			}
 		} finally {
@@ -1462,10 +1477,18 @@ function createSessionDecodeCoordinator(deps) {
 * Build a {@link DecodedFrame} from one pulled {@link VideoFrame}. Downscales to
 * the detection working width (see {@link resolveWorkingResize}) so the ROI
 * scaler ships a small frame instead of the full source resolution.
-* `capturedAt` is set to `Date.now()` so downstream frameAge metrics diff
-* against the wall clock (mirrors the shm-ring source, which stamps commit
-* time) — this is what lets Step 5 MEASURE session-decode frameAge vs the
-* shm-ring cameras.
+* `capturedAt` is the frame's OWN moment: the worker's media clock when it has
+* one (`media-clock.ts`), else `Date.now()` as before, so downstream frameAge
+* metrics keep diffing against the wall clock (mirroring the shm-ring source,
+* which stamps commit time) — this is what lets Step 5 MEASURE session-decode
+* frameAge vs the shm-ring cameras.
+*
+* The fallback is deliberate and must stay: a `Date.now()` here for a frame
+* replayed out of ~4 s of retained history would date its detections, its
+* track's `firstSeen`, its media and the notification's instant at SESSION
+* OPEN. That is a silently wrong timestamp — nothing downstream can tell it
+* from a right one — and it is a worse failure than the late birth the pre-roll
+* pass exists to fix.
 */
 async function toDecodedFrame(frame, format, viewSpec) {
 	const geometry = viewSpec ? resolveFrameViewGeometry(frame.image.width, frame.image.height, viewSpec) : void 0;
@@ -1480,7 +1503,8 @@ async function toDecodedFrame(frame, format, viewSpec) {
 		height: geometry?.output.height ?? frame.image.height,
 		format: viewSpec?.format ?? format,
 		timestamp: frame.timestamp,
-		capturedAt: Date.now()
+		capturedAt: frame.capturedAt ?? Date.now(),
+		...frame.preRoll === true ? { preRoll: true } : {}
 	};
 }
 /**
@@ -1501,7 +1525,8 @@ function startSessionDecodePump(deps) {
 			dialTiming = timing;
 		},
 		...deps.firstFrameTimeoutMs !== void 0 ? { firstFrameTimeoutMs: deps.firstFrameTimeoutMs } : {},
-		...deps.frameTimeoutMs !== void 0 ? { frameTimeoutMs: deps.frameTimeoutMs } : {}
+		...deps.frameTimeoutMs !== void 0 ? { frameTimeoutMs: deps.frameTimeoutMs } : {},
+		...deps.onPreRollReport ? { onPreRollReport: deps.onPreRollReport } : {}
 	}).generateVideoFrames(deps.source, deps.opts);
 	let stopped = false;
 	let releaseSpawnSlot = null;
@@ -1543,7 +1568,7 @@ function startSessionDecodePump(deps) {
 				}
 				let imageOwnershipTransferred = false;
 				try {
-					if (deps.shouldMaterializeFrame && !deps.shouldMaterializeFrame()) continue;
+					if (deps.shouldMaterializeFrame && !deps.shouldMaterializeFrame(frame.preRoll === true)) continue;
 					const image = frame.image;
 					const cropFn = image.nativeCrop;
 					const nativeCrop = cropFn ? Object.assign((bbox, maxWidth) => cropFn(bbox, maxWidth), {
@@ -1552,7 +1577,7 @@ function startSessionDecodePump(deps) {
 						markInferred: () => image.markInferred?.()
 					}) : void 0;
 					if (deps.frameRegistry && deps.onFrameRef && deps.inlineWhen?.() !== true) {
-						const capturedAt = Date.now();
+						const capturedAt = frame.capturedAt ?? Date.now();
 						const ref = deps.frameRegistry.register(image, {
 							timestamp: frame.timestamp,
 							capturedAt
@@ -1566,7 +1591,8 @@ function startSessionDecodePump(deps) {
 							format: ref.format,
 							timestamp: ref.timestamp,
 							capturedAt,
-							frameRef: ref
+							frameRef: ref,
+							...frame.preRoll === true ? { preRoll: true } : {}
 						};
 						try {
 							if (!await deps.onFrameRef(lazyFrame, nativeCrop)) deps.frameRegistry.release(ref, "drop");
@@ -4696,6 +4722,44 @@ function ownFrame(frame) {
 	};
 }
 //#endregion
+//#region src/pipeline-runner/pre-roll-lane.ts
+var PreRollLane = class {
+	items = [];
+	capacity;
+	clone;
+	dispose;
+	_refused = 0;
+	constructor(options) {
+		this.capacity = Math.max(0, options.capacity);
+		this.clone = options.clone;
+		this.dispose = options.dispose;
+	}
+	/** Append one entry. `false` ⇒ the lane is full and the caller must log it. */
+	enqueue(item) {
+		if (this.items.length >= this.capacity) {
+			this._refused++;
+			return false;
+		}
+		this.items.push(this.clone(item));
+		return true;
+	}
+	/** Oldest first — the point of the lane. */
+	dequeue() {
+		return this.items.shift();
+	}
+	get size() {
+		return this.items.length;
+	}
+	/** Entries refused because the lane was full, for the session's report line. */
+	get refused() {
+		return this._refused;
+	}
+	clear() {
+		for (const item of this.items) this.dispose?.(item);
+		this.items.length = 0;
+	}
+};
+//#endregion
 //#region src/pipeline-runner/semaphore.ts
 /**
 * Counting semaphore with FIFO waiter queue. Used by the runner to bound
@@ -5014,8 +5078,6 @@ var PipelineTimingSampler = class {
 		this.audioSamples.clear();
 	}
 };
-//#endregion
-//#region src/pipeline-runner/runner.ts
 /**
 * Bound on one `processFrame` call. Chosen well above the slowest legitimate
 * inference seen in production (8 617 ms, GPU contention on the hub) so the
@@ -5190,6 +5252,14 @@ var PipelineRunner = class {
 			registration,
 			motionQueue,
 			detectionQueue,
+			preRollQueue: new PreRollLane({
+				capacity: this.config.maxPreRollQueueDepth ?? 12,
+				clone: ownDetectionEntry,
+				dispose: (entry) => {
+					if (entry.handle) this.config.releaseRetention?.(entry.handle, "drop");
+					if (entry.frame.frameRef) this.config.releaseFrameRef?.(entry.frame.frameRef, "drop");
+				}
+			}),
 			inferenceTimes: [],
 			shedFrames: 0,
 			inflight: 0,
@@ -5236,6 +5306,7 @@ var PipelineRunner = class {
 		if (state.phase === "active") this.detectionStreamHandler?.(deviceId, "unsubscribe");
 		state.motionQueue.clear();
 		state.detectionQueue.clear();
+		state.preRollQueue.clear();
 		this.timingSampler.clearDroppedFramesSource(deviceId);
 		this.cameras.delete(deviceId);
 		this.lastAdmittedAt.delete(deviceId);
@@ -5317,6 +5388,59 @@ var PipelineRunner = class {
 			maxInflightPerCamera: cap
 		};
 	}
+	/**
+	* Queue one PRE-ROLL frame — a frame decoded out of the restreamer's retained
+	* history at session open, carrying its own capture moment
+	* (`session-decode/media-clock.ts`), not the moment it was decoded.
+	*
+	* Deliberately NOT routed through {@link reserveDetectionFrame}: that gate
+	* paces on WALL CLOCK, and a catch-up burst delivers seconds of media inside
+	* milliseconds of wall clock, so the governor would reject the whole burst
+	* bar one frame. The burst's own bound is a MEDIA-time stride applied
+	* upstream, under an explicit frame + wall-clock budget
+	* (`session-decode/pre-roll-burst.ts`); by the time a frame reaches here it
+	* has already been chosen.
+	*
+	* `false` means the lane is full or the camera is not taking detection
+	* frames. The caller LOGS that: a burst silently truncated by the lane and a
+	* burst that fit read identically otherwise, and this is a branch that drops
+	* work.
+	*/
+	enqueuePreRollFrame(deviceId, frame, handle) {
+		const state = this.cameras.get(deviceId);
+		if (!state || state.phase !== "active") return false;
+		return state.preRollQueue.enqueue({
+			frame,
+			handle
+		});
+	}
+	/**
+	* Whether one more history frame would be taken. Asked BEFORE pixels are
+	* materialized so a burst that has already filled the lane costs no RGB
+	* conversion, no IPC and no retention work — the same pixel-free discipline
+	* the live path gets from `reserveDetectionFrame`.
+	*/
+	preRollLaneAccepting(deviceId) {
+		const state = this.cameras.get(deviceId);
+		if (!state || state.phase !== "active") return false;
+		return state.preRollQueue.size < (this.config.maxPreRollQueueDepth ?? 12);
+	}
+	/** Frames of history waiting for a spare permit, for the session report line. */
+	preRollQueueDepth(deviceId) {
+		return this.cameras.get(deviceId)?.preRollQueue.size ?? 0;
+	}
+	/** Frames this camera lane REFUSED because it was full. */
+	preRollRefusedCount(deviceId) {
+		return this.cameras.get(deviceId)?.preRollQueue.refused ?? 0;
+	}
+	/**
+	* Whether the node has a permit to spare for history right now — i.e. one
+	* would still be free after the burst took one. See
+	* {@link PRE_ROLL_PERMIT_RESERVE}.
+	*/
+	preRollDispatchable() {
+		return this.semaphore.available > 1;
+	}
 	enqueueReservedDetectionFrame(deviceId, frame, handle) {
 		const state = this.cameras.get(deviceId);
 		if (!state || state.phase !== "active") return false;
@@ -5747,7 +5871,7 @@ var PipelineRunner = class {
 			entry: state.detectionQueue.dequeue(),
 			state
 		};
-		if (this.defaultRoundRobinKeys.length === 0) return null;
+		if (this.defaultRoundRobinKeys.length === 0) return this.pickNextPreRollFrame();
 		const startIndex = this.defaultRoundRobinIndex;
 		for (let i = 0; i < this.defaultRoundRobinKeys.length; i++) {
 			const idx = (startIndex + i) % this.defaultRoundRobinKeys.length;
@@ -5766,6 +5890,30 @@ var PipelineRunner = class {
 				};
 			}
 		}
+		return this.pickNextPreRollFrame();
+	}
+	/**
+	* The catch-up lane, reached ONLY after every camera's live queue came back
+	* empty. That ordering IS the priority rule: a live frame is always picked
+	* first, so a pre-roll frame can never delay one — and the burst simply
+	* stops progressing while the camera is busy, which is the correct behaviour
+	* for one-shot work whose value does not decay.
+	*/
+	pickNextPreRollFrame() {
+		if (!this.preRollDispatchable()) return null;
+		for (const [deviceId, state] of this.cameras) {
+			if (state.phase !== "active") continue;
+			if (state.preRollQueue.size === 0) continue;
+			if (state.detectionQueue.size > 0) continue;
+			if (state.inflight >= this.maxInflightPerCamera()) continue;
+			const entry = state.preRollQueue.dequeue();
+			if (!entry) continue;
+			return {
+				deviceId,
+				entry,
+				state
+			};
+		}
 		return null;
 	}
 };
@@ -8569,10 +8717,23 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends BaseAddon {
 	/** Attach → first decoded detection frame, one line per attach. See
 	*  {@link FirstDetectionFrameTimer}. */
 	firstDetectionFrame = new FirstDetectionFrameTimer();
+	/**
+	* Frames this camera's pre-roll catch-up burst may send to inference.
+	*
+	* The switch and the budget are ONE number here on purpose: `false` and
+	* `0` mean the same thing to every layer below (no burst is constructed, the
+	* history is decoded to reach a GOP and then discarded exactly as it was
+	* before D411), and two independent ways to say it is two ways to disagree.
+	*/
+	preRollBudgetFor(config) {
+		if (!config.preRollInferenceEnabled) return 0;
+		const frames = config.preRollInferenceFrames;
+		return Number.isFinite(frames) && frames > 0 ? frames : 0;
+	}
 	enqueueSharedDetectionFrame(deviceId, frame, handle, reservation) {
 		const runner = this.runner;
 		if (!runner) return false;
-		const admitted = reservation ? reservation.detection && runner.enqueueReservedDetectionFrame(deviceId, frame, handle) : runner.enqueueDetectionFrame(deviceId, frame, handle);
+		const admitted = frame.preRoll === true ? runner.enqueuePreRollFrame(deviceId, frame, handle) : reservation ? reservation.detection && runner.enqueueReservedDetectionFrame(deviceId, frame, handle) : runner.enqueueDetectionFrame(deviceId, frame, handle);
 		if (admitted) {
 			const latencyMs = this.firstDetectionFrame.takeLatency(deviceId, Date.now());
 			if (latencyMs !== null) this.ctx?.logger.info("session-decode: first detection frame after attach", {
@@ -8690,9 +8851,19 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends BaseAddon {
 					source,
 					opts: {
 						fps: config.detectionFps,
-						format: "rgb"
+						format: "rgb",
+						preRollMs: preRollRequestOf(source.restreamUrl),
+						preRollMaxFrames: this.preRollBudgetFor(config)
 					},
-					shouldMaterializeFrame: () => {
+					shouldMaterializeFrame: (preRoll) => {
+						if (preRoll) {
+							const accepting = runner.preRollLaneAccepting(config.deviceId);
+							reservation = {
+								detection: accepting,
+								motion: false
+							};
+							return accepting;
+						}
 						reservation = this.reserveSharedDetectionFrame(config.deviceId);
 						const materialize = reservation.detection || reservation.motion;
 						this.retention?.noteFrame({
@@ -8726,7 +8897,7 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends BaseAddon {
 								materialized: false,
 								workerToRunnerBytes: 0
 							});
-							const admitted = current.detection && runner.enqueueReservedDetectionFrame(config.deviceId, frame, handle);
+							const admitted = current.detection && (frame.preRoll === true ? runner.enqueuePreRollFrame(config.deviceId, frame, handle) : runner.enqueueReservedDetectionFrame(config.deviceId, frame, handle));
 							if (admitted) nativeCrop?.markInferred();
 							if (current.motion) {
 								const motion = await resolveMotionFrameView(localFrameRegistry, frame.frameRef);
@@ -8743,6 +8914,24 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends BaseAddon {
 						}
 					} : { inlineViewSpec: SPLIT_DETECTION_VIEW },
 					acquireSpawnSlot: this.buildDecodeSpawnAcquire(log, "detect"),
+					onPreRollReport: (report) => {
+						log.info("session-decode: pre-roll catch-up burst", {
+							tags: { deviceId: config.deviceId },
+							meta: {
+								streamId: config.detectionStreamId,
+								requestedMs: preRollRequestOf(source.restreamUrl),
+								spanMs: report.spanMs,
+								offered: report.offered,
+								inferred: report.inferred,
+								dropped: report.dropped,
+								droppedByReason: report.droppedByReason,
+								strideMs: report.strideMs,
+								subsampled: report.subsampled,
+								laneRefused: runner.preRollRefusedCount(config.deviceId),
+								budgetFrames: this.preRollBudgetFor(config)
+							}
+						});
+					},
 					onFirstFrame: (timing) => {
 						const phaseActiveAt = this.lastMotionAt.get(config.deviceId);
 						log.info("session-decode: detection first frame", {
@@ -9691,6 +9880,7 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends BaseAddon {
 			frame: result,
 			nodeId: this.nodeId,
 			frameHandle: handle,
+			emittedAt: Date.now(),
 			...typeof capturedAt === "number" && capturedAt > 0 ? { capturedAt } : {},
 			...detailSteps && detailSteps.length > 0 ? { detailSteps } : {}
 		};

package/dist/{process-memory-B8yoOaEl.js → process-memory-BRdyl5fE.js}

@@ -1,4 +1,4 @@
-const require_dist = require("./dist-CyfP2nFh.js");
+const require_dist = require("./dist-DoHcimdu.js");
 let node_fs = require("node:fs");
 node_fs = require_dist.__toESM(node_fs);
 let node_child_process = require("node:child_process");

package/dist/{process-memory-B_-QzMHn.mjs → process-memory-CddpCDWL.mjs}

@@ -1,4 +1,4 @@
-import { mt as parseProcStatus } from "./dist-CsI90TVi.mjs";
+import { mt as parseProcStatus } from "./dist-DttqKvsQ.mjs";
 import * as fs from "node:fs";
 import { execFile } from "node:child_process";
 //#region src/shared/node-topology-platform.ts

package/dist/recorder/index.js

@@ -2,11 +2,10 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-const require_dist = require("../dist-CyfP2nFh.js");
-const require_node = require("../node-CkBqyM-0.js");
+const require_dist = require("../dist-DoHcimdu.js");
+const require_node = require("../node-6uF72wri.js");
 const require_hub_hostname = require("../hub-hostname-DAJXlOgV.js");
 const require_restream_intent = require("../restream-intent-B1Difcnq.js");
-const require_event_loop_stall_monitor = require("../event-loop-stall-monitor-DaUBcb13.js");
 const require_retire_root_keys = require("../retire-root-keys-Csb8z2f3.js");
 let node_crypto = require("node:crypto");
 let node_fs = require("node:fs");
@@ -10468,6 +10467,8 @@ Object.freeze({
 			"pipelineEnabled": true,
 			"zones": [],
 			"onboardMotionDrivesAnalyzer": true,
+			"preRollInferenceEnabled": true,
+			"preRollInferenceFrames": 12,
 			"occupancyRecheckEnabled": true,
 			"occupancyRecheckSec": 300,
 			"occupancyRecheckFrames": 4,
@@ -16981,11 +16982,15 @@ var RecorderV2Addon = class extends require_dist.BaseAddon {
 	/**
 	* Stops the GC-attributing stall monitor armed in {@link onInitialize}.
 	*
-	* REUSED, not re-implemented, and not promoted: `startEventLoopStallMonitor`
-	* already ships inside `@camstack/addon-pipeline` — the same bundle as this
-	* addon — and moving it into `@camstack/system` would duplicate a mechanism
-	* that already exists (forbidden) or relocate it across a package boundary,
-	* which is a refactor with a slower ship chain, not a measurement.
+	* REUSED, never re-implemented. It used to live next door in this bundle;
+	* on 2026-09-09 it moved to `@camstack/system/addon-utils` (the subpath, never
+	* the barrel — that one drags the kernel into the runner) because two more
+	* processes that do NOT share this bundle needed it — `pipeline-analytics` and
+	* hub-main — and a per-bundle copy is how two diagnostics end up disagreeing
+	* about the same freeze. The cost of the move is a slower ship chain: this
+	* import is host-resolved, so a `camstack deploy` of this addon onto a hub
+	* whose server closure predates the export fails to load. Deploy order is
+	* closure first, addons second. See D417.
 	*/
 	stopStallMonitor = null;
 	/**
@@ -17186,7 +17191,7 @@ var RecorderV2Addon = class extends require_dist.BaseAddon {
 		} });
 	}
 	async onInitialize() {
-		this.stopStallMonitor = require_event_loop_stall_monitor.startEventLoopStallMonitor(this.ctx.logger);
+		this.stopStallMonitor = (0, _camstack_system_addon_utils.startEventLoopStallMonitor)(this.ctx.logger);
 		const raw = this.ctx.kernel.localNodeId ?? this.ctx.id;
 		this.nodeId = raw.includes("/") ? raw.split("/")[0] : raw;
 		const configuredNode = this.config.recordingNodeId;

package/dist/recorder/index.mjs

@@ -1,15 +1,14 @@
-import { At as storageEvictableCapability, Ct as recordingSignalCapability, D as RecordingSignalStatusSchema, E as RecordingConfigSchema, Et as resolveLocationMode, Gt as DeviceFeature, H as deriveBatteryPresence, It as errMsg, Jt as hydrateSchema, Kt as DeviceType, Nt as stripRetiredBandPreBufferSec, Ot as resolveRecordingProfiles, P as batteryCapability, Q as evictionPolicyOfLocation, Qt as nodePin, R as customAction, St as recordingExportCapability, T as RECORDING_EXPORT_MAX_READ_BYTES, Ut as BaseAddon, V as defineCustomActions, W as deriveRecordingMode, Y as evaluateSensorEdge, Z as evictionPolicyForMode, an as boolean, ct as mayReadLocation, d as DEFAULT_EVENTS_BAND_BUFFER_SEC, dn as preprocess, dt as modeMayWrite, et as gbToBytes, fn as record, g as ExportRecordSchema, hn as EventCategory, i as BatteryStatusSchema, in as array, it as loadContributionCapability, jt as storageOccupancyCapability, ln as number, lt as mayWriteToLocation, nn as sleep$1, pn as string, rn as _enum, rt as isFirstLevelMacroClass, tn as selectAssignedProfileSlots, un as object, ut as migrateLegacyDeviceSignalConfig, x as OpsLogEntrySchema, xt as recordingCapability } from "../dist-CsI90TVi.mjs";
-import { a as physicalRootOf, i as NO_COST_CLAIM, t as ChildCostRegistry } from "../node-6Pb_t1Fm.mjs";
+import { At as storageEvictableCapability, Ct as recordingSignalCapability, D as RecordingSignalStatusSchema, E as RecordingConfigSchema, Et as resolveLocationMode, Gt as DeviceFeature, H as deriveBatteryPresence, It as errMsg, Jt as hydrateSchema, Kt as DeviceType, Nt as stripRetiredBandPreBufferSec, Ot as resolveRecordingProfiles, P as batteryCapability, Q as evictionPolicyOfLocation, Qt as nodePin, R as customAction, St as recordingExportCapability, T as RECORDING_EXPORT_MAX_READ_BYTES, Ut as BaseAddon, V as defineCustomActions, W as deriveRecordingMode, Y as evaluateSensorEdge, Z as evictionPolicyForMode, an as boolean, ct as mayReadLocation, d as DEFAULT_EVENTS_BAND_BUFFER_SEC, dn as preprocess, dt as modeMayWrite, et as gbToBytes, fn as record, g as ExportRecordSchema, hn as EventCategory, i as BatteryStatusSchema, in as array, it as loadContributionCapability, jt as storageOccupancyCapability, ln as number, lt as mayWriteToLocation, nn as sleep$1, pn as string, rn as _enum, rt as isFirstLevelMacroClass, tn as selectAssignedProfileSlots, un as object, ut as migrateLegacyDeviceSignalConfig, x as OpsLogEntrySchema, xt as recordingCapability } from "../dist-DttqKvsQ.mjs";
+import { a as physicalRootOf, i as NO_COST_CLAIM, t as ChildCostRegistry } from "../node-NtM7__8q.mjs";
 import { t as resolveHubHostname } from "../hub-hostname-cCknRYKj.mjs";
 import { c as PREBUFFER_MAX_MS, r as RECORDING_PRE_ROLL_REQUEST_MS, s as withRecordingIntent } from "../restream-intent-DWe2kInY.mjs";
-import { n as startEventLoopStallMonitor } from "../event-loop-stall-monitor-DXLNBMkY.mjs";
 import { n as RowMapStore, t as retireRootKeys } from "../retire-root-keys-DZvlso2l.mjs";
 import { randomUUID } from "node:crypto";
 import { createReadStream, promises, realpathSync } from "node:fs";
 import path from "node:path";
 import { spawn } from "node:child_process";
 import { open } from "node:fs/promises";
-import { contentTypeFor, createFileDataPlaneHandler, parseRangeHeader } from "@camstack/system/addon-utils";
+import { contentTypeFor, createFileDataPlaneHandler, parseRangeHeader, startEventLoopStallMonitor } from "@camstack/system/addon-utils";
 //#region src/recorder/event-capture.ts
 /**
 * La sottoscrizione motion del recorder: bus → `onTrigger(deviceId, atMs)`.
@@ -10462,6 +10461,8 @@ Object.freeze({
 			"pipelineEnabled": true,
 			"zones": [],
 			"onboardMotionDrivesAnalyzer": true,
+			"preRollInferenceEnabled": true,
+			"preRollInferenceFrames": 12,
 			"occupancyRecheckEnabled": true,
 			"occupancyRecheckSec": 300,
 			"occupancyRecheckFrames": 4,
@@ -16975,11 +16976,15 @@ var RecorderV2Addon = class extends BaseAddon {
 	/**
 	* Stops the GC-attributing stall monitor armed in {@link onInitialize}.
 	*
-	* REUSED, not re-implemented, and not promoted: `startEventLoopStallMonitor`
-	* already ships inside `@camstack/addon-pipeline` — the same bundle as this
-	* addon — and moving it into `@camstack/system` would duplicate a mechanism
-	* that already exists (forbidden) or relocate it across a package boundary,
-	* which is a refactor with a slower ship chain, not a measurement.
+	* REUSED, never re-implemented. It used to live next door in this bundle;
+	* on 2026-09-09 it moved to `@camstack/system/addon-utils` (the subpath, never
+	* the barrel — that one drags the kernel into the runner) because two more
+	* processes that do NOT share this bundle needed it — `pipeline-analytics` and
+	* hub-main — and a per-bundle copy is how two diagnostics end up disagreeing
+	* about the same freeze. The cost of the move is a slower ship chain: this
+	* import is host-resolved, so a `camstack deploy` of this addon onto a hub
+	* whose server closure predates the export fails to load. Deploy order is
+	* closure first, addons second. See D417.
 	*/
 	stopStallMonitor = null;
 	/**

package/dist/{segment-demux-js-oOpXzk2J.js → segment-demux-js-CkJPdyDH.js}

@@ -1,4 +1,4 @@
-const require_dist = require("./dist-CyfP2nFh.js");
+const require_dist = require("./dist-DoHcimdu.js");
 let node_child_process = require("node:child_process");
 //#region ../../node_modules/mp4box/dist/mp4box.all.js
 var require_mp4box_all = /* @__PURE__ */ require_dist.__commonJSMin(((exports) => {

package/dist/{segment-demux-js-CBvM6zIM.mjs → segment-demux-js-CsFtPVzH.mjs}

@@ -1,5 +1,5 @@
 import { r as __toESM, t as __commonJSMin } from "./chunk-DnnnRqeS.mjs";
-import { It as errMsg } from "./dist-CsI90TVi.mjs";
+import { It as errMsg } from "./dist-DttqKvsQ.mjs";
 import { spawn } from "node:child_process";
 //#region ../../node_modules/mp4box/dist/mp4box.all.js
 var require_mp4box_all = /* @__PURE__ */ __commonJSMin(((exports) => {