@camstack/addon-pipeline 1.2.220 → 1.2.222

package/dist/audio-analyzer/index.js

@@ -3,8 +3,8 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 const require_chunk = require("../chunk-emK7D4bc.js");
-const require_dist = require("../dist-ByPsWlTa.js");
-const require_process_memory = require("../process-memory-9KqRtUHt.js");
+const require_dist = require("../dist-DZsjVFey.js");
+const require_process_memory = require("../process-memory-BozKb5-g.js");
 let node_fs = require("node:fs");
 node_fs = require_chunk.__toESM(node_fs);
 let node_path = require("node:path");
@@ -397,6 +397,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 }, require_dist.nodePin(options.ownerNodeId)).catch((err) => {
+				options.logger.warn("audio-chunk poller: unsubscribeAudioChunks failed", { meta: {
+					brokerId: options.brokerId,
+					subscriptionId: subId,
+					error: require_dist.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 = require_dist.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: require_dist.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: require_dist.errMsg(err),
+				nextRetryInMs: backoffMs
+			} });
+			else logger.debug("audio-chunk poller: subscribeAudioChunks still failing", { meta: {
+				brokerId,
+				tag,
+				attempt,
+				error: require_dist.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: require_dist.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 = require_dist.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: require_dist.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 / require_dist.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 : require_dist.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: require_dist.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: require_dist.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
 /**
@@ -433,6 +985,7 @@ var AudioAnalyzerProvider = class {
 	deviceContributionResolver;
 	deviceSettingsPatcher;
 	reprobeImpl;
+	attachments;
 	log;
 	classifyCallCount = 0;
 	lastClassifyErrorMs = 0;
@@ -466,12 +1019,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;
@@ -609,6 +1163,20 @@ 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);
@@ -846,6 +1414,13 @@ var AudioAnalyzerAddon = class extends require_dist.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(require_dist.DEFAULT_AUDIO_ANALYZER_CONFIG);
 	}
@@ -990,7 +1565,40 @@ var AudioAnalyzerAddon = class extends require_dist.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: require_dist.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: require_dist.audioAnalyzerCapability,
 			provider: this.provider
@@ -1000,6 +1608,8 @@ var AudioAnalyzerAddon = class extends require_dist.BaseAddon {
 		}];
 	}
 	async onShutdown() {
+		this.attachments?.detachAll();
+		this.attachments = null;
 		if (this.provider) {
 			await this.provider.dispose();
 			this.provider = null;