@camstack/addon-pipeline-orchestrator 1.2.45 → 1.2.47

package/assets/viewer/_expo/static/js/web/{node-fs-7cc97cb7668ecaeabcbcfee447afb982.js → node-fs-48d2a76a1b4358828a29686e594be263.js}

@@ -1 +1 @@
-__d(function(g,r,i,a,m,e,d){function n(){throw new Error("node:fs is unavailable in the Viewer runtime")}m.exports={chmodSync:n,createWriteStream:n,existsSync:n,mkdirSync:n,promises:new Proxy({},{get:()=>n}),readFileSync:n,readdirSync:n,renameSync:n,rmSync:n,unlinkSync:n,writeFileSync:n}},2163,[]);
+__d(function(g,r,i,a,m,e,d){function n(){throw new Error("node:fs is unavailable in the Viewer runtime")}m.exports={chmodSync:n,createWriteStream:n,existsSync:n,mkdirSync:n,promises:new Proxy({},{get:()=>n}),readFileSync:n,readdirSync:n,renameSync:n,rmSync:n,unlinkSync:n,writeFileSync:n}},2164,[]);

package/assets/viewer/_expo/static/js/web/{node-path-b4104903c9511874cbbf037d17e9f78d.js → node-path-f5cd235cc4e30b6508669583b1b2c718.js}

@@ -1 +1 @@
-__d(function(g,r,i,a,m,e,d){function n(){throw new Error("node:path is unavailable in the Viewer runtime")}m.exports={basename:n,join:n}},2162,[]);
+__d(function(g,r,i,a,m,e,d){function n(){throw new Error("node:path is unavailable in the Viewer runtime")}m.exports={basename:n,join:n}},2163,[]);

package/assets/viewer/index.html

@@ -36,6 +36,6 @@
     </noscript>
     <!-- The root element for your Expo app. -->
     <div id="root"></div>
-  <script src="/viewer/camstack/_expo/static/js/web/index-5b79e9d56650c4720921fd27c27ccb33.js" defer></script>
+  <script src="/viewer/camstack/_expo/static/js/web/index-a8dfe1019b6f61fc84bf4dba973b9571.js" defer></script>
 </body>
 </html>

package/dist/{_virtual_mf-localSharedImportMap___mfe_internal__addon_pipeline_orchestrator_widgets-9CKmTiwO.mjs → _virtual_mf-localSharedImportMap___mfe_internal__addon_pipeline_orchestrator_widgets-DVSFAO6F.mjs}

