@camstack/addon-pipeline-orchestrator 1.2.222 → 1.2.223

package/dist/index.js

@@ -5391,7 +5391,7 @@ var ZodIssueCode = {
 var ZodFirstPartyTypeKind;
 ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {});
 //#endregion
-//#region ../types/dist/sleep-GU_us3DG.mjs
+//#region ../types/dist/sleep-CiR4z7r9.mjs
 /**
 * The audio chunk plane's byte format, and the ONE expansion from a coded
 * window to float samples (D455).
@@ -6549,6 +6549,23 @@ var CamProfileSchema = _enum([
 	"mid",
 	"low"
 ]);
+/** Canonical ordering. Hard-coded; never sorted. */
+var CAM_PROFILE_ORDER = [
+	"high",
+	"mid",
+	"low"
+];
+/**
+* Which rung a per-camera consumer listens on: an explicit profile, or `auto`.
+*
+* `auto` is a REAL value, not an absent one — it means "resolve it by the rule
+* that consumer owns". It lives beside `CamProfile` because a rung is the only
+* operator-facing way to name a stream: a cam-stream id is broker-internal and
+* moves when a slot is reassigned, so a stored id silently stops meaning what
+* the operator picked. Today's one user is the audio analyser, whose rule is
+* "the lowest AVAILABLE native rung" (D537).
+*/
+var AudioStreamPickSchema = union([CamProfileSchema, literal("auto")]);
 var CamStreamKindSchema = _enum([
 	"pull-rtsp",
 	"pull-rtmp",
@@ -21032,6 +21049,7 @@ var MediaFileKindEnum = _enum([
 	"keyFrameSmall",
 	"thumbnailSmall",
 	"confirmationCrop",
+	"debugCrop",
 	"sceneFrame"
 ]);
 /**
@@ -22696,6 +22714,18 @@ var RunnerCameraConfigSchema = object({
 	motionStreamId: string(),
 	detectionStreamId: string(),
 	/**
+	* Which rung this camera's audio analysis listens on — `auto` (the lowest
+	* AVAILABLE native rung) or an explicit one.
+	*
+	* Not consumed by the runner: carried here so it travels with the camera's
+	* config the way `audioMotionWindowMs` does, and so the orchestrator's
+	* watchdog resolves the same stream the audio subscription did. OPTIONAL
+	* with no default — absent means `auto`, which is what every camera written
+	* before this field had, and an absent optional adds nothing to the
+	* generated cap-input defaults (D537).
+	*/
+	audioStreamPick: AudioStreamPickSchema.optional(),
+	/**
 	* Motion sources that can activate the pipeline. At least one must
 	* be present. Multiple sources OR-ed: any one firing arms the
 	* cooldown timer and transitions watching → active. The same
@@ -25718,6 +25748,104 @@ var WebrtcStreamChoiceSchema = object({
 	/** Bitrate in kbps (null for adaptive). */
 	bitrateKbps: number().nullable()
 });
