@camstack/addon-pipeline 1.2.36 → 1.2.37

package/dist/detection-pipeline/index.js

@@ -16,6 +16,7 @@ let node_fs = require("node:fs");
 node_fs = require_chunk.__toESM(node_fs);
 let node_path = require("node:path");
 node_path = require_chunk.__toESM(node_path);
+let node_perf_hooks = require("node:perf_hooks");
 //#region src/detection-pipeline/runtimes.ts
 var KNOWN_PLATFORMS = [
 	"darwin",
@@ -597,8 +598,12 @@ var PoolWorker = class {
 			this.ready = false;
 		});
 		this.process.stdout.on("data", (chunk) => {
+			const t0 = Date.now();
 			this.receiveBuffer = Buffer.concat([this.receiveBuffer, chunk]);
+			this.recvConcatMs += Date.now() - t0;
+			if (this.receiveBuffer.length > this.recvPeakBytes) this.recvPeakBytes = this.receiveBuffer.length;
 			this.drainResponses();
+			this.reportRecvCostIfDue();
 		});
 		const config = {
 			runtime: this.opts.poolRuntime,
@@ -785,7 +790,7 @@ var PoolWorker = class {
 					device: this.opts.device ?? "default",
 					inFlight: this.pending.size,
 					reqId,
-					timeoutMs: POOL_INFER_TIMEOUT_MS
+					timeoutMs
 				} });
 				reject(/* @__PURE__ */ new Error(`PoolWorker[${this.opts.workerLabel}]: inference request ${reqId} timed out after ${timeoutMs}ms (worker alive, no reply)`));
 			}
