@camstack/addon-pipeline 1.2.132 → 1.2.133

package/dist/recorder/index.mjs

@@ -1,4 +1,4 @@
-import { B as deriveRecordingMode, Dt as hydrateSchema, F as customAction, Gt as string, Ht as number, L as defineCustomActions, Lt as array, M as batteryCapability, Pt as selectAssignedProfileSlots, R as deriveBatteryPresence, Rt as boolean, St as BaseAddon, T as RecordingConfigSchema, Tt as DeviceType, Ut as object, Wt as record, at as recordingCapability, b as OpsLogEntrySchema, d as DEFAULT_EVENTS_BAND_BUFFER_SEC, ft as storageEvictableCapability, g as ExportRecordSchema, gt as errMsg, i as BatteryStatusSchema, jt as nodePin, m as EVENT_PAD_MS, ot as recordingExportCapability, qt as EventCategory, ut as resolveRecordingProfiles, w as RECORDING_EXPORT_MAX_READ_BYTES, wt as DeviceFeature } from "../dist-BZYUUBUx.mjs";
+import { At as hydrateSchema, Bt as array, Dt as DeviceFeature, E as RecordingConfigSchema, Gt as number, I as customAction, Jt as string, K as evaluateSensorEdge, Kt as object, Lt as selectAssignedProfileSlots, N as batteryCapability, Ot as DeviceType, Pt as nodePin, R as defineCustomActions, T as RECORDING_EXPORT_MAX_READ_BYTES, Tt as BaseAddon, V as deriveRecordingMode, Vt as boolean, X as isFirstLevelMacroClass, Xt as EventCategory, _ as ExportRecordSchema, ct as recordingCapability, d as DEFAULT_EVENTS_BAND_BUFFER_SEC, h as EVENT_PAD_MS, ht as storageEvictableCapability, i as BatteryStatusSchema, lt as recordingExportCapability, pt as resolveRecordingProfiles, qt as record, x as OpsLogEntrySchema, yt as errMsg, z as deriveBatteryPresence } from "../dist-7Uc6NdFm.mjs";
 import { t as resolveHubHostname } from "../hub-hostname-cCknRYKj.mjs";
 import { r as withRecordingIntent } from "../restream-intent-B4BXZra7.mjs";
 import { n as createFileDataPlaneHandler, s as parseRangeHeader, t as contentTypeFor } from "../addon-utils-CgBCF-mE.mjs";
@@ -32,6 +32,185 @@ function subscribeEventCapture(deps) {
 	});
 }
 //#endregion