+/**
+* The last move the adaptive ladder made on this session, and the numbers it
+* rested on. Mirrors `LadderDecision` in the stream-broker's
+* `adaptive-controller.ts` — the log line's evidence, made readable.
+*
+* Nullability is load-bearing: `lossRatio: null` means the loss tracker had
+* no window to report, which is NOT a link with zero loss.
+*/
+var WebrtcLadderDecisionSchema = object({
+	/** `loss` — RTCP / client-reported packet loss; `stall` — the picture
+	*  stopped moving; `healthy` — a promotion. */
+	cause: _enum([
+		"loss",
+		"stall",
+		"healthy"
+	]),
+	/** The rung the ladder moved TO. Null for a move that changed no rung
+	*  (an MTU reduction, a forced transcode-down at the bottom). */
+	tier: CamProfileSchema.nullable(),
+	/** Whether that move forced the egress transcode-down rung. */
+	forcedTranscodeDown: boolean(),
+	/** Loss ratio over the tracker's window at the moment of the decision. */
+	lossRatio: number().nullable(),
+	/** The client's reported downlink at that moment, in kbps. */
+	clientKbps: number().nullable(),
+	/** How long the stall detector had been seeing nothing arrive. */
+	stalledForMs: number().nullable(),
+	/** Whether the broker WAS sending while that was measured — the half that
+	*  separates "the camera stopped" from "the link stopped". */
+	serverSending: boolean().nullable(),
+	/** Epoch ms. The overlay prints its age; a decision from 40 minutes ago
+	*  must not read like one from this second. */
+	at: number()
+});
+/** Per-tier count of MEASURED downgrades this viewer session has suffered. */
+var WebrtcTierFailureSchema = object({
+	tier: CamProfileSchema,
+	failures: number().int().nonnegative()
+});
+/**
+* What the SERVER decided for one WebRTC session — the half the client cannot
+* measure. See `getSessionDebug`.
+*/
+var WebrtcSessionDebugSchema = object({
+	sessionId: string(),
+	/** Whether the session still exists here. Everything below is null when
+	*  it does not — a dead session has no measurements, not zero ones. */
+	alive: boolean(),
+	/** Epoch ms this snapshot was taken, so the overlay can show its age. */
+	observedAt: number(),
+	/** The broker actually feeding this session (`<deviceId>/<camStreamId>`). */
+	brokerId: string().nullable(),
+	camStreamId: string().nullable(),
+	/** `derived` = this hub BUILT the rung being served (a transcode/scale of
+	*  another stream); `native` = the camera's own encode. */
+	sourceKind: _enum([
+		"native",
+		"derived",
+		"unknown"
+	]),
+	/** Whether the ladder is running at all (an `adaptive` target). */
+	adaptive: boolean(),
+	/** The rung `auto` ACTUALLY resolved to right now. Null when the broker
+	*  is bound to no profile slot (a manually-activated stream). */
+	servedTier: CamProfileSchema.nullable(),
+	/** Which node ingests the source. Null when unresolved. */
+	ingestNodeId: string().nullable(),
+	/** Whether that node is a remote one (the media crosses a node boundary
+	*  before it reaches this session). Null when unresolved. */
+	ingestIsRemote: boolean().nullable(),
+	/** Codec off the source, and the one negotiated with this client. */
+	sourceCodec: string().nullable(),
+	negotiatedCodec: string().nullable(),
+	/** Whether the EGRESS leg re-encodes for this client or forwards the
+	*  source bytes untouched. */
+	egressLeg: _enum([
+		"copy",
+		"transcode",
+		"unknown"
+	]),
+	/** What the broker itself reports about the rung it is serving. */
+	brokerStatus: string().nullable(),
+	brokerCodec: string().nullable(),
+	brokerBitrateKbps: number().nullable(),
+	brokerInputFps: number().nullable(),
+	brokerUptimeMs: number().nullable(),
+	/** RTP packets this session has sent — the server's own "am I sending?". */
+	rtpPacketsSent: number().nullable(),
+	/** D42: the track may be carrying the recorded feeder, not live. The ladder
+	*  is suspended there, so a frozen picture in `recorded` mode means
+	*  something entirely different. */
+	trackMode: _enum(["live", "recorded"]).nullable(),
+	lastDecision: WebrtcLadderDecisionSchema.nullable(),
+	tierFailures: array(WebrtcTierFailureSchema),
+	/** Successful promotions in this viewer session (drives the progressive
+	*  healthy timer). Null when no ladder is running. */
+	upgradeCount: number().nullable()
+});
 DeviceType.Camera, method(object({ deviceId: number().int().nonnegative() }), array(WebrtcStreamChoiceSchema)), method(object({
 	deviceId: number().int().nonnegative(),
 	target: WebrtcStreamTargetSchema,
@@ -25882,7 +26010,10 @@ DeviceType.Camera, method(object({ deviceId: number().int().nonnegative() }), ar
 	* the same answer as "it ended": either way nothing is holding it up.
 	*/
 	alive: boolean()
-}));
+})), method(object({
+	deviceId: number().int().nonnegative(),
+	sessionId: string()
+}), WebrtcSessionDebugSchema, { kind: "query" });
 object({
 	/** All accessory children of the parent. */
 	childDeviceIds: array(number()).readonly(),
@@ -28970,16 +29101,37 @@ var GridProfileOfferSchema = object({
 	]),
 	offered: boolean(),
 	/** Sources that cannot serve it. Empty when it is offered, or when there are no cells. */
-	missingSources: array(number().int().positive())
+	missingSources: array(number().int().positive()),
+	/**
+	* The canvas this profile composes onto, `WxH`, or empty when it is not
+	* offered. DERIVED from the cells and the sources' own size at this profile —
+	* it is reported because nothing else in the system would ever say what the
+	* grid came out as, and because it is the number an operator would otherwise
+	* expect to type.
+	*/
+	canvas: string(),
+	/**
+	* Whether this profile is PUBLISHED, of the ones the grid could serve.
+	*
+	* A grid's `high` is composed of its sources' `high`, so on a 4K fleet it is
+	* a 4K canvas built from 4K decodes — something to opt into, not something a
+	* viewer's adaptive should be handed by climbing to the top rung it can see.
+	* Default is `mid` + `low`.
+	*/
+	published: boolean()
 });
 var GridLayoutViewSchema = object({
 	/** The persisted grid row this camera was declared from. */
 	instanceId: string(),
 	deviceId: number().int().nonnegative(),
 	name: string(),
-	/** The canvas the operator laid out — this grid's `high`. mid/low are scaled from it. */
-	width: number().int(),
-	height: number().int(),
+	/**
+	* NO canvas size. A grid's resolution is not authored: each profile derives
+	* its own from the cells and its sources' dimensions. The two numbers that
+	* used to be here were a text field that silently decided both how much the
+	* composite cost and how sharp it was — see `profiles[].canvas` for what it
+	* came out as.
+	*/
 	fps: number().int(),
 	cells: array(GridLayoutCellSchema),
 	/** What the catalog will publish, and what it refuses to. Read-only. */
@@ -28988,9 +29140,13 @@ var GridLayoutViewSchema = object({
 var GridLayoutPatchSchema = object({
 	deviceId: number().int().nonnegative(),
 	name: string().min(1).max(160).optional(),
-	width: number().int().min(160).max(7680).optional(),
-	height: number().int().min(120).max(4320).optional(),
 	fps: number().int().min(1).max(60).optional(),
+	/** Which profiles to publish. See `GridProfileOffer.published`. */
+	publishedProfiles: array(_enum([
+		"high",
+		"mid",
+		"low"
+	])).max(3).optional(),
 	/**
 	* The whole cell list at once. A per-cell patch would need an ordering the
 	* editor does not have, and a half-applied layout is a picture nobody asked
@@ -39659,6 +39815,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"webrtcSession.getSessionDebug": {
+		capName: "webrtc-session",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"webrtcSession.getSessionState": {
 		capName: "webrtc-session",
 		capScope: "device",
@@ -41642,6 +41804,11 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"webrtcSession.getSessionDebug": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"webrtcSession.getSessionState": [{
 		name: "deviceId",
 		form: "single",
@@ -42505,6 +42672,106 @@ function balanceAudio(input) {
 	};
 }
 //#endregion
+//#region src/audio-stream-selection.ts
+/**
+* Rung order for an audio consumer: cheapest first. The inverse of
+* `CAM_PROFILE_ORDER` (`high → mid → low`), derived from it rather than
+* re-spelled so the two can never disagree about which rungs exist.
+*/
+var AUDIO_RUNG_PREFERENCE = [...CAM_PROFILE_ORDER].reverse();
+/**
+* True when a cam-stream id names a broker-spawned transcode plane.
+*
+* The `derived:` prefix is the repo-wide convention (`stream-broker-manager`'s
+* `derivedDefinition`, `snapshot-grab-pick`, `prefer-live-adaptive-candidates`,
+* the device-scoped stream pickers). Judged from the ID because that is what
+* the caller holds: the profile-slot table carries `sourceCamStreamId`, not the
+* published `CameraStream.kind`, and asking the broker for the whole stream
+* catalogue to re-derive a fact the id already states would add an RPC to every
+* audio subscribe.
+*/
+function isDerivedCamStream(camStreamId) {
+	return camStreamId.startsWith("derived:");
+}
+/** Every value the per-camera setting may hold, in the order the UI offers them. */
+var AUDIO_STREAM_PICKS = ["auto", ...CAM_PROFILE_ORDER];
+/**
+* Narrow a stored settings value to an {@link AudioStreamPick}.
+*
+* Anything that is not one of the four known values — absent, empty, a rung
+* from a schema this build does not have — reads as `auto`. That is the
+* behaviour every camera already has, so an unreadable value degrades to
+* today's rather than throwing the camera's whole detection-settings read.
+*/
+function toAudioStreamPick(value) {
+	return AUDIO_STREAM_PICKS.find((pick) => pick === value) ?? "auto";
+}
+/**
+* Choose the cam-stream this camera's audio analysis attaches to.
+*
+* Pure. Every branch is either a selection carrying the reason, or a refusal
+* carrying the cause — there is no third answer and no silent default.
+*/
+function selectAudioCamStream(input) {
+	const { pick, motionStreamId, assigned } = input;
+	if (pick !== "auto") {
+		if (assigned === null) return {
+			kind: "refused",
+			reason: "pick-unresolvable",
+			pick,
+			rejectedCamStreamId: null
+		};
+		const picked = assigned.get(pick);
+		if (picked === void 0) return {
+			kind: "refused",
+			reason: "pick-unassigned",
+			pick,
+			rejectedCamStreamId: null
+		};
+		return {
+			kind: "selected",
+			camStreamId: picked,
+			profile: pick,
+			selectedBy: "operator-pick",
+			derived: isDerivedCamStream(picked)
+		};
+	}
+	if (assigned === null) {
+		if (isDerivedCamStream(motionStreamId)) return {
+			kind: "refused",
+			reason: "slots-unknown-and-fallback-derived",
+			pick,
+			rejectedCamStreamId: motionStreamId
+		};
+		return {
+			kind: "selected",
+			camStreamId: motionStreamId,
+			profile: null,
+			selectedBy: "motion-stream-fallback",
+			derived: false
+		};
+	}
+	for (const profile of AUDIO_RUNG_PREFERENCE) {
+		const camStreamId = assigned.get(profile);
+		if (camStreamId === void 0) continue;
+		if (isDerivedCamStream(camStreamId)) continue;
+		return {
+			kind: "selected",
+			camStreamId,
+			profile,
+			selectedBy: "lowest-native-rung",
+			derived: false
+		};
+	}
+	const anyAssigned = AUDIO_RUNG_PREFERENCE.some((profile) => assigned.has(profile));
+	return {
+		kind: "refused",
+		reason: anyAssigned ? "all-rungs-derived" : "no-assigned-rung",
+		pick,
+		rejectedCamStreamId: anyAssigned ? motionStreamId : null
+	};
+}
+//#endregion
 //#region src/keyed-async-lock.ts
 /**
 * Serializes critical sections per key. Different keys run fully
@@ -43004,15 +43271,46 @@ var AudioSubscriptionController = class {
 			this.deps.logger.info("audio subscribe deferred: audioMode=on-motion, no window open", { tags: { deviceId } });
 			return null;
 		}
-		const audioStream = config.audioStreamId ?? config.motionStreamId;
+		const selection = selectAudioCamStream({
+			pick: config.audioStreamPick ?? "auto",
+			motionStreamId: config.motionStreamId,
+			assigned: await this.deps.assignedProfiles(deviceId)
+		});
+		if (selection.kind === "refused") {
+			this.deps.logger.warn("audio subscription REFUSED — no native rung to listen on (an audio-only consumer never causes a video transcode)", {
+				tags: { deviceId },
+				meta: {
+					reason: selection.reason,
+					pick: selection.pick,
+					rejectedCamStreamId: selection.rejectedCamStreamId,
+					motionStreamId: config.motionStreamId,
+					hint: selection.reason === "pick-unassigned" ? "this camera no longer publishes the rung its audio is pinned to — repoint the Audio stream setting, or set it back to Auto" : "assign a native (non-derived) stream to one of this camera’s profile slots, or pick a rung explicitly"
+				}
+			});
+			return null;
+		}
+		const audioStream = selection.camStreamId;
 		const audioBrokerId = makeSourceBrokerId(deviceId, audioStream);
+		this.deps.logger.info("audio stream selected", {
+			tags: { deviceId },
+			meta: {
+				camStreamId: audioStream,
+				profile: selection.profile,
+				selectedBy: selection.selectedBy,
+				derived: selection.derived,
+				pick: config.audioStreamPick ?? "auto",
+				motionStreamId: config.motionStreamId,
+				...selection.derived ? { note: "this pick is a derived stream — the audio subscription keeps its transcode feeder alive" } : {}
+			}
+		});
 		if ((await this.deps.probeAudioTrack(deviceId, audioStream)).kind === "absent") {
 			this.deps.logger.warn("audio subscription REFUSED — this stream carries no audio track", {
 				tags: { deviceId },
 				meta: {
 					camStreamId: audioStream,
 					brokerId: audioBrokerId,
-					selectedBy: config.audioStreamId !== void 0 ? "audioStreamId" : "motionStreamId",
+					selectedBy: selection.selectedBy,
+					profile: selection.profile,
 					hint: "point the camera’s audio at a stream that has an audio track — no stream is substituted automatically"
 				}
 			});
@@ -45948,6 +46246,39 @@ var pipelineOrchestratorActions = defineCustomActions({
 var TRANSIENT_SLOT_READ = Symbol("transient-slot-read");
 //#endregion
 //#region src/device-detection-settings.ts
+/**
+* Pure device-detection-settings derivation for the pipeline orchestrator.
+*
+* Extracted from `index.ts`'s `resolveDeviceDetectionSettings` (S3 refactor
+* step — zero behavior change). That ~185-line method interleaved I/O
+* (device-store read, binding/feature lookups) with a 5-branch
+* `motionSources` default ladder and several other operator-wins→profile→
+* fallback resolutions. The class-side method now does ONLY the I/O
+* gathering (`readDeviceStore`, `hydrateSchema`, `lookupDeviceFeatures`,
+* `deviceHasOnboardMotionCap`, `isDetectionPipelineActive`,
+* `isMotionDetectionActive`) and hands the raw materials to
+* `resolveDetectionSettings`, the pure decision half that used to be
+* interleaved with that I/O.
+*
+* Also carries:
+*  - `resolveAssignedProfile` — the profile-slot fallback chain (was already
+*    pure; moved verbatim, no `this` usage in the original).
+*  - `detectionConfigEquals` — the field-by-field `CameraDetectionConfig`
+*    comparator (was already a pure `static`; moved verbatim).
+*  - `buildDetectionConfigFromInputs` — the pure tail of
+*    `buildDetectionConfig`: given the resolved settings + the assigned
+*    profile-slot map, resolves motion/detection profiles and shapes the
+*    `CameraDetectionConfig` result.
+*  - `buildRunnerConfig` — a single-source-of-truth `RunnerCameraConfig`
+*    literal builder (smell #10: the literal was built field-by-field in 3
+*    places — `startDetection`, `ensureMotionWatch`,
+*    `dispatchDetectionSession` — differing only in `motionSources` /
+*    `detectionMode` / `audioMode` / `steps` / `audio`). Wired ONLY into
+*    `startDetection`'s always-on/config-build branch in this step; the two
+*    Phase-3 session-time sites intentionally still build their own literals
+*    inline — a later refactor step migrates them so this step never touches
+*    the session-dispatch path.
+*/
 /** Read a required string leaf out of the hydrated `flat` schema values. */
 function mustString(flat, deviceId, key) {
 	const v = flat[key];
@@ -46024,6 +46355,7 @@ function resolveDetectionSettings(input) {
 	}
 	const userDetectionMode = raw["detectionMode"];
 	const detectionMode = typeof userDetectionMode === "string" && isPipelinePhaseMode(userDetectionMode) ? userDetectionMode : profile?.defaults.detectionMode ?? "on-motion";
+	const audioStreamPick = toAudioStreamPick(raw["audioStreamPick"]);
 	const userAudioMode = raw["audioMode"];
 	const audioMode = typeof userAudioMode === "string" && isPipelinePhaseMode(userAudioMode) ? userAudioMode : profile?.defaults.audioMode ?? "always-on";
 	const userOnboardMotionDrivesAnalyzer = raw["onboardMotionDrivesAnalyzer"];
@@ -46049,6 +46381,7 @@ function resolveDetectionSettings(input) {
 		motionCooldownMs: numberOrDefault(flat, "motionCooldownMs"),
 		maxSessionHoldMs: numberOrDefault(flat, "maxSessionHoldMs"),
 		audioMotionWindowMs: numberOrDefault(flat, "audioMotionWindowMs"),
+		audioStreamPick,
 		detectionMode,
 		audioMode,
 		onboardMotionDrivesAnalyzer,
@@ -46109,7 +46442,7 @@ function buildDetectionConfigFromInputs(resolved, assigned) {
 		motionCooldownMs: resolved.motionCooldownMs,
 		maxSessionHoldMs: resolved.maxSessionHoldMs,
 		audioMotionWindowMs: resolved.audioMotionWindowMs,
-		audioStreamId: void 0,
+		audioStreamPick: resolved.audioStreamPick,
 		detectionMode: resolved.detectionMode,
 		audioMode: resolved.audioMode,
 		onboardMotionDrivesAnalyzer: resolved.onboardMotionDrivesAnalyzer,
@@ -46137,7 +46470,7 @@ function detectionConfigEquals(a, b) {
 	if (a.motionCooldownMs !== b.motionCooldownMs) return false;
 	if (a.maxSessionHoldMs !== b.maxSessionHoldMs) return false;
 	if (a.audioMotionWindowMs !== b.audioMotionWindowMs) return false;
-	if (a.audioStreamId !== b.audioStreamId) return false;
+	if (a.audioStreamPick !== b.audioStreamPick) return false;
 	if (a.onboardMotionDrivesAnalyzer !== b.onboardMotionDrivesAnalyzer) return false;
 	if (a.occupancyRecheckEnabled !== b.occupancyRecheckEnabled) return false;
 	if (a.occupancyRecheckSec !== b.occupancyRecheckSec) return false;
@@ -46167,6 +46500,7 @@ function buildRunnerConfig(base, overrides) {
 		detectionFps: config.detectionFps,
 		motionStreamId: config.motionStreamId,
 		detectionStreamId: config.detectionStreamId,
+		...config.audioStreamPick !== void 0 ? { audioStreamPick: config.audioStreamPick } : {},
 		motionSources: overrides?.motionSources ?? config.motionSources,
 		...(() => {
 			const sources = overrides?.detectionSources ?? config.detectionSources;
@@ -46669,8 +47003,15 @@ async function reconcileOnboardForwarding(input, deps) {
 /**
 * 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.
+* always-on detection) → the camStreamId feeding each.
+*
+* Audio no longer shares the motion stream id. It rides the camera's lowest
+* NATIVE rung (`selectAudioCamStream`) because an audio-only consumer must
+* never cause a video transcode, and on this fleet the motion rung IS a
+* `derived:*` transcode. The caller therefore hands the resolved audio stream
+* in {@link WatchdogAudioSource} — reading `motionStreamId` here would label
+* and RECOVER the wrong stream, which is how camera 618's audio stage watched
+* a plane the analyser was not listening to.
 *
 * `pipelineEnabled === false` (the `object-detection` switch, D62/ADR-0109)
 * arms NOTHING: `startDetection` deliberately performs no attach and opens no
@@ -46679,12 +47020,14 @@ async function reconcileOnboardForwarding(input, deps) {
 * 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
+* `audio.hasTrack` is the caller's evidence that the AUDIO stream 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.
+* and a false negative silently stops watching a working camera. A `null`
+* `audio.camStreamId` means the subscription itself was refused (no native
+* rung, or `audioMode` cannot arm the stage) — there is nothing to watch.
 */
-function buildWatchdogCamera(config, deviceName, hasAudioSource) {
+function buildWatchdogCamera(config, deviceName, audio) {
 	const continuousStages = /* @__PURE__ */ new Map();
 	if (config.pipelineEnabled === false) return {
 		deviceId: config.deviceId,
@@ -46694,7 +47037,7 @@ function buildWatchdogCamera(config, deviceName, hasAudioSource) {
 		motionSources: config.motionSources,
 		continuousStages
 	};
-	if (config.audioMode === "always-on" && hasAudioSource) continuousStages.set("audio", config.motionStreamId);
+	if (config.audioMode === "always-on" && audio.camStreamId !== null && audio.hasTrack) continuousStages.set("audio", audio.camStreamId);
 	if (config.motionSources.includes("analyzer")) continuousStages.set("motion", config.motionStreamId);
 	if (config.detectionMode === "always-on") continuousStages.set("detection", config.detectionStreamId);
 	return {
@@ -46879,6 +47222,11 @@ var DetectionWiringController = class {
 	* `CamProfile → sourceCamStreamId` so callers can both check which
 	* profiles are live AND resolve a profile to the cam-stream-keyed
 	* brokerId (`${deviceId}/${camStreamId}`) used by the broker.
+	*
+	* Public because the AUDIO plane needs the same answer, from the same read:
+	* `selectAudioCamStream` picks the lowest NATIVE rung, and a second reader
+	* of the slot table would be a second authority on which rung is backed by
+	* which cam-stream.
 	*/
 	async fetchAssignedProfiles(deviceId) {
 		const api = this.deps.api();
@@ -47258,10 +47606,10 @@ var DetectionWiringController = class {
 	*
 	* Public — `PlacementService`'s `buildWatchdogCamera` closure (wired in
 	* `orchestrator-bootstrap.ts`) calls straight through to this method; the
-	* caller resolves `hasAudioSource` once per dispatch.
+	* caller resolves the {@link WatchdogAudioSource} once per dispatch.
 	*/
-	buildWatchdogCamera(config, deviceName, hasAudioSource) {
-		return buildWatchdogCamera(config, deviceName, hasAudioSource);
+	buildWatchdogCamera(config, deviceName, audio) {
+		return buildWatchdogCamera(config, deviceName, audio);
 	}
 	/**
 	* Watchdog recovery callback. Invoked when a camera's continuous stage
@@ -48196,8 +48544,8 @@ var PlacementService = class {
 			await this.attachOn(targetNodeId, attachConfig);
 			this.deps.ledger.setConfig(runnerConfig.deviceId, attachConfig);
 			if (targetNodeId === this.deps.localNodeId()) {
-				const hasAudioSource = await this.resolveHasAudioSource(runnerConfig);
-				this.deps.watchdog()?.register(this.deps.buildWatchdogCamera(runnerConfig, String(runnerConfig.deviceId), hasAudioSource));
+				const audioSource = await this.resolveAudioSource(runnerConfig);
+				this.deps.watchdog()?.register(this.deps.buildWatchdogCamera(runnerConfig, String(runnerConfig.deviceId), audioSource));
 			}
 			this.deps.ledger.recordAssignment(runnerConfig.deviceId, targetNodeId, reason, reason === "manual");
 		} finally {
@@ -48625,19 +48973,35 @@ var PlacementService = class {
 		}
 		await this.attachOn(nodeId, cached);
 		if (nodeId === this.deps.localNodeId()) {
-			const hasAudioSource = await this.resolveHasAudioSource(cached);
-			this.deps.watchdog()?.register(this.deps.buildWatchdogCamera(cached, String(cached.deviceId), hasAudioSource));
+			const audioSource = await this.resolveAudioSource(cached);
+			this.deps.watchdog()?.register(this.deps.buildWatchdogCamera(cached, String(cached.deviceId), audioSource));
 		}
 	}
 	/**
-	* 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.
+	* Resolve the watchdog's audio plane for ONE dispatch: which stream audio
+	* rides, and whether it carries a track. Skipped entirely (and answered
+	* "nothing to watch") when `audioMode` could not arm the stage anyway, so a
+	* camera with on-motion audio costs no broker round-trip.
+	*
+	* The stream comes from the SAME selection the subscription makes — reading
+	* `motionStreamId` here would arm the stage on the derived rung the audio
+	* analyser deliberately does not listen to, and both the label and the
+	* recovery would name a stream nobody is on.
 	*/
-	async resolveHasAudioSource(config) {
-		if (config.audioMode !== "always-on") return false;
-		return this.deps.hasAudioSource(config.deviceId, config.motionStreamId);
+	async resolveAudioSource(config) {
+		if (config.audioMode !== "always-on") return {
+			camStreamId: null,
+			hasTrack: false
+		};
+		const camStreamId = await this.deps.audioCamStreamFor(config);
+		if (camStreamId === null) return {
+			camStreamId: null,
+			hasTrack: false
+		};
+		return {
+			camStreamId,
+			hasTrack: await this.deps.hasAudioSource(config.deviceId, camStreamId)
+		};
 	}
 	/**
 	* Normalizes the `decision.kind === 'pending'` → `setPendingReason` +
@@ -54596,6 +54960,7 @@ async function buildOrchestratorControllers(deps) {
 		logger: deps.ctx().logger,
 		readDeviceStore: async (deviceId) => await deps.ctxIfReady()?.settings?.readDeviceStore(deviceId) ?? {},
 		probeAudioTrack: (deviceId, camStreamId) => resolveAudioTrackProbe(deviceId, camStreamId),
+		assignedProfiles: (deviceId) => detectionWiring.fetchAssignedProfiles(deviceId),
 		ingestNode: () => topology.clusterRoles.ingestNode,
 		localNodeId: () => localNodeId,
 		enabledAudioNodes: () => topology.enabledAudioNodes,
@@ -54696,6 +55061,21 @@ async function buildOrchestratorControllers(deps) {
 	* stage that never produced one signal, with one line.
 	*/
 	const resolveHasAudioSource = async (deviceId, camStreamId) => (await resolveAudioTrackProbe(deviceId, camStreamId)).kind !== "absent";
+	/**
+	* The cam-stream a camera's audio subscription rides — `selectAudioCamStream`
+	* over the same profile-slot read the detection plane uses. `null` when the
+	* selection refuses (every rung is a `derived:*` transcode, or nothing is
+	* assigned): an audio-only consumer never causes a video transcode, so there
+	* is genuinely no stream and the watchdog must not arm its audio stage.
+	*/
+	const resolveAudioCamStream = async (config) => {
+		const selection = selectAudioCamStream({
+			pick: config.audioStreamPick ?? "auto",
+			motionStreamId: config.motionStreamId,
+			assigned: await detectionWiring.fetchAssignedProfiles(config.deviceId)
+		});
+		return selection.kind === "selected" ? selection.camStreamId : null;
+	};
 	const placement = new PlacementService({
 		ctx: () => deps.ctx(),
 		ctxIfReady: () => deps.ctxIfReady(),
@@ -54712,8 +55092,9 @@ async function buildOrchestratorControllers(deps) {
 		getInferenceDeviceCaps: (nodeId) => deps.getInferenceDeviceCaps(nodeId),
 		readPipelineDevicePin: (deviceId) => deps.readPipelineDevicePin(deviceId),
 		inferenceRotation,
-		buildWatchdogCamera: (config, deviceName, hasAudioSource) => detectionWiring.buildWatchdogCamera(config, deviceName, hasAudioSource),
+		buildWatchdogCamera: (config, deviceName, audio) => detectionWiring.buildWatchdogCamera(config, deviceName, audio),
 		hasAudioSource: (deviceId, camStreamId) => resolveHasAudioSource(deviceId, camStreamId),
+		audioCamStreamFor: (config) => resolveAudioCamStream(config),
 		isIdleSessionCamera: (deviceId) => deps.isIdleSessionCamera(deviceId),
 		activeSessionNode: (deviceId) => session.activeSessionNode(deviceId),
 		closeActiveSession: (deviceId) => session.closeSessionForReassign(deviceId),
@@ -55516,6 +55897,34 @@ function buildDeviceSettingsSections(nodeOptions) {
 						label: "On motion (firmware/PIR/SW)"
 					}
 				]
+			}, {
+				key: "audioStreamPick",
+				type: "select",
+				label: "Audio stream",
+				default: "auto",
+				description: "Which camera stream the audio classifier listens on. Auto picks the lowest stream the camera serves natively — a transcoded stream is never started just to hear a camera.",
+				options: [
+					{
+						value: "auto",
+						label: "Auto (lowest native)"
+					},
+					{
+						value: "high",
+						label: "High"
+					},
+					{
+						value: "mid",
+						label: "Medium"
+					},
+					{
+						value: "low",
+						label: "Low"
+					}
+				],
+				showWhen: {
+					field: "audioMode",
+					notEquals: "disabled"
+				}
 			}]
 		},
 		{