@camstack/addon-pipeline 1.2.222 → 1.2.223

package/dist/audio-analyzer/index.js

@@ -397,8 +397,20 @@ function resampleMono16k(chunk) {
 	}
 	return out;
 }
-/** How many chunks to drain per poll — a small burst absorbs jitter. */
-var PULL_MAX_COUNT = 8;
+/**
+* How many times one tick may re-poll immediately after a FULL batch (D465).
+*
+* A batch that comes back full is not a drain, it is a backlog: there is more
+* waiting and the next chunk is already older than the window it belongs to.
+* Continuing bounds the damage for any producer cadence — including one this
+* file cannot know — without adding a single request when there is no backlog.
+* The broker's FIFO holds 64, so two continuations clear a completely full
+* queue; four is margin, and the bound is what stops a permanently faster
+* producer from turning this into a spin.
+*/
+var MAX_DRAIN_CONTINUATIONS = 4;
+/** Re-state a standing backlog at most this often. */
+var BACKLOG_RELOG_MS = 3e4;
 /**
 * 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
@@ -441,7 +453,9 @@ function startAudioChunkPoller(options) {
 		stopped: false,
 		retryTimer: void 0,
 		pollTimer: void 0,
-		activeSubscriptionId: null
+		activeSubscriptionId: null,
+		backlogged: false,
+		lastBacklogLogAt: 0
 	};
 	const teardown = () => {
 		if (lifecycle.stopped) return;
@@ -567,19 +581,44 @@ function startPolling(options, lifecycle) {
 		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) {
+			let continuations = 0;
+			let drained = 0;
+			for (;;) {
+				const chunks = await api.streamBroker.pullAudioChunks.query({
+					subscriptionId: subId,
+					maxCount: 32
+				}, pin);
+				if (consecutiveFailures > 0) logger.info("audio-chunk poller: stream recovered", { meta: {
+					brokerId,
+					subscriptionId: subId
+				} });
+				consecutiveFailures = 0;
+				drained += chunks.length;
+				for (const chunk of chunks) {
+					if (lifecycle.stopped) break;
+					await onChunk(chunk);
+				}
 				if (lifecycle.stopped) break;
-				await onChunk(chunk);
+				if (chunks.length < 32) break;
+				if (continuations >= MAX_DRAIN_CONTINUATIONS) break;
+				continuations += 1;
 			}
+			if (continuations > 0) {
+				const now = Date.now();
+				if (!lifecycle.backlogged || now - lifecycle.lastBacklogLogAt >= BACKLOG_RELOG_MS) {
+					lifecycle.lastBacklogLogAt = now;
+					logger.warn("audio-chunk poller: backlog — a full batch is not a drain", { meta: {
+						brokerId,
+						subscriptionId: subId,
+						drained,
+						maxCount: 32,
+						continuations,
+						pollIntervalMs: options.pollIntervalMs ?? 200,
+						hint: "this camera produces chunks faster than one poll of this cadence can carry — the broker FIFO is overwriting next"
+					} });
+				}
+				lifecycle.backlogged = true;
+			} else lifecycle.backlogged = false;
 		} catch (err) {
 			consecutiveFailures += 1;
 			if (consecutiveFailures === 1) logger.warn("audio-chunk poller: pullAudioChunks failed — attempting recovery", { meta: {

package/dist/audio-analyzer/index.mjs

@@ -391,8 +391,20 @@ function resampleMono16k(chunk) {
 	}
 	return out;
 }
-/** How many chunks to drain per poll — a small burst absorbs jitter. */
-var PULL_MAX_COUNT = 8;
+/**
+* How many times one tick may re-poll immediately after a FULL batch (D465).
+*
+* A batch that comes back full is not a drain, it is a backlog: there is more
+* waiting and the next chunk is already older than the window it belongs to.
+* Continuing bounds the damage for any producer cadence — including one this
+* file cannot know — without adding a single request when there is no backlog.
+* The broker's FIFO holds 64, so two continuations clear a completely full
+* queue; four is margin, and the bound is what stops a permanently faster
+* producer from turning this into a spin.
+*/
+var MAX_DRAIN_CONTINUATIONS = 4;
+/** Re-state a standing backlog at most this often. */
+var BACKLOG_RELOG_MS = 3e4;
 /**
 * 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
@@ -435,7 +447,9 @@ function startAudioChunkPoller(options) {
 		stopped: false,
 		retryTimer: void 0,
 		pollTimer: void 0,
-		activeSubscriptionId: null
+		activeSubscriptionId: null,
+		backlogged: false,
+		lastBacklogLogAt: 0
 	};
 	const teardown = () => {
 		if (lifecycle.stopped) return;
@@ -561,19 +575,44 @@ function startPolling(options, lifecycle) {
 		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) {
+			let continuations = 0;
+			let drained = 0;
+			for (;;) {
+				const chunks = await api.streamBroker.pullAudioChunks.query({
+					subscriptionId: subId,
+					maxCount: 32
+				}, pin);
+				if (consecutiveFailures > 0) logger.info("audio-chunk poller: stream recovered", { meta: {
+					brokerId,
+					subscriptionId: subId
+				} });
+				consecutiveFailures = 0;
+				drained += chunks.length;
+				for (const chunk of chunks) {
+					if (lifecycle.stopped) break;
+					await onChunk(chunk);
+				}
 				if (lifecycle.stopped) break;
-				await onChunk(chunk);
+				if (chunks.length < 32) break;
+				if (continuations >= MAX_DRAIN_CONTINUATIONS) break;
+				continuations += 1;
 			}
+			if (continuations > 0) {
+				const now = Date.now();
+				if (!lifecycle.backlogged || now - lifecycle.lastBacklogLogAt >= BACKLOG_RELOG_MS) {
+					lifecycle.lastBacklogLogAt = now;
+					logger.warn("audio-chunk poller: backlog — a full batch is not a drain", { meta: {
+						brokerId,
+						subscriptionId: subId,
+						drained,
+						maxCount: 32,
+						continuations,
+						pollIntervalMs: options.pollIntervalMs ?? 200,
+						hint: "this camera produces chunks faster than one poll of this cadence can carry — the broker FIFO is overwriting next"
+					} });
+				}
+				lifecycle.backlogged = true;
+			} else lifecycle.backlogged = false;
 		} catch (err) {
 			consecutiveFailures += 1;
 			if (consecutiveFailures === 1) logger.warn("audio-chunk poller: pullAudioChunks failed — attempting recovery", { meta: {

package/dist/pipeline-runner/index.js

@@ -6507,41 +6507,34 @@ function isUsable(bbox) {
 //#endregion
 //#region src/pipeline-runner/runtime-labels.ts
 /**
-* `null` for either input means "could not be read", and the corresponding
-* field is OMITTED. The two are independent: an engine that failed to answer
-* must not also erase the models, which is how the original field managed to
-* be null on every line ever logged.
-*/
-function buildRuntimeLabels(engine, steps) {
-	const runtime = engine === null ? void 0 : [
-		engine.runtime,
-		engine.backend,
-		engine.device
-	].filter((part) => part !== void 0 && part !== "").join("/");
-	const models = steps === null ? void 0 : [...new Set(steps.filter((s) => s.enabled).map((s) => s.modelId))];
+* `null` means the read FAILED; `[]` means nothing is resident. Both omit the
+* fields, but they are different facts and the caller logs the failure.
+*
+* The `runtime` pool is named first because it is the one serving cameras; the
+* rest follow in arrival order. `python` is deliberately NOT printed: every
+* engine available on this cluster is python, and a token that cannot vary
+* costs a column and tells the reader nothing.
+*/
+function buildRuntimeLabels(engines) {
+	if (engines === null || engines.length === 0) return {};
+	const ordered = [...engines.filter((e) => e.kind === "runtime"), ...engines.filter((e) => e.kind !== "runtime")];
+	const devices = [...new Set(ordered.map((e) => e.device).filter((d) => !!d))];
+	const backends = [...new Set(ordered.map((e) => e.backend))];
+	const backend = backends.length === 1 ? backends[0] : "mixed";
+	const runtime = devices.length === 0 ? backend : `${backend}/${devices.join("+")}`;
+	const primary = ordered[0];
+	if (primary === void 0) return {};
+	const models = [];
+	for (const engine of ordered) for (const model of engine.modelsLoaded) {
+		if (models.includes(model)) continue;
+		if (engine === primary || primary.modelsLoaded.includes(model)) models.push(model);
+		else models.push(engine.device === void 0 ? model : `${model}@${engine.device}`);
+	}
 	return {
-		...runtime !== void 0 ? { pipelineRuntime: runtime } : {},
-		...models !== void 0 ? { pipelineModels: models } : {}
+		pipelineRuntime: runtime,
+		pipelineModels: models
 	};
 }
-/**
-* Depth-first flatten of the active pipeline tree.
-*
-* A DISABLED step takes its subtree with it: the children of a step that does
-* not run did not run either, and listing a face model under a disabled face
-* detector would name a model that never loaded.
-*/
-function flattenLabelledSteps(steps) {
-	const out = [];
-	for (const step of steps) {
-		out.push({
-			modelId: step.modelId,
-			enabled: step.enabled
-		});
-		if (step.enabled && step.children !== void 0) out.push(...flattenLabelledSteps(step.children));
-	}
-	return out;
-}
 //#endregion
 //#region src/pipeline-runner/track-frame-park.ts
 /** Park one frame for one track. Never throws; a refusal is an answer. */
@@ -6702,6 +6695,8 @@ var TILE_CUT_DROP_LOG_INTERVAL_MS = 6e4;
 * operator re-selects one or lazy provisioning completes — not per frame.
 */
 var RUNTIME_INFO_REFRESH_MS = 3e5;
+/** Sentinel for "no api" so it is one transition, not a per-refresh line. */
+var NO_API_FAILURE = "no addon api";
 /** How often a camera reports parcels that left without a release (D422). */
 var PARKED_EVICTION_LOG_INTERVAL_MS = 6e4;
 /**
@@ -7139,6 +7134,8 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 	nodeId = "unknown";
 	metricsSnapshotTimer = null;
 	runtimeInfoTimer = null;
+	/** Last runtime-label failure, so only a CHANGE is logged (D463). */
+	lastRuntimeInfoFailure = null;
 	unsubMotionEvents = null;
 	/** Devices we have positively observed reporting `battery.sleeping: true`.
 	*  Absent = unknown or awake; both mean "do not gate" (D49). Fed only by
@@ -8823,28 +8820,47 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 	*/
 	async refreshRuntimeInfo() {
 		const api = this.ctxIfReady?.api;
-		if (!api) return;
-		let engine = null;
-		let steps = null;
-		try {
-			engine = await api.pipelineExecutor.getSelectedEngine.query();
-		} catch (err) {
-			this.ctxIfReady?.logger.debug("runtime labels: selected engine unreadable", { meta: { error: require_dist.errMsg(err) } });
+		const sampler = this.runner?.timingSampler;
+		if (!api || sampler === void 0 || sampler === null) {
+			this.noteRuntimeInfoFailure(NO_API_FAILURE);
+			return;
 		}
+		let engines = null;
+		let failure = null;
 		try {
-			const active = await api.pipelineExecutor.getGlobalSteps.query();
-			steps = active === null ? null : flattenLabelledSteps(active);
+			engines = (await api.pipelineExecutor.listLoadedEngines.query()).map((r) => ({
+				backend: r.engine.backend,
+				...r.engine.device !== void 0 ? { device: r.engine.device } : {},
+				kind: r.kind,
+				modelsLoaded: r.modelsLoaded
+			}));
 		} catch (err) {
-			this.ctxIfReady?.logger.debug("runtime labels: active steps unreadable", { meta: { error: require_dist.errMsg(err) } });
+			failure = require_dist.errMsg(err);
 		}
-		const sampler = this.runner?.timingSampler;
-		if (sampler === void 0 || sampler === null) return;
+		this.noteRuntimeInfoFailure(failure);
 		sampler.runtimeInfo = {
 			...sampler.runtimeInfo,
-			...buildRuntimeLabels(engine, steps)
+			...buildRuntimeLabels(engines)
 		};
 	}
 	/**
+	* Log a runtime-label failure at its TRANSITION, and at `warn`.
+	*
+	* This branch first shipped at `debug`, on the argument that the absent field
+	* in the line was signal enough. It was not: within the hour `little-unraid`
+	* was the one node still logging `pipelineRuntime=null` and there was no way
+	* to tell "this node has no engine" from "the read threw", because the hub
+	* writes `info` and the agent forwards to it. That is D438's blind
+	* instrument for the third time. Logging the transition rather than every
+	* refresh is what keeps it from becoming a storm.
+	*/
+	noteRuntimeInfoFailure(failure) {
+		if (failure === this.lastRuntimeInfoFailure) return;
+		if (failure === null) this.ctxIfReady?.logger.info("runtime labels: readable again");
+		else this.ctxIfReady?.logger.warn("runtime labels unreadable — this node cannot name its engines", { meta: { error: failure } });
+		this.lastRuntimeInfoFailure = failure;
+	}
+	/**
 	* The model format this node dispatches on when no `deviceKey` is given —
 	* its selected engine's format. `null` on any failure, which the caller
 	* turns into a refusal rather than a guess: a model pin that cannot be

package/dist/pipeline-runner/index.mjs

@@ -6499,41 +6499,34 @@ function isUsable(bbox) {
 //#endregion
 //#region src/pipeline-runner/runtime-labels.ts
 /**
-* `null` for either input means "could not be read", and the corresponding
-* field is OMITTED. The two are independent: an engine that failed to answer
-* must not also erase the models, which is how the original field managed to
-* be null on every line ever logged.
-*/
-function buildRuntimeLabels(engine, steps) {
-	const runtime = engine === null ? void 0 : [
-		engine.runtime,
-		engine.backend,
-		engine.device
-	].filter((part) => part !== void 0 && part !== "").join("/");
-	const models = steps === null ? void 0 : [...new Set(steps.filter((s) => s.enabled).map((s) => s.modelId))];
+* `null` means the read FAILED; `[]` means nothing is resident. Both omit the
+* fields, but they are different facts and the caller logs the failure.
+*
+* The `runtime` pool is named first because it is the one serving cameras; the
+* rest follow in arrival order. `python` is deliberately NOT printed: every
+* engine available on this cluster is python, and a token that cannot vary
+* costs a column and tells the reader nothing.
+*/
+function buildRuntimeLabels(engines) {
+	if (engines === null || engines.length === 0) return {};
+	const ordered = [...engines.filter((e) => e.kind === "runtime"), ...engines.filter((e) => e.kind !== "runtime")];
+	const devices = [...new Set(ordered.map((e) => e.device).filter((d) => !!d))];
+	const backends = [...new Set(ordered.map((e) => e.backend))];
+	const backend = backends.length === 1 ? backends[0] : "mixed";
+	const runtime = devices.length === 0 ? backend : `${backend}/${devices.join("+")}`;
+	const primary = ordered[0];
+	if (primary === void 0) return {};
+	const models = [];
+	for (const engine of ordered) for (const model of engine.modelsLoaded) {
+		if (models.includes(model)) continue;
+		if (engine === primary || primary.modelsLoaded.includes(model)) models.push(model);
+		else models.push(engine.device === void 0 ? model : `${model}@${engine.device}`);
+	}
 	return {
-		...runtime !== void 0 ? { pipelineRuntime: runtime } : {},
-		...models !== void 0 ? { pipelineModels: models } : {}
+		pipelineRuntime: runtime,
+		pipelineModels: models
 	};
 }
-/**
-* Depth-first flatten of the active pipeline tree.
-*
-* A DISABLED step takes its subtree with it: the children of a step that does
-* not run did not run either, and listing a face model under a disabled face
-* detector would name a model that never loaded.
-*/
-function flattenLabelledSteps(steps) {
-	const out = [];
-	for (const step of steps) {
-		out.push({
-			modelId: step.modelId,
-			enabled: step.enabled
-		});
-		if (step.enabled && step.children !== void 0) out.push(...flattenLabelledSteps(step.children));
-	}
-	return out;
-}
 //#endregion
 //#region src/pipeline-runner/track-frame-park.ts
 /** Park one frame for one track. Never throws; a refusal is an answer. */
@@ -6694,6 +6687,8 @@ var TILE_CUT_DROP_LOG_INTERVAL_MS = 6e4;
 * operator re-selects one or lazy provisioning completes — not per frame.
 */
 var RUNTIME_INFO_REFRESH_MS = 3e5;
+/** Sentinel for "no api" so it is one transition, not a per-refresh line. */
+var NO_API_FAILURE = "no addon api";
 /** How often a camera reports parcels that left without a release (D422). */
 var PARKED_EVICTION_LOG_INTERVAL_MS = 6e4;
 /**
@@ -7131,6 +7126,8 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends BaseAddon {
 	nodeId = "unknown";
 	metricsSnapshotTimer = null;
 	runtimeInfoTimer = null;
+	/** Last runtime-label failure, so only a CHANGE is logged (D463). */
+	lastRuntimeInfoFailure = null;
 	unsubMotionEvents = null;
 	/** Devices we have positively observed reporting `battery.sleeping: true`.
 	*  Absent = unknown or awake; both mean "do not gate" (D49). Fed only by
@@ -8815,28 +8812,47 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends BaseAddon {
 	*/
 	async refreshRuntimeInfo() {
 		const api = this.ctxIfReady?.api;
-		if (!api) return;
-		let engine = null;
-		let steps = null;
-		try {
-			engine = await api.pipelineExecutor.getSelectedEngine.query();
-		} catch (err) {
-			this.ctxIfReady?.logger.debug("runtime labels: selected engine unreadable", { meta: { error: errMsg(err) } });
+		const sampler = this.runner?.timingSampler;
+		if (!api || sampler === void 0 || sampler === null) {
+			this.noteRuntimeInfoFailure(NO_API_FAILURE);
+			return;
 		}
+		let engines = null;
+		let failure = null;
 		try {
-			const active = await api.pipelineExecutor.getGlobalSteps.query();
-			steps = active === null ? null : flattenLabelledSteps(active);
+			engines = (await api.pipelineExecutor.listLoadedEngines.query()).map((r) => ({
+				backend: r.engine.backend,
+				...r.engine.device !== void 0 ? { device: r.engine.device } : {},
+				kind: r.kind,
+				modelsLoaded: r.modelsLoaded
+			}));
 		} catch (err) {
-			this.ctxIfReady?.logger.debug("runtime labels: active steps unreadable", { meta: { error: errMsg(err) } });
+			failure = errMsg(err);
 		}
-		const sampler = this.runner?.timingSampler;
-		if (sampler === void 0 || sampler === null) return;
+		this.noteRuntimeInfoFailure(failure);
 		sampler.runtimeInfo = {
 			...sampler.runtimeInfo,
-			...buildRuntimeLabels(engine, steps)
+			...buildRuntimeLabels(engines)
 		};
 	}
 	/**
+	* Log a runtime-label failure at its TRANSITION, and at `warn`.
+	*
+	* This branch first shipped at `debug`, on the argument that the absent field
+	* in the line was signal enough. It was not: within the hour `little-unraid`
+	* was the one node still logging `pipelineRuntime=null` and there was no way
+	* to tell "this node has no engine" from "the read threw", because the hub
+	* writes `info` and the agent forwards to it. That is D438's blind
+	* instrument for the third time. Logging the transition rather than every
+	* refresh is what keeps it from becoming a storm.
+	*/
+	noteRuntimeInfoFailure(failure) {
+		if (failure === this.lastRuntimeInfoFailure) return;
+		if (failure === null) this.ctxIfReady?.logger.info("runtime labels: readable again");
+		else this.ctxIfReady?.logger.warn("runtime labels unreadable — this node cannot name its engines", { meta: { error: failure } });
+		this.lastRuntimeInfoFailure = failure;
+	}
+	/**
 	* The model format this node dispatches on when no `deviceKey` is given —
 	* its selected engine's format. `null` on any failure, which the caller
 	* turns into a refusal rather than a guess: a model pin that cannot be

package/dist/recorder/index.js

@@ -7777,6 +7777,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) {
@@ -10963,29 +10964,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 },
@@ -10993,17 +11040,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: require_dist.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
@@ -17459,21 +17518,22 @@ var RecorderV2Addon = class extends require_dist.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;
@@ -17721,7 +17781,7 @@ var RecorderV2Addon = class extends require_dist.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
@@ -17860,6 +17920,9 @@ var RecorderV2Addon = class extends require_dist.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());