@camstack/addon-pipeline 1.2.191 → 1.2.193

package/dist/recorder/index.js

@@ -2,8 +2,8 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-const require_dist = require("../dist-PQArEi7A.js");
-const require_node = require("../node-wFmd_eR_.js");
+const require_dist = require("../dist-HG5geL9t.js");
+const require_node = require("../node--my8JTOW.js");
 const require_hub_hostname = require("../hub-hostname-DAJXlOgV.js");
 const require_restream_intent = require("../restream-intent-Cv9x3jmu.js");
 const require_event_loop_stall_monitor = require("../event-loop-stall-monitor-DaUBcb13.js");
@@ -12523,6 +12523,7 @@ function triggerKey(source) {
 		case "audio": return "audio";
 		case "object": return `object:${source.macroClass}`;
 		case "sensor": return `sensor:${source.sourceDeviceId}`;
+		case "signal": return "signal";
 	}
 }
 /**
@@ -12553,6 +12554,7 @@ function bandTriggerSources(band) {
 		kind: "sensor",
 		sourceDeviceId
 	});
+	if (t.deviceSignal === true) sources.push({ kind: "signal" });
 	return sources;
 }
 /**
@@ -12607,7 +12609,69 @@ function withWindows(state, source, windows) {
 	const key = triggerKey(source);
 	if (windows.length === 0) next.delete(key);
 	else next.set(key, windows);
-	return { windows: next };
+	return withHeld({ windows: next }, state.held);
+}
+/** The same state with `held` replaced — absent when there is nothing held, so
+*  a state that holds nothing is shaped exactly like one built before holds
+*  existed. */
+function withHeld(state, held) {
+	if (held === void 0 || held.size === 0) {
+		const { held: _dropped, ...rest } = state;
+		return rest;
+	}
+	return {
+		...state,
+		held
+	};
+}
+/** When the source rose, or null when it is not held. */
+function heldSinceMs(state, source) {
+	return state.held?.get(triggerKey(source)) ?? null;
+}
+/**
+* Raise a LEVEL source: from `atMs` on, the live gate demands and the keep
+* gate retains, until {@link releaseTrigger}. Idempotent — a second rise of a
+* source already held keeps the ORIGINAL rise, because the level never fell in
+* between and the footage since then belongs to the same episode. A re-emitted
+* `active: true` (a slice rewritten for another field, a reconcile read) must
+* not shorten the keep span.
+*/
+function holdTrigger(state, source, atMs) {
+	const key = triggerKey(source);
+	if (state.held?.has(key)) return state;
+	const held = new Map(state.held);
+	held.set(key, atMs);
+	return withHeld(state, held);
+}
+/**
+* Lower a LEVEL source: the hold becomes the window `[since, atMs]`, folded
+* through the SAME merge every other source uses — so a rise landing inside
+* the post-buffer of the previous fall extends that episode rather than
+* opening a second one, exactly as consecutive motion triggers do. From here
+* on the band's `postBufferSec` runs and the schedule arms the close.
+*
+* A release of a source that is not held returns the SAME object: a falling
+* edge the recorder never saw rise (a runner respawn mid-job, a reconcile
+* read) has nothing to close, and the caller can skip a write.
+*/
+function releaseTrigger(state, source, atMs, mergeGapMs) {
+	const key = triggerKey(source);
+	const since = state.held?.get(key);
+	if (since === void 0) return state;
+	const held = new Map(state.held);
+	held.delete(key);
+	const span = {
+		firstMs: since,
+		lastMs: Math.max(since, atMs)
+	};
+	const windows = triggerWindowsFor(state, source);
+	const newest = windows[windows.length - 1];
+	const merged = newest !== void 0 && span.firstMs - newest.lastMs <= mergeGapMs ? [...windows.slice(0, -1), {
+		firstMs: Math.min(newest.firstMs, span.firstMs),
+		lastMs: Math.max(newest.lastMs, span.lastMs)
+	}] : [...windows, span];
+	const evicted = Math.max(0, merged.length - 32);
+	return withWindows(withHeld(state, held), source, evicted > 0 ? merged.slice(evicted) : merged);
 }
 /**
 * Fold one qualifying trigger into the history, immutably. It EXTENDS the newest
@@ -12649,7 +12713,7 @@ function pruneTriggerHistory(state, postMs, nowMs) {
 		if (live.length !== windows.length) changed = true;
 		if (live.length > 0) next.set(key, live);
 	}
-	return changed ? { windows: next } : state;
+	return changed ? withHeld({ windows: next }, state.held) : state;
 }
 /** Most recent trigger for a source, or null when none is retained. */
 function latestTriggerMs(state, source) {
@@ -12664,6 +12728,7 @@ function latestTriggerMs(state, source) {
 function eventsBandDemanded(band, triggers, atMs) {
 	const { postMs } = resolveBandBufferMs(band);
 	return bandTriggerSources(band).some((source) => {
+		if (heldSinceMs(triggers, source) !== null) return true;
 		const lastMs = latestTriggerMs(triggers, source);
 		return lastMs !== null && atMs - lastMs <= postMs;
 	});
@@ -12737,7 +12802,11 @@ function segmentRetainedForEvents(segStartMs, segEndMs, band, triggers, attach)
 		if (segStartMs <= window.lastMs + postMs) return true;
 		return attach.attachedAtMs <= window.lastMs + postMs && segStartMs <= deadlineMs;
 	};
-	return bandTriggerSources(band).some((source) => triggerWindowsFor(triggers, source).some(overlaps));
+	return bandTriggerSources(band).some((source) => {
+		const since = heldSinceMs(triggers, source);
+		if (since !== null && segEndMs >= since - preMs) return true;
+		return triggerWindowsFor(triggers, source).some(overlaps);
+	});
 }
 /**
 * By how many ms a discarded segment missed being kept — its start past the
@@ -12759,7 +12828,10 @@ function segmentMissedByMs(segStartMs, band, triggers, attach) {
 		const windowEndMs = window.lastMs + postMs;
 		return attach.attachedAtMs <= windowEndMs ? Math.max(windowEndMs, deadlineMs) : windowEndMs;
 	};
-	const considered = bandTriggerSources(band).flatMap((source) => [...triggerWindowsFor(triggers, source)]);
+	const sources = bandTriggerSources(band);
+	const holds = sources.map((source) => heldSinceMs(triggers, source)).filter((s) => s !== null);
+	if (holds.length > 0) return Math.min(-1, segStartMs - Math.min(...holds));
+	const considered = sources.flatMap((source) => [...triggerWindowsFor(triggers, source)]);
 	if (considered.length === 0) return null;
 	return segStartMs - Math.max(...considered.map(latestKeptStart));
 }
@@ -12943,7 +13015,9 @@ function nextBandEdgeMs(config, nowMs) {
 function eventsWindowCloseMs(band, triggers, nowMs) {
 	if (band.mode !== "events") return null;
 	const { postMs } = resolveBandBufferMs(band);
-	const open = bandTriggerSources(band).map((source) => latestTriggerMs(triggers, source)).filter((ms) => ms !== null).map((ms) => ms + postMs).filter((ms) => ms >= nowMs);
+	const sources = bandTriggerSources(band);
+	if (sources.some((source) => heldSinceMs(triggers, source) !== null)) return null;
+	const open = sources.map((source) => latestTriggerMs(triggers, source)).filter((ms) => ms !== null).map((ms) => ms + postMs).filter((ms) => ms >= nowMs);
 	if (open.length === 0) return null;
 	return Math.max(...open) + 1;
 }
@@ -13951,6 +14025,25 @@ var PLACEMENT_TICK_MS = 3e4;
 */
 var RECONCILE_TICK_MS = 12e4;
 /**
+* How long a `recording-signal` hold may stand WITHOUT a read confirming it
+* before the reconcile releases it anyway.
+*
+* The hold is opened by an event (D8: telemetry, may be dropped) and closed by
+* an event; the reconcile beat re-reads the level through RPC every
+* {@link RECONCILE_TICK_MS} and that read is what normally keeps or ends it. This
+* bound is for the case where the READ itself keeps failing — the device-state
+* door unreachable for hours — so that one lost falling edge can never pin a
+* camera for ever (D11). It counts from the last confirmation (the rise event,
+* or the last read that said `active`), never from the rise alone: a job that
+* genuinely lasts longer than this, with the level re-read every two minutes,
+* is never cut.
+*
+* Four hours: the longest whole-house clean-and-mop observed is under three,
+* and a device-state door down for four hours is an outage that has already
+* cost more than one recording.
+*/
+var SIGNAL_HOLD_MAX_MS = 4 * 36e5;
+/**
 * Bound on the ONE store read at the head of every placement and reconcile pass
 * (`enabledDeviceIds` → `readDeviceConfigs`).
 *
@@ -14121,6 +14214,18 @@ var RecordingController = class {
 	*  {@link TriggerState}. */
 	triggers = /* @__PURE__ */ new Map();
 	/**
+	* Per device, when the `recording-signal` hold was last CONFIRMED — by the
+	* rise event or by a reconcile read that said `active`. The clock
+	* {@link SIGNAL_HOLD_MAX_MS} counts from. Deleted with the hold.
+	*/
+	signalConfirmedAt = /* @__PURE__ */ new Map();
+	/**
+	* Per device, how many CONSECUTIVE reconcile reads have said `active: false`
+	* while a hold stood. Reset by any read that says `active` and by the rise
+	* event. Reaches {@link SIGNAL_RELEASE_READS} → the reconcile releases.
+	*/
+	signalContradictions = /* @__PURE__ */ new Map();
+	/**
 	* Last sign of life per `deviceId:profile` — seeded at attach (so the grace
 	* window starts at the pin, not at the first segment) and stamped on every
 	* finalize. Read by {@link checkIdleWriters}. Stamped BEFORE the keep/discard
@@ -14392,7 +14497,8 @@ var RecordingController = class {
 	async reconcileTriggerHistory(deviceId) {
 		const loadMotion = this.deps.loadMotionEvents;
 		const loadObject = this.deps.loadObjectEvents;
-		if (loadMotion === void 0 && loadObject === void 0 || this.stopped) return;
+		const loadSignal = this.deps.loadDeviceSignal;
+		if (loadMotion === void 0 && loadObject === void 0 && loadSignal === void 0 || this.stopped) return;
 		try {
 			const config = await this.deps.loadConfig(deviceId);
 			if (config.enabled !== true) return;
@@ -14410,6 +14516,10 @@ var RecordingController = class {
 			};
 			for (const source of bandTriggerSources(band)) {
 				if (this.stopped) return;
+				if (source.kind === "signal") {
+					if (loadSignal !== void 0) await this.reconcileSignalLevel(deviceId, source, postMs);
+					continue;
+				}
 				const rows = await durableRowsFor(source);
 				if (rows === null || rows.length === 0) continue;
 				if (this.stopped) return;
@@ -14442,6 +14552,164 @@ var RecordingController = class {
 		}
 	}
 	/**
+	* Compare the `recording-signal` HOLD with the slice the device publishes
+	* now, and correct the hold the way D49 allows: a read that raises the level
+	* is applied at once (footage is what is at stake); a read that lowers it is
+	* applied only when {@link SIGNAL_RELEASE_READS} consecutive reads agree; a
+	* read that fails changes nothing — except that a hold nobody has confirmed
+	* for {@link SIGNAL_HOLD_MAX_MS} is released anyway, and says so.
+	*
+	* Never throws: called from the head of the reconcile beat.
+	*/
+	async reconcileSignalLevel(deviceId, source, postMs) {
+		const load = this.deps.loadDeviceSignal;
+		if (load === void 0) return;
+		const nowMs = this.now();
+		const since = heldSinceMs(this.triggersFor(deviceId), source);
+		let level;
+		try {
+			level = await load(deviceId);
+		} catch (err) {
+			this.deps.logger.warn("recorder: device signal read failed — the hold stands", {
+				tags: { deviceId },
+				meta: {
+					held: since !== null,
+					error: require_dist.errMsg(err)
+				}
+			});
+			this.releaseIfHeldPastBound(deviceId, source, since, postMs, nowMs);
+			return;
+		}
+		if (this.stopped) return;
+		if (level?.active === true) {
+			this.signalConfirmedAt.set(deviceId, nowMs);
+			this.signalContradictions.delete(deviceId);
+			if (since !== null) return;
+			const rise = level.lastChangedAt > 0 ? Math.min(level.lastChangedAt, nowMs) : nowMs;
+			this.triggers.set(deviceId, holdTrigger(this.triggersFor(deviceId), source, rise));
+			this.deps.logger.info("recorder: device signal recovered from the slice — the bus had not delivered the rise", {
+				tags: { deviceId },
+				meta: {
+					since: rise,
+					lastChangedAt: level.lastChangedAt
+				}
+			});
+			return;
+		}
+		if (since === null) return;
+		const contradictions = (this.signalContradictions.get(deviceId) ?? 0) + 1;
+		if (contradictions < 2) {
+			this.signalContradictions.set(deviceId, contradictions);
+			this.deps.logger.debug("recorder: device signal read contradicts the hold — waiting for a second read to agree", {
+				tags: { deviceId },
+				meta: {
+					since,
+					reads: contradictions,
+					absent: level === null
+				}
+			});
+			return;
+		}
+		this.applySignalRelease(deviceId, source, nowMs, postMs);
+		this.deps.logger.info("recorder: device signal released by reconcile — two reads agreed the level is down", {
+			tags: { deviceId },
+			meta: {
+				since,
+				heldMs: nowMs - since,
+				absent: level === null
+			}
+		});
+	}
+	/** The bound on a hold the reads could not confirm. Warns, because it DROPS
+	*  the rest of an episode the operator may still want. */
+	releaseIfHeldPastBound(deviceId, source, since, postMs, nowMs) {
+		if (since === null) return;
+		const confirmedAt = this.signalConfirmedAt.get(deviceId) ?? since;
+		if (nowMs - confirmedAt <= 144e5) return;
+		this.applySignalRelease(deviceId, source, nowMs, postMs);
+		this.deps.logger.warn("recorder: device signal held past its bound with no read confirming it — released, the episode may be cut", {
+			tags: { deviceId },
+			meta: {
+				since,
+				confirmedAt,
+				heldMs: nowMs - since,
+				boundMs: SIGNAL_HOLD_MAX_MS
+			}
+		});
+	}
+	/** Lower the hold into a window and forget the per-device signal clocks. */
+	applySignalRelease(deviceId, source, atMs, postMs) {
+		const pruned = pruneTriggerHistory(this.triggersFor(deviceId), postMs, atMs);
+		this.triggers.set(deviceId, releaseTrigger(pruned, source, atMs, postMs));
+		this.signalConfirmedAt.delete(deviceId);
+		this.signalContradictions.delete(deviceId);
+	}
+	/**
+	* Feed the camera's own `recording-signal` LEVEL — the counterpart of
+	* `onTrigger` for `RecordingTriggers.deviceSignal`, fed from the
+	* `DeviceStateChanged` subscription in `recorder/addon/index.ts`.
+	*
+	* `active: true` HOLDS the source open (idempotent: a re-emitted slice never
+	* moves the rise); `active: false` releases it into a window ending at `atMs`,
+	* after which the band's `postBufferSec` runs and `evaluateDevice` arms the
+	* close exactly as it does for a motion episode. Both converge at once: the
+	* rise is what wakes a battery camera and pins its source (the robot's
+	* monitor opens through `battery.wakeForStream` on the attach), the fall is
+	* what lets the source be released and the monitor close.
+	*
+	* No config read on this path (D49): the hold is recorded unconditionally —
+	* it costs one map entry — and `evaluateDevice`, which reads the last-known
+	* config, decides whether any band listens. A camera whose bands do not name
+	* the signal simply never demands.
+	*/
+	async onSignalLevel(deviceId, source, active, atMs) {
+		if (this.stopped) return;
+		const before = this.triggersFor(deviceId);
+		if (active) {
+			const held = holdTrigger(before, source, atMs);
+			this.signalConfirmedAt.set(deviceId, this.now());
+			this.signalContradictions.delete(deviceId);
+			if (held !== before) {
+				this.triggers.set(deviceId, held);
+				this.deps.logger.info("recorder: device signal raised — recording window held open", {
+					tags: { deviceId },
+					meta: {
+						source: triggerKey(source),
+						atMs
+					}
+				});
+			}
+		} else {
+			const postMs = await this.postBufferMsFor(deviceId, atMs);
+			if (this.stopped) return;
+			const since = heldSinceMs(this.triggersFor(deviceId), source);
+			if (since === null) return;
+			this.applySignalRelease(deviceId, source, atMs, postMs);
+			this.deps.logger.info("recorder: device signal fell — post-buffer running, then the window closes", {
+				tags: { deviceId },
+				meta: {
+					source: triggerKey(source),
+					since,
+					atMs,
+					heldMs: atMs - since,
+					postMs
+				}
+			});
+		}
+		try {
+			await this.evaluateDevice(deviceId);
+		} catch (err) {
+			this.deps.logger.warn("recorder: device signal attach deferred — stream not available yet (retries on next broker ready/reconcile)", {
+				tags: { deviceId },
+				meta: {
+					source: triggerKey(source),
+					active,
+					error: require_dist.errMsg(err)
+				}
+			});
+		}
+	}
+	/**
 	* Re-evaluate one device after a config change (called from `setDeviceConfig`).
 	* Failures propagate so the caller can surface them, but the persisted config
 	* has already been written by the time this runs.
@@ -16544,6 +16812,13 @@ var RecorderV2Addon = class extends require_dist.BaseAddon {
 	*/
 	sensorTriggerUnsub = null;
 	/**
+	* Unsubscribe handle for the `DeviceStateChanged` subscription filtered on
+	* the camera's own `recording-signal` slice — the feed behind
+	* `RecordingTriggers.deviceSignal`. A LEVEL, so it has no edge memory of its
+	* own: the controller holds and releases (`onSignalLevel`).
+	*/
+	signalTriggerUnsub = null;
+	/**
 	* Edge memory + reverse index (source device → cameras) for the sensor
 	* trigger. Constructed once per addon instance: `startedAtMs` is the floor a
 	* first-sighting rise must beat, and a fresh instance per boot is exactly
@@ -16795,6 +17070,26 @@ var RecorderV2Addon = class extends require_dist.BaseAddon {
 					limit: TRIGGER_RECONCILE_ROW_LIMIT
 				})).filter((event) => (event.source ?? "pipeline") === "pipeline").map((event) => event.timestamp);
 			},
+			/**
+			* The DURABLE half of the DEVICE-SIGNAL source: the camera's own
+			* `recording-signal` slice, read back through the kernel's state door.
+			* `null` when the device has never written it; a slice that does not
+			* parse is a REJECTION, not a level — the reconcile must not read
+			* garbage as "down" and release on it.
+			*/
+			loadDeviceSignal: async (deviceId) => {
+				const slice = await this.ctx.api.deviceState.getCapSlice.query({
+					deviceId,
+					capName: require_dist.recordingSignalCapability.name
+				});
+				if (slice === null) return null;
+				const parsed = require_dist.RecordingSignalStatusSchema.safeParse(slice);
+				if (!parsed.success) throw new Error(`recording-signal slice for device ${deviceId} does not parse`);
+				return {
+					active: parsed.data.active,
+					lastChangedAt: parsed.data.lastChangedAt
+				};
+			},
 			locations: () => this.resolvedLocations,
 			placeProfile: (deviceId, profile) => this.placeProfile(deviceId, profile),
 			onPlacementTick: (deviceIds) => this.recomputePlacement(deviceIds),
@@ -17130,6 +17425,8 @@ var RecorderV2Addon = class extends require_dist.BaseAddon {
 		this.detectionTriggerUnsub = null;
 		this.sensorTriggerUnsub?.();
 		this.sensorTriggerUnsub = null;
+		this.signalTriggerUnsub?.();
+		this.signalTriggerUnsub = null;
 		await this.controller?.stop();
 		this.controller = null;
 		this.segmentStore = null;
@@ -17302,6 +17599,20 @@ var RecorderV2Addon = class extends require_dist.BaseAddon {
 				});
 			});
 		}
+		if (this.signalTriggerUnsub === null) this.signalTriggerUnsub = this.ctx.eventBus.subscribe({ category: require_dist.EventCategory.DeviceStateChanged }, (event) => {
+			const parsed = parseSensorStateChanged(event.data);
+			if (parsed === null || parsed.capName !== require_dist.recordingSignalCapability.name) return;
+			const level = require_dist.RecordingSignalStatusSchema.safeParse(parsed.slice);
+			if (!level.success) {
+				this.ctx.logger.warn("recorder: device signal slice does not parse — ignored", {
+					tags: { deviceId: parsed.deviceId },
+					meta: { slice: parsed.slice }
+				});
+				return;
+			}
+			const atMs = event.timestamp instanceof Date ? event.timestamp.getTime() : Date.now();
+			this.controller?.onSignalLevel(parsed.deviceId, { kind: "signal" }, level.data.active, atMs);
+		});
 		try {
 			await this.segmentHours?.load();
 			this.segmentHours?.repairAggregates();