@camstack/addon-pipeline 1.2.51 → 1.2.53

package/dist/{event-loop-stall-monitor-DqJXi0_B.js → event-loop-stall-monitor-Bs6d-u_F.js}

@@ -1,4 +1,4 @@
-const require_dist = require("./dist-BsBEe_rX.js");
+const require_dist = require("./dist-D8TX_P_A.js");
 let node_perf_hooks = require("node:perf_hooks");
 //#region src/detection-pipeline/registry/model-catalogs.ts
 var HF_REPO = "camstack/camstack-models";

package/dist/{event-loop-stall-monitor-BvtjRcal.mjs → event-loop-stall-monitor-Cq_KOlfb.mjs}

@@ -1,4 +1,4 @@
-import { R as hfModelUrl, a as COCO_TO_MACRO, i as COCO_80_LABELS, r as AUDIO_MACRO_LABELS } from "./dist-Dkvk5ykl.mjs";
+import { R as hfModelUrl, a as COCO_TO_MACRO, i as COCO_80_LABELS, r as AUDIO_MACRO_LABELS } from "./dist-B55xTTsS.mjs";
 import { PerformanceObserver } from "node:perf_hooks";
 //#region src/detection-pipeline/registry/model-catalogs.ts
 var HF_REPO = "camstack/camstack-models";

package/dist/motion-wasm/index.js

@@ -2,7 +2,7 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-const require_dist = require("../dist-BsBEe_rX.js");
+const require_dist = require("../dist-D8TX_P_A.js");
 const require_lazy_sharp = require("../lazy-sharp-CcYuXtsa.js");
 let node_fs = require("node:fs");
 let node_path = require("node:path");

package/dist/motion-wasm/index.mjs

@@ -1,4 +1,4 @@
-import { L as evaluateZoneRules, V as motionDetectionCapability, dt as hydrateSchema, lt as DeviceType, ot as BaseAddon } from "../dist-Dkvk5ykl.mjs";
+import { L as evaluateZoneRules, V as motionDetectionCapability, dt as hydrateSchema, lt as DeviceType, ot as BaseAddon } from "../dist-B55xTTsS.mjs";
 import { t as getSharp } from "../lazy-sharp-B-mb8uWx.mjs";
 import { readFileSync } from "node:fs";
 import { join } from "node:path";

package/dist/pipeline-runner/index.js

@@ -3,9 +3,9 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 const require_chunk = require("../chunk-emK7D4bc.js");
-const require_dist = require("../dist-BsBEe_rX.js");
-const require_event_loop_stall_monitor = require("../event-loop-stall-monitor-DqJXi0_B.js");
-const require_worker_protocol = require("../worker-protocol-CWhkLkHx.js");
+const require_dist = require("../dist-D8TX_P_A.js");
+const require_event_loop_stall_monitor = require("../event-loop-stall-monitor-Bs6d-u_F.js");
+const require_worker_protocol = require("../worker-protocol-C2uctCrd.js");
 const require_hub_hostname = require("../hub-hostname-DAJXlOgV.js");
 const require_lazy_sharp = require("../lazy-sharp-CcYuXtsa.js");
 const require_remote_restream = require("../remote-restream-CO36Sr30.js");