@@ -841,6 +846,36 @@ var PoolWorker = class {
 	ensureReady() {
 		if (!this.ready || !this.process?.stdin) throw new Error(`PoolWorker[${this.opts.workerLabel}]: not initialized`);
 	}
+	/** Time spent in `Buffer.concat` since the last report. */
+	recvConcatMs = 0;
+	/** Largest the receive buffer has grown since the last report. */
+	recvPeakBytes = 0;
+	/** When the last receive-cost report was emitted. */
+	recvReportedAt = 0;
+	/**
+	* Emit the receive-path cost at most once every 10s, and only when it is
+	* actually interesting — silence when the reader costs nothing is the whole
+	* point, otherwise this becomes another line nobody reads.
+	*/
+	reportRecvCostIfDue() {
+		const now = Date.now();
+		if (this.recvReportedAt === 0) this.recvReportedAt = now;
+		if (now - this.recvReportedAt < 1e4) return;
+		const concatMs = this.recvConcatMs;
+		const peak = this.recvPeakBytes;
+		this.recvConcatMs = 0;
+		this.recvPeakBytes = 0;
+		this.recvReportedAt = now;
+		if (concatMs < 250) return;
+		this.log.warn("pool receive path is copying", { meta: {
+			worker: this.opts.workerLabel,
+			runtime: this.opts.poolRuntime,
+			device: this.opts.device ?? "default",
+			concatMs,
+			peakBufferKb: Math.round(peak / 1024),
+			windowMs: 1e4
+		} });
+	}
 	drainResponses() {
 		while (this.receiveBuffer.length >= 8) {
 			const totalLen = this.receiveBuffer.readUInt32LE(0);
@@ -4584,10 +4619,27 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	* Idle-TTL for a per-device inference pool (multi-device C3). A device pool
 	* with no dispatch for this long is disposed and recreated on next use — the
 	* memory guardrail that keeps `factoriesByDevice` from accumulating warm pools
-	* forever. Longer than the override cache (60s) since a device pool is heavier
-	* to respin; still well above any real inter-session gap for an active camera.
+	* forever as an operator toggles device sets over a long run.
+	*
+	* It was 120s, on the stated assumption that this was "well above any real
+	* inter-session gap for an active camera". Measured 2026-08-02, that is
+	* false: detection is dispatched ON MOTION, so at night the gap between
+	* events routinely exceeds two minutes, and the eviction fires constantly.
+	* The rebuild is not cheap — `ensureModelsForSteps` loads EVERY enabled step
+	* into the fresh factory, which on the hub is seven models
+	* (yolov9m-320-int8, scrfd-2.5g, arcface-r100, yolov8n-plate,
+	* vgg_english_g2, mobileclip-s1-vision, yolov8n-package). The hub log shows
+	* the cycle plainly: `COMPILE ×7` → shed within 7-15s → `EVICT` ~2.5 min
+	* later → repeat. So the first seconds of a motion event — precisely when
+	* detection matters — were spent recompiling models that had just been
+	* thrown away.
+	*
+	* Hours, not minutes. At this TTL only a pool that is genuinely unused
+	* (device disabled, routing changed) is reclaimed, which is what the
+	* guardrail was for; a nightly lull no longer costs a recompile. Override
+	* via env for a memory-constrained node.
 	*/
-	static DEVICE_POOL_IDLE_TTL_MS = 12e4;
+	static DEVICE_POOL_IDLE_TTL_MS = Math.max(6e4, Number(process.env["CAMSTACK_DEVICE_POOL_IDLE_TTL_MS"]) || 360 * 60 * 1e3);
 	deviceReaper = new IdlePoolReaper({
 		ttlMs: DetectionPipelineProvider.DEVICE_POOL_IDLE_TTL_MS,
 		dispose: (deviceKey) => this.disposeDevicePool(deviceKey),
@@ -7154,6 +7206,142 @@ function applyDeviceOverridesToTree(tree, rootStepId, overrides) {
 	} : root) };
 }
 //#endregion
+//#region src/detection-pipeline/diagnostics/event-loop-stall-monitor.ts
+/**
+* event-loop-stall-monitor — names the thing that freezes the detection process.
+*
+* ## What this exists to settle
+*
+* On 2026-08-01/02 inference across the whole fleet stalled in bursts: 759
+* calls in 90 minutes crossed the runner's 20s deadline, p50 41s and max 80s,
+* and EVERY one of them eventually resolved. Six explanations were killed with
+* telemetry alone:
+*
+*  - not a slow GPU or a wedged pool — the work completes, just enormously late;
+*  - not CPU starvation — hosts sat at 8-48% during the freezes;
+*  - not swap — `pswpin/pswpout` are flat zero on every host;
+*  - not a logging artifact — Loki's timestamp trails the in-process one by
+*    0.1-1.0s at p95, so the gaps are real, not buffered delivery;
+*  - not the v1.2.30 release — the stalls predate it by a day;
+*  - not only the idle-pool recompile — that is real and hub-side, but the
+*    agent stalls with no eviction and no compile at all.
+*
+* What IS established: the 10s stats timer — which touches no inference code —
+* stops firing for 22-88s and resumes at the same instant the abandoned calls
+* settle. The event loop itself freezes. From outside the process, GC and a
+* synchronous block are indistinguishable, and guessing between them is how
+* this investigation would go wrong. So measure it.
+*
+* ## How
+*
+* A 1s interval whose LATENESS is the freeze: a tick that arrives 40s late means
+* the loop was blocked ~39s, whatever blocked it. In the same window the GC
+* observer accumulates pause time. The two numbers together answer the question
+* outright:
+*
+*  - `gcMs` ≈ `stallMs` → garbage collection. Look at heap growth.
+*  - `gcMs` ≈ 0 → something SYNCHRONOUS blocked the loop, and GC is innocent.
+*
+* Heap and RSS ride along because if it is GC, the next question is always
+* "growing since when?".
+*
+* Deliberately not a histogram (`monitorEventLoopDelay`): that reports a
+* distribution, and the question here is about ONE outlier and what coincided
+* with it.
+*/
+/** Tick period. Small enough to bound attribution error, large enough to cost
+*  nothing on a process already doing frame work. */
+var STALL_TICK_MS = 1e3;
+/**
+* Report a freeze only past this. The runner's own inference deadline is 20s
+* and the observed freezes run 22-88s, so this is far below the signal while
+* staying clear of ordinary scheduling jitter (a busy frame path routinely
+* overruns a 1s timer by tens of ms).
+*/
+var STALL_REPORT_MS = 2e3;
+/**
+* Attribute a freeze. Pure, because this is the ONE judgement the whole module
+* exists to make and it must be testable without freezing a real event loop.
+*
+* `gc` when garbage collection accounts for most of the stall; a
+* `synchronous-block` when it accounts for almost none — that verdict points
+* away from the heap entirely and at whatever ran without yielding.
+*/
+function attributeStall(stallMs, gcMs, gcCount, longestGcMs) {
+	const share = stallMs > 0 ? gcMs / stallMs : 0;
+	return {
+		stallMs,
+		gcMs,
+		gcCount,
+		longestGcMs,
+		cause: share >= .7 ? "gc" : share <= .2 ? "synchronous-block" : "mixed"
+	};
+}
+/**
+* Start watching. Returns a stop function; safe to call twice.
+*
+* Never throws into the caller: a diagnostic that can take the detection
+* process down is worse than no diagnostic. `PerformanceObserver` for `gc` is
+* unavailable in some embedded runtimes, and that must degrade to
+* stall-detection-without-attribution rather than a boot failure.
+*/
+function startEventLoopStallMonitor(logger, reportThresholdMs = STALL_REPORT_MS) {
+	let gc = {
+		totalMs: 0,
+		count: 0,
+		longestMs: 0
+	};
+	let observer = null;
+	try {
+		observer = new node_perf_hooks.PerformanceObserver((list) => {
+			for (const entry of list.getEntries()) {
+				gc.totalMs += entry.duration;
+				gc.count += 1;
+				if (entry.duration > gc.longestMs) gc.longestMs = entry.duration;
+			}
+		});
+		observer.observe({ entryTypes: ["gc"] });
+	} catch {
+		observer = null;
+	}
+	let expected = Date.now() + STALL_TICK_MS;
+	const timer = setInterval(() => {
+		const now = Date.now();
+		const lateBy = now - expected;
+		const window = gc;
+		gc = {
+			totalMs: 0,
+			count: 0,
+			longestMs: 0
+		};
+		expected = now + STALL_TICK_MS;
+		if (lateBy < reportThresholdMs) return;
+		const verdict = attributeStall(lateBy, Math.round(window.totalMs), window.count, Math.round(window.longestMs));
+		const mem = process.memoryUsage();
+		logger.warn("event loop stalled", { meta: {
+			stallMs: verdict.stallMs,
+			cause: verdict.cause,
+			gcMs: verdict.gcMs,
+			gcCount: verdict.gcCount,
+			longestGcMs: verdict.longestGcMs,
+			gcObserved: observer !== null,
+			heapUsedMb: Math.round(mem.heapUsed / 1e6),
+			heapTotalMb: Math.round(mem.heapTotal / 1e6),
+			rssMb: Math.round(mem.rss / 1e6),
+			externalMb: Math.round(mem.external / 1e6),
+			arrayBuffersMb: Math.round(mem.arrayBuffers / 1e6)
+		} });
+	}, STALL_TICK_MS);
+	timer.unref?.();
+	let stopped = false;
+	return () => {
+		if (stopped) return;
+		stopped = true;
+		clearInterval(timer);
+		observer?.disconnect();
+	};
+}
+//#endregion
 //#region src/detection-pipeline/python-readiness.ts
 /**
 * Resolve the embedded Python once, turning the null/throw failure modes into
@@ -7274,6 +7462,8 @@ var DetectionPipelineAddon = class extends require_dist.BaseAddon {
 	*  doesn't flip a remote node's env back to the serving hub's platform. */
 	lastGoodHardwareByNode = /* @__PURE__ */ new Map();
 	engineMetricsTimer = null;
+	/** Stops the event-loop stall monitor on shutdown. */
+	stopStallMonitor = null;
 	/** Snapshot-equality cache for engine-metrics emit. Most ticks
 	*  the engine inventory is unchanged (no model load/unload), so
 	*  we skip the bus emit and let the heartbeat re-emit at
@@ -7612,6 +7802,7 @@ var DetectionPipelineAddon = class extends require_dist.BaseAddon {
 	async onInitialize() {
 		const modelsDir = await this.resolveModelsDir();
 		if (!this.ctx.settings) throw new Error("DetectionPipelineAddon: ctx.settings not available");
+		this.stopStallMonitor = startEventLoopStallMonitor(this.ctx.logger);
 		this.pythonAddonDir = resolveAddonPythonDir();
 		const py = await ensurePythonReady(this.ctx.deps, this.ctx.logger);
 		if (py.ok && py.pythonPath) this.pythonPath = py.pythonPath;
@@ -7698,6 +7889,10 @@ var DetectionPipelineAddon = class extends require_dist.BaseAddon {
 		}
 	}
 	async onShutdown() {
+		if (this.stopStallMonitor) {
+			this.stopStallMonitor();
+			this.stopStallMonitor = null;
+		}
 		if (this.engineMetricsTimer) {
 			clearInterval(this.engineMetricsTimer);
 			this.engineMetricsTimer = null;

package/dist/detection-pipeline/index.mjs

@@ -8,6 +8,7 @@ import { spawn } from "node:child_process";
 import sharp from "sharp";
 import * as fs from "node:fs";
 import * as path$1 from "node:path";
+import { PerformanceObserver } from "node:perf_hooks";
 //#region src/detection-pipeline/runtimes.ts
 var KNOWN_PLATFORMS = [
 	"darwin",
@@ -589,8 +590,12 @@ var PoolWorker = class {
 			this.ready = false;
 		});
 		this.process.stdout.on("data", (chunk) => {
+			const t0 = Date.now();
 			this.receiveBuffer = Buffer.concat([this.receiveBuffer, chunk]);
+			this.recvConcatMs += Date.now() - t0;
+			if (this.receiveBuffer.length > this.recvPeakBytes) this.recvPeakBytes = this.receiveBuffer.length;
 			this.drainResponses();
+			this.reportRecvCostIfDue();
 		});
 		const config = {
 			runtime: this.opts.poolRuntime,
@@ -777,7 +782,7 @@ var PoolWorker = class {
 					device: this.opts.device ?? "default",
 					inFlight: this.pending.size,
 					reqId,
-					timeoutMs: POOL_INFER_TIMEOUT_MS
+					timeoutMs
 				} });
 				reject(/* @__PURE__ */ new Error(`PoolWorker[${this.opts.workerLabel}]: inference request ${reqId} timed out after ${timeoutMs}ms (worker alive, no reply)`));
 			}
