@camstack/addon-pipeline 1.2.219 → 1.2.221

package/dist/audio-analyzer/index.mjs

@@ -1,6 +1,6 @@
 import { n as __require } from "../chunk-DnnnRqeS.mjs";
-import { Dt as resolvePoolMemoryPolicy, It as errMsg, Jt as hydrateSchema, M as audioAnalyzerCapability, S as PoolMemoryWatchdog, Ut as BaseAddon, j as audioAnalysisCapability, n as AUDIO_BACKEND_CHOICES, ot as mapAudioLabelToMacro, s as DEFAULT_AUDIO_ANALYZER_CONFIG, v as HF_BASE_URL } from "../dist-CKK0CBUW.mjs";
-import { n as pickNodePlatformArch, t as readProcessMemory } from "../process-memory-BRQOtDN1.mjs";
+import { C as PoolMemoryWatchdog, Jt as audioChunkBytesPerSample, Lt as errMsg, M as audioAnalysisCapability, N as audioAnalyzerCapability, Ot as resolvePoolMemoryPolicy, Wt as BaseAddon, Xt as expandAudioChunkToF32le, Zt as hydrateSchema, n as AUDIO_BACKEND_CHOICES, s as DEFAULT_AUDIO_ANALYZER_CONFIG, st as mapAudioLabelToMacro, tn as nodePin, vn as EventCategory, y as HF_BASE_URL } from "../dist-CEFC3PkP.mjs";
+import { n as pickNodePlatformArch, t as readProcessMemory } from "../process-memory-DqYj5IAb.mjs";
 import * as fs from "node:fs";
 import * as path$1 from "node:path";
 import { downloadFile } from "@camstack/system/addon-utils";
@@ -364,7 +364,12 @@ var AppleSoundAnalysisPipeline = class {
 		}
 	}
 };
-/** Simple resample to 16kHz mono by linear interpolation. */
+/**
+* Resample to 16 kHz mono by linear interpolation — the ONE place a window
+* is brought to the classifier's rate. The plane carries the source rate
+* (8 kHz for G.711, D450); the model that needs 16 kHz gets it here, next to
+* the model, over a whole window. Exported so the guard can pin it.
+*/
 function resampleMono16k(chunk) {
 	const { data, sampleRate, channels } = chunk;
 	const numSamples = data.length / channels;
@@ -386,6 +391,558 @@ function resampleMono16k(chunk) {
 	}
 	return out;
 }