+//#region src/recorder/object-trigger.ts
+/**
+* Il gate fra `pipeline-analytics.detection-event` e "apri una finestra di
+* registrazione".
+*
+* Fratello di `recorder/event-capture.ts` e per lo stesso motivo: la qualifica
+* ha dei rami, e un ramo che scarta lavoro senza dirlo è indistinguibile da una
+* funzione mai cablata. Ogni verdetto negativo NOMINA il motivo, e il chiamante
+* lo logga.
+*
+* Puro: nessun bus, nessun orologio, nessuna config. La scelta di QUALI classi
+* ascoltare è della banda (`bandTriggerSources`); qui si decide solo se
+* l'evento è una detection utilizzabile e di che macro classe è.
+*/
+/** Type guard, non cast: `event.data` è `unknown` finché non passa di qui. */
+function isDetectionEventData(value) {
+	if (typeof value !== "object" || value === null) return false;
+	if (!("deviceId" in value) || typeof value.deviceId !== "number") return false;
+	if (!("kind" in value) || typeof value.kind !== "string") return false;
+	if (!("timestamp" in value) || typeof value.timestamp !== "number") return false;
+	if (!Number.isFinite(value.timestamp) || value.timestamp <= 0) return false;
+	if (!("className" in value) || typeof value.className !== "string") return false;
+	if ("source" in value && value.source !== void 0 && typeof value.source !== "string") return false;
+	return true;
+}
+function qualifyObjectTrigger(data) {
+	if (!isDetectionEventData(data)) return {
+		qualified: false,
+		reason: "malformed"
+	};
+	if (data.kind !== "object") return {
+		qualified: false,
+		reason: "not-object"
+	};
+	if ((data.source ?? "pipeline") !== "pipeline") return {
+		qualified: false,
+		reason: "not-pipeline"
+	};
+	const className = data.className.trim().toLowerCase();
+	if (!isFirstLevelMacroClass(className)) return {
+		qualified: false,
+		reason: "not-a-macro"
+	};
+	return {
+		qualified: true,
+		deviceId: data.deviceId,
+		macroClass: className,
+		atMs: data.timestamp
+	};
+}
+//#endregion
+//#region src/recorder/sensor-trigger.ts
+/**
+* Da `DeviceStateChanged` a "quali camere devono registrare".
+*
+* Due responsabilità, entrambe in RAM e nessuna durevole:
+*  - la MEMORIA del fronte, per `(deviceId, capName)`, che rende `false→true`
+*    distinguibile da una ri-emissione. Il predicato è `evaluateSensorEdge`
+*    (`@camstack/types`) — la stessa tabella `SOURCE_CAP_ACTIVE_FIELD` del
+*    virtual-doorbell, non una copia;
+*  - l'INDICE INVERSO sorgente→camere, uno stato rispecchiato aggiornato FUORI
+*    dal percorso dell'evento (D49): `setBindings` è chiamato al boot dalle
+*    config già lette e a ogni `onConfigChanged`, che è un'RPC. Una lettura
+*    fallibile sul percorso del trigger potrebbe rispondere "nessuno ascolta"
+*    e perdere l'episodio, che è il fallimento contro cui D49 è scritta.
+*
+* L'ordine dei controlli è deliberato: `DeviceStateChanged` viaggia a ritmo di
+* bus su tutta la flotta (batteria, la `motion` nativa di ogni camera, la
+* connettività). L'indice inverso è una `Map.get` senza allocazioni e va per
+* primo; il fronte — che legge due tabelle e la slice — viene dopo. È la stessa
+* scelta che post-analysis scrive per la sua sottoscrizione: *"the
+* EVENT_KIND_BY_CAP gate runs FIRST so non-sensor cap churn exits before any
+* async work"*.
+*
+* Puro rispetto al mondo: nessun bus, nessun logger, nessun orologio proprio.
+* Il chiamante logga il verdetto — un ramo che non accende nulla lo DICE.
+*/
+/**
+* Type GUARD, not a cast: `event.data` is `unknown`, and a version-skewed
+* emitter must leave this router untouched rather than route a `deviceId` of
+* `undefined`. Same discipline as `parseTopologySnapshotNodes`.
+*
+* A missing or non-object `slice` is REFUSED rather than defaulted to `{}`:
+* `evaluateSensorEdge` would read `non-boolean-value` from an empty object and
+* that would look like a sensor reporting nonsense, when what actually
+* happened is that there was nothing to read.
+*/
+function parseSensorStateChanged(data) {
+	if (typeof data !== "object" || data === null) return null;
+	if (!("deviceId" in data) || typeof data.deviceId !== "number") return null;
+	if (!("capName" in data) || typeof data.capName !== "string") return null;
+	if (!("slice" in data) || typeof data.slice !== "object" || data.slice === null) return null;
+	const slice = { ...data.slice };
+	return {
+		deviceId: data.deviceId,
+		capName: data.capName,
+		slice
+	};
+}
+/**
+* sourceDeviceId → cameras whose config names it.
+*
+* From EVERY band, not only the one active now: the index only changes on a
+* config write, while the active band changes with the clock, and an index
+* that followed the clock would lose the first trigger after every band edge.
+* Filtering by band is already the gate's job — `bandTriggerSources` reads the
+* band active at the instant of evaluation.
+*
+* A disabled camera is skipped: it records nothing whatever a sensor does, and
+* it re-enters through `onConfigChanged`, which rebuilds this.
+*/
+function buildSensorTriggerBindings(configs) {
+	const index = /* @__PURE__ */ new Map();
+	for (const [cameraId, config] of configs) {
+		if (config.enabled !== true) continue;
+		for (const band of config.bands ?? []) for (const sourceDeviceId of band.triggers?.sensorDeviceIds ?? []) {
+			const cameras = index.get(sourceDeviceId) ?? /* @__PURE__ */ new Set();
+			cameras.add(cameraId);
+			index.set(sourceDeviceId, cameras);
+		}
+	}
+	return index;
+}
+var SensorTriggerRouter = class {
+	/** sourceDeviceId → camere la cui config lo nomina. */
+	bindings = /* @__PURE__ */ new Map();
+	/** Ultimo booleano osservato, per `${deviceId}:${capName}`. */
+	lastValues = /* @__PURE__ */ new Map();
+	now;
+	startedAtMs;
+	freshnessMs;
+	constructor(options) {
+		this.now = options.now;
+		this.startedAtMs = options.startedAtMs;
+		this.freshnessMs = options.firstSightingFreshnessMs ?? 3e4;
+	}
+	/**
+	* Sostituisce l'indice inverso. NON tocca `lastValues`: un sensore tolto e
+	* rimesso in una banda deve ritrovare il suo livello precedente, altrimenti
+	* la prima slice dopo il rientro sarebbe una "prima osservazione" e un
+	* contatto rimasto aperto tutto il tempo diventerebbe un fronte alto.
+	*/
+	setBindings(bindings) {
+		this.bindings = bindings;
+	}
+	/** Quali sorgenti l'indice contiene ora — per la riga di log al boot. */
+	listenedSourceIds() {
+		return [...this.bindings.keys()];
+	}
+	onStateSlice(deviceId, capName, slice) {
+		const cameras = this.bindings.get(deviceId);
+		if (cameras === void 0 || cameras.size === 0) return {
+			fired: [],
+			skipped: "not-listened"
+		};
+		const key = `${deviceId}:${capName}`;
+		const verdict = evaluateSensorEdge({
+			capName,
+			slice,
+			prior: this.lastValues.get(key),
+			startedAtMs: this.startedAtMs,
+			nowMs: this.now(),
+			firstSightingFreshnessMs: this.freshnessMs
+		});
+		if (verdict.edge === "none") {
+			if (verdict.value !== null) this.lastValues.set(key, verdict.value);
+			return {
+				fired: [],
+				skipped: verdict.reason
+			};
+		}
+		this.lastValues.set(key, true);
+		return {
+			fired: [...cameras],
+			skipped: null
+		};
+	}
+};
+//#endregion
 //#region src/recorder/event-map.ts
 var EventMap = class {
 	byDevice = /* @__PURE__ */ new Map();
@@ -7741,17 +7920,47 @@ function eventsBandCanEverDemand(band) {
 	return bandTriggerSources(band).length > 0 && resolveBandBufferMs(band).postMs > 0;
 }
 /**
+* La chiave sotto cui una sorgente conserva le sue finestre. È anche la stringa
+* che compare nei log — quattro sorgenti che aprono la stessa finestra senza
+* dire chi è stato rendono impossibile rispondere a "perché questa camera
+* registra tanto" — quindi è leggibile per progetto.
+*/
+function triggerKey(source) {
+	switch (source.kind) {
+		case "motion": return "motion";
+		case "audio": return "audio";
+		case "object": return `object:${source.macroClass}`;
+		case "sensor": return `sensor:${source.sourceDeviceId}`;
+	}
+}
+/**
 * LE sorgenti che questa banda ascolta — l'unico posto dove i `triggers` di
-* una banda diventano `TriggerSource[]`. `eventsBandCanEverDemand` e
-* `RecordingController.reportUnrecordable` lo leggono invece di ripetere
-* l'if-ladder motion/audio a mano.
+* una banda diventano `TriggerSource[]`.
+*
+* Prima erano CINQUE copie dello stesso if-ladder motion/audio
+* (`eventsBandCanEverDemand`, `eventsBandDemanded`, `segmentRetainedForEvents`,
+* `segmentMissedByMs`, `eventsWindowCloseMs`), che con quattro sorgenti
+* sarebbero diventate cinque scale a quattro rami. `RecordingController`
+* (`reportUnrecordable`, la riconciliazione durevole) legge la stessa lista.
+*
+* Una chiave in {@link UNFED_TRIGGER_KEYS} non produce sorgenti: la banda che
+* ascolta solo quella "non può mai chiedere", ed è così che il recorder la
+* denuncia invece di restare zitto.
 */
 function bandTriggerSources(band) {
 	const t = band.triggers;
 	if (t === void 0) return [];
 	const sources = [];
-	if (t.motion === true) sources.push("motion");
-	if (t.audioThresholdDbfs !== void 0) sources.push("audio");
+	if (t.motion === true) sources.push({ kind: "motion" });
+	if (t.audioThresholdDbfs !== void 0) sources.push({ kind: "audio" });
+	for (const macroClass of t.objectClasses ?? []) sources.push({
+		kind: "object",
+		macroClass
+	});
+	for (const sourceDeviceId of t.sensorDeviceIds ?? []) sources.push({
+		kind: "sensor",
+		sourceDeviceId
+	});
 	return sources;
 }
 /**
@@ -7780,10 +7989,7 @@ function audioLevelQualifies(band, dbfs) {
 	return threshold !== void 0 && dbfs >= threshold;
 }
 /** No trigger has been seen for this device yet. */
-var EMPTY_TRIGGER_STATE = {
-	motion: [],
-	audio: []
-};
+var EMPTY_TRIGGER_STATE = { windows: /* @__PURE__ */ new Map() };
 /**
 * How long a window is retained PAST the end of its own keep span
 * (`lastMs + postBufferSec`).
@@ -7795,18 +8001,21 @@ var EMPTY_TRIGGER_STATE = {
 * room to spare, while bounding a busy camera to a handful of windows.
 */
 var TRIGGER_HISTORY_MARGIN_MS = 12e4;
-/** The windows for a source, in the order they opened. */
-function windowsFor(state, source) {
-	return source === "motion" ? state.motion : state.audio;
-}
+/** The windows for a source, in the order they opened. Empty when the source
+*  has never fired — an absent key and a source with no history are the same
+*  fact, and only one of them is ever stored. */
+function triggerWindowsFor(state, source) {
+	return state.windows.get(triggerKey(source)) ?? [];
+}
+/** Replace one source's windows. An EMPTY list deletes the key rather than
+*  storing a zero-length array: that is what bounds the map when an operator
+*  removes a sensor from a band. */
 function withWindows(state, source, windows) {
-	return source === "motion" ? {
-		...state,
-		motion: windows
-	} : {
-		...state,
-		audio: windows
-	};
+	const next = new Map(state.windows);
+	const key = triggerKey(source);
+	if (windows.length === 0) next.delete(key);
+	else next.set(key, windows);
+	return { windows: next };
 }
 /**
 * Fold one qualifying trigger into the history, immutably. It EXTENDS the newest
@@ -7818,7 +8027,7 @@ function withWindows(state, source, windows) {
 * predates the episode, so the keep span can only ever grow.
 */
 function recordTrigger(state, source, atMs, mergeGapMs) {
-	const windows = windowsFor(state, source);
+	const windows = triggerWindowsFor(state, source);
 	const newest = windows[windows.length - 1];
 	const merged = newest !== void 0 && atMs - newest.lastMs <= mergeGapMs && atMs >= newest.firstMs - mergeGapMs ? [...windows.slice(0, -1), {
 		firstMs: Math.min(newest.firstMs, atMs),
@@ -7841,18 +8050,18 @@ function recordTrigger(state, source, atMs, mergeGapMs) {
 */
 function pruneTriggerHistory(state, postMs, nowMs) {
 	const cutoffMs = nowMs - postMs - TRIGGER_HISTORY_MARGIN_MS;
-	const live = (w) => w.lastMs >= cutoffMs;
-	const motion = state.motion.filter(live);
-	const audio = state.audio.filter(live);
-	if (motion.length === state.motion.length && audio.length === state.audio.length) return state;
-	return {
-		motion,
-		audio
-	};
+	const next = /* @__PURE__ */ new Map();
+	let changed = false;
+	for (const [key, windows] of state.windows) {
+		const live = windows.filter((w) => w.lastMs >= cutoffMs);
+		if (live.length !== windows.length) changed = true;
+		if (live.length > 0) next.set(key, live);
+	}
+	return changed ? { windows: next } : state;
 }
 /** Most recent trigger for a source, or null when none is retained. */
 function latestTriggerMs(state, source) {
-	const windows = windowsFor(state, source);
+	const windows = triggerWindowsFor(state, source);
 	return windows[windows.length - 1]?.lastMs ?? null;
 }
 /**
@@ -7862,10 +8071,10 @@ function latestTriggerMs(state, source) {
 */
 function eventsBandDemanded(band, triggers, atMs) {
 	const { postMs } = resolveBandBufferMs(band);
-	const fresh = (lastMs) => lastMs != null && atMs - lastMs <= postMs;
-	if (band.triggers?.motion && fresh(latestTriggerMs(triggers, "motion"))) return true;
-	if (band.triggers?.audioThresholdDbfs != null && fresh(latestTriggerMs(triggers, "audio"))) return true;
-	return false;
+	return bandTriggerSources(band).some((source) => {
+		const lastMs = latestTriggerMs(triggers, source);
+		return lastMs !== null && atMs - lastMs <= postMs;
+	});
 }
 /**
 * Should recording (any mode) be active for this device at `at`? The live
@@ -7936,9 +8145,7 @@ function segmentRetainedForEvents(segStartMs, segEndMs, band, triggers, attach)
 		if (segStartMs <= window.lastMs + postMs) return true;
 		return attach.attachedAtMs <= window.lastMs + postMs && segStartMs <= deadlineMs;
 	};
-	if (band.triggers?.motion && triggers.motion.some(overlaps)) return true;
-	if (band.triggers?.audioThresholdDbfs != null && triggers.audio.some(overlaps)) return true;
-	return false;
+	return bandTriggerSources(band).some((source) => triggerWindowsFor(triggers, source).some(overlaps));
 }
 /**
 * By how many ms a discarded segment missed being kept — its start past the
@@ -7960,7 +8167,7 @@ function segmentMissedByMs(segStartMs, band, triggers, attach) {
 		const windowEndMs = window.lastMs + postMs;
 		return attach.attachedAtMs <= windowEndMs ? Math.max(windowEndMs, deadlineMs) : windowEndMs;
 	};
-	const considered = [...band.triggers?.motion === true ? triggers.motion : [], ...band.triggers?.audioThresholdDbfs != null ? triggers.audio : []];
+	const considered = bandTriggerSources(band).flatMap((source) => [...triggerWindowsFor(triggers, source)]);
 	if (considered.length === 0) return null;
 	return segStartMs - Math.max(...considered.map(latestKeptStart));
 }
@@ -7994,10 +8201,10 @@ function foldDurableTriggers(state, source, timestamps, mergeGapMs) {
 	let recovered = 0;
 	let evicted = 0;
 	for (const atMs of rows) {
-		const before = windowsFor(next, source);
+		const before = triggerWindowsFor(next, source);
 		const folded = recordTrigger(next, source, atMs, mergeGapMs);
 		evicted += folded.evicted;
-		const after = windowsFor(folded.state, source);
+		const after = triggerWindowsFor(folded.state, source);
 		if (folded.evicted > 0 || after.length !== before.length || after.some((w, i) => w.firstMs !== before[i]?.firstMs || w.lastMs !== before[i]?.lastMs)) recovered++;
 		next = folded.state;
 	}
@@ -8144,12 +8351,7 @@ function nextBandEdgeMs(config, nowMs) {
 function eventsWindowCloseMs(band, triggers, nowMs) {
 	if (band.mode !== "events") return null;
 	const { postMs } = resolveBandBufferMs(band);
-	const ends = [];
-	const motionMs = latestTriggerMs(triggers, "motion");
-	const audioMs = latestTriggerMs(triggers, "audio");
-	if (band.triggers?.motion === true && motionMs != null) ends.push(motionMs + postMs);
-	if (band.triggers?.audioThresholdDbfs != null && audioMs != null) ends.push(audioMs + postMs);
-	const open = ends.filter((ms) => ms >= nowMs);
+	const open = bandTriggerSources(band).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;
 }
@@ -9415,44 +9617,78 @@ var RecordingController = class {
 	* of it is discarded and the footage is gone for ever — durable state resting
 	* on telemetry, which D8/D11 forbid.
 	*
-	* Motion only. Audio triggers have no durable counterpart the recorder can
-	* ask for at the same granularity, and a reconcile that silently covered one
-	* source and not the other would read as covering both.
+	* ## Which sources it covers, and which it does NOT
+	*
+	* MOTION and OBJECT-DETECTION. Both have a durable counterpart at the same
+	* granularity the bus carries — `pipelineAnalytics.getMotionEvents` and
+	* `getObjectEvents` — so a dropped event is recoverable from rows.
+	*
+	* AUDIO and SENSOR are NOT covered, and that is a stated gap, not an
+	* oversight:
+	*  - audio has no per-window durable row the recorder can ask for;
+	*  - `SensorEvent` rows exist but are LEVEL, not EDGE (a contact closing
+	*    writes a row exactly like one opening), and they carry the taxonomy
+	*    `kind`, not the `capName` that `SOURCE_CAP_ACTIVE_FIELD` is indexed by.
+	*    The inversion was MEASURED on 2026-08-27 rather than eyeballed:
+	*    `CAP_TO_KIND` (`types/capabilities/sensor-event-kinds.ts`) has no two
+	*    caps sharing a kind, so `kind → capName` is invertible — but `binary`,
+	*    a source cap, has NO entry in it at all, so a `binary` sensor's edges
+	*    never reach the `SensorEvent` table and could never be recovered. A
+	*    reconcile covering nine source caps out of ten reads as covering all
+	*    ten, which is the failure this whole comment exists to avoid.
+	*
+	* A reconcile that silently covered some sources and not others would read as
+	* covering all of them, so it is named here and the un-covered sources are
+	* simply skipped — never faked.
 	*
 	* Never throws: this runs at the head of the reconcile beat and an escape
 	* here would cancel the evaluate for the whole device.
 	*/
 	async reconcileTriggerHistory(deviceId) {
-		const load = this.deps.loadMotionEvents;
-		if (load === void 0 || this.stopped) return;
+		const loadMotion = this.deps.loadMotionEvents;
+		const loadObject = this.deps.loadObjectEvents;
+		if (loadMotion === void 0 && loadObject === void 0 || this.stopped) return;
 		try {
 			const config = await this.deps.loadConfig(deviceId);
 			if (config.enabled !== true) return;
 			const nowMs = this.now();
 			const band = activeBandAt({ bands: config.bands ?? [] }, new Date(nowMs));
-			if (!band || band.mode !== "events" || band.triggers?.motion !== true) return;
+			if (!band || band.mode !== "events") return;
 			const { postMs } = resolveBandBufferMs(band);
 			const sinceMs = nowMs - postMs - TRIGGER_HISTORY_MARGIN_MS;
-			const rows = await load(deviceId, sinceMs, nowMs);
-			if (this.stopped || rows.length === 0) return;
-			const folded = foldDurableTriggers(pruneTriggerHistory(this.triggersFor(deviceId), postMs, this.now()), "motion", rows, postMs);
-			this.triggers.set(deviceId, folded.state);
-			if (folded.recovered > 0) this.deps.logger.info("recorder: trigger windows recovered from the durable rows — the bus had not delivered them", {
-				tags: { deviceId },
-				meta: {
-					rows: rows.length,
-					recovered: folded.recovered,
-					sinceMs,
-					postMs
-				}
-			});
-			if (folded.evicted > 0) this.deps.logger.warn("recorder: trigger history full during reconcile — oldest window(s) evicted", {
-				tags: { deviceId },
-				meta: {
-					evicted: folded.evicted,
-					maxWindows: 32
-				}
-			});
+			/** Durable rows for one source, or null when that source has no durable
+			*  half (audio, sensor) or its loader was not injected. */
+			const durableRowsFor = async (source) => {
+				if (source.kind === "motion") return loadMotion === void 0 ? null : await loadMotion(deviceId, sinceMs, nowMs);
+				if (source.kind === "object") return loadObject === void 0 ? null : await loadObject(deviceId, source.macroClass, sinceMs, nowMs);
+				return null;
+			};
+			for (const source of bandTriggerSources(band)) {
+				if (this.stopped) return;
+				const rows = await durableRowsFor(source);
+				if (rows === null || rows.length === 0) continue;
+				if (this.stopped) return;
+				const folded = foldDurableTriggers(pruneTriggerHistory(this.triggersFor(deviceId), postMs, this.now()), source, rows, postMs);
+				this.triggers.set(deviceId, folded.state);
+				if (folded.recovered > 0) this.deps.logger.info("recorder: trigger windows recovered from the durable rows — the bus had not delivered them", {
+					tags: { deviceId },
+					meta: {
+						source: triggerKey(source),
+						rows: rows.length,
+						recovered: folded.recovered,
+						sinceMs,
+						postMs
+					}
+				});
+				if (folded.evicted > 0) this.deps.logger.warn("recorder: trigger history full during reconcile — oldest window(s) evicted", {
+					tags: { deviceId },
+					meta: {
+						source: triggerKey(source),
+						evicted: folded.evicted,
+						maxWindows: 32
+					}
+				});
+			}
 		} catch (err) {
 			this.deps.logger.warn("recorder: trigger reconcile failed — retries on the next beat", {
 				tags: { deviceId },
@@ -9619,7 +9855,7 @@ var RecordingController = class {
 		if (receivedLagMs > TRIGGER_LAG_WARN_MS) this.deps.logger.warn("recorder: trigger arrived late — part of its window is already spent", {
 			tags: { deviceId },
 			meta: {
-				source,
+				source: triggerKey(source),
 				atMs,
 				receivedLagMs
 			}
@@ -9632,7 +9868,7 @@ var RecordingController = class {
 			this.deps.logger.warn("recorder: trigger attach deferred — stream not available yet (retries on next broker ready/reconcile)", {
 				tags: { deviceId },
 				meta: {
-					source,
+					source: triggerKey(source),
 					atMs,
 					error: errMsg(err)
 				}
@@ -9674,7 +9910,7 @@ var RecordingController = class {
 			return;
 		}
 		if (!audioLevelQualifies(band, dbfs)) return;
-		await this.onTrigger(deviceId, "audio", atMs);
+		await this.onTrigger(deviceId, { kind: "audio" }, atMs);
 	}
 	/**
 	* The post-buffer that governs this device's trigger history right now: it is
@@ -9710,7 +9946,7 @@ var RecordingController = class {
 		if (evicted > 0) this.deps.logger.warn("recorder: trigger history full — oldest window(s) evicted, their footage may be discarded", {
 			tags: { deviceId },
 			meta: {
-				source,
+				source: triggerKey(source),
 				atMs,
 				postMs,
 				evicted,
@@ -10155,14 +10391,10 @@ var RecordingController = class {
 			profile,
 			startMs,
 			durMs,
-			motionWindows: triggers.motion.map((w) => ({
-				firstMs: w.firstMs,
-				lastMs: w.lastMs
-			})),
-			audioWindows: triggers.audio.map((w) => ({
+			triggerWindows: Object.fromEntries(bandTriggerSources(band).map((source) => [triggerKey(source), triggerWindowsFor(triggers, source).map((w) => ({
 				firstMs: w.firstMs,
 				lastMs: w.lastMs
-			})),
+			}))])),
 			postMs,
 			preMs,
 			attachedAtMs: attach.attachedAtMs,
@@ -11853,6 +12085,28 @@ var RecorderV2Addon = class extends BaseAddon {
 	* down the same way, idempotent re-entry included.
 	*/
 	audioTriggerUnsub = null;
+	/**
+	* Unsubscribe handle for the `PipelineAnalyticsDetectionEvent` subscription —
+	* the feed behind `RecordingTriggers.objectClasses` (Traccia A of the same
+	* plan). Same guard/teardown discipline as the two above.
+	*/
+	detectionTriggerUnsub = null;
+	/**
+	* Unsubscribe handle for the `DeviceStateChanged` subscription — the feed
+	* behind `RecordingTriggers.sensorDeviceIds` (Traccia B).
+	*/
+	sensorTriggerUnsub = 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
+	* what makes a runner respawn err towards silence rather than record 30 s
+	* per camera on every hydrated contact.
+	*/
+	sensorRouter = new SensorTriggerRouter({
+		now: () => Date.now(),
+		startedAtMs: Date.now()
+	});
 	/** Resolved recordings locations (id + root). Refreshed on boot + rescan.
 	*  Already ALIAS-GUARDED: a writable same-type duplicate of another
 	*  location's physical root arrives here demoted to read-only. */
@@ -12068,6 +12322,29 @@ var RecorderV2Addon = class extends BaseAddon {
 					projection: "slim"
 				})).map((event) => event.timestamp);
 			},
+			/**
+			* The DURABLE half of the OBJECT source. Same shape as `loadMotionEvents`
+			* — SQLite rows instead of a broadcast, one call per macro class because
+			* `TriggerState` keys per class and the store filters server-side.
+			*
+			* `projection: 'full'` and NOT `'slim'`, deliberately: `SLIM_OBJECT_COLUMNS`
+			* (`addon-post-analysis/.../store/event-store.ts`) does not carry `source`,
+			* and the filter below reads an absent `source` as `pipeline` — so a slim
+			* read would fold ONBOARD rows, re-opening from SQL exactly the windows
+			* `qualifyObjectTrigger` refuses on the live path. Two truths about one
+			* detection, which is what this whole track exists to avoid. The extra
+			* cost is bounded: only bands that actually list `objectClasses` reach
+			* here, `classFilter` narrows to one class, and `limit` caps the rows.
+			*/
+			loadObjectEvents: async (deviceId, macroClass, sinceMs, untilMs) => {
+				return (await this.ctx.api.pipelineAnalytics.getObjectEvents.query({
+					deviceId,
+					since: sinceMs,
+					until: untilMs,
+					classFilter: macroClass,
+					limit: TRIGGER_RECONCILE_ROW_LIMIT
+				})).filter((event) => (event.source ?? "pipeline") === "pipeline").map((event) => event.timestamp);
+			},
 			locations: () => this.resolvedLocations,
 			placeProfile: (deviceId, profile) => this.placeProfile(deviceId, profile),
 			onPlacementTick: (deviceIds) => this.recomputePlacement(deviceIds),
@@ -12135,7 +12412,10 @@ var RecorderV2Addon = class extends BaseAddon {
 			calendar: this.calendar,
 			mfraFor: (deviceId, profile, startMs) => this.mfraTables.get(deviceId, profile, startMs),
 			hydrateWindow: (deviceId, fromMs, toMs) => hydrateWindowFromStorage(this.index, deviceId, fromMs, toMs, this.resolvedLocations, this.ctx.logger),
-			onConfigChanged: (deviceId) => this.controller?.onConfigChanged(deviceId) ?? Promise.resolve(),
+			onConfigChanged: async (deviceId) => {
+				await this.refreshSensorTriggerBindings();
+				await (this.controller?.onConfigChanged(deviceId) ?? Promise.resolve());
+			},
 			pauseForStorageMigration: (leaseId) => this.pauseForStorageMigration(leaseId),
 			resumeForStorageMigration: (leaseId) => this.resumeForStorageMigration(leaseId),
 			refreshStorageLocationsForMigration: (leaseId) => this.refreshStorageLocationsForMigration(leaseId),
@@ -12326,6 +12606,10 @@ var RecorderV2Addon = class extends BaseAddon {
 		this.eventUnsub = null;
 		this.audioTriggerUnsub?.();
 		this.audioTriggerUnsub = null;
+		this.detectionTriggerUnsub?.();
+		this.detectionTriggerUnsub = null;
+		this.sensorTriggerUnsub?.();
+		this.sensorTriggerUnsub = null;
 		await this.controller?.stop();
 		this.controller = null;
 		this.segmentStore = null;
@@ -12397,7 +12681,7 @@ var RecorderV2Addon = class extends BaseAddon {
 			padPreMs: MARKER_PAD_PRE_MS,
 			padPostMs: MARKER_PAD_POST_MS,
 			onMotion: (deviceId, atMs) => {
-				this.controller?.onTrigger(deviceId, "motion", atMs);
+				this.controller?.onTrigger(deviceId, { kind: "motion" }, atMs);
 			}
 		});
 		if (this.audioTriggerUnsub === null) this.audioTriggerUnsub = this.ctx.eventBus.subscribe({ category: EventCategory.PipelineAudioInferenceResult }, (event) => {
@@ -12405,6 +12689,48 @@ var RecorderV2Addon = class extends BaseAddon {
 			if (dbfs === void 0) return;
 			this.controller?.onAudioLevel(event.data.deviceId, dbfs, event.data.frame.timestamp);
 		});
+		if (this.detectionTriggerUnsub === null) this.detectionTriggerUnsub = this.ctx.eventBus.subscribe({ category: EventCategory.PipelineAnalyticsDetectionEvent }, (event) => {
+			const verdict = qualifyObjectTrigger(event.data);
+			if (!verdict.qualified) {
+				this.ctx.logger.debug("recorder: detection event did not qualify as a trigger", { meta: { reason: verdict.reason } });
+				return;
+			}
+			this.controller?.onTrigger(verdict.deviceId, {
+				kind: "object",
+				macroClass: verdict.macroClass
+			}, verdict.atMs);
+		});
+		if (this.sensorTriggerUnsub === null) {
+			await this.refreshSensorTriggerBindings();
+			this.sensorTriggerUnsub = this.ctx.eventBus.subscribe({ category: EventCategory.DeviceStateChanged }, (event) => {
+				const parsed = parseSensorStateChanged(event.data);
+				if (parsed === null) return;
+				const atMs = event.timestamp instanceof Date ? event.timestamp.getTime() : Date.now();
+				const result = this.sensorRouter.onStateSlice(parsed.deviceId, parsed.capName, parsed.slice);
+				for (const cameraId of result.fired) {
+					this.ctx.logger.info("recorder: sensor rising edge opened a recording window", {
+						tags: { deviceId: cameraId },
+						meta: {
+							sourceDeviceId: parsed.deviceId,
+							capName: parsed.capName
+						}
+					});
+					this.controller?.onTrigger(cameraId, {
+						kind: "sensor",
+						sourceDeviceId: parsed.deviceId
+					}, atMs);
+				}
+				if (result.skipped === null || result.skipped === "not-listened") return;
+				const level = result.skipped === "baseline-seeded-stale-active" ? "warn" : "debug";
+				this.ctx.logger[level]("recorder: sensor state change opened no window", {
+					tags: { deviceId: parsed.deviceId },
+					meta: {
+						capName: parsed.capName,
+						reason: result.skipped
+					}
+				});
+			});
+		}
 		try {
 			await this.segmentHours?.load();
 			this.segmentHours?.hydrateIndex(this.index);
@@ -12418,6 +12744,7 @@ var RecorderV2Addon = class extends BaseAddon {
 			this.ctx.logger.warn("recorder: reading persisted device configs failed — skipping hydrate", { meta: { error: errMsg(err) } });
 			return;
 		}
+		this.applySensorTriggerBindings(configs);
 		this.warmToday([...configs.keys()]);
 		this.ctx.logger.info("recorder: full-archive index walk skipped", { meta: {
 			reason: "on-demand-windows",
@@ -12436,6 +12763,39 @@ var RecorderV2Addon = class extends BaseAddon {
 		this.retentionSweeper?.start();
 	}
 	/**
+	* Rebuild the sensor trigger's reverse index from the persisted configs.
+	*
+	* D49: this is a MIRROR refreshed off the event path — at boot and on every
+	* config write (an RPC that cannot be dropped), never from a fallible read
+	* while a `DeviceStateChanged` is being routed.
+	*
+	* A failed read leaves the PREVIOUS index standing and says so. An index that
+	* emptied itself on a transient store failure would answer "nobody listens"
+	* to every sensor edge until the next config write — silently, and that is
+	* precisely the "a read that fails changes nothing" half of D49.
+	*/
+	async refreshSensorTriggerBindings() {
+		try {
+			this.applySensorTriggerBindings(await readDeviceConfigs(this.configStore()));
+		} catch (err) {
+			this.ctx.logger.warn("recorder: sensor trigger index NOT refreshed — config read failed, the previous index stands", { meta: { error: errMsg(err) } });
+		}
+	}
+	/** Apply an already-read config map to the sensor index. Logs only when the
+	*  set of listened sources CHANGED — a config write that touches something
+	*  else must not print a line that reads as a rewiring. */
+	applySensorTriggerBindings(configs) {
+		const before = [...this.sensorRouter.listenedSourceIds()].toSorted((a, b) => a - b);
+		const bindings = buildSensorTriggerBindings(configs);
+		this.sensorRouter.setBindings(bindings);
+		const after = [...bindings.keys()].toSorted((a, b) => a - b);
+		if (before.length === after.length && before.every((id, i) => id === after[i])) return;
+		this.ctx.logger.info("recorder: sensor trigger index rebuilt", { meta: {
+			sourceDeviceIds: after,
+			cameras: configs.size
+		} });
+	}
+	/**
 	* Resume interrupted exports and arm the expiry sweep.
 	*
 	* The resume itself lives in `export-reconcile.ts` — pure, tested, and loud