@@ -833,6 +838,36 @@ var PoolWorker = class {
 	ensureReady() {
 		if (!this.ready || !this.process?.stdin) throw new Error(`PoolWorker[${this.opts.workerLabel}]: not initialized`);
 	}
+	/** Time spent in `Buffer.concat` since the last report. */
+	recvConcatMs = 0;
+	/** Largest the receive buffer has grown since the last report. */
+	recvPeakBytes = 0;
+	/** When the last receive-cost report was emitted. */
+	recvReportedAt = 0;
+	/**
+	* Emit the receive-path cost at most once every 10s, and only when it is
+	* actually interesting — silence when the reader costs nothing is the whole
+	* point, otherwise this becomes another line nobody reads.
+	*/
+	reportRecvCostIfDue() {
+		const now = Date.now();
+		if (this.recvReportedAt === 0) this.recvReportedAt = now;
+		if (now - this.recvReportedAt < 1e4) return;
+		const concatMs = this.recvConcatMs;
+		const peak = this.recvPeakBytes;
+		this.recvConcatMs = 0;
+		this.recvPeakBytes = 0;
+		this.recvReportedAt = now;
+		if (concatMs < 250) return;
+		this.log.warn("pool receive path is copying", { meta: {
+			worker: this.opts.workerLabel,
+			runtime: this.opts.poolRuntime,
+			device: this.opts.device ?? "default",
+			concatMs,
+			peakBufferKb: Math.round(peak / 1024),
+			windowMs: 1e4
+		} });
+	}
 	drainResponses() {
 		while (this.receiveBuffer.length >= 8) {
 			const totalLen = this.receiveBuffer.readUInt32LE(0);
@@ -4576,10 +4611,27 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	* Idle-TTL for a per-device inference pool (multi-device C3). A device pool
 	* with no dispatch for this long is disposed and recreated on next use — the
 	* memory guardrail that keeps `factoriesByDevice` from accumulating warm pools
-	* forever. Longer than the override cache (60s) since a device pool is heavier
-	* to respin; still well above any real inter-session gap for an active camera.
+	* forever as an operator toggles device sets over a long run.
+	*
+	* It was 120s, on the stated assumption that this was "well above any real
+	* inter-session gap for an active camera". Measured 2026-08-02, that is
+	* false: detection is dispatched ON MOTION, so at night the gap between
+	* events routinely exceeds two minutes, and the eviction fires constantly.
+	* The rebuild is not cheap — `ensureModelsForSteps` loads EVERY enabled step
+	* into the fresh factory, which on the hub is seven models
+	* (yolov9m-320-int8, scrfd-2.5g, arcface-r100, yolov8n-plate,
+	* vgg_english_g2, mobileclip-s1-vision, yolov8n-package). The hub log shows
+	* the cycle plainly: `COMPILE ×7` → shed within 7-15s → `EVICT` ~2.5 min
+	* later → repeat. So the first seconds of a motion event — precisely when
+	* detection matters — were spent recompiling models that had just been
+	* thrown away.
+	*
+	* Hours, not minutes. At this TTL only a pool that is genuinely unused
+	* (device disabled, routing changed) is reclaimed, which is what the
+	* guardrail was for; a nightly lull no longer costs a recompile. Override
+	* via env for a memory-constrained node.
 	*/
-	static DEVICE_POOL_IDLE_TTL_MS = 12e4;
+	static DEVICE_POOL_IDLE_TTL_MS = Math.max(6e4, Number(process.env["CAMSTACK_DEVICE_POOL_IDLE_TTL_MS"]) || 360 * 60 * 1e3);
 	deviceReaper = new IdlePoolReaper({
 		ttlMs: DetectionPipelineProvider.DEVICE_POOL_IDLE_TTL_MS,
 		dispose: (deviceKey) => this.disposeDevicePool(deviceKey),
@@ -7146,6 +7198,142 @@ function applyDeviceOverridesToTree(tree, rootStepId, overrides) {
 	} : root) };
 }
 //#endregion
+//#region src/detection-pipeline/diagnostics/event-loop-stall-monitor.ts
+/**
+* event-loop-stall-monitor — names the thing that freezes the detection process.
+*
+* ## What this exists to settle
+*
+* On 2026-08-01/02 inference across the whole fleet stalled in bursts: 759
+* calls in 90 minutes crossed the runner's 20s deadline, p50 41s and max 80s,
+* and EVERY one of them eventually resolved. Six explanations were killed with
+* telemetry alone:
+*
+*  - not a slow GPU or a wedged pool — the work completes, just enormously late;
+*  - not CPU starvation — hosts sat at 8-48% during the freezes;
+*  - not swap — `pswpin/pswpout` are flat zero on every host;
+*  - not a logging artifact — Loki's timestamp trails the in-process one by
+*    0.1-1.0s at p95, so the gaps are real, not buffered delivery;
+*  - not the v1.2.30 release — the stalls predate it by a day;
+*  - not only the idle-pool recompile — that is real and hub-side, but the
+*    agent stalls with no eviction and no compile at all.
+*
+* What IS established: the 10s stats timer — which touches no inference code —
+* stops firing for 22-88s and resumes at the same instant the abandoned calls
+* settle. The event loop itself freezes. From outside the process, GC and a
+* synchronous block are indistinguishable, and guessing between them is how
+* this investigation would go wrong. So measure it.
+*
+* ## How
+*
+* A 1s interval whose LATENESS is the freeze: a tick that arrives 40s late means
+* the loop was blocked ~39s, whatever blocked it. In the same window the GC
+* observer accumulates pause time. The two numbers together answer the question
+* outright:
+*
+*  - `gcMs` ≈ `stallMs` → garbage collection. Look at heap growth.
+*  - `gcMs` ≈ 0 → something SYNCHRONOUS blocked the loop, and GC is innocent.
+*
+* Heap and RSS ride along because if it is GC, the next question is always
+* "growing since when?".
+*
+* Deliberately not a histogram (`monitorEventLoopDelay`): that reports a
+* distribution, and the question here is about ONE outlier and what coincided
+* with it.
+*/
+/** Tick period. Small enough to bound attribution error, large enough to cost
+*  nothing on a process already doing frame work. */
+var STALL_TICK_MS = 1e3;
+/**
+* Report a freeze only past this. The runner's own inference deadline is 20s
+* and the observed freezes run 22-88s, so this is far below the signal while
+* staying clear of ordinary scheduling jitter (a busy frame path routinely
+* overruns a 1s timer by tens of ms).
+*/
+var STALL_REPORT_MS = 2e3;
+/**
+* Attribute a freeze. Pure, because this is the ONE judgement the whole module
+* exists to make and it must be testable without freezing a real event loop.
+*
+* `gc` when garbage collection accounts for most of the stall; a
+* `synchronous-block` when it accounts for almost none — that verdict points
+* away from the heap entirely and at whatever ran without yielding.
+*/
+function attributeStall(stallMs, gcMs, gcCount, longestGcMs) {
+	const share = stallMs > 0 ? gcMs / stallMs : 0;
+	return {
+		stallMs,
+		gcMs,
+		gcCount,
+		longestGcMs,
+		cause: share >= .7 ? "gc" : share <= .2 ? "synchronous-block" : "mixed"
+	};
+}
+/**
+* Start watching. Returns a stop function; safe to call twice.
+*
+* Never throws into the caller: a diagnostic that can take the detection
+* process down is worse than no diagnostic. `PerformanceObserver` for `gc` is
+* unavailable in some embedded runtimes, and that must degrade to
+* stall-detection-without-attribution rather than a boot failure.
+*/
+function startEventLoopStallMonitor(logger, reportThresholdMs = STALL_REPORT_MS) {
+	let gc = {
+		totalMs: 0,
+		count: 0,
+		longestMs: 0
+	};
+	let observer = null;
+	try {
+		observer = new PerformanceObserver((list) => {
+			for (const entry of list.getEntries()) {
+				gc.totalMs += entry.duration;
+				gc.count += 1;
+				if (entry.duration > gc.longestMs) gc.longestMs = entry.duration;
+			}
+		});
+		observer.observe({ entryTypes: ["gc"] });
+	} catch {
+		observer = null;
+	}
+	let expected = Date.now() + STALL_TICK_MS;
+	const timer = setInterval(() => {
+		const now = Date.now();
+		const lateBy = now - expected;
+		const window = gc;
+		gc = {
+			totalMs: 0,
+			count: 0,
+			longestMs: 0
+		};
+		expected = now + STALL_TICK_MS;
+		if (lateBy < reportThresholdMs) return;
+		const verdict = attributeStall(lateBy, Math.round(window.totalMs), window.count, Math.round(window.longestMs));
+		const mem = process.memoryUsage();
+		logger.warn("event loop stalled", { meta: {
+			stallMs: verdict.stallMs,
+			cause: verdict.cause,
+			gcMs: verdict.gcMs,
+			gcCount: verdict.gcCount,
+			longestGcMs: verdict.longestGcMs,
+			gcObserved: observer !== null,
+			heapUsedMb: Math.round(mem.heapUsed / 1e6),
+			heapTotalMb: Math.round(mem.heapTotal / 1e6),
+			rssMb: Math.round(mem.rss / 1e6),
+			externalMb: Math.round(mem.external / 1e6),
+			arrayBuffersMb: Math.round(mem.arrayBuffers / 1e6)
+		} });
+	}, STALL_TICK_MS);
+	timer.unref?.();
+	let stopped = false;
+	return () => {
+		if (stopped) return;
+		stopped = true;
+		clearInterval(timer);
+		observer?.disconnect();
+	};
+}
+//#endregion
 //#region src/detection-pipeline/python-readiness.ts
 /**
 * Resolve the embedded Python once, turning the null/throw failure modes into
@@ -7266,6 +7454,8 @@ var DetectionPipelineAddon = class extends BaseAddon {
 	*  doesn't flip a remote node's env back to the serving hub's platform. */
 	lastGoodHardwareByNode = /* @__PURE__ */ new Map();
 	engineMetricsTimer = null;
+	/** Stops the event-loop stall monitor on shutdown. */
+	stopStallMonitor = null;
 	/** Snapshot-equality cache for engine-metrics emit. Most ticks
 	*  the engine inventory is unchanged (no model load/unload), so
 	*  we skip the bus emit and let the heartbeat re-emit at
@@ -7604,6 +7794,7 @@ var DetectionPipelineAddon = class extends BaseAddon {
 	async onInitialize() {
 		const modelsDir = await this.resolveModelsDir();
 		if (!this.ctx.settings) throw new Error("DetectionPipelineAddon: ctx.settings not available");
+		this.stopStallMonitor = startEventLoopStallMonitor(this.ctx.logger);
 		this.pythonAddonDir = resolveAddonPythonDir();
 		const py = await ensurePythonReady(this.ctx.deps, this.ctx.logger);
 		if (py.ok && py.pythonPath) this.pythonPath = py.pythonPath;
@@ -7690,6 +7881,10 @@ var DetectionPipelineAddon = class extends BaseAddon {
 		}
 	}
 	async onShutdown() {
+		if (this.stopStallMonitor) {
+			this.stopStallMonitor();
+			this.stopStallMonitor = null;
+		}
 		if (this.engineMetricsTimer) {
 			clearInterval(this.engineMetricsTimer);
 			this.engineMetricsTimer = null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camstack/addon-pipeline",
-  "version": "1.2.36",
+  "version": "1.2.37",
   "description": "CamStack Pipeline bundle — runner, detection, motion, audio + stream broker. Multi-entry npm package shipping pipeline addons under a single bundle.",
   "keywords": [
     "camstack",