+/** How many chunks to drain per poll — a small burst absorbs jitter. */
+var PULL_MAX_COUNT = 8;
+/**
+* Consecutive pull failures before we attempt to re-subscribe. A single failed
+* poll is treated as a blip (re-subscribing would leak a broker-side FIFO); a
+* sustained failure means the broker child restarted and dropped our
+* subscription, so we re-establish it.
+*/
+var RESUBSCRIBE_AFTER_FAILURES = 2;
+/** Re-subscribe at most once every N ticks while failing (~1s at 200ms). */
+var RESUBSCRIBE_THROTTLE_TICKS = 5;
+/** First subscribe-retry delay, doubled on every subsequent failure. */
+var INITIAL_SUBSCRIBE_RETRY_BACKOFF_MS = 250;
+/**
+* Subscribe-retry backoff ceiling. 5 s matches the frame-handle poller — fast
+* enough to recover within a single reconcile of the orchestrator and slow
+* enough that a misconfigured camStream costs ~12 op/min, not 5/s.
+*/
+var MAX_SUBSCRIBE_RETRY_BACKOFF_MS = 5e3;
+/**
+* Attempts after which a still-failing subscribe escalates from the fast 5 s
+* ceiling to {@link LONG_SUBSCRIBE_RETRY_BACKOFF_MS}. ~15 attempts ≈ one
+* minute of fast retries — plenty for the boot races the 5 s ceiling exists
+* for. A broker that is STILL absent after that is a long-lived condition
+* (e.g. a DISABLED camera, whose broker the stream-broker reconcile refuses
+* to recreate — 2026-07-23) and retrying every 5 s forever is pure log/RPC
+* churn. The slow loop stays alive so audio still recovers automatically
+* (≤60 s) once the camera is re-enabled.
+*/
+var PERSISTENT_SUBSCRIBE_FAILURE_ATTEMPTS = 15;
+var LONG_SUBSCRIBE_RETRY_BACKOFF_MS = 6e4;
+/**
+* Subscribe to a broker's decoded audio-chunk stream and start the poll loop.
+*
+* Always resolves to a teardown closure — when the broker is not yet
+* registered the closure cancels the ongoing retry loop; when polling is
+* active it stops the loop and releases the broker subscription. Mirrors
+* `startFrameHandlePoller` so video and audio recover identically.
+*/
+function startAudioChunkPoller(options) {
+	const lifecycle = {
+		stopped: false,
+		retryTimer: void 0,
+		pollTimer: void 0,
+		activeSubscriptionId: null
+	};
+	const teardown = () => {
+		if (lifecycle.stopped) return;
+		lifecycle.stopped = true;
+		if (lifecycle.retryTimer) {
+			clearTimeout(lifecycle.retryTimer);
+			lifecycle.retryTimer = void 0;
+		}
+		if (lifecycle.pollTimer) {
+			clearTimeout(lifecycle.pollTimer);
+			lifecycle.pollTimer = void 0;
+		}
+		const subId = lifecycle.activeSubscriptionId;
+		if (subId) {
+			lifecycle.activeSubscriptionId = null;
+			options.api.streamBroker.unsubscribeAudioChunks.mutate({ subscriptionId: subId }, nodePin(options.ownerNodeId)).catch((err) => {
+				options.logger.warn("audio-chunk poller: unsubscribeAudioChunks failed", { meta: {
+					brokerId: options.brokerId,
+					subscriptionId: subId,
+					error: errMsg(err)
+				} });
+			});
+		}
+	};
+	subscribeWithRetry(options, lifecycle);
+	return teardown;
+}
+/**
+* Run the subscribe → poll handshake with exponential backoff on subscribe
+* failures. Resolves once the subscription is acquired (and the poll loop has
+* been started) or once `lifecycle.stopped` flips, whichever comes first.
+*/
+async function subscribeWithRetry(options, lifecycle) {
+	const { api, brokerId, tag, ownerNodeId, logger } = options;
+	const pin = nodePin(ownerNodeId);
+	let backoffMs = INITIAL_SUBSCRIBE_RETRY_BACKOFF_MS;
+	let attempt = 0;
+	while (!lifecycle.stopped) {
+		attempt += 1;
+		try {
+			const result = await api.streamBroker.subscribeAudioChunks.mutate({
+				brokerId,
+				tag,
+				...options.accept ? { accept: options.accept } : {}
+			}, pin);
+			if (lifecycle.stopped) {
+				await api.streamBroker.unsubscribeAudioChunks.mutate({ subscriptionId: result.subscriptionId }, pin).catch((err) => {
+					logger.warn("audio-chunk poller: late unsubscribe failed", { meta: {
+						brokerId,
+						subscriptionId: result.subscriptionId,
+						error: errMsg(err)
+					} });
+				});
+				return;
+			}
+			if (attempt > 1) logger.info("audio-chunk poller: subscribeAudioChunks recovered", { meta: {
+				brokerId,
+				tag,
+				attempt
+			} });
+			lifecycle.activeSubscriptionId = result.subscriptionId;
+			startPolling(options, lifecycle);
+			return;
+		} catch (err) {
+			if (lifecycle.stopped) return;
+			if (attempt === 1) logger.warn("audio-chunk poller: subscribeAudioChunks failed, retrying", { meta: {
+				brokerId,
+				tag,
+				error: errMsg(err),
+				nextRetryInMs: backoffMs
+			} });
+			else logger.debug("audio-chunk poller: subscribeAudioChunks still failing", { meta: {
+				brokerId,
+				tag,
+				attempt,
+				error: errMsg(err),
+				nextRetryInMs: backoffMs
+			} });
+			if (attempt === PERSISTENT_SUBSCRIBE_FAILURE_ATTEMPTS) logger.warn("audio-chunk poller: broker still absent after a minute — slowing the retry", { meta: {
+				brokerId,
+				tag,
+				attempt,
+				error: errMsg(err),
+				nextRetryInMs: LONG_SUBSCRIBE_RETRY_BACKOFF_MS,
+				hint: "a DISABLED camera, or a camStreamId the broker never registered — audio stays absent until the broker appears"
+			} });
+			await sleep(backoffMs, lifecycle);
+			backoffMs = Math.min(attempt >= PERSISTENT_SUBSCRIBE_FAILURE_ATTEMPTS ? LONG_SUBSCRIBE_RETRY_BACKOFF_MS : MAX_SUBSCRIBE_RETRY_BACKOFF_MS, backoffMs * 2);
+		}
+	}
+}
+/**
+* Drive the steady-state poll loop. Mid-stream `pullAudioChunks` failures
+* trigger a fresh `subscribeAudioChunks` via the recovery branch — covers
+* the broker child restart case where our `subscriptionId` is silently
+* disowned.
+*/
+function startPolling(options, lifecycle) {
+	const { api, brokerId, tag, ownerNodeId, onChunk, logger } = options;
+	const pin = nodePin(ownerNodeId);
+	let consecutiveFailures = 0;
+	const resubscribe = async () => {
+		try {
+			const result = await api.streamBroker.subscribeAudioChunks.mutate({
+				brokerId,
+				tag,
+				...options.accept ? { accept: options.accept } : {}
+			}, pin);
+			lifecycle.activeSubscriptionId = result.subscriptionId;
+			logger.info("audio-chunk poller: re-subscribed after broker outage", { meta: {
+				brokerId,
+				tag,
+				subscriptionId: result.subscriptionId,
+				afterFailures: consecutiveFailures
+			} });
+			return true;
+		} catch {
+			return false;
+		}
+	};
+	const tick = async () => {
+		if (lifecycle.stopped) return;
+		const subId = lifecycle.activeSubscriptionId;
+		if (!subId) return;
+		try {
+			const chunks = await api.streamBroker.pullAudioChunks.query({
+				subscriptionId: subId,
+				maxCount: PULL_MAX_COUNT
+			}, pin);
+			if (consecutiveFailures > 0) logger.info("audio-chunk poller: stream recovered", { meta: {
+				brokerId,
+				subscriptionId: subId
+			} });
+			consecutiveFailures = 0;
+			for (const chunk of chunks) {
+				if (lifecycle.stopped) break;
+				await onChunk(chunk);
+			}
+		} catch (err) {
+			consecutiveFailures += 1;
+			if (consecutiveFailures === 1) logger.warn("audio-chunk poller: pullAudioChunks failed — attempting recovery", { meta: {
+				brokerId,
+				subscriptionId: subId,
+				error: errMsg(err)
+			} });
+			if (!lifecycle.stopped && consecutiveFailures >= RESUBSCRIBE_AFTER_FAILURES && (consecutiveFailures - RESUBSCRIBE_AFTER_FAILURES) % RESUBSCRIBE_THROTTLE_TICKS === 0) await resubscribe();
+		}
+		if (!lifecycle.stopped) lifecycle.pollTimer = setTimeout(() => void tick(), options.pollIntervalMs ?? 200);
+	};
+	tick();
+}
+/**
+* Cancellable sleep — wakes early when `lifecycle.stopped` flips. We
+* keep a local wrapper around the shared {@link sleep} helper because
+* the lifecycle tracks the active retry timer for `teardown()` to
+* clear; pure `sleep()` would leak the timer if teardown fired while
+* we were waiting.
+*/
+function sleep(ms, lifecycle) {
+	return new Promise((resolve) => {
+		if (lifecycle.stopped) {
+			resolve();
+			return;
+		}
+		lifecycle.retryTimer = setTimeout(() => {
+			lifecycle.retryTimer = void 0;
+			resolve();
+		}, ms);
+	});
+}
+function sameFormat(a, b) {
+	return a.sampleRate === b.sampleRate && a.channels === b.channels && a.format === b.format;
+}
+var AudioWindowAccumulator = class {
+	deviceId;
+	onFormat;
+	pcmParts = [];
+	accumulatedBytes = 0;
+	accumulatedMs = 0;
+	windowSampleRate = 0;
+	windowChannels = 0;
+	windowFormat = "f32le";
+	windowTimestamp = 0;
+	windowOpen = false;
+	/** Last format seen on this subscription — survives a flush, unlike the window anchor. */
+	lastFormat = null;
+	constructor(deviceId, onFormat) {
+		this.deviceId = deviceId;
+		this.onFormat = onFormat;
+	}
+	/**
+	* Append one decoded PCM chunk to the open window. Returns the flushed
+	* `AudioChunkInput` once the accumulated duration reaches
+	* `AUDIO_WINDOW_TARGET_MS` (and resets for the next window), else `null`
+	* (accumulate-only, no flush yet).
+	*/
+	push(chunk) {
+		const byteLength = chunk.data.byteLength;
+		const bytes = new Uint8Array(byteLength);
+		bytes.set(new Uint8Array(chunk.data.buffer, chunk.data.byteOffset, byteLength));
+		const format = chunk.format ?? "f32le";
+		this.observeFormat({
+			sampleRate: chunk.sampleRate,
+			channels: chunk.channels,
+			format
+		});
+		if (!this.windowOpen) {
+			this.windowSampleRate = chunk.sampleRate;
+			this.windowChannels = chunk.channels;
+			this.windowFormat = format;
+			this.windowTimestamp = chunk.timestamp;
+			this.windowOpen = true;
+		}
+		this.pcmParts.push(bytes);
+		this.accumulatedBytes += byteLength;
+		const channels = chunk.channels > 0 ? chunk.channels : 1;
+		const framesPerChannel = byteLength / audioChunkBytesPerSample(format) / channels;
+		this.accumulatedMs += framesPerChannel / chunk.sampleRate * 1e3;
+		if (this.accumulatedMs < 1e3) return null;
+		const windowData = new Uint8Array(this.accumulatedBytes);
+		let offset = 0;
+		for (const part of this.pcmParts) {
+			windowData.set(part, offset);
+			offset += part.byteLength;
+		}
+		const flushSampleRate = this.windowSampleRate;
+		const flushChannels = this.windowChannels;
+		const flushFormat = this.windowFormat;
+		const flushTimestamp = this.windowTimestamp;
+		this.reset();
+		return {
+			data: flushFormat === "f32le" ? windowData : expandAudioChunkToF32le(windowData, flushFormat),
+			sampleRate: flushSampleRate,
+			channels: flushChannels,
+			timestamp: flushTimestamp,
+			deviceId: this.deviceId
+		};
+	}
+	/**
+	* Report the first format and every change; a change under an OPEN window
+	* drops the partial window so the flushed bytes never mix two rates.
+	*/
+	observeFormat(format) {
+		const previous = this.lastFormat;
+		if (previous !== null && sameFormat(previous, format)) return;
+		const droppedMs = this.windowOpen ? Math.round(this.accumulatedMs) : 0;
+		if (this.windowOpen) this.reset();
+		this.lastFormat = format;
+		this.onFormat?.({
+			from: previous,
+			to: format,
+			droppedMs
+		});
+	}
+	/**
+	* Drop any partially-accumulated window. Called on unsubscribe / device
+	* audio stop (no trailing flush — a sub-second partial window is not worth
+	* a classify during teardown) and internally after every flush.
+	*/
+	reset() {
+		this.pcmParts = [];
+		this.accumulatedBytes = 0;
+		this.accumulatedMs = 0;
+		this.windowOpen = false;
+	}
+};
+/**
+* Build the canonical `AudioResult` frame from one `analyseChunk` result —
+* extracted verbatim from `subscribeAudioStream`'s result→event-payload
+* mapping. The caller wraps this in the `pipeline.audio-inference-result`
+* event; building the frame is pure and needs no controller state.
+*/
+function buildAudioResultFrame(deviceId, result) {
+	const windowId = `${deviceId}-${result.timestamp}`;
+	const audioDetections = [];
+	let idCounter = 0;
+	if (result.classification && result.classification.labels.length > 0) for (const label of result.classification.labels) {
+		idCounter += 1;
+		audioDetections.push({
+			id: `a${idCounter}`,
+			kind: "audio",
+			macroClass: label.className,
+			score: label.score,
+			labels: [{
+				label: label.className,
+				score: label.score
+			}],
+			startMs: 0,
+			endMs: 0
+		});
+	}
+	return {
+		kind: "audio-window",
+		windowId,
+		deviceId,
+		timestamp: result.timestamp,
+		startMs: 0,
+		endMs: 0,
+		level: {
+			rms: result.level.rms,
+			dbfs: result.level.dbfs
+		},
+		detections: audioDetections,
+		debug: result.classification ? {
+			totalInferenceMs: result.classification.inferenceMs,
+			stepTimings: [{
+				source: "audio-analyzer",
+				ms: result.classification.inferenceMs,
+				detectionCount: audioDetections.length
+			}]
+		} : void 0
+	};
+}
+//#endregion
+//#region src/audio-analyzer/audio-device-attachments.ts
+/**
+* `AudioDeviceAttachments` — the analyzer's own audio subscriptions (D461).
+*
+* ## What this replaces
+*
+* Until 2026-09-11 the decoded audio-chunk plane ran through
+* `pipeline-orchestrator`: it drained the broker's FIFO, accumulated ~1 s
+* windows and pushed them back out to `audioAnalyzer.analyseChunk`. The
+* orchestrator neither produced nor consumed the audio — it buffered it, and
+* every byte crossed hub-main twice for the privilege. The poller's own
+* docblock named the reason, and it was an accident: the code had been a
+* closure INSIDE the broker's process, and when the `pipeline` co-location
+* group was dissolved nobody moved it.
+*
+* D455 proved the relay was the PREMISE of the remaining cost rather than an
+* alternative to it. It put the SOURCE bytes on the plane — one G.711 byte per
+* sample instead of four f32le ones — but only for a consumer that declared it
+* could read them, and the accumulator (the declaring consumer) sat in a third
+* process that had to expand before forwarding. So legs one and two went coded
+* and legs three and four stayed at ~49 MB/min each. Here the subscriber IS
+* the decoder: there is no third interlocutor, the negotiation needs none, and
+* legs three and four do not exist.
+*
+* ## What the orchestrator still owns
+*
+* Everything about WHETHER and WHERE, which is all policy: the `audioMode`
+* gate, the on-motion window, the audio-track probe, the per-device node
+* assignment and the settings read. It calls `attachDevice` / `detachDevice`
+* and holds the teardown. What it no longer owns is the bytes.
+*
+* ## The failure this split ADDS, and where it is caught
+*
+* The broker subscription is now opened by a process the orchestrator does not
+* supervise. A detach that never arrives — an analyzer runner that crashed, a
+* node that went offline mid-teardown — leaves a FIFO nobody drains, and on
+* this plane that is not merely a leak: `AudioChunkPlane.subscriberCount` is
+* broker DEMAND, so an orphan pins the source dial and the decode session open
+* for as long as the broker lives. It is caught in the broker
+* (`AudioChunkPlane`'s idle lease), not here, because a process that has died
+* cannot clean up after itself.
+*/
+var AudioDeviceAttachments = class {
+	deps;
+	attachments = /* @__PURE__ */ new Map();
+	shuttingDown = false;
+	constructor(deps) {
+		this.deps = deps;
+	}
+	/** Live attachment count — diagnostics only. */
+	get size() {
+		return this.attachments.size;
+	}
+	/**
+	* Open (or replace) this camera's audio pull. Returns as soon as the
+	* attachment exists: the first `subscribeAudioChunks` retries with backoff
+	* behind it, because the broker for a camStream may not be registered yet.
+	* That boot-race tolerance travelled with the poller and is unchanged.
+	*
+	* Idempotent BY REPLACEMENT. Two pollers on one camera would double the
+	* broker's fanout and each would flush its own half-windows; a re-attach
+	* (a rebalance, a settings change, a watchdog recovery) must therefore drop
+	* the prior one, and it is reported so an unexpected churn is visible.
+	*/
+	attach(request) {
+		if (this.shuttingDown) {
+			this.deps.logger.warn("audio attach REFUSED — analyzer is shutting down", {
+				tags: { deviceId: request.deviceId },
+				meta: { brokerId: request.brokerId }
+			});
+			return {
+				attached: false,
+				replaced: false
+			};
+		}
+		const api = this.deps.api();
+		if (!api) {
+			this.deps.logger.warn("audio attach REFUSED — no cross-addon api available", {
+				tags: { deviceId: request.deviceId },
+				meta: { brokerId: request.brokerId }
+			});
+			return {
+				attached: false,
+				replaced: false
+			};
+		}
+		const replaced = this.releaseAttachment(request.deviceId, "replaced");
+		const { deviceId, brokerId, ingestNodeId, settings } = request;
+		const logger = this.deps.logger.withTags({ deviceId });
+		const isRemoteBroker = ingestNodeId !== this.deps.localNodeId();
+		const accumulator = new AudioWindowAccumulator(deviceId, (change) => {
+			const meta = {
+				sampleRate: change.to.sampleRate,
+				channels: change.to.channels,
+				format: change.to.format,
+				previous: change.from,
+				droppedMs: change.droppedMs
+			};
+			if (change.from === null) {
+				logger.info("audio stream delivering", {
+					tags: { deviceId },
+					meta
+				});
+				return;
+			}
+			logger.warn("audio stream format changed — partial window dropped", {
+				tags: { deviceId },
+				meta
+			});
+		});
+		const teardown = startAudioChunkPoller({
+			api,
+			brokerId,
+			tag: "audio-analyzer",
+			ownerNodeId: ingestNodeId,
+			accept: ["pcmu", "pcma"],
+			pollIntervalMs: isRemoteBroker ? 500 : 200,
+			logger,
+			onChunk: async (chunk) => {
+				try {
+					const window = accumulator.push(chunk);
+					if (!window) return;
+					const result = await this.deps.analyse(window, settings);
+					if (!result) return;
+					this.deps.emitResult(deviceId, buildAudioResultFrame(deviceId, result));
+				} catch (err) {
+					logger.error("Audio analysis failed", {
+						tags: { deviceId },
+						meta: { error: errMsg(err) }
+					});
+				}
+			}
+		});
+		this.attachments.set(deviceId, {
+			brokerId,
+			teardown,
+			accumulator
+		});
+		this.deps.logger.info("audio attached", {
+			tags: { deviceId },
+			meta: {
+				brokerId,
+				ingestNodeId,
+				remoteBroker: isRemoteBroker,
+				pollIntervalMs: isRemoteBroker ? 500 : 200,
+				replaced
+			}
+		});
+		return {
+			attached: true,
+			replaced
+		};
+	}
+	/** Close this camera's audio pull and release the broker subscription. Idempotent. */
+	detach(deviceId) {
+		return { detached: this.releaseAttachment(deviceId, "detached") };
+	}
+	/**
+	* Release every attachment — the analyzer's own shutdown. This is the only
+	* orderly path that can return the broker's FIFOs; a crash cannot, which is
+	* what the plane's idle lease exists for.
+	*/
+	detachAll() {
+		this.shuttingDown = true;
+		for (const deviceId of [...this.attachments.keys()]) this.releaseAttachment(deviceId, "shutdown");
+	}
+	releaseAttachment(deviceId, reason) {
+		const existing = this.attachments.get(deviceId);
+		if (!existing) return false;
+		this.attachments.delete(deviceId);
+		try {
+			existing.teardown();
+		} catch (err) {
+			this.deps.logger.warn("audio detach: poller teardown threw", {
+				tags: { deviceId },
+				meta: {
+					brokerId: existing.brokerId,
+					reason,
+					error: errMsg(err)
+				}
+			});
+		}
+		existing.accumulator.reset();
+		this.deps.logger.info("audio detached", {
+			tags: { deviceId },
+			meta: {
+				brokerId: existing.brokerId,
+				reason
+			}
+		});
+		return true;
+	}
+};
 //#endregion
 //#region src/audio-analyzer/addons/analyzer/index.ts
 /**
@@ -399,6 +956,9 @@ var CLASSIFY_ERROR_SUPPRESS_MS = 3e4;
 var CLASSIFY_MIN_INTERVAL_MS = 500;
 var PIPELINE_IDLE_DISPOSE_MS = 5 * 6e4;
 var GLOBAL_DEVICE_KEY = -1;
+/** What the classifier consumes natively; anything else is resampled next to it. */
+var CLASSIFIER_SAMPLE_RATE = 16e3;
+var CLASSIFIER_CHANNELS = 1;
 /**
 * Reconstruct a Float32 view over f32le PCM bytes carried in a Uint8Array.
 *
@@ -419,6 +979,7 @@ var AudioAnalyzerProvider = class {
 	deviceContributionResolver;
 	deviceSettingsPatcher;
 	reprobeImpl;
+	attachments;
 	log;
 	classifyCallCount = 0;
 	lastClassifyErrorMs = 0;
@@ -430,6 +991,8 @@ var AudioAnalyzerProvider = class {
 	debugClassifySamples = false;
 	/** Per-camera in-flight state. Key = deviceId (or GLOBAL_DEVICE_KEY for legacy callers). */
 	cameraState = /* @__PURE__ */ new Map();