@@ -18,7 +18,7 @@ var e = {
 	},
 	"@camstack/types": {
 		name: "@camstack/types",
-		version: "1.2.59",
+		version: "1.2.60",
 		scope: ["default"],
 		loaded: !1,
 		from: "addon_pipeline_orchestrator_widgets",

package/dist/{hostInit-CpXFeXA9.mjs → hostInit-D4Kq_1dM.mjs}

@@ -36,7 +36,7 @@ async function r() {
 				}
 			},
 			"@camstack/types": {
-				version: "1.2.59",
+				version: "1.2.60",
 				scope: "default",
 				shareConfig: {
 					singleton: !0,

package/dist/index.js

@@ -34988,6 +34988,48 @@ var DeviceFeaturesMirror = class {
 	}
 };
 //#endregion
+//#region src/watchdog-camera.ts
+/**
+* Derive the watchdog camera descriptor from a runner config. Captures which
+* stages are expected to flow CONTINUOUSLY (always-on audio, analyzer motion,
+* always-on detection) → the camStreamId feeding each. Audio has no dedicated
+* stream field on the runner config, so it shares the motion stream id.
+*
+* `pipelineEnabled === false` (the `object-detection` switch, D62/ADR-0109)
+* arms NOTHING: `startDetection` deliberately performs no attach and opens no
+* decode session for such a camera, so no continuous stage can ever produce a
+* signal. The camera is still returned (and still registered by the caller) so
+* its watchdog row stays visible — a switched-off camera must read as off, not
+* as broken.
+*
+* `hasAudioSource` is the caller's evidence that the camera's source actually
+* carries an audio track (`BrokerStats.audio !== null`). It fails OPEN: an
+* unknown or failed read passes `true`, because the audio stage is diagnostic
+* and a false negative silently stops watching a working camera.
+*/
+function buildWatchdogCamera(config, deviceName, hasAudioSource) {
+	const continuousStages = /* @__PURE__ */ new Map();
+	if (config.pipelineEnabled === false) return {
+		deviceId: config.deviceId,
+		deviceName,
+		audioMode: config.audioMode,
+		detectionMode: config.detectionMode,
+		motionSources: config.motionSources,
+		continuousStages
+	};
+	if (config.audioMode === "always-on" && hasAudioSource) continuousStages.set("audio", config.motionStreamId);
+	if (config.motionSources.includes("analyzer")) continuousStages.set("motion", config.motionStreamId);
+	if (config.detectionMode === "always-on") continuousStages.set("detection", config.detectionStreamId);
+	return {
+		deviceId: config.deviceId,
+		deviceName,
+		audioMode: config.audioMode,
+		detectionMode: config.detectionMode,
+		motionSources: config.motionSources,
+		continuousStages
+	};
+}
+//#endregion
 //#region src/detection-wiring-controller.ts
 var DetectionWiringController = class {
 	deps;
@@ -35192,7 +35234,8 @@ var DetectionWiringController = class {
 			await this.stopDetection(deviceId);
 		}
 		this.activeDetections.set(deviceId, config);
-		if (config.detectionMode === "on-motion") {
+		if (!config.pipelineEnabled) log.info("object detection switched off — no attach, no decode session", { meta: { detectionMode: config.detectionMode } });
+		else if (config.detectionMode === "on-motion") {
 			if (config.motionSources.includes("analyzer")) try {
 				await this.deps.session.ensureMotionWatch(deviceId, config);
 			} catch (err) {
@@ -35283,11 +35326,44 @@ var DetectionWiringController = class {
 		this.deps.forgetDeviceZones(deviceId);
 		this.deps.forgetDeviceZoneRules(deviceId);
 		this.deps.loadShed.forgetDevice(deviceId);
-		if (!this.deps.ctx().settings) return;
+		const settings = this.deps.ctx().settings;
+		if (!settings) return;
 		await this.deps.settingsStore.deleteCameraSettings(deviceId);
+		try {
+			await settings.clearDeviceStore(deviceId);
+		} catch (err) {
+			this.deps.logger.warn("failed to clear per-device orchestrator settings on removal", {
+				tags: { deviceId },
+				meta: { error: errMsg(err) }
+			});
+		}
 		this.deps.logger.info("Purged pipeline config for removed device", { tags: { deviceId } });
 	}
 	/**
+	* True ONLY when the device registry positively answered "this device does
+	* not exist" (`getDevice` → `null`, per the cap contract).
+	*
+	* A FAILED read answers `false` — D49: a read that fails changes nothing, and
+	* the destructive direction here is refusing to run a live camera.
+	* Deliberately NOT routed through {@link lookupDeviceFeatures}'s mirror: that
+	* one treats missing-as-unknown on purpose (a provider restart passes through
+	* exactly that state and must not re-derive a battery camera's profile), and
+	* conflating the two would make a provider restart look like a deletion.
+	*/
+	async isDeviceDeleted(deviceId) {
+		const api = this.deps.api();
+		if (!api) return false;
+		try {
+			return await api.deviceManager.getDevice.query({ deviceId }) === null;
+		} catch (err) {
+			this.deps.logger.debug("device existence check failed — proceeding as before", {
+				tags: { deviceId },
+				meta: { error: errMsg(err) }
+			});
+			return false;
+		}
+	}
+	/**
 	* Handle a profile-slot change: build a fresh detection config from
 	* per-device settings and start detection if motion is enabled.
 	* Fires on `camera-streams.onProfileSlotsChanged` — any publish,
@@ -35297,6 +35373,11 @@ var DetectionWiringController = class {
 		if (!this.deps.ctx()) return;
 		const log = this.deps.logger.withTags({ deviceId });
 		log.info("handleDeviceRegistered", { meta: { phase: "handleDeviceRegistered" } });
+		if (await this.isDeviceDeleted(deviceId)) {
+			log.warn("device no longer exists — refusing to start detection");
+			await this.handleDeviceUnregistered(deviceId);
+			return;
+		}
 		const config = await this.buildDetectionConfig(deviceId);
 		if (config === TRANSIENT_SLOT_READ) {
 			log.warn("Profile-slot read failed transiently — keeping detection, scheduling retry");
@@ -35436,28 +35517,17 @@ var DetectionWiringController = class {
 		});
 	}
 	/**
-	* Derive the watchdog camera descriptor from a runner config. Captures
-	* which stages are expected to flow CONTINUOUSLY (always-on audio,
-	* analyzer motion, always-on detection) → the camStreamId feeding each.
-	* Audio has no dedicated stream field on the runner config, so it shares
-	* the motion stream id.
+	* Derive the watchdog camera descriptor from a runner config — thin delegate
+	* onto the pure `buildWatchdogCamera` (`watchdog-camera.ts`), where the
+	* arming rules live (a switched-off camera arms nothing; the audio stage
+	* needs evidence of an audio track).
 	*
 	* Public — `PlacementService`'s `buildWatchdogCamera` closure (wired in
-	* `orchestrator-bootstrap.ts`) calls straight through to this method.
+	* `orchestrator-bootstrap.ts`) calls straight through to this method; the
+	* caller resolves `hasAudioSource` once per dispatch.
 	*/
-	buildWatchdogCamera(config, deviceName) {
-		const continuousStages = /* @__PURE__ */ new Map();
-		if (config.audioMode === "always-on") continuousStages.set("audio", config.motionStreamId);
-		if (config.motionSources.includes("analyzer")) continuousStages.set("motion", config.motionStreamId);
-		if (config.detectionMode === "always-on") continuousStages.set("detection", config.detectionStreamId);
-		return {
-			deviceId: config.deviceId,
-			deviceName,
-			audioMode: config.audioMode,
-			detectionMode: config.detectionMode,
-			motionSources: config.motionSources,
-			continuousStages
-		};
+	buildWatchdogCamera(config, deviceName, hasAudioSource) {
+		return buildWatchdogCamera(config, deviceName, hasAudioSource);
 	}
 	/**
 	* Watchdog recovery callback. Invoked when a camera's continuous stage
@@ -35470,7 +35540,7 @@ var DetectionWiringController = class {
 	* Public — `PipelineWatchdog`'s `recover` closure (wired in
 	* `orchestrator-bootstrap.ts`) calls straight through to this method.
 	*/
-	recoverPipelineStage(deviceId, stage, streamId) {
+	recoverPipelineStage(deviceId, stage, streamId, attempt) {
 		if (stage === "audio") {
 			const cfg = this.deps.ledger.getConfig(deviceId);
 			const audioCfg = cfg ? {
@@ -35484,6 +35554,14 @@ var DetectionWiringController = class {
 				});
 			});
 		}
+		this.deps.logger.debug("watchdog recovery: requesting source refresh", {
+			tags: { deviceId },
+			meta: {
+				stage,
+				camStreamId: streamId,
+				attempt
+			}
+		});
 		this.deps.eventBus.emit({
 			id: `watchdog-refresh-${deviceId}-${Date.now()}`,
 			timestamp: /* @__PURE__ */ new Date(),
@@ -35886,6 +35964,64 @@ function computeDispatchGap(desired, known) {
 	return [...desired].filter((id) => !known.has(id));
 }
 /**
+* Split the desired fleet (derived from broker profile slots) against the LIVE
+* device registry.
+*
+* The broker keeps a deleted device's profile-slot assignments forever, so
+* `desiredDeviceIdsFromSlots` alone re-proposes a camera the operator already
+* deleted — and the reconcile's gap-fill then resurrects it. Callers dispatch
+* `existing` only.
+*
+* The caller MUST NOT call this with a failed/partial registry read: a read
+* that fails changes nothing (D49), it never prunes the fleet.
+*/
+function splitDesiredByExistence(desired, liveDeviceIds) {
+	const existing = /* @__PURE__ */ new Set();
+	const vanished = /* @__PURE__ */ new Set();
+	for (const deviceId of desired) if (liveDeviceIds.has(deviceId)) existing.add(deviceId);
+	else vanished.add(deviceId);
+	return {
+		existing,
+		vanished
+	};
+}
+/**
+* Decide which vanished devices are CONFIRMED gone (D49's two-disagreements
+* rule). Teardown destroys work — stopping detection, releasing the camera and
+* purging its persisted config — so a single registry read is never enough: a
+* device must be missing in TWO consecutive reconcile passes before it is torn
+* down. Anything that puts the device back (a successful listing that contains
+* it, or a failed read the caller declines to act on) resets the streak, so the
+* count only ever advances on agreeing evidence.
+*
+* Teardown fires ONCE per vanish streak (`torn-down`) — the broker's slots
+* outlive the device, so it stays vanished on every later pass and would
+* otherwise be re-purged forever.
+*
+* Pure — the caller owns the (in-memory, boot-empty) state map.
+*/
+function reconcileVanishedDevices(vanished, prior) {
+	const tearDown = [];
+	const nextState = /* @__PURE__ */ new Map();
+	for (const deviceId of vanished) {
+		const state = prior.get(deviceId);
+		if (state === void 0) {
+			nextState.set(deviceId, "first-pass");
+			continue;
+		}
+		if (state === "first-pass") {
+			tearDown.push(deviceId);
+			nextState.set(deviceId, "torn-down");
+			continue;
+		}
+		nextState.set(deviceId, "torn-down");
+	}
+	return {
+		tearDown,
+		nextState
+	};
+}
+/**
 * Converge the orchestrator's `assignments` map to runner truth. Runner
 * attachments (`getLocalCameras`) are AUTHORITATIVE; this returns the actions
 * that make the map agree with them:
@@ -36133,7 +36269,10 @@ var PlacementService = class {
 		try {
 			await this.attachOn(targetNodeId, attachConfig);
 			this.deps.ledger.setConfig(runnerConfig.deviceId, attachConfig);
-			if (targetNodeId === this.deps.localNodeId()) this.deps.watchdog()?.register(this.deps.buildWatchdogCamera(runnerConfig, String(runnerConfig.deviceId)));
+			if (targetNodeId === this.deps.localNodeId()) {
+				const hasAudioSource = await this.resolveHasAudioSource(runnerConfig);
+				this.deps.watchdog()?.register(this.deps.buildWatchdogCamera(runnerConfig, String(runnerConfig.deviceId), hasAudioSource));
+			}
 			this.deps.ledger.recordAssignment(runnerConfig.deviceId, targetNodeId, reason, reason === "manual");
 		} finally {
 			dispatchGuard.dispose();
@@ -36559,7 +36698,20 @@ var PlacementService = class {
 			return;
 		}
 		await this.attachOn(nodeId, cached);
-		if (nodeId === this.deps.localNodeId()) this.deps.watchdog()?.register(this.deps.buildWatchdogCamera(cached, String(cached.deviceId)));
+		if (nodeId === this.deps.localNodeId()) {
+			const hasAudioSource = await this.resolveHasAudioSource(cached);
+			this.deps.watchdog()?.register(this.deps.buildWatchdogCamera(cached, String(cached.deviceId), hasAudioSource));
+		}
+	}
+	/**
+	* Resolve the watchdog's audio-track evidence for ONE dispatch. Skipped
+	* entirely (and answered `false`) when `audioMode` could not arm the stage
+	* anyway — `buildWatchdogCamera` needs both — so a camera with on-motion
+	* audio costs no broker round-trip.
+	*/
+	async resolveHasAudioSource(config) {
+		if (config.audioMode !== "always-on") return false;
+		return this.deps.hasAudioSource(config.deviceId, config.motionStreamId);
 	}
 	/**
 	* Normalizes the `decision.kind === 'pending'` → `setPendingReason` +
@@ -37931,7 +38083,9 @@ var PipelineWatchdog = class {
 		for (const [stage] of cam.continuousStages) stages.set(stage, {
 			lastSeenMs: now,
 			attempts: 0,
-			lastAttemptMs: 0
+			lastAttemptMs: 0,
+			everSeen: false,
+			registeredAtMs: now
 		});
 		this.state.set(cam.deviceId, stages);
 	}
@@ -37945,20 +38099,34 @@ var PipelineWatchdog = class {
 		if (!rt) return;
 		rt.lastSeenMs = this.deps.now();
 		rt.attempts = 0;
+		rt.everSeen = true;
 	}
 	tick() {
 		const now = this.deps.now();
 		for (const cam of this.cameras.values()) {
-			const { line, stalled, recoveries } = this.evaluate(cam, now);
+			const { line, stalled, recoveries, disarms } = this.evaluate(cam, now);
 			if (stalled) this.deps.logger.warn(line, { tags: { deviceId: cam.deviceId } });
 			else this.deps.logger.info(line, { tags: { deviceId: cam.deviceId } });
+			for (const d of disarms) {
+				this.deps.logger.warn("watchdog stage never produced a signal — disarming", {
+					tags: { deviceId: cam.deviceId },
+					meta: {
+						stage: d.stage,
+						streamId: d.streamId,
+						sinceRegisteredMs: d.sinceRegisteredMs
+					}
+				});
+				this.state.get(cam.deviceId)?.delete(d.stage);
+			}
 			for (const r of recoveries) {
 				const rt = this.state.get(cam.deviceId)?.get(r.stage);
+				let attempt = this.deps.thresholds.maxRecoveryAttempts;
 				if (rt) {
 					if (rt.attempts < this.deps.thresholds.maxRecoveryAttempts) rt.attempts += 1;
 					rt.lastAttemptMs = now;
+					attempt = rt.attempts;
 				}
-				this.deps.recover(cam.deviceId, r.stage, r.streamId);
+				this.deps.recover(cam.deviceId, r.stage, r.streamId, attempt);
 			}
 		}
 	}
@@ -37973,6 +38141,7 @@ var PipelineWatchdog = class {
 	evaluate(cam, now) {
 		const parts = [];
 		const recoveries = [];
+		const disarms = [];
 		let stalled = false;
 		const stageOrder = [
 			"audio",
@@ -37999,7 +38168,14 @@ var PipelineWatchdog = class {
 			const thresholdMs = this.deps.thresholds[STAGE_THRESHOLD_KEY[stage]];
 			const sSec = Math.round(staleness / 1e3);
 			if (staleness <= thresholdMs) parts.push(`${stage}=${stageMode[stage]}@${streamId}(OK ${sSec}s)`);
-			else if (rt.attempts >= this.deps.thresholds.maxRecoveryAttempts) {
+			else if (rt.attempts >= this.deps.thresholds.maxRecoveryAttempts && !rt.everSeen) {
+				disarms.push({
+					stage,
+					streamId,
+					sinceRegisteredMs: now - rt.registeredAtMs
+				});
+				parts.push(`${stage}=${stageMode[stage]}@${streamId}(NEVER SIGNALLED ${sSec}s · disarmed)`);
+			} else if (rt.attempts >= this.deps.thresholds.maxRecoveryAttempts) {
 				stalled = true;
 				if (now - rt.lastAttemptMs >= this.deps.thresholds.exhaustedRetryMs) {
 					recoveries.push({
@@ -38020,7 +38196,8 @@ var PipelineWatchdog = class {
 		return {
 			line: `[watchdog] cam${cam.deviceId} ${cam.deviceName} · ${parts.join(" · ")} → ${stalled ? "STALLED" : "OK"}`,
 			stalled,
-			recoveries
+			recoveries,
+			disarms
 		};
 	}
 };
@@ -38917,6 +39094,14 @@ var ReconcileController = class ReconcileController {
 	/** Shared in-flight pass so a session dispatch waits for runner truth instead of racing it. */
 	attachmentReconcilePromise = null;
 	/**
+	* Desired-but-nonexistent devices and how far their vanish streak has got
+	* (`dispatch-reconcile.ts`). PURELY in-memory and seeded EMPTY on boot: it is
+	* a confirmation counter, not a record — after a restart the first pass only
+	* ever re-observes, never destroys. Cleared whenever the registry read fails,
+	* so a failed read can never advance a device toward teardown.
+	*/
+	vanishedDevices = /* @__PURE__ */ new Map();
+	/**
 	* Per-device backoff for retrying `handleDeviceRegistered` after a
 	* TRANSIENT profile-slot read failure. Timers are `unref`'d and cleared on
 	* shutdown / device removal.
@@ -38985,13 +39170,24 @@ var ReconcileController = class ReconcileController {
 				return;
 			}
 			const desired = desiredDeviceIdsFromSlots(slots);
+			const liveDeviceIds = await this.readLiveDeviceIds();
+			const { existing, vanished } = liveDeviceIds === null ? {
+				existing: desired,
+				vanished: /* @__PURE__ */ new Set()
+			} : splitDesiredByExistence(desired, liveDeviceIds);
+			if (liveDeviceIds === null) {
+				this.deps.logger.warn("dispatch reconcile: device existence filter SKIPPED — registry read failed", { meta: { desired: desired.size } });
+				this.vanishedDevices = /* @__PURE__ */ new Map();
+			}
 			const known = new Set(this.deps.ledger.listConfigIds());
-			const gap = computeDispatchGap(desired, known);
+			const gap = computeDispatchGap(existing, known);
 			this.deps.logger.info("dispatch reconcile", { meta: {
 				desired: desired.size,
 				known: known.size,
-				gap
+				gap,
+				vanished: vanished.size
 			} });
+			await this.tearDownVanishedDevices(vanished);
 			for (const deviceId of gap) try {
 				await this.deps.handleDeviceRegistered(deviceId);
 			} catch (err) {
@@ -39010,6 +39206,53 @@ var ReconcileController = class ReconcileController {
 		}
 	}
 	/**
+	* The live device registry as an id set, or `null` when the read FAILED.
+	* `null` is the caller's signal to skip the existence filter entirely — it
+	* must never be confused with "the registry is empty", which would prune the
+	* whole fleet.
+	*
+	* Asks for the slim projection: this needs identity only, never
+	* `config`/`sourceInfo` (a full listing of 293 devices measured 271 KB).
+	*/
+	async readLiveDeviceIds() {
+		const api = this.deps.api();
+		if (!api) return null;
+		try {
+			const devices = await api.deviceManager.listAll.query({ projection: "slim" });
+			return new Set(devices.map((device) => device.id));
+		} catch (err) {
+			this.deps.logger.debug("dispatch reconcile: deviceManager.listAll failed", { meta: { error: errMsg(err) } });
+			return null;
+		}
+	}
+	/**
+	* Tear down the desired devices the registry no longer has — but only once
+	* TWO consecutive passes agree they are gone (`reconcileVanishedDevices`,
+	* D49). Teardown destroys work, so a single listing that omits a device
+	* (which a partial or racy read looks exactly like) is not enough.
+	*
+	* Runs the SAME `handleDeviceUnregistered` the `DeviceUnregistered` event
+	* runs, so there is exactly one teardown path.
+	*/
+	async tearDownVanishedDevices(vanished) {
+		const { tearDown, nextState } = reconcileVanishedDevices(vanished, this.vanishedDevices);
+		this.vanishedDevices = nextState;
+		for (const deviceId of tearDown) {
+			this.deps.logger.warn("dispatch reconcile: device no longer exists — tearing down instead of dispatching", {
+				tags: { deviceId },
+				meta: { confirmedPasses: 2 }
+			});
+			try {
+				await this.deps.handleDeviceUnregistered(deviceId);
+			} catch (err) {
+				this.deps.logger.warn("dispatch reconcile: teardown of vanished device failed", {
+					tags: { deviceId },
+					meta: { error: errMsg(err) }
+				});
+			}
+		}
+	}
+	/**
 	* Converge the in-memory `assignments` map to runner truth (Phase 1 of the
 	* placement-derived-state design). Runner attachments (`getLocalCameras`) are
 	* authoritative: detach duplicates/orphans, and drop stale assignments
@@ -39320,6 +39563,7 @@ var ReconcileController = class ReconcileController {
 		this.slotReadRetryTimers.clear();
 		this.slotReadRetryAttempts.clear();
 		this.remoteHealthAttempts.clear();
+		this.vanishedDevices = /* @__PURE__ */ new Map();
 	}
 };
 //#endregion
@@ -40385,6 +40629,31 @@ async function buildOrchestratorControllers(deps) {
 		getInitTimestamp: () => deps.initTimestamp
 	});
 	const inferenceRotation = new RoundRobinInferenceDeviceRotation();
+	/**
+	* Does this camera's source carry an audio track? Read from the broker that
+	* owns the stream (`BrokerStats.audio === null` is the documented no-audio
+	* signal), pinned to the cluster's source owner exactly like the
+	* camera-status broker stage. FAILS OPEN: no api, an RPC error, or a broker
+	* that has not detected the track yet (`undefined`, cold start) all answer
+	* `true`, because the only consumer is the watchdog's diagnostic audio stage
+	* and a false negative silently stops watching a working camera.
+	*/
+	const resolveHasAudioSource = async (deviceId, camStreamId) => {
+		const api = deps.ctx().api;
+		if (!api) return true;
+		try {
+			return (await api.streamBroker.getBrokerStats.query({ brokerId: makeSourceBrokerId(deviceId, camStreamId) }, nodePin(topology.assignSource(deviceId)))).audio !== null;
+		} catch (err) {
+			deps.ctx().logger.debug("audio-source probe failed — assuming the source has audio", {
+				tags: { deviceId },
+				meta: {
+					camStreamId,
+					error: errMsg(err)
+				}
+			});
+			return true;
+		}
+	};
 	const placement = new PlacementService({
 		ctx: () => deps.ctx(),
 		ctxIfReady: () => deps.ctxIfReady(),
@@ -40400,7 +40669,8 @@ async function buildOrchestratorControllers(deps) {
 		getInferenceDeviceCaps: (nodeId) => deps.getInferenceDeviceCaps(nodeId),
 		readPipelineDevicePin: (deviceId) => deps.readPipelineDevicePin(deviceId),
 		inferenceRotation,
-		buildWatchdogCamera: (config, deviceName) => detectionWiring.buildWatchdogCamera(config, deviceName),
+		buildWatchdogCamera: (config, deviceName, hasAudioSource) => detectionWiring.buildWatchdogCamera(config, deviceName, hasAudioSource),
+		hasAudioSource: (deviceId, camStreamId) => resolveHasAudioSource(deviceId, camStreamId),
 		isIdleSessionCamera: (deviceId) => deps.isIdleSessionCamera(deviceId),
 		activeSessionNode: (deviceId) => session.activeSessionNode(deviceId),
 		closeActiveSession: (deviceId) => session.closeSessionForReassign(deviceId),
@@ -40475,6 +40745,7 @@ async function buildOrchestratorControllers(deps) {
 		loadShed,
 		logger: deps.ctx().logger,
 		handleDeviceRegistered: (deviceId) => deps.handleDeviceRegistered(deviceId),
+		handleDeviceUnregistered: (deviceId) => deps.handleDeviceUnregistered(deviceId),
 		dispatchCamera: (config) => deps.dispatchCamera(config),
 		detachOn: (nodeId, deviceId) => deps.detachOn(nodeId, deviceId),
 		localNodeId: () => localNodeId,
@@ -40575,7 +40846,7 @@ async function buildOrchestratorControllers(deps) {
 	const pipelineWatchdog = new PipelineWatchdog({
 		now: () => Date.now(),
 		logger: deps.ctx().logger,
-		recover: (deviceId, stage, streamId) => detectionWiring.recoverPipelineStage(deviceId, stage, streamId),
+		recover: (deviceId, stage, streamId, attempt) => detectionWiring.recoverPipelineStage(deviceId, stage, streamId, attempt),
 		thresholds: DEFAULT_WATCHDOG_THRESHOLDS
 	});
 	pipelineWatchdog.start(deps.watchdogIntervalMs);