@camstack/addon-pipeline 1.2.222 → 1.2.224

package/dist/recorder/index.mjs

@@ -7770,6 +7770,7 @@ function buildRecordingProvider(deps) {
 		},
 		setDeviceConfig: async ({ deviceId, config }) => {
 			const saved = await saveDeviceConfig(deps.configStore, deviceId, config);
+			deps.onConfigSaved?.(deviceId, saved);
 			if (deps.onConfigChanged) try {
 				await deps.onConfigChanged(deviceId);
 			} catch (err) {
@@ -10956,29 +10957,75 @@ Object.freeze({
 	"turn-provider": ["getTurnServers"],
 	"user-passkeys": ["listPasskeys"]
 });
-//#endregion
-//#region src/recorder/addon/last-known-config.ts
 /**
-* Wrap `load` so a failed read serves the last value that succeeded.
+* Build the recorder's config mirror.
 *
-* Returns a drop-in replacement for {@link LoadDeviceConfigFn}: every existing
-* call site gains the fallback without changing, which is the point — the
-* trigger post-buffer was the path that got CAUGHT writing a wrong number, but
-* it is one of five reads and the other four fail the same way.
+* `load` is the fallible store read (`loadDeviceConfig(configStore, id)`), and
+* every existing call site keeps its signature: the controller is handed
+* {@link RecordingConfigMirror.read} and cannot tell the difference, which is
+* the point — the trigger post-buffer is the path that got CAUGHT writing a
+* wrong number, but it is one of six reads and the other five are the volume.
 */
-function withLastKnownConfig(deps) {
+function createRecordingConfigMirror(deps) {
 	const now = deps.now ?? (() => Date.now());
-	const cache = /* @__PURE__ */ new Map();
-	return async (deviceId) => {
+	const freshMs = deps.freshMs ?? 3e4;
+	const reportIntervalMs = deps.reportIntervalMs ?? 6e4;
+	const mirror = /* @__PURE__ */ new Map();
+	const window = {
+		served: 0,
+		storeReads: 0,
+		fallbacks: 0,
+		startedAt: now()
+	};
+	/**
+	* One line per window, fleet-level (no `deviceId`: this aggregates every
+	* camera, and the per-camera lines are the fallback WARNs above).
+	*
+	* It exists because a branch that ACCEPTS work and produces no store traffic
+	* is indistinguishable from a branch nobody calls: without this line, a
+	* mirror that silently stopped mirroring and a mirror doing its job both look
+	* like silence, and the only visible difference is 1 800 calls a minute on a
+	* runner nobody is watching.
+	*/
+	const reportIfDue = (atMs) => {
+		const windowMs = atMs - window.startedAt;
+		if (windowMs < reportIntervalMs) return;
+		const calls = window.served + window.storeReads;
+		window.startedAt = atMs;
+		const served = window.served;
+		const storeReads = window.storeReads;
+		const fallbacks = window.fallbacks;
+		window.served = 0;
+		window.storeReads = 0;
+		window.fallbacks = 0;
+		if (calls === 0) return;
+		deps.logger.info("recorder: config mirror window", { meta: {
+			served,
+			storeReads,
+			fallbacks,
+			devices: mirror.size,
+			windowMs,
+			freshMs
+		} });
+	};
+	const read = async (deviceId) => {
+		const atMs = now();
+		reportIfDue(atMs);
+		const held = mirror.get(deviceId);
+		if (held !== void 0 && atMs - held.atMs < freshMs) {
+			window.served += 1;
+			return held.config;
+		}
+		window.storeReads += 1;
 		try {
 			const config = await deps.load(deviceId);
-			cache.set(deviceId, {
+			mirror.set(deviceId, {
 				config,
 				atMs: now()
 			});
 			return config;
 		} catch (err) {
-			const cached = cache.get(deviceId);
+			const cached = mirror.get(deviceId);
 			if (cached === void 0) {
 				deps.logger.warn("recorder: config read failed and NOTHING is cached for this camera — no last-known-good to serve", {
 					tags: { deviceId },
@@ -10986,17 +11033,29 @@ function withLastKnownConfig(deps) {
 				});
 				throw err;
 			}
-			const ageMs = now() - cached.atMs;
+			window.fallbacks += 1;
 			deps.logger.warn("recorder: config read failed — serving the LAST-KNOWN-GOOD config (not the shipped default)", {
 				tags: { deviceId },
 				meta: {
-					ageMs,
+					ageMs: now() - cached.atMs,
 					error: errMsg(err)
 				}
 			});
 			return cached.config;
 		}
 	};
+	return {
+		read,
+		put(deviceId, config) {
+			mirror.set(deviceId, {
+				config,
+				atMs: now()
+			});
+		},
+		invalidate(deviceId) {
+			mirror.delete(deviceId);
+		}
+	};
 }
 //#endregion
 //#region src/recorder/addon/ledger-walk-reconcile.ts
@@ -17452,21 +17511,22 @@ var RecorderV2Addon = class extends BaseAddon {
 	/** Continuous + events band write-path controller (ffmpeg writers + watchers). */
 	controller = null;
 	/**
-	* The controller's config read, with last-known-good fallback.
+	* The controller's config read — this addon's mirror of the rows it owns
+	* (`config-mirror.ts`, D466), with the last-known-good fallback.
 	*
-	* Built ONCE and memoized, because the cache lives INSIDE the wrapper:
-	* rebuilding it per call would throw away the very value the fallback exists
-	* to serve. Lazy rather than a field initializer — a field initializer runs
-	* before the constructor assigns `this.ctx`, so `this.ctx.logger` would be
-	* `undefined` at that point.
+	* Built ONCE and memoized, because the map lives INSIDE it: rebuilding it per
+	* call would throw away both the freshness the trigger path is served from
+	* and the last value a failed read falls back to. Lazy rather than a field
+	* initializer — a field initializer runs before the constructor assigns
+	* `this.ctx`, so `this.ctx.logger` would be `undefined` at that point.
 	*/
-	lastKnownGoodRead = null;
-	get loadConfigLastKnownGood() {
-		this.lastKnownGoodRead ??= withLastKnownConfig({
+	mirroredConfigRead = null;
+	get configMirror() {
+		this.mirroredConfigRead ??= createRecordingConfigMirror({
 			load: (deviceId) => loadDeviceConfig(this.configStore(), deviceId),
 			logger: this.ctx.logger
 		});
-		return this.lastKnownGoodRead;
+		return this.mirroredConfigRead;
 	}
 	/** Unsubscribe handle for the EventCapture motion subscription. */
 	eventUnsub = null;
@@ -17714,7 +17774,7 @@ var RecorderV2Addon = class extends BaseAddon {
 			nodeId: this.nodeId,
 			ownerNodeId: ingestOwner.ownerNodeId,
 			segmentStore: this.segmentStore,
-			loadConfig: this.loadConfigLastKnownGood,
+			loadConfig: this.configMirror.read,
 			enabledDeviceIds: async () => [...(await readDeviceConfigs(this.configStore())).keys()],
 			/**
 			* The DURABLE half of the trigger path (D8/D11). `pipelineAnalytics` rows
@@ -17853,6 +17913,9 @@ var RecorderV2Addon = class extends BaseAddon {
 			calendar: this.calendar,
 			mfraFor: (deviceId, profile, startMs) => this.mfraTables.get(deviceId, profile, startMs),
 			hydrateWindow: (deviceId, fromMs, toMs, verifyClosedHours) => hydrateWindowFromStorage(this.index, deviceId, fromMs, toMs, this.resolvedLocations, this.ctx.logger, this.segmentHours ?? void 0, { verifyClosedHours: verifyClosedHours === true }),
+			onConfigSaved: (deviceId, config) => {
+				this.configMirror.put(deviceId, config);
+			},
 			onConfigChanged: async (deviceId) => {
 				await this.refreshSensorTriggerBindings();
 				await (this.controller?.onConfigChanged(deviceId) ?? Promise.resolve());

package/dist/stream-broker/index.js

@@ -9409,42 +9409,14 @@ function extractQuoted(header, key) {
 	const unquotedRegex = new RegExp(`${key}=([^,\\s]+)`, "i");
 	return header.match(unquotedRegex)?.[1];
 }
-//#endregion
-//#region src/stream-broker/stream-broker/audio-chunk-plane.ts
-/**
-* `AudioChunkPlane` — the broker's serialisable decoded audio-chunk surface
-* (Phase 5 / D9).
-*
-* This is the poll-based replacement for `StreamBroker.onDecodedAudioChunk`'s
-* live-object callback path. A live callback cannot cross a process boundary;
-* once the `pipeline` group is dissolved (Task 8) the audio consumer
-* (`pipeline-orchestrator`) runs in a different process from the broker, so
-* audio delivery must go over tRPC like the video frame plane.
-*
-* ## Why no shared memory
-*
-* Unlike video frames (~6 MB at 1080p RGB), a decoded audio chunk is tiny — a
-* ~500ms `AudioCodecSession` window is a few KB of Float32 PCM. Tiny payloads
-* serialise over tRPC cheaply, so audio ships its bytes INLINE on the RPC
-* wire; there is no shm ring.
-*
-* ## FIFO / no-drop queue policy
-*
-* Audio wants FIFO arrival order with no latest-wins drop: a missing chunk is
-* an audible gap and breaks the audio analyzer's fixed-length analysis
-* window. Each subscription therefore owns a generously-sized FIFO queue
-* (`AUDIO_QUEUE_CAPACITY`). Chunks arrive roughly every
-* `AudioCodecSession`-window (~500ms), so the queue buffers tens of seconds
-* of audio — a healthy poll loop never fills it. The queue only drops its
-* OLDEST chunk if a truly stalled consumer lets it overflow (a bounded safety
-* valve, not the steady-state behaviour).
-*/
 /**
-* Per-subscription FIFO capacity. A chunk is a few KB and arrives ~every
-* 500ms, so 64 buffers ~30s of audio between two `pullAudioChunks` polls
-* without unbounded growth.
+* Re-state a standing overflow at most this often (D465). The line fires when a
+* subscription STARTS overwriting, and again every 30 s while it still is — a
+* per-chunk warn is ~25 writes/s per camera of synchronous winston on the
+* broker's event loop, which is the cost the `pullPcm` warn coalescing exists
+* to avoid.
 */
-var AUDIO_QUEUE_CAPACITY = 64;
+var OVERFLOW_RELOG_MS = 3e4;
 /**
 * How long a subscription may go without a `pull` before the plane releases it
 * (D461).
@@ -9515,10 +9487,13 @@ var AudioChunkPlane = class {
 			id: subscriptionId,
 			tag: input?.tag ?? "unknown",
 			subscribedAt: Date.now(),
-			queue: new require_dist.RingBuffer(AUDIO_QUEUE_CAPACITY),
+			queue: new require_dist.RingBuffer(64),
 			accept: new Set(input?.accept ?? []),
 			servedKey: null,
 			chunksDelivered: 0,
+			chunksDropped: 0,
+			overflowing: false,
+			lastOverflowLogAt: 0,
 			lastPulledAt: Date.now()
 		};
 		this.subscriptions.set(subscriptionId, subscription);
@@ -9570,6 +9545,7 @@ var AudioChunkPlane = class {
 				leaseMs: AUDIO_SUBSCRIPTION_IDLE_MS,
 				queued: subscription.queue.size,
 				chunksDelivered: subscription.chunksDelivered,
+				chunksDropped: subscription.chunksDropped,
 				hint: "the consumer process died without detaching — its subscription was holding this broker in demand"
 			} });
 		}
@@ -9605,13 +9581,47 @@ var AudioChunkPlane = class {
 		for (const subscription of this.subscriptions.values()) {
 			if (sourceFormat === "f32le" || subscription.accept.has(sourceFormat)) {
 				this.noteServed(subscription, sourceFormat, sourceFormat);
-				subscription.queue.push(chunk);
+				this.enqueue(subscription, chunk);
 				continue;
 			}
 			expanded ??= expandChunk(chunk, sourceFormat);
 			this.noteServed(subscription, sourceFormat, "f32le");
-			subscription.queue.push(expanded);
+			this.enqueue(subscription, expanded);
+		}
+	}
+	/**
+	* Push one chunk into a subscription's FIFO and NAME the loss when the FIFO
+	* had no room (D465).
+	*
+	* `RingBuffer.push` overwrites its oldest entry. Every docblock on this path
+	* called that "a bounded safety valve, not the steady-state behaviour" and
+	* nothing ever said when the valve opened, so a consumer polling too slowly
+	* for its producer lost audio permanently and in silence — the exact shape
+	* CLAUDE.md forbids. The realistic cause is a cadence chosen for the
+	* BOUNDARY rather than for the producer's chunk rate: 500 ms of a ~42 ms AAC
+	* chunk is ~12 chunks against a batch that used to drain 8.
+	*/
+	enqueue(subscription, chunk) {
+		const wasFull = subscription.queue.size >= 64;
+		subscription.queue.push(chunk);
+		if (!wasFull) {
+			subscription.overflowing = false;
+			return;
 		}
+		subscription.chunksDropped += 1;
+		const now = Date.now();
+		const isNewEpisode = !subscription.overflowing;
+		subscription.overflowing = true;
+		if (!isNewEpisode && now - subscription.lastOverflowLogAt < OVERFLOW_RELOG_MS) return;
+		subscription.lastOverflowLogAt = now;
+		this.logger?.warn("audio-chunk subscription OVERFLOW — oldest audio overwritten", { meta: {
+			subscriptionId: subscription.id,
+			tag: subscription.tag,
+			capacity: 64,
+			chunksDropped: subscription.chunksDropped,
+			chunksDelivered: subscription.chunksDelivered,
+			hint: "the consumer is pulling slower than this camera produces — its poll cadence or drain batch is wrong for the producer, not the boundary"
+		} });
 	}
 	/**
 	* Run the idle-lease sweep on a cadence rather than on every chunk. A quarter
@@ -9669,10 +9679,6 @@ var AudioChunkPlane = class {
 		this.subscriptions.clear();
 	}
 };
-//#endregion
-//#region src/stream-broker/stream-broker/audio-codec-session.ts
-var POLL_INTERVAL_MS$1 = 40;
-var MAX_PCM_PER_POLL = 16;
 var RTP_HEADER_LENGTH = 12;
 var WARN_THROTTLE_MS$1 = 5e3;
 var SESSION_NOT_FOUND_RE$1 = /decode session\b.*\bnot found\b/;
@@ -9684,19 +9690,23 @@ var AudioCodecSession = class {
 	cfg;
 	emit;
 	logger;
+	realtimeDemand;
 	sessionId = null;
 	sessionNodeId = null;
 	creating = null;
 	pollTimer = null;
+	/** The cadence the loop last armed, so a change can be NAMED once (D465). */
+	pollIntervalMs = null;
 	closed = false;
 	packetsIn = 0;
 	packetsDropped = 0;
 	warnState = /* @__PURE__ */ new Map();
-	constructor(api, cfg, emit, logger) {
+	constructor(api, cfg, emit, logger, realtimeDemand) {
 		this.api = api;
 		this.cfg = cfg;
 		this.emit = emit;
 		this.logger = logger;
+		this.realtimeDemand = realtimeDemand;
 	}
 	processPacket(rtpData) {
 		if (this.closed) return;
@@ -9764,7 +9774,7 @@ var AudioCodecSession = class {
 		if (this.creating) await this.creating;
 		if (this.closed) return;
 		if (this.pollTimer) {
-			clearInterval(this.pollTimer);
+			clearTimeout(this.pollTimer);
 			this.pollTimer = null;
 		}
 		if (!this.sessionId) return;
@@ -9786,7 +9796,7 @@ var AudioCodecSession = class {
 		if (this.closed) return;
 		this.closed = true;
 		if (this.pollTimer) {
-			clearInterval(this.pollTimer);
+			clearTimeout(this.pollTimer);
 			this.pollTimer = null;
 		}
 		if (this.sessionId) {
@@ -9852,11 +9862,43 @@ var AudioCodecSession = class {
 		})();
 		return this.creating;
 	}
+	/**
+	* The cadence this tick should use. Re-read every tick rather than latched at
+	* arm time: a WebRTC session attaching mid-stream must be served at
+	* {@link REALTIME_POLL_INTERVAL_MS}, and it costs at most one idle interval
+	* (400 ms) to notice — against an ICE/DTLS handshake measured in seconds.
+	*/
+	currentPollIntervalMs() {
+		if (!this.realtimeDemand) return 40;
+		return this.realtimeDemand() ? 40 : 400;
+	}
 	startPollLoop() {
 		if (this.pollTimer || this.closed) return;
-		this.pollTimer = setInterval(() => {
-			this.pollOnce();
-		}, POLL_INTERVAL_MS$1);
+		this.scheduleNextPoll();
+	}
+	/**
+	* Self-scheduling tick. `setInterval` cannot change period, and the period is
+	* now a property of who is listening (D465), so the loop re-arms itself.
+	*/
+	scheduleNextPoll() {
+		if (this.closed || !this.sessionId) return;
+		const intervalMs = this.currentPollIntervalMs();
+		if (intervalMs !== this.pollIntervalMs) {
+			const previous = this.pollIntervalMs;
+			this.pollIntervalMs = intervalMs;
+			this.logger?.info("audio-codec: poll cadence", { meta: {
+				intervalMs,
+				previousMs: previous,
+				reason: intervalMs === 40 ? "realtime-consumer" : "plane-only",
+				maxPcmPerPoll: 32
+			} });
+		}
+		this.pollTimer = setTimeout(() => {
+			this.pollTimer = null;
+			this.pollOnce().finally(() => {
+				this.scheduleNextPoll();
+			});
+		}, intervalMs);
 		if (typeof this.pollTimer.unref === "function") this.pollTimer.unref();
 	}
 	async pollOnce() {
@@ -9867,7 +9909,7 @@ var AudioCodecSession = class {
 			const pcms = await this.api.pullPcm({
 				sessionId: sid,
 				...nodeId ? { nodeId } : {},
-				maxCount: MAX_PCM_PER_POLL
+				maxCount: 32
 			});
 			for (const pcm of pcms) this.appendPcm(pcm);
 		} catch (err) {
@@ -9911,7 +9953,7 @@ var AudioCodecSession = class {
 		this.sessionId = null;
 		this.sessionNodeId = null;
 		if (this.pollTimer) {
-			clearInterval(this.pollTimer);
+			clearTimeout(this.pollTimer);
 			this.pollTimer = null;
 		}
 		this.warnThrottled("audio-codec: session reaped upstream — will re-create on next packet", `staleSessionId=${staleSid}`);
@@ -12619,7 +12661,7 @@ var StreamBroker = class StreamBroker {
 				this.logger?.debug("audio-codec: prior session close failed", { meta: { error: require_dist.errMsg(err) } });
 			});
 		}
-		this.audioCodecSession = new AudioCodecSession(this.audioCodecApi, cfg, this.buildAudioCodecEmitCallback(), this.logger?.child("audio-codec"));
+		this.audioCodecSession = new AudioCodecSession(this.audioCodecApi, cfg, this.buildAudioCodecEmitCallback(), this.logger?.child("audio-codec"), () => this.encodedCallbacks.size > 0);
 		this.logger?.info("push-audio: decode session armed", { meta: {
 			codec: cfg.codec,
 			sourceSampleRate: cfg.sourceSampleRate,
@@ -13825,7 +13867,7 @@ var StreamBroker = class StreamBroker {
 								this.logger?.debug("audio-codec: prior RTSP session close failed", { meta: { error: require_dist.errMsg(err) } });
 							});
 						}
-						this.audioCodecSession = new AudioCodecSession(this.audioCodecApi, capCfg, this.buildAudioCodecEmitCallback(), this.logger?.child("audio-codec"));
+						this.audioCodecSession = new AudioCodecSession(this.audioCodecApi, capCfg, this.buildAudioCodecEmitCallback(), this.logger?.child("audio-codec"), () => this.encodedCallbacks.size > 0);
 						this.logger?.info("audio-codec: decode session armed", { meta: {
 							codec: capCfg.codec,
 							sourceSampleRate: capCfg.sourceSampleRate,