+	/** Last window format seen per camera — the first and every change is logged (D450). */
+	windowFormats = /* @__PURE__ */ new Map();
 	/** Global pipeline lock — Apple SA and ONNX are single-channel: only one classify() can
 	*  run at a time. Without this, concurrent calls from different cameras overwrite the
 	*  single pendingResolve slot in AppleSoundAnalysisPipeline, causing 30s timeouts. */
@@ -450,12 +1013,13 @@ var AudioAnalyzerProvider = class {
 	/** Set on `dispose()` (addon stop) so a late classify/idle-timer never
 	*  re-spawns the subprocess after teardown. */
 	disposed = false;
-	constructor(logger, pipelineFactory, initialBackend, deviceSettingsResolver, deviceContributionResolver, deviceSettingsPatcher, reprobeImpl) {
+	constructor(logger, pipelineFactory, initialBackend, deviceSettingsResolver, deviceContributionResolver, deviceSettingsPatcher, reprobeImpl, attachments) {
 		this.pipelineFactory = pipelineFactory;
 		this.deviceSettingsResolver = deviceSettingsResolver;
 		this.deviceContributionResolver = deviceContributionResolver;
 		this.deviceSettingsPatcher = deviceSettingsPatcher;
 		this.reprobeImpl = reprobeImpl;
+		this.attachments = attachments;
 		this.log = logger;
 		this.backendName = initialBackend;
 		this.desiredBackend = initialBackend;
@@ -593,8 +1157,23 @@ var AudioAnalyzerProvider = class {
 	async resolveDeviceSettings({ deviceId }) {
 		return this.deviceSettingsResolver(deviceId);
 	}
+	/**
+	* Start pulling this camera's audio from the broker, in THIS process (D461).
+	* Thin delegate — the attachment registry owns the poller, the window and
+	* the result event; this method exists so the orchestrator can express the
+	* policy it still owns ("this camera's audio runs, on this node") without
+	* owning the bytes.
+	*/
+	async attachDevice(input) {
+		return this.attachments.attach(input);
+	}
+	/** Stop pulling this camera's audio and release the broker subscription. */
+	async detachDevice({ deviceId }) {
+		return this.attachments.detach(deviceId);
+	}
 	async analyseChunk({ chunk, settings }) {
 		const samples = float32FromBytes(chunk.data);
+		this.reportWindowFormat(chunk, samples.length);
 		let sumSquares = 0;
 		for (let i = 0; i < samples.length; i++) sumSquares += samples[i] * samples[i];
 		const rms = Math.sqrt(sumSquares / samples.length);
@@ -663,6 +1242,38 @@ var AudioAnalyzerProvider = class {
 			timestamp: chunk.timestamp
 		};
 	}
+	/**
+	* Say what this camera's windows arrive as — once, and again on every
+	* change. The plane carries the source rate (8 kHz for G.711 since D450,
+	* 16 kHz for AAC through the codec session), and the classifier resamples
+	* anything that is not 16 kHz mono next to the model. A camera whose
+	* format flips mid-subscription (a broker redeploy) is visible here, and
+	* a consumer that stopped receiving what it expected is never silent
+	* (D427).
+	*/
+	reportWindowFormat(chunk, sampleCount) {
+		const key = chunk.deviceId ?? GLOBAL_DEVICE_KEY;
+		const format = {
+			sampleRate: chunk.sampleRate,
+			channels: chunk.channels
+		};
+		const previous = this.windowFormats.get(key) ?? null;
+		if (previous !== null && previous.sampleRate === format.sampleRate && previous.channels === format.channels) return;
+		this.windowFormats.set(key, format);
+		const channels = chunk.channels > 0 ? chunk.channels : 1;
+		const windowMs = chunk.sampleRate > 0 ? Math.round(sampleCount / channels / chunk.sampleRate * 1e3) : null;
+		this.log.info("audio window format", {
+			tags: chunk.deviceId !== void 0 ? { deviceId: chunk.deviceId } : void 0,
+			meta: {
+				sampleRate: chunk.sampleRate,
+				channels: chunk.channels,
+				bytes: chunk.data.byteLength,
+				windowMs,
+				classifierResamples: chunk.sampleRate !== CLASSIFIER_SAMPLE_RATE || chunk.channels !== CLASSIFIER_CHANNELS,
+				previous
+			}
+		});
+	}
 	async classify(chunk) {
 		const camKey = chunk.deviceId ?? GLOBAL_DEVICE_KEY;
 		const now = Date.now();
@@ -797,6 +1408,13 @@ var AudioAnalyzerAddon = class extends BaseAddon {
 	*  in-place rebuild in `onConfigChanged` (rebuild only when it genuinely
 	*  flips). The provider owns the (lazy) pipeline itself. */
 	activeBackend = null;
+	/**
+	* This node's live audio attachments (D461). Held on the ADDON rather than
+	* only inside the provider because shutdown must release the broker's FIFOs
+	* even if the provider never came up — an orphaned audio subscription is
+	* broker DEMAND, not merely a leak.
+	*/
+	attachments = null;
 	constructor() {
 		super(DEFAULT_AUDIO_ANALYZER_CONFIG);
 	}
@@ -941,7 +1559,40 @@ var AudioAnalyzerAddon = class extends BaseAddon {
 			return null;
 		};
 		const deviceSettingsPatcher = async (_deviceId, _patch) => {};
-		this.provider = new AudioAnalyzerProvider(logger, (b) => this.buildPipeline(b), backend, deviceSettingsResolver, deviceContributionResolver, deviceSettingsPatcher, () => this.reprobeAudioEngine());
+		this.attachments = new AudioDeviceAttachments({
+			api: () => this.ctx.api,
+			localNodeId: () => this.ctx.kernel?.localNodeId ?? "hub",
+			logger: logger.child("audio-attach"),
+			analyse: async (chunk, settings) => {
+				const provider = this.provider;
+				if (!provider) return null;
+				return provider.analyseChunk({
+					chunk,
+					settings
+				});
+			},
+			emitResult: (deviceId, frame) => {
+				const nodeId = this.ctx.kernel?.localNodeId ?? "hub";
+				this.ctx.eventBus.emit({
+					id: `audio-inference-${deviceId}-${Date.now()}`,
+					timestamp: /* @__PURE__ */ new Date(),
+					source: {
+						type: "device",
+						id: deviceId,
+						nodeId,
+						addonId: "audio-analyzer",
+						deviceId
+					},
+					category: EventCategory.PipelineAudioInferenceResult,
+					data: {
+						deviceId,
+						frame,
+						nodeId
+					}
+				});
+			}
+		});
+		this.provider = new AudioAnalyzerProvider(logger, (b) => this.buildPipeline(b), backend, deviceSettingsResolver, deviceContributionResolver, deviceSettingsPatcher, () => this.reprobeAudioEngine(), this.attachments);
 		return [{
 			capability: audioAnalyzerCapability,
 			provider: this.provider
@@ -951,6 +1602,8 @@ var AudioAnalyzerAddon = class extends BaseAddon {
 		}];
 	}
 	async onShutdown() {
+		this.attachments?.detachAll();
+		this.attachments = null;
 		if (this.provider) {
 			await this.provider.dispose();
 			this.provider = null;