@@ -543,11 +543,35 @@ function cropRgb(frame, bbox, maxWidth) {
 /** How long to wait after `kill()` before escalating to `kill('SIGKILL')`. */
 var SIGKILL_FALLBACK_MS = 1e3;
 /**
-* Default timeout for the `pull` round-trip preceding the FIRST delivered
-* frame. Task 0 live-measured cold-start (restream dial + hwaccel context +
-* keyframe wait) at 5-8s, so this must tolerate a slow-but-healthy start.
+* How often the cold-start wait REPORTS that it is still waiting. Task 0
+* live-measured cold-start (restream dial + hwaccel context + keyframe wait) at
+* 5-8s, so this must tolerate a slow-but-healthy start.
+*
+* It is no longer the point at which the session is abandoned — see
+* {@link DEFAULT_FIRST_FRAME_MAX_WAIT_MS}.
 */
 var DEFAULT_FIRST_FRAME_TIMEOUT_MS = 2e4;
+/**
+* Hard ceiling on the TOTAL wait for the FIRST frame of a dial.
+*
+* The first decodable frame is not a fixed cost: it is one IDR interval plus
+* every GOP the decoder has to discard. Measured on device 618 (2560x1440
+* h264, 8.0 s IDR interval, `Invalid NAL unit` / `corrupt decoded frame` in its
+* bitstream), dial → first decoded frame over the broker's own muted restream
+* was 1.8 / 6.5 / 7.0 / 7.2 / 9.2 / 10.0 / 10.8 / 12.9 / 14.9 / 20.0 / 30.3 /
+* >40 s across 12 trials — against a healthy 587's 2.0 s ± 0.02.
+*
+* Abandoning at 20 s was therefore not a timeout, it was a coin flip, and the
+* recovery made it worse: ending the session RE-DIALS, which throws the
+* accumulated wait away and re-pays the RTSP setup + probe from zero, and two
+* ends inside 60 s DETACH the camera. That loop cost 618 25.9% of its assigned
+* decode airtime in one day (325 of 1257 ten-second windows delivered nothing).
+*
+* The wait is bounded instead of deadlined: the worker keeps the outstanding
+* `pull` latched, so re-arming costs nothing but the wait, and the ceiling is
+* what stops a genuinely dead input from holding a spawn permit forever.
+*/
+var DEFAULT_FIRST_FRAME_MAX_WAIT_MS = 45e3;
 /** Default timeout for every `pull` round-trip AFTER the first frame arrives. */
 var DEFAULT_FRAME_TIMEOUT_MS = 1e4;
 /** Narrow an 'exit' payload to {@link WorkerExitInfo} (fakes may emit undefined). */
@@ -567,8 +591,10 @@ function toError(err) {
 var SessionDecodeSession = class {
 	child;
 	logger;
+	deviceId;
 	firstFrameTimeoutMs;
 	frameTimeoutMs;
+	firstFrameMaxWaitMs;
 	pendingPull = null;
 	pendingToBuffers = /* @__PURE__ */ new Map();
 	/** Outstanding `nativeCrop` requests, keyed by the monotonic `requestId`. */
@@ -580,11 +606,15 @@ var SessionDecodeSession = class {
 	sigkillTimer = null;
 	pullTimeoutTimer = null;
 	firstFrameReceived = false;
-	constructor(child, logger, firstFrameTimeoutMs, frameTimeoutMs) {
+	/** `Date.now()` of the FIRST `pull` — the origin of the cold-start ceiling. */
+	firstPullAt = 0;
+	constructor(child, logger, deviceId, firstFrameTimeoutMs, frameTimeoutMs, firstFrameMaxWaitMs) {
 		this.child = child;
 		this.logger = logger;
+		this.deviceId = deviceId;
 		this.firstFrameTimeoutMs = firstFrameTimeoutMs;
 		this.frameTimeoutMs = frameTimeoutMs;
+		this.firstFrameMaxWaitMs = firstFrameMaxWaitMs;
 		this.child.on("message", (m) => this.handleMessage(m));
 		this.child.on("exit", (m) => this.handleExit(toWorkerExitInfo(m)));
 	}
@@ -604,6 +634,7 @@ var SessionDecodeSession = class {
 	*/
 	pullNext() {
 		if (this.exited) return Promise.resolve({ kind: "ended" });
+		if (this.firstPullAt === 0) this.firstPullAt = Date.now();
 		return new Promise((resolve, reject) => {
 			this.pendingPull = {
 				resolve,
@@ -785,25 +816,63 @@ var SessionDecodeSession = class {
 	}
 	/**
 	* Fires when a `pull` round-trip outlives its liveness timeout — the child
-	* stopped producing frames WITHOUT exiting (a hung decode). Settles the
-	* outstanding pull as `ended` (not a throw) so the consumer's async
-	* generator resumes cleanly, runs its `finally`, and tears the child down
-	* via {@link teardown} — which sends `stop`, `kill()`s, and arms the 1s
-	* SIGKILL fallback.
+	* has not produced a frame and has not exited.
+	*
+	* BEFORE the first frame this is not yet a failure. The worker latches the
+	* outstanding `pull` (`decode-worker-child.handlePull` sets `pendingPull` and
+	* delivers on the next decoded frame), so re-arming the timer costs nothing
+	* but the wait and the session keeps the dial, the RTSP setup and the probe
+	* it has already paid for. Only the {@link firstFrameMaxWaitMs} ceiling ends
+	* it — see that constant for the measurement that set it.
+	*
+	* AFTER the first frame the deadline is unchanged: a steady stream that stops
+	* is a hung decode, and ending settles the outstanding pull as `ended` (not a
+	* throw) so the consumer's async generator resumes cleanly, runs its
+	* `finally`, and tears the child down via {@link teardown}.
+	*
+	* Every line here carries `tags: { deviceId }` and a `reason`, because
+	* "detaching" a camera is the loudest dropped work in this path and an
+	* operator has to be able to answer "why did 618 stop" from the logs alone.
 	*/
 	handlePullTimeout(timeoutMs) {
 		this.pullTimeoutTimer = null;
 		const waiter = this.pendingPull;
 		if (!waiter) return;
+		const waitedMs = this.firstPullAt === 0 ? timeoutMs : Date.now() - this.firstPullAt;
+		if (!this.firstFrameReceived && waitedMs < this.firstFrameMaxWaitMs) {
+			this.logger.warn("session-decode-coordinator: still waiting for its first decodable frame — holding the dial", {
+				tags: { deviceId: this.deviceId },
+				meta: {
+					waitedMs,
+					reportEveryMs: timeoutMs,
+					maxWaitMs: this.firstFrameMaxWaitMs,
+					hint: "long IDR interval or a discarded GOP looks exactly like this"
+				}
+			});
+			this.armPullTimeout();
+			return;
+		}
 		this.pendingPull = null;
-		this.logger.warn(`session-decode-coordinator: decode worker produced no frame within ${timeoutMs}ms — ending session`, { meta: {
-			timeoutMs,
-			firstFrameReceived: this.firstFrameReceived
-		} });
+		const reason = this.firstFrameReceived ? "stalled-after-first-frame" : "no-first-frame";
+		this.logger.warn(this.firstFrameReceived ? "session-decode-coordinator: gave up waiting for the next frame — ending session" : "session-decode-coordinator: gave up waiting for the first decodable frame — ending session", {
+			tags: { deviceId: this.deviceId },
+			meta: {
+				reason,
+				waitedMs,
+				timeoutMs,
+				...this.firstFrameReceived ? {} : { maxWaitMs: this.firstFrameMaxWaitMs }
+			}
+		});
 		waiter.resolve({ kind: "ended" });
 	}
+	/**
+	* Arm the next round-trip deadline. Before the first frame the timer is
+	* clamped to what is LEFT of the ceiling, so the give-up lands exactly on
+	* {@link firstFrameMaxWaitMs} instead of on the next report boundary past it
+	* — otherwise a 45 s ceiling reported every 20 s would really give up at 60 s.
+	*/
 	armPullTimeout() {
-		const timeoutMs = this.firstFrameReceived ? this.frameTimeoutMs : this.firstFrameTimeoutMs;
+		const timeoutMs = this.firstFrameReceived ? this.frameTimeoutMs : Math.max(1, Math.min(this.firstFrameTimeoutMs, this.firstFrameMaxWaitMs - (this.firstPullAt === 0 ? 0 : Date.now() - this.firstPullAt)));
 		this.pullTimeoutTimer = setTimeout(() => this.handlePullTimeout(timeoutMs), timeoutMs);
 		this.pullTimeoutTimer.unref?.();
 	}
@@ -925,8 +994,9 @@ function buildFrameImage(session, reply) {
 function createSessionDecodeCoordinator(deps) {
 	const firstFrameTimeoutMs = deps.firstFrameTimeoutMs ?? DEFAULT_FIRST_FRAME_TIMEOUT_MS;
 	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, firstFrameTimeoutMs, frameTimeoutMs);
+		const session = new SessionDecodeSession(deps.fork(source), deps.logger, source.deviceId, firstFrameTimeoutMs, frameTimeoutMs, firstFrameMaxWaitMs);
 		session.start(source, opts);
 		try {
 			while (true) {
@@ -1036,6 +1106,7 @@ function startSessionDecodePump(deps) {
 					break;
 				}
 				try {
+					if (deps.shouldMaterializeFrame && !deps.shouldMaterializeFrame()) continue;
 					const decoded = await toDecodedFrame(frame, format);
 					const image = frame.image;
 					const cropFn = image.nativeCrop;
@@ -3067,15 +3138,8 @@ var PipelineRunner = class {
 	*   (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 on `this.config` (read
-	*   by `getLimits()`), but NOT re-fed into the live `FrameGovernor` — the
-	*   governor is built once, at construction, from the config snapshot
-	*   passed to the constructor. A hot patch to either knob changes what
-	*   `getLimits()` reports but does not change live admission pacing until
-	*   the runner is reconstructed. (Rebuilding the governor live is a
-	*   follow-up, not in scope here — `maxConcurrentInferences` has the same
-	*   gap: the semaphore resizes live but the governor's budget calc keeps
-	*   the construction-time value.)
+	* - `targetLoadPercent` / `minThrottledFps` and inference concurrency:
+	*   rebuild the live governor and immediately recompute admission intervals.
 	*
 	* Only keys present in the patch are overwritten; unspecified keys
 	* retain their current value. Any illegal combination (e.g.
@@ -3091,6 +3155,12 @@ var PipelineRunner = class {
 		};
 		if (next.maxConcurrentInferences !== this.config.maxConcurrentInferences) this.semaphore.resize(next.maxConcurrentInferences);
 		this.config = next;
+		this.governor = new FrameGovernor({
+			targetLoadPercent: next.targetLoadPercent,
+			minThrottledFps: next.minThrottledFps,
+			maxConcurrentInferences: next.maxConcurrentInferences
+		});
+		this.recomputeGovernor();
 	}
 	/** Read the current tuning fields for diagnostics / tests. */
 	getLimits() {
@@ -3184,17 +3254,36 @@ var PipelineRunner = class {
 	* saving; do not turn it back into `void` for tidiness.
 	*/
 	enqueueDetectionFrame(deviceId, frame, handle) {
+		if (!this.reserveDetectionFrame(deviceId)) return false;
+		return this.enqueueReservedDetectionFrame(deviceId, frame, handle);
+	}
+	/**
+	* Reserve adaptive admission before a session-decode frame is materialized.
+	* This is intentionally pixel-free: the pump can skip `toBuffer()` entirely
+	* when the frame is outside the governor interval, avoiding RGB conversion,
+	* IPC and retention work. Raw arrivals are counted here, before the gate, so
+	* recomputation never feeds the throttled output rate back in as source FPS.
+	*/
+	reserveDetectionFrame(deviceId, now = Date.now()) {
 		const state = this.cameras.get(deviceId);
 		if (!state) return false;
 		this.arrivalCounts.set(deviceId, (this.arrivalCounts.get(deviceId) ?? 0) + 1);
 		if (state.phase !== "active") return false;
 		const interval = this.governor.minIntervalMs(deviceId);
 		if (interval > 0) {
-			const last = this.lastAdmittedAt.get(deviceId) ?? 0;
-			const now = Date.now();
-			if (now - last < interval) return false;
+			if (now - (this.lastAdmittedAt.get(deviceId) ?? 0) < interval) return false;
 			this.lastAdmittedAt.set(deviceId, now);
 		}
+		return true;
+	}
+	/**
+	* Queue a frame whose admission was already reserved synchronously through
+	* {@link reserveDetectionFrame}. Kept separate so the ordinary public path
+	* cannot accidentally count one source frame twice.
+	*/
+	enqueueReservedDetectionFrame(deviceId, frame, handle) {
+		const state = this.cameras.get(deviceId);
+		if (!state || state.phase !== "active") return false;
 		frame._enqueuedAt = Date.now();
 		state.detectionQueue.enqueue({
 			frame,
@@ -5580,21 +5669,44 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 	* no second dial, no second decode, no GPU). Mirrors the shm shared-motion
 	* seam (`subscribeMotionFrames` `shared` branch).
 	*/
-	enqueueSharedDetectionFrame(deviceId, frame, handle) {
+	enqueueSharedDetectionFrame(deviceId, frame, handle, reservation) {
 		const runner = this.runner;
 		if (!runner) return false;
-		const admitted = runner.enqueueDetectionFrame(deviceId, frame, handle);
-		const sink = this.sharedMotionSinks.get(deviceId);
-		if (sink) {
-			const now = this.sharedSinkNow();
-			if (now - sink.lastMotionEnqueueTs >= sink.minIntervalMs) {
-				sink.lastMotionEnqueueTs = now;
-				runner.enqueueMotionFrame(deviceId, rgbFrameToGrayFrame(frame), void 0);
+		const admitted = reservation ? reservation.detection && runner.enqueueReservedDetectionFrame(deviceId, frame, handle) : runner.enqueueDetectionFrame(deviceId, frame, handle);
+		if (reservation?.motion) runner.enqueueMotionFrame(deviceId, rgbFrameToGrayFrame(frame), void 0);
+		else if (!reservation) {
+			const sink = this.sharedMotionSinks.get(deviceId);
+			if (sink) {
+				const now = this.sharedSinkNow();
+				if (now - sink.lastMotionEnqueueTs >= sink.minIntervalMs) {
+					sink.lastMotionEnqueueTs = now;
+					runner.enqueueMotionFrame(deviceId, rgbFrameToGrayFrame(frame), void 0);
+				}
 			}
 		}
 		return admitted;
 	}
 	/**
+	* Reserve all consumers of one lazy RGB frame before materializing pixels.
+	* Detection follows the adaptive governor; shared motion keeps its independent
+	* cadence so throttling inference cannot starve the analyzer.
+	*/
+	reserveSharedDetectionFrame(deviceId) {
+		const detection = this.runner?.reserveDetectionFrame(deviceId) ?? false;
+		const sink = this.sharedMotionSinks.get(deviceId);
+		if (!sink) return {
+			detection,
+			motion: false
+		};
+		const now = this.sharedSinkNow();
+		const motion = now - sink.lastMotionEnqueueTs >= sink.minIntervalMs;
+		if (motion) sink.lastMotionEnqueueTs = now;
+		return {
+			detection,
+			motion
+		};
+	}
+	/**
 	* Epic C P1 detection path for a flagged camera: decode `rgb` in a
 	* per-session forked worker and feed the runner's detection queue INLINE (no
 	* `FrameHandle`), exactly like the shared shm path. Teardown stops the pump
@@ -5647,6 +5759,7 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 					streamId: config.detectionStreamId,
 					codec: source.codec
 				} });
+				let reservation = null;
 				return startSessionDecodePump({
 					fork: this.forkDecodeWorkerWithLease,
 					logger: log,
@@ -5655,12 +5768,19 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 						fps: config.detectionFps,
 						format: "rgb"
 					},
+					shouldMaterializeFrame: () => {
+						reservation = this.reserveSharedDetectionFrame(config.deviceId);
+						return reservation.detection || reservation.motion;
+					},
 					acquireSpawnSlot: this.buildDecodeSpawnAcquire(log, "detect"),
 					onEnded: () => this.handleDetectionDecodeEnded(config.deviceId),
 					onDecodedFrame: (frame, nativeCrop) => {
-						const handle = retainedFrames?.write(config.deviceId, frame) ?? void 0;
+						const current = reservation;
+						reservation = null;
+						if (!current) return;
+						const handle = current.detection ? retainedFrames?.write(config.deviceId, frame) ?? void 0 : void 0;
 						if (handle && nativeCrop) this.nativeCropRegistry.register(handle, nativeCrop, config.deviceId);
-						if (this.enqueueSharedDetectionFrame(config.deviceId, frame, handle)) nativeCrop?.markInferred();
+						if (this.enqueueSharedDetectionFrame(config.deviceId, frame, handle, current)) nativeCrop?.markInferred();
 					}
 				});
 			}