@camstack/addon-pipeline 1.2.297 → 1.2.298

package/dist/audio-analyzer/index.js

@@ -3,13 +3,167 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 const require_chunk = require("../chunk-emK7D4bc.js");
-const require_dist = require("../dist-DUqr1zyq.js");
-const require_process_memory = require("../process-memory-CMJ3NY-s.js");
+const require_dist = require("../dist-L_HlB0At.js");
+const require_process_memory = require("../process-memory-FfRDGu11.js");
 let node_fs = require("node:fs");
 node_fs = require_chunk.__toESM(node_fs);
 let node_path = require("node:path");
 node_path = require_chunk.__toESM(node_path);
 let _camstack_system_addon_utils = require("@camstack/system/addon-utils");
+//#region src/audio-analyzer/audio-subprocess-channel.ts
+/** The backend process ended (or was disposed) while — or before — a request waited on it. */
+var AudioBackendExitedError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "AudioBackendExitedError";
+	}
+};
+/** How long `dispose()` waits for a graceful exit before SIGKILL. */
+var DISPOSE_GRACE_MS = 5e3;
+function isReplyObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var AudioSubprocessChannel = class {
+	label;
+	log;
+	process = null;
+	receiveBuffer = Buffer.alloc(0);
+	pending = null;
+	constructor(label, log) {
+		this.label = label;
+		this.log = log;
+	}
+	/** Wire a freshly spawned process. Stderr stays the caller's (each backend formats it). */
+	attach(proc) {
+		this.process = proc;
+		proc.on("error", (err) => {
+			this.log.error(`${this.label} process error`, { meta: { error: err.message } });
+			this.failPending(new AudioBackendExitedError(`${this.label}: process error: ${err.message}`));
+		});
+		proc.on("exit", (code, signal) => {
+			if (this.process === proc) this.process = null;
+			const clean = code === 0 && signal === null;
+			const meta = {
+				code,
+				signal
+			};
+			if (clean) this.log.info(`${this.label} process exited`, { meta });
+			else this.log.error(`${this.label} process exited`, { meta });
+			this.failPending(new AudioBackendExitedError(`${this.label}: process exited (code ${String(code)}, signal ${String(signal)})`));
+		});
+		proc.stdout?.on("data", (chunk) => {
+			this.receiveBuffer = Buffer.concat([this.receiveBuffer, chunk]);
+			this.tryReceive();
+		});
+	}
+	get pid() {
+		return this.process?.pid ?? null;
+	}
+	get alive() {
+		return this.process !== null;
+	}
+	/** Wait for the next reply frame without sending (the init handshake). */
+	receive() {
+		if (this.process === null) return Promise.reject(new AudioBackendExitedError(`${this.label}: process not running`));
+		return new Promise((resolve, reject) => {
+			this.pending = {
+				resolve,
+				reject
+			};
+		});
+	}
+	/** Send one payload frame and wait for its reply. */
+	request(payload) {
+		const stdin = this.process?.stdin;
+		if (!stdin) return Promise.reject(new AudioBackendExitedError(`${this.label}: process not initialized`));
+		const reply = this.receive();
+		const lengthBuf = Buffer.allocUnsafe(4);
+		lengthBuf.writeUInt32LE(payload.length, 0);
+		stdin.write(Buffer.concat([lengthBuf, payload]));
+		return reply;
+	}
+	/**
+	* Stop the process. The waiting request (if any) is rejected FIRST — the
+	* exit event would do it too, but a process that ignores SIGTERM for five
+	* seconds must not hold the caller for five seconds.
+	*/
+	async dispose() {
+		this.failPending(new AudioBackendExitedError(`${this.label}: disposed`));
+		const proc = this.process;
+		if (!proc) return;
+		this.process = null;
+		proc.stdin?.end();
+		proc.kill("SIGTERM");
+		if (!await new Promise((resolve) => {
+			if (proc.exitCode !== null || proc.signalCode !== null) {
+				resolve(true);
+				return;
+			}
+			const timer = setTimeout(() => resolve(false), DISPOSE_GRACE_MS);
+			proc.once("exit", () => {
+				clearTimeout(timer);
+				resolve(true);
+			});
+		})) {
+			try {
+				proc.kill("SIGKILL");
+			} catch {}
+			this.log.warn(`${this.label} process did not exit gracefully — sent SIGKILL`);
+		}
+	}
+	failPending(err) {
+		const pending = this.pending;
+		this.pending = null;
+		pending?.reject(err);
+	}
+	tryReceive() {
+		while (this.receiveBuffer.length >= 4) {
+			const length = this.receiveBuffer.readUInt32LE(0);
+			if (this.receiveBuffer.length < 4 + length) return;
+			const bytes = this.receiveBuffer.subarray(4, 4 + length);
+			this.receiveBuffer = this.receiveBuffer.subarray(4 + length);
+			const pending = this.pending;
+			this.pending = null;
+			if (!pending) {
+				this.log.warn(`${this.label}: reply with no request waiting — discarded`, { meta: { bytes: length } });
+				continue;
+			}
+			let parsed;
+			try {
+				parsed = JSON.parse(bytes.toString("utf8"));
+			} catch (err) {
+				pending.reject(/* @__PURE__ */ new Error(`${this.label}: unparseable reply: ${require_dist.errMsg(err)}`));
+				continue;
+			}
+			if (isReplyObject(parsed)) pending.resolve(parsed);
+			else pending.reject(/* @__PURE__ */ new Error(`${this.label}: reply is not an object`));
+		}
+	}
+};
+function isBackendLabel(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const className = Reflect.get(value, "className");
+	const score = Reflect.get(value, "score");
+	return typeof className === "string" && typeof score === "number";
+}
+/**
+* Read a classify reply. A reply carrying `error` is a FAILED inference and
+* throws (D660): `yamnet_audio.py` answers an exception with an empty label
+* list plus `error`, and reading that as "no labels" is the silence-vs-nobody-
+* listened confusion D660 removed.
+*/
+function parseClassifyReply(label, reply) {
+	const error = reply["error"];
+	if (typeof error === "string" && error.length > 0) throw new Error(`${label}: inference failed: ${error}`);
+	const raw = reply["classifications"];
+	const classifications = Array.isArray(raw) ? raw.filter(isBackendLabel) : [];
+	const ms = reply["inferenceMs"];
+	return {
+		classifications,
+		inferenceMs: typeof ms === "number" ? ms : 0
+	};
+}
+//#endregion
 //#region src/audio-analyzer/audio-pipeline.ts
 /**
 * Create the appropriate audio pipeline.
@@ -66,15 +220,14 @@ var YamnetPythonPipeline = class {
 	pythonPath;
 	installPythonRequirements;
 	log;
-	process = null;
-	receiveBuffer = Buffer.alloc(0);
-	pendingResolve = null;
-	pendingReject = null;
+	/** The wire + reply slot; settles a waiting request on ANY exit (D660). */
+	channel;
 	constructor(modelsDir, logger, pythonPath, installPythonRequirements) {
 		this.modelsDir = modelsDir;
 		this.pythonPath = pythonPath;
 		this.installPythonRequirements = installPythonRequirements;
 		this.log = logger;
+		this.channel = new AudioSubprocessChannel("YAMNet Python", logger);
 	}
 	async initialize() {
 		const modelPath = node_path.join(this.modelsDir, "camstack-yamnet.onnx");
@@ -98,7 +251,7 @@ var YamnetPythonPipeline = class {
 		if (this.installPythonRequirements) await this.installPythonRequirements(node_path.join(pythonDir, "requirements-audio.txt"));
 		const scriptPath = node_path.join(pythonDir, "yamnet_audio.py");
 		const { spawn } = await import("node:child_process");
-		this.process = spawn(this.pythonPath, [
+		const proc = spawn(this.pythonPath, [
 			scriptPath,
 			"--model",
 			modelPath,
@@ -109,219 +262,79 @@ var YamnetPythonPipeline = class {
 			"pipe",
 			"pipe"
 		] });
-		this.process.stderr?.on("data", (chunk) => {
+		proc.stderr?.on("data", (chunk) => {
 			const text = chunk.toString().trim();
 			if (text) this.log.warn(text);
 		});
-		this.process.on("error", (err) => {
-			this.log.error("YAMNet Python process error", { meta: { error: err.message } });
-			this.pendingReject?.(err);
-			this.pendingReject = null;
-			this.pendingResolve = null;
-		});
-		this.process.on("exit", (code) => {
-			if (code !== 0 && code !== null) {
-				this.log.error("YAMNet Python process exited", { meta: { code } });
-				const err = /* @__PURE__ */ new Error(`YAMNet Python: process exited with code ${code}`);
-				this.pendingReject?.(err);
-				this.pendingReject = null;
-				this.pendingResolve = null;
-			}
-		});
-		this.process.stdout.on("data", (chunk) => {
-			this.receiveBuffer = Buffer.concat([this.receiveBuffer, chunk]);
-			this.tryReceive();
-		});
-		const ready = await this.receiveMessage();
+		this.channel.attach(proc);
+		const ready = await this.channel.receive();
 		if (ready["status"] !== "ready") throw new Error(`YAMNet Python: unexpected init response: ${JSON.stringify(ready)}`);
 		this.log.info(`YAMNet Python pipeline initialized (${String(ready["labels"] ?? "?")} labels)`);
 	}
 	getPid() {
-		return this.process?.pid ?? null;
+		return this.channel.pid;
 	}
 	async classify(chunk) {
-		if (!this.process?.stdin) throw new Error("YAMNet Python: process not initialized");
 		const waveform = chunk.sampleRate === 16e3 && chunk.channels === 1 ? chunk.data : resampleMono16k(chunk);
-		const audioBuffer = Buffer.from(waveform.buffer, waveform.byteOffset, waveform.byteLength);
-		const lengthBuf = Buffer.allocUnsafe(4);
-		lengthBuf.writeUInt32LE(audioBuffer.length, 0);
-		this.process.stdin.write(Buffer.concat([lengthBuf, audioBuffer]));
-		const result = await this.receiveMessage();
-		return {
-			classifications: result["classifications"] ?? [],
-			inferenceMs: result["inferenceMs"] ?? 0
-		};
+		return parseClassifyReply("YAMNet Python", await this.channel.request(Buffer.from(waveform.buffer, waveform.byteOffset, waveform.byteLength)));
 	}
 	async dispose() {
-		const proc = this.process;
-		if (!proc) return;
-		this.process = null;
-		proc.stdin?.end();
-		proc.kill("SIGTERM");
-		if (!await new Promise((resolve) => {
-			const timer = setTimeout(() => resolve(false), 5e3);
-			proc.once("exit", () => {
-				clearTimeout(timer);
-				resolve(true);
-			});
-		})) {
-			try {
-				proc.kill("SIGKILL");
-			} catch {}
-			this.log.warn("YAMNet Python process did not exit gracefully — sent SIGKILL");
-		}
-	}
-	receiveMessage() {
-		return new Promise((resolve, reject) => {
-			this.pendingResolve = resolve;
-			this.pendingReject = reject;
-		});
-	}
-	tryReceive() {
-		if (this.receiveBuffer.length < 4) return;
-		const length = this.receiveBuffer.readUInt32LE(0);
-		if (this.receiveBuffer.length < 4 + length) return;
-		const jsonBytes = this.receiveBuffer.subarray(4, 4 + length);
-		this.receiveBuffer = this.receiveBuffer.subarray(4 + length);
-		const resolve = this.pendingResolve;
-		const reject = this.pendingReject;
-		this.pendingResolve = null;
-		this.pendingReject = null;
-		if (!resolve) return;
-		try {
-			resolve(JSON.parse(jsonBytes.toString("utf8")));
-		} catch (err) {
-			reject?.(err instanceof Error ? err : new Error(String(err)));
-		}
+		await this.channel.dispose();
 	}
 };
 var AppleSoundAnalysisPipeline = class {
 	log;
-	process = null;
-	receiveBuffer = Buffer.alloc(0);
-	pendingResolve = null;
-	pendingReject = null;
+	/** The wire + reply slot; settles a waiting request on ANY exit (D660). */
+	channel;
 	binaryPath = null;
 	debugCount = 0;
 	constructor(logger) {
 		this.log = logger;
+		this.channel = new AudioSubprocessChannel("Apple SoundAnalysis", logger);
 	}
 	async initialize() {
 		this.binaryPath = await this.resolveSwiftBinary();
 		if (!this.binaryPath) throw new Error("Apple SoundAnalysis: Swift CLI not found and compilation failed. macOS with Xcode CLI tools required.");
 		const { spawn } = await import("node:child_process");
-		this.process = spawn(this.binaryPath, ["--sample-rate=16000", "--top-k=10"], { stdio: [
+		const proc = spawn(this.binaryPath, ["--sample-rate=16000", "--top-k=10"], { stdio: [
 			"pipe",
 			"pipe",
 			"pipe"
 		] });
-		this.process.stderr?.on("data", (chunk) => {
+		proc.stderr?.on("data", (chunk) => {
 			const lines = chunk.toString().split("\n");
 			for (const line of lines) {
 				const trimmed = line.trim();
 				if (trimmed) this.log.warn(trimmed);
 			}
 		});
-		this.process.on("error", (err) => {
-			this.log.error("Swift process error", { meta: { error: err.message } });
-			this.pendingReject?.(err);
-			this.pendingReject = null;
-			this.pendingResolve = null;
-		});
-		this.process.on("exit", (code) => {
-			if (code !== 0 && code !== null) {
-				this.log.error("Swift process exited", { meta: { code } });
-				const err = /* @__PURE__ */ new Error(`Apple SoundAnalysis: process exited with code ${code}`);
-				this.pendingReject?.(err);
-				this.pendingReject = null;
-				this.pendingResolve = null;
-			}
-		});
-		this.process.stdout.on("data", (chunk) => {
-			this.receiveBuffer = Buffer.concat([this.receiveBuffer, chunk]);
-			this.tryReceive();
-		});
-		const ready = await this.receiveMessage();
+		this.channel.attach(proc);
+		const ready = await this.channel.receive();
 		if (ready["status"] !== "ready") throw new Error(`Apple SoundAnalysis: unexpected init response: ${JSON.stringify(ready)}`);
 		this.log.info("Apple SoundAnalysis pipeline initialized (macOS built-in, Swift CLI bridge)");
 	}
 	getPid() {
-		return this.process?.pid ?? null;
+		return this.channel.pid;
 	}
 	async classify(chunk) {
-		if (!this.process?.stdin) throw new Error("Apple SoundAnalysis: process not initialized");
 		const waveform = chunk.sampleRate === 16e3 && chunk.channels === 1 ? chunk.data : resampleMono16k(chunk);
 		const audioBuffer = Buffer.from(waveform.buffer, waveform.byteOffset, waveform.byteLength);
-		const lengthBuf = Buffer.allocUnsafe(4);
-		lengthBuf.writeUInt32LE(audioBuffer.length, 0);
-		this.process.stdin.write(Buffer.concat([lengthBuf, audioBuffer]));
-		const result = await this.receiveMessage();
-		const classifications = result["classifications"] ?? [];
-		const inferenceMs = result["inferenceMs"] ?? 0;
+		const reply = await this.channel.request(audioBuffer);
 		if (this.debugCount < 3) {
-			const keys = Object.keys(result);
 			this.log.info("classify debug sample", { meta: {
 				phase: "apple-sa",
 				index: this.debugCount,
-				keys,
-				classifications: classifications.length,
-				inferenceMs,
-				audioBytes: Buffer.from(chunk.data.buffer, chunk.data.byteOffset, chunk.data.byteLength).length,
+				keys: Object.keys(reply),
+				audioBytes: audioBuffer.length,
 				sampleRate: chunk.sampleRate,
 				channels: chunk.channels
 			} });
-			if (result["error"]) this.log.error("Swift error", { meta: {
-				phase: "apple-sa",
-				error: result["error"]
-			} });
 			this.debugCount++;
 		}
-		return {
-			classifications,
-			inferenceMs
-		};
+		return parseClassifyReply("Apple SoundAnalysis", reply);
 	}
 	async dispose() {
-		const proc = this.process;
-		if (!proc) return;
-		this.process = null;
-		proc.stdin?.end();
-		proc.kill("SIGTERM");
-		if (!await new Promise((resolve) => {
-			const timer = setTimeout(() => resolve(false), 5e3);
-			proc.once("exit", () => {
-				clearTimeout(timer);
-				resolve(true);
-			});
-		})) {
-			try {
-				proc.kill("SIGKILL");
-			} catch {}
-			this.log.warn("Swift process did not exit gracefully — sent SIGKILL");
-		}
-	}
-	receiveMessage() {
-		return new Promise((resolve, reject) => {
-			this.pendingResolve = resolve;
-			this.pendingReject = reject;
-		});
-	}
-	tryReceive() {
-		if (this.receiveBuffer.length < 4) return;
-		const length = this.receiveBuffer.readUInt32LE(0);
-		if (this.receiveBuffer.length < 4 + length) return;
-		const jsonBytes = this.receiveBuffer.subarray(4, 4 + length);
-		this.receiveBuffer = this.receiveBuffer.subarray(4 + length);
-		const resolve = this.pendingResolve;
-		const reject = this.pendingReject;
-		this.pendingResolve = null;
-		this.pendingReject = null;
-		if (!resolve) return;
-		try {
-			resolve(JSON.parse(jsonBytes.toString("utf8")));
-		} catch (err) {
-			reject?.(err instanceof Error ? err : new Error(String(err)));
-		}
+		await this.channel.dispose();
 	}
 	/** Find pre-compiled binary or compile from Swift source. */
 	async resolveSwiftBinary() {
@@ -784,6 +797,7 @@ function buildAudioResultFrame(deviceId, result) {
 			dbfs: result.level.dbfs
 		},
 		detections: audioDetections,
+		classifyOutcome: result.classifyOutcome,
 		debug: result.classification ? {
 			totalInferenceMs: result.classification.inferenceMs,
 			stepTimings: [{
@@ -794,49 +808,8 @@ function buildAudioResultFrame(deviceId, result) {
 		} : 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.
-*/
+/** One over-bound report per camera per this window; the rest are counted. */
+var OVER_BOUND_LOG_INTERVAL_MS = 6e4;
 var AudioDeviceAttachments = class {
 	deps;
 	attachments = /* @__PURE__ */ new Map();
@@ -905,6 +878,25 @@ var AudioDeviceAttachments = class {
 				meta
 			});
 		});
+		let emitChain = Promise.resolve();
+		let awaiting = 0;
+		let droppedOverBound = 0;
+		let lastOverBoundLogMs = null;
+		const reportOverBound = () => {
+			droppedOverBound += 1;
+			const now = Date.now();
+			if (lastOverBoundLogMs !== null && now - lastOverBoundLogMs < OVER_BOUND_LOG_INTERVAL_MS) return;
+			lastOverBoundLogMs = now;
+			logger.warn("audio windows dropped — too many already awaiting a result", {
+				tags: { deviceId },
+				meta: {
+					dropped: droppedOverBound,
+					bound: 16,
+					awaiting
+				}
+			});
+			droppedOverBound = 0;
+		};
 		const teardown = startAudioChunkPoller({
 			api,
 			brokerId,
@@ -913,19 +905,39 @@ var AudioDeviceAttachments = class {
 			accept: ["pcmu", "pcma"],
 			pollIntervalMs: isRemoteBroker ? 500 : 200,
 			logger,
-			onChunk: async (chunk) => {
+			onChunk: (chunk) => {
+				let window;
 				try {
-					const window = accumulator.push(chunk);
-					if (!window) return;
-					const result = await this.deps.analyse(window, settings);
+					window = accumulator.push(chunk);
+				} catch (err) {
+					logger.error("audio window accumulate failed — chunk dropped", {
+						tags: { deviceId },
+						meta: {
+							error: require_dist.errMsg(err),
+							timestamp: chunk.timestamp
+						}
+					});
+					return;
+				}
+				if (!window) return;
+				if (awaiting >= 16) {
+					reportOverBound();
+					return;
+				}
+				awaiting += 1;
+				const analysed = this.deps.analyse(window, settings);
+				analysed.catch(() => void 0);
+				emitChain = emitChain.then(() => analysed).then((result) => {
 					if (!result) return;
 					this.deps.emitResult(deviceId, buildAudioResultFrame(deviceId, result));
-				} catch (err) {
+				}).catch((err) => {
 					logger.error("Audio analysis failed", {
 						tags: { deviceId },
 						meta: { error: require_dist.errMsg(err) }
 					});
-				}
+				}).finally(() => {
+					awaiting -= 1;
+				});
 			}
 		});
 		this.attachments.set(deviceId, {
@@ -989,6 +1001,112 @@ var AudioDeviceAttachments = class {
 	}
 };
 //#endregion
+//#region src/audio-analyzer/audio-classify-queue.ts
+function emptyCounts() {
+	return {
+		classified: 0,
+		superseded: 0,
+		errors: 0,
+		disposed: 0
+	};
+}
+var AudioClassifyQueue = class {
+	/** Pending job per camera, in arrival order. */
+	pending = /* @__PURE__ */ new Map();
+	counts = /* @__PURE__ */ new Map();
+	running = false;
+	closed = false;
+	/** True while an inference is running or a window is waiting for one. */
+	get busy() {
+		return this.running || this.pending.size > 0;
+	}
+	/**
+	* Queue `run` for camera `key`. Resolves when it ran (`ran: true`), or when
+	* it was superseded / the queue closed first (`ran: false`). A job that
+	* throws rejects this promise with its error, and is counted as an error.
+	*/
+	submit(key, run) {
+		if (this.closed) {
+			this.count(key, "disposed");
+			return Promise.resolve({
+				ran: false,
+				reason: "disposed"
+			});
+		}
+		return new Promise((resolve, reject) => {
+			const previous = this.pending.get(key);
+			if (previous) {
+				this.count(key, "superseded");
+				previous.settle({
+					ran: false,
+					reason: "superseded"
+				});
+			}
+			this.pending.set(key, {
+				run,
+				settle: resolve,
+				fail: reject
+			});
+			this.drain();
+		});
+	}
+	/**
+	* Hand back, and reset, the per-camera counts for every camera that had any
+	* activity since the last call.
+	*/
+	takeAccounting() {
+		const out = [];
+		for (const [key, c] of this.counts) out.push({
+			key,
+			...c
+		});
+		this.counts.clear();
+		return out;
+	}
+	/** Answer every waiting window `disposed` and refuse new ones. */
+	close() {
+		this.closed = true;
+		for (const [key, job] of this.pending) {
+			this.count(key, "disposed");
+			job.settle({
+				ran: false,
+				reason: "disposed"
+			});
+		}
+		this.pending.clear();
+	}
+	async drain() {
+		if (this.running) return;
+		this.running = true;
+		try {
+			for (;;) {
+				const next = this.pending.entries().next();
+				if (next.done === true) return;
+				const [key, job] = next.value;
+				this.pending.delete(key);
+				try {
+					const value = await job.run();
+					this.count(key, "classified");
+					job.settle({
+						ran: true,
+						value
+					});
+				} catch (err) {
+					this.count(key, "errors");
+					job.fail(err);
+				}
+			}
+		} finally {
+			this.running = false;
+		}
+	}
+	count(key, field) {
+		const c = this.counts.get(key) ?? emptyCounts();
+		c[field] += 1;
+		this.counts.set(key, c);
+	}
+};
+//#endregion
 //#region src/audio-analyzer/addons/analyzer/index.ts
 /**
 * AudioAnalyzerProvider — implements IAudioAnalyzer.
@@ -998,9 +1116,26 @@ var AudioDeviceAttachments = class {
 * to a separate audio-classifier addon.
 */
 var CLASSIFY_ERROR_SUPPRESS_MS = 3e4;
-var CLASSIFY_MIN_INTERVAL_MS = 500;
+var INFERENCE_TIMEOUT_MS = 5e3;
+/** An inference that did not answer within {@link INFERENCE_TIMEOUT_MS}. */
+var AudioInferenceTimeoutError = class extends Error {
+	timeoutMs;
+	constructor(timeoutMs) {
+		super(`audio inference did not answer within ${timeoutMs} ms`);
+		this.timeoutMs = timeoutMs;
+		this.name = "AudioInferenceTimeoutError";
+	}
+};
+var CLASSIFY_ACCOUNTING_PERIOD_MS = 6e4;
+var NEAR_MISS_WATCHED_MACROS = new Set(["crying", "scream"]);
+var NEAR_MISS_LOG_INTERVAL_MS = 6e4;
 var PIPELINE_IDLE_DISPOSE_MS = 5 * 6e4;
 var GLOBAL_DEVICE_KEY = -1;
+/** The labels a window cleared the camera's floor (and allow-list) with. */
+function labelsAboveFloor(result, settings) {
+	const allowed = settings.allowedClasses.length > 0 ? new Set(settings.allowedClasses.map((c) => c.toLowerCase())) : null;
+	return result.labels.filter((c) => c.score >= settings.minConfidence && (allowed === null || allowed.has(c.className.toLowerCase())));
+}
 /** What the classifier consumes natively; anything else is resampled next to it. */
 var CLASSIFIER_SAMPLE_RATE = 16e3;
 var CLASSIFIER_CHANNELS = 1;
@@ -1034,14 +1169,15 @@ var AudioAnalyzerProvider = class {
 	/** When true, logs a raw-label sample every 100 classifications (opt-in
 	*  debug aid). Off by default — the watchdog heartbeat covers liveness. */
 	debugClassifySamples = false;
-	/** Per-camera in-flight state. Key = deviceId (or GLOBAL_DEVICE_KEY for legacy callers). */
-	cameraState = /* @__PURE__ */ new Map();
+	/** The one line every camera's windows wait in for the single pipeline (D660).
+	*  Key = deviceId (or GLOBAL_DEVICE_KEY for legacy callers). */
+	classifyQueue = new AudioClassifyQueue();
+	/** Periodic per-camera classify accounting (D660). */
+	accountingTimer;
+	/** Near-miss line rate limit, per camera (D660). */
+	nearMissLog = /* @__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. */
-	pipelineBusy = false;
 	/** Live inference pipeline. LAZY: null until the first classify() spawns it
 	*  (see `ensurePipeline`); idle-disposed back to null after a long quiet
 	*  window so a node hosting the addon with no consumer never keeps the
@@ -1075,6 +1211,29 @@ var AudioAnalyzerProvider = class {
 			restart: () => this.restartPipelineForMemory()
 		});
 		this.memoryGuard.start();
+		this.accountingTimer = setInterval(() => this.reportClassifyAccounting(), CLASSIFY_ACCOUNTING_PERIOD_MS);
+		if (typeof this.accountingTimer.unref === "function") this.accountingTimer.unref();
+	}
+	/**
+	* One line per camera that lost a window since the last report (D660):
+	* how many were classified, superseded by the camera's own newer window,
+	* failed, or cut off by shutdown. Never one line per window, and nothing
+	* for a camera that lost none.
+	*/
+	reportClassifyAccounting() {
+		for (const a of this.classifyQueue.takeAccounting()) {
+			if (a.superseded + a.errors + a.disposed === 0) continue;
+			this.log.info("audio classify accounting", {
+				tags: a.key === GLOBAL_DEVICE_KEY ? void 0 : { deviceId: a.key },
+				meta: {
+					classified: a.classified,
+					superseded: a.superseded,
+					errors: a.errors,
+					disposed: a.disposed,
+					periodMs: CLASSIFY_ACCOUNTING_PERIOD_MS
+				}
+			});
+		}
 	}
 	/** Memory watchdog for the inference subprocess (see constructor). */
 	memoryGuard;
@@ -1166,7 +1325,7 @@ var AudioAnalyzerProvider = class {
 	*/
 	async disposeIdlePipeline() {
 		if (this.disposed) return;
-		if (this.pipelineBusy || this.pipelineInitPromise) {
+		if (this.classifyQueue.busy || this.pipelineInitPromise) {
 			this.scheduleIdleDispose();
 			return;
 		}
@@ -1227,67 +1386,133 @@ var AudioAnalyzerProvider = class {
 			rms: Math.round(rms * 1e4) / 1e4,
 			dbfs: Math.round(dbfs * 10) / 10
 		};
-		let classification;
-		try {
-			const result = await this.classify(chunk);
-			if (this.classifyCallCount < 3) {
-				const topRaw = result.labels.slice(0, 5).map((l) => `${l.className}(${(l.score * 100).toFixed(0)}%)`).join(", ");
-				this.log.info("classify debug sample", {
-					tags: chunk.deviceId !== void 0 ? { deviceId: chunk.deviceId } : void 0,
-					meta: {
-						index: this.classifyCallCount,
-						labelCount: result.labels.length,
-						top: topRaw,
-						inferenceMs: result.inferenceMs,
-						minConf: settings.minConfidence,
-						allowedClasses: settings.allowedClasses
-					}
-				});
-			}
-			this.classifyCallCount++;
-			const meaningful = result.labels.filter((l) => l.score >= .15 && l.className.toLowerCase() !== "silence");
-			if (meaningful.length > 0) this.log.debug("audio classification", {
-				tags: chunk.deviceId !== void 0 ? { deviceId: chunk.deviceId } : void 0,
-				meta: {
-					top: meaningful.slice(0, 4).map((l) => `${l.className}(${(l.score * 100).toFixed(0)}%)`).join(", "),
-					inferenceMs: result.inferenceMs
-				}
-			});
-			if (result.inferenceMs > 0) {
-				const minConf = settings.minConfidence;
-				const allowedSet = settings.allowedClasses.length > 0 ? new Set(settings.allowedClasses.map((c) => c.toLowerCase())) : null;
-				let filtered = result.labels.filter((c) => c.score >= minConf);
-				if (allowedSet) filtered = filtered.filter((c) => allowedSet.has(c.className.toLowerCase()));
-				if (filtered.length > 0) classification = {
-					labels: filtered,
-					inferenceMs: result.inferenceMs
-				};
-			}
-		} catch (err) {
-			const now = Date.now();
-			if (now - this.lastClassifyErrorMs >= CLASSIFY_ERROR_SUPPRESS_MS) {
-				const suppressed = this.suppressedClassifyErrors;
-				this.suppressedClassifyErrors = 0;
-				this.lastClassifyErrorMs = now;
-				const msg = require_dist.errMsg(err);
-				const stack = err instanceof Error ? err.stack : void 0;
-				this.log.warn("Audio classification failed", {
-					tags: chunk.deviceId !== void 0 ? { deviceId: chunk.deviceId } : void 0,
-					meta: {
-						error: msg,
-						stack,
-						suppressedSince: suppressed > 0 ? suppressed : void 0
-					}
-				});
-			} else this.suppressedClassifyErrors++;
-		}
+		const { classification, classifyOutcome } = await this.classifyForAnalysis(chunk, settings);
 		return {
 			level,
 			classification,
+			classifyOutcome,
 			timestamp: chunk.timestamp
 		};
 	}
 	/**
+	* Run one window through the shared queue and apply the camera's floor.
+	* Every exit names whether the model RAN (`classifyOutcome`, D660): a window
+	* superseded by the camera's newer one, or whose inference failed, is
+	* `not-classified` — never an empty classification.
+	*/
+	async classifyForAnalysis(chunk, settings) {
+		let submission;
+		try {
+			submission = await this.classifyWindow(chunk);
+		} catch (err) {
+			const timedOut = err instanceof AudioInferenceTimeoutError;
+			if (!timedOut) this.reportClassifyError(chunk, err);
+			return {
+				classification: void 0,
+				classifyOutcome: {
+					state: "not-classified",
+					reason: timedOut ? "timeout" : "error"
+				}
+			};
+		}
+		if (!submission.ran) return {
+			classification: void 0,
+			classifyOutcome: {
+				state: "not-classified",
+				reason: submission.reason
+			}
+		};
+		const result = submission.value;
+		this.logClassifySample(chunk, result, settings);
+		this.reportNearMiss(chunk, result, settings);
+		const filtered = labelsAboveFloor(result, settings);
+		return {
+			classification: filtered.length > 0 ? {
+				labels: filtered,
+				inferenceMs: result.inferenceMs
+			} : void 0,
+			classifyOutcome: { state: "classified" }
+		};
+	}
+	/** First-three debug samples + the per-window debug line (unchanged behaviour). */
+	logClassifySample(chunk, result, settings) {
+		const tags = chunk.deviceId !== void 0 ? { deviceId: chunk.deviceId } : void 0;
+		if (this.classifyCallCount < 3) this.log.info("classify debug sample", {
+			tags,
+			meta: {
+				index: this.classifyCallCount,
+				labelCount: result.labels.length,
+				top: result.labels.slice(0, 5).map((l) => `${l.className}(${(l.score * 100).toFixed(0)}%)`).join(", "),
+				inferenceMs: result.inferenceMs,
+				minConf: settings.minConfidence,
+				allowedClasses: settings.allowedClasses
+			}
+		});
+		this.classifyCallCount++;
+		const meaningful = result.labels.filter((l) => l.score >= .15 && l.className.toLowerCase() !== "silence");
+		if (meaningful.length > 0) this.log.debug("audio classification", {
+			tags,
+			meta: {
+				top: meaningful.slice(0, 4).map((l) => `${l.className}(${(l.score * 100).toFixed(0)}%)`).join(", "),
+				inferenceMs: result.inferenceMs
+			}
+		});
+	}
+	/**
+	* A watched macro (crying, scream) the model heard BELOW this camera's
+	* floor — one line per camera per {@link NEAR_MISS_LOG_INTERVAL_MS}, the
+	* rest counted into the next line (D660). This is the line that tells an
+	* operator whose rule never fires whether the sound was heard at all.
+	*/
+	reportNearMiss(chunk, result, settings) {
+		const miss = result.labels.find((l) => NEAR_MISS_WATCHED_MACROS.has(l.className) && l.score < settings.minConfidence);
+		if (miss === void 0) return;
+		const key = chunk.deviceId ?? GLOBAL_DEVICE_KEY;
+		const now = Date.now();
+		const prev = this.nearMissLog.get(key) ?? null;
+		if (prev !== null && now - prev.lastLoggedMs < NEAR_MISS_LOG_INTERVAL_MS) {
+			this.nearMissLog.set(key, {
+				...prev,
+				suppressed: prev.suppressed + 1
+			});
+			return;
+		}
+		this.nearMissLog.set(key, {
+			lastLoggedMs: now,
+			suppressed: 0
+		});
+		this.log.info("audio near-miss below floor", {
+			tags: chunk.deviceId !== void 0 ? { deviceId: chunk.deviceId } : void 0,
+			meta: {
+				label: miss.className,
+				originalClass: miss.originalClass,
+				score: miss.score,
+				floor: settings.minConfidence,
+				suppressedSince: prev?.suppressed ?? 0,
+				intervalMs: NEAR_MISS_LOG_INTERVAL_MS
+			}
+		});
+	}
+	/** Rate-limited classify-failure line (unchanged behaviour). */
+	reportClassifyError(chunk, err) {
+		const now = Date.now();
+		if (now - this.lastClassifyErrorMs < CLASSIFY_ERROR_SUPPRESS_MS) {
+			this.suppressedClassifyErrors++;
+			return;
+		}
+		const suppressed = this.suppressedClassifyErrors;
+		this.suppressedClassifyErrors = 0;
+		this.lastClassifyErrorMs = now;
+		this.log.warn("Audio classification failed", {
+			tags: chunk.deviceId !== void 0 ? { deviceId: chunk.deviceId } : void 0,
+			meta: {
+				error: require_dist.errMsg(err),
+				stack: err instanceof Error ? err.stack : void 0,
+				suppressedSince: suppressed > 0 ? suppressed : void 0
+			}
+		});
+	}
+	/**
 	* 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
@@ -1319,33 +1544,31 @@ var AudioAnalyzerProvider = class {
 			}
 		});
 	}
+	/**
+	* The cap's `classify`: one window through the same queue every camera
+	* uses. A window that never reached the model is an ERROR here, not an
+	* empty result — the caller asked for a classification and did not get one.
+	*/
 	async classify(chunk) {
-		const camKey = chunk.deviceId ?? GLOBAL_DEVICE_KEY;
-		const now = Date.now();
-		const state = this.cameraState.get(camKey);
-		if (state?.inProgress || state !== void 0 && now - state.lastEndMs < CLASSIFY_MIN_INTERVAL_MS) return {
-			labels: [],
-			rawLabels: [],
-			inferenceMs: 0
-		};
-		if (this.pipelineBusy) return {
-			labels: [],
-			rawLabels: [],
-			inferenceMs: 0
-		};
-		this.cameraState.set(camKey, {
-			inProgress: true,
-			lastEndMs: state?.lastEndMs ?? 0
-		});
-		this.pipelineBusy = true;
+		const submission = await this.classifyWindow(chunk);
+		if (!submission.ran) throw new Error(`audio classify not run: ${submission.reason}`);
+		return submission.value;
+	}
+	/**
+	* Queue one window for the single pipeline (D660). Per camera at most one
+	* waits; a newer window from the same camera supersedes it and takes its
+	* place in line. Cameras are served in arrival order. Rejects with the
+	* inference's own error.
+	*/
+	classifyWindow(chunk) {
+		return this.classifyQueue.submit(chunk.deviceId ?? GLOBAL_DEVICE_KEY, () => this.runInference(chunk));
+	}
+	/** One inference on the live pipeline. Only ever called by the queue — never two at once. */
+	async runInference(chunk) {
 		try {
 			const pipeline = await this.ensurePipeline();
 			const f32Data = float32FromBytes(chunk.data);
-			const result = await pipeline.classify({
-				data: f32Data,
-				sampleRate: chunk.sampleRate,
-				channels: chunk.channels
-			});
+			const result = await this.boundedInference(pipeline, chunk, f32Data);
 			if (this.debugClassifySamples && (this.classifyCount < 3 || this.classifyCount % 100 === 0)) {
 				const rawTop = result.classifications.slice(0, 5).map((c) => `"${c.className}"(${(c.score * 100).toFixed(0)}%)`).join(", ");
 				this.log.info("classify debug sample", {
@@ -1384,20 +1607,63 @@ var AudioAnalyzerProvider = class {
 				inferenceMs: result.inferenceMs
 			};
 		} finally {
-			this.pipelineBusy = false;
-			this.cameraState.set(camKey, {
-				inProgress: false,
-				lastEndMs: Date.now()
-			});
 			this.scheduleIdleDispose();
 		}
 	}
+	/**
+	* One inference under {@link INFERENCE_TIMEOUT_MS}. A backend that timed
+	* out, exited or was disposed under the call is DROPPED (killed, and the
+	* next window lazily respawns it) — a dead pipeline kept as `this.pipeline`
+	* would answer every later window with the same error forever.
+	*/
+	async boundedInference(pipeline, chunk, data) {
+		const inference = pipeline.classify({
+			data,
+			sampleRate: chunk.sampleRate,
+			channels: chunk.channels
+		});
+		inference.catch(() => void 0);
+		let timer = null;
+		const timeout = new Promise((_, reject) => {
+			timer = setTimeout(() => reject(new AudioInferenceTimeoutError(INFERENCE_TIMEOUT_MS)), INFERENCE_TIMEOUT_MS);
+		});
+		try {
+			return await Promise.race([inference, timeout]);
+		} catch (err) {
+			if (err instanceof AudioInferenceTimeoutError) {
+				this.log.warn("audio inference timed out — killing the backend, next window respawns it", {
+					tags: chunk.deviceId !== void 0 ? { deviceId: chunk.deviceId } : void 0,
+					meta: {
+						timeoutMs: INFERENCE_TIMEOUT_MS,
+						backend: this.backendName
+					}
+				});
+				this.dropPipeline(pipeline);
+			} else if (err instanceof AudioBackendExitedError) this.dropPipeline(pipeline);
+			throw err;
+		} finally {
+			if (timer !== null) clearTimeout(timer);
+		}
+	}
+	/** Forget (if still current) and dispose a pipeline that can no longer answer. */
+	dropPipeline(pipeline) {
+		if (this.pipeline === pipeline) this.pipeline = null;
+		pipeline.dispose().catch((err) => {
+			this.log.warn("audio pipeline dispose after failure threw", { meta: {
+				error: require_dist.errMsg(err),
+				backend: this.backendName
+			} });
+		});
+	}
 	isReady() {
 		return !this.disposed;
 	}
 	async dispose() {
 		this.disposed = true;
 		this.memoryGuard.stop();
+		clearInterval(this.accountingTimer);
+		this.classifyQueue.close();
+		this.reportClassifyAccounting();
 		if (this.idleTimer) {
 			clearTimeout(this.idleTimer);
 			this.idleTimer = null;