@camstack/addon-post-analysis 1.2.181 → 1.2.182

package/dist/pipeline-analytics/index.js

@@ -2,7 +2,7 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-const require_dist = require("../dist-BB70nZUm.js");
+const require_dist = require("../dist-_fedHYU3.js");
 let node_fs = require("node:fs");
 node_fs = require_dist.__toESM(node_fs, 1);
 let node_path = require("node:path");
@@ -35980,6 +35980,7 @@ var EMPTY_CASCADE_TALLY = {
 	faces: 0,
 	plates: 0,
 	embeddings: 0,
+	summaries: 0,
 	bytesReclaimed: 0
 };
 /** Fold a leaf store's receipts into a running tally. */
@@ -36023,6 +36024,13 @@ function addLeafCounts(tally, counts) {
 					bytesReclaimed
 				};
 				break;
+			case "summaries":
+				next = {
+					...next,
+					summaries: next.summaries + c.rows,
+					bytesReclaimed
+				};
+				break;
 		}
 	}
 	return next;
@@ -36036,6 +36044,7 @@ function mergeCascadeTallies(a, b) {
 		faces: a.faces + b.faces,
 		plates: a.plates + b.plates,
 		embeddings: a.embeddings + b.embeddings,
+		summaries: a.summaries + b.summaries,
 		bytesReclaimed: a.bytesReclaimed + b.bytesReclaimed
 	};
 }
@@ -36098,6 +36107,7 @@ function absentCascadeLegs(stores) {
 	if (!stores.faceStore) absent.push("faces");
 	if (!stores.plateStore) absent.push("plates");
 	if (!stores.objectEmbeddingStore) absent.push("embeddings");
+	if (!stores.summaryStore) absent.push("summaries");
 	return absent;
 }
 function buildAnalyticsCascadeRegistry(stores) {
@@ -36105,6 +36115,7 @@ function buildAnalyticsCascadeRegistry(stores) {
 	if (stores.faceStore) registry.push(stores.faceStore);
 	if (stores.plateStore) registry.push(stores.plateStore);
 	if (stores.objectEmbeddingStore) registry.push(stores.objectEmbeddingStore);
+	if (stores.summaryStore) registry.push(stores.summaryStore);
 	return registry;
 }
 /**
@@ -56314,6 +56325,344 @@ async function reconcileGallerySamples(deps, options) {
 		stoppedByCeiling
 	};
 }
+//#endregion
+//#region src/pipeline-analytics/summary/summary-store.ts
+var SUMMARIES_COLLECTION = "pipeline-analytics:summaries";
+var SUMMARY_MEMBERS_COLLECTION = "pipeline-analytics:summary-members";
+var SUMMARIES_COLUMNS = [
+	{
+		name: "id",
+		type: "TEXT",
+		primaryKey: true,
+		notNull: true
+	},
+	{
+		name: "deviceId",
+		type: "INTEGER",
+		notNull: true
+	},
+	{
+		name: "openedAt",
+		type: "INTEGER",
+		notNull: true
+	},
+	{
+		name: "lastActiveAt",
+		type: "INTEGER",
+		notNull: true
+	},
+	{
+		name: "sealedAt",
+		type: "INTEGER"
+	},
+	(
+	/** `deviceId` while open, NULL once sealed — the unique "one open per camera". */
+	{
+		name: "openDeviceId",
+		type: "INTEGER"
+	}),
+	{
+		name: "memberCount",
+		type: "INTEGER",
+		notNull: true
+	}
+];
+var SUMMARIES_INDEXES = [{
+	name: "summaries_open_device",
+	columns: ["openDeviceId"],
+	unique: true
+}, {
+	name: "summaries_device_opened",
+	columns: ["deviceId", "openedAt"]
+}];
+var SUMMARY_MEMBERS_COLUMNS = [
+	{
+		name: "id",
+		type: "TEXT",
+		primaryKey: true,
+		notNull: true
+	},
+	{
+		name: "summaryId",
+		type: "TEXT",
+		notNull: true
+	},
+	{
+		name: "trackId",
+		type: "TEXT",
+		notNull: true
+	},
+	{
+		name: "deviceId",
+		type: "INTEGER",
+		notNull: true
+	},
+	(
+	/** When the track joined — named `timestamp` so the orphan audit's declared-owner scope reads it. */
+	{
+		name: "timestamp",
+		type: "INTEGER",
+		notNull: true
+	})
+];
+var SUMMARY_MEMBERS_INDEXES = [{
+	name: "summary_members_summary",
+	columns: ["summaryId"]
+}, {
+	name: "summary_members_track",
+	columns: ["trackId"]
+}];
+function summaryId(deviceId, openedAt) {
+	return `sum-${deviceId}-${openedAt}`;
+}
+function memberRowId(summaryIdValue, trackId) {
+	return `${summaryIdValue}:${trackId}`;
+}
+function num$1(value, fallback = 0) {
+	return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+function toRow$1(id, data) {
+	return {
+		id,
+		deviceId: num$1(data["deviceId"]),
+		openedAt: num$1(data["openedAt"]),
+		lastActiveAt: num$1(data["lastActiveAt"]),
+		sealedAt: typeof data["sealedAt"] === "number" ? data["sealedAt"] : null,
+		memberCount: num$1(data["memberCount"])
+	};
+}
+function isUniqueViolation(err) {
+	return err instanceof Error && /UNIQUE constraint failed/i.test(err.message);
+}
+var SummaryStore = class {
+	store;
+	logger;
+	constructor(deps) {
+		this.store = deps.store;
+		this.logger = deps.logger;
+	}
+	static async declare(store) {
+		await Promise.all([store.declareCollection.mutate({
+			collection: SUMMARIES_COLLECTION,
+			columns: [...SUMMARIES_COLUMNS],
+			indexes: [...SUMMARIES_INDEXES]
+		}), store.declareCollection.mutate({
+			collection: SUMMARY_MEMBERS_COLLECTION,
+			columns: [...SUMMARY_MEMBERS_COLUMNS],
+			indexes: [...SUMMARY_MEMBERS_INDEXES]
+		})]);
+	}
+	/** The camera's OPEN summary, from the row — `null` when none. */
+	async findOpen(deviceId) {
+		const first = (await this.store.query.query({
+			collection: SUMMARIES_COLLECTION,
+			filter: {
+				where: { openDeviceId: deviceId },
+				limit: 1
+			}
+		}))[0];
+		return first === void 0 ? null : toRow$1(first.id, first.data);
+	}
+	async listOpen() {
+		return (await this.store.query.query({
+			collection: SUMMARIES_COLLECTION,
+			filter: {
+				where: { sealedAt: null },
+				limit: 1e4
+			}
+		})).filter((r) => r.data["openDeviceId"] !== null).map((r) => toRow$1(r.id, r.data));
+	}
+	async membersOf(summaryIdValue) {
+		return (await this.store.query.query({
+			collection: SUMMARY_MEMBERS_COLLECTION,
+			filter: {
+				where: { summaryId: summaryIdValue },
+				limit: 1e4
+			}
+		})).map((r) => ({
+			summaryId: summaryIdValue,
+			trackId: String(r.data["trackId"] ?? ""),
+			deviceId: num$1(r.data["deviceId"]),
+			joinedAt: num$1(r.data["timestamp"])
+		}));
+	}
+	/**
+	* Put a track into the camera's open summary, opening one when there is
+	* none. Racing opens are settled by the store: the loser's insert hits the
+	* unique `openDeviceId` and is re-read as an absorb.
+	*/
+	async openOrAbsorb(input) {
+		const existing = await this.findOpen(input.deviceId);
+		if (existing !== null) return this.absorb(existing, input);
+		const id = summaryId(input.deviceId, input.at);
+		try {
+			await this.store.set.mutate({
+				collection: SUMMARIES_COLLECTION,
+				key: id,
+				value: {
+					deviceId: input.deviceId,
+					openedAt: input.at,
+					lastActiveAt: input.at,
+					sealedAt: null,
+					openDeviceId: input.deviceId,
+					memberCount: 1
+				}
+			});
+		} catch (err) {
+			if (!isUniqueViolation(err)) throw err;
+			const winner = await this.findOpen(input.deviceId);
+			if (winner === null) throw err;
+			return this.absorb(winner, input);
+		}
+		await this.addMember(id, input);
+		return {
+			id,
+			deviceId: input.deviceId,
+			openedAt: input.at,
+			lastActiveAt: input.at,
+			sealedAt: null,
+			memberCount: 1
+		};
+	}
+	async absorb(summary, input) {
+		const members = await this.membersOf(summary.id);
+		if (members.some((m) => m.trackId === input.trackId)) return summary;
+		await this.addMember(summary.id, input);
+		const memberCount = members.length + 1;
+		const lastActiveAt = Math.max(summary.lastActiveAt, input.at);
+		await this.store.updateWhere.mutate({
+			collection: SUMMARIES_COLLECTION,
+			filter: { where: {
+				openDeviceId: summary.deviceId,
+				openedAt: summary.openedAt
+			} },
+			data: {
+				memberCount,
+				lastActiveAt
+			}
+		});
+		return {
+			...summary,
+			memberCount,
+			lastActiveAt
+		};
+	}
+	async addMember(summaryIdValue, input) {
+		await this.store.insertMany.mutate({
+			collection: SUMMARY_MEMBERS_COLLECTION,
+			records: [{
+				id: memberRowId(summaryIdValue, input.trackId),
+				data: {
+					summaryId: summaryIdValue,
+					trackId: input.trackId,
+					deviceId: input.deviceId,
+					timestamp: input.at
+				}
+			}]
+		});
+	}
+	/**
+	* Seal in place. `true` when THIS call sealed it; `false` when the row was
+	* already sealed (or gone) — the second sealer learns, it does not write.
+	*/
+	async seal(summary, sealedAt) {
+		const { updated } = await this.store.updateWhere.mutate({
+			collection: SUMMARIES_COLLECTION,
+			filter: { where: {
+				openDeviceId: summary.deviceId,
+				openedAt: summary.openedAt
+			} },
+			data: {
+				sealedAt,
+				openDeviceId: null
+			}
+		});
+		if (updated > 1) this.logger.error("summary seal touched more than one row — the open key is not unique", {
+			tags: { deviceId: summary.deviceId },
+			meta: {
+				summaryId: summary.id,
+				updated
+			}
+		});
+		return updated >= 1;
+	}
+	/**
+	* Track cascade leaf: a member row whose track is gone is gone too, and
+	* the summary's count follows. The envelope itself outlives its members
+	* — it is an age-keyed root (`RETENTION_ROOTS`, `summary`).
+	*/
+	async deleteByTracks(trackIds) {
+		if (trackIds.length === 0) return [{
+			family: "summaries",
+			rows: 0,
+			bytes: 0
+		}];
+		const members = await this.store.query.query({
+			collection: SUMMARY_MEMBERS_COLLECTION,
+			filter: {
+				whereIn: { trackId: [...trackIds] },
+				limit: 1e4
+			}
+		});
+		if (members.length === 0) return [{
+			family: "summaries",
+			rows: 0,
+			bytes: 0
+		}];
+		const { deleted } = await this.store.deleteWhere.mutate({
+			collection: SUMMARY_MEMBERS_COLLECTION,
+			filter: { whereIn: { trackId: [...trackIds] } }
+		});
+		const touched = new Set(members.map((m) => String(m.data["summaryId"] ?? "")));
+		for (const summaryIdValue of touched) {
+			const remaining = await this.membersOf(summaryIdValue);
+			const raw = await this.store.get.query({
+				collection: SUMMARIES_COLLECTION,
+				key: summaryIdValue
+			});
+			if (typeof raw !== "object" || raw === null) continue;
+			const row = raw;
+			await this.store.updateWhere.mutate({
+				collection: SUMMARIES_COLLECTION,
+				filter: { where: {
+					deviceId: num$1(row["deviceId"]),
+					openedAt: num$1(row["openedAt"])
+				} },
+				data: { memberCount: remaining.length }
+			});
+		}
+		return [{
+			family: "summaries",
+			rows: deleted,
+			bytes: 0
+		}];
+	}
+	/** Age sweep on the device window: everything opened before `cutoffMs`, members included. */
+	async evictBefore(deviceId, cutoffMs) {
+		const rows = await this.store.query.query({
+			collection: SUMMARIES_COLLECTION,
+			filter: {
+				where: { deviceId },
+				whereBetween: { openedAt: [0, cutoffMs - 1] },
+				limit: 1e4
+			}
+		});
+		if (rows.length === 0) return 0;
+		const ids = rows.map((r) => r.id);
+		await this.store.deleteWhere.mutate({
+			collection: SUMMARY_MEMBERS_COLLECTION,
+			filter: { whereIn: { summaryId: ids } }
+		});
+		const { deleted } = await this.store.deleteWhere.mutate({
+			collection: SUMMARIES_COLLECTION,
+			filter: {
+				where: { deviceId },
+				whereBetween: { openedAt: [0, cutoffMs - 1] }
+			}
+		});
+		return deleted;
+	}
+};
 /**
 * Where the completion marker lives.
 *
@@ -58609,6 +58958,10 @@ var ANALYTICS_COLLECTIONS = [
 		collection: PLATES_COLLECTION,
 		classification: derived(PLATE_COLUMNS)
 	},
+	{
+		collection: SUMMARY_MEMBERS_COLLECTION,
+		classification: derived(SUMMARY_MEMBERS_COLUMNS)
+	},
 	{
 		collection: MEDIA_COLLECTION,
 		classification: {
@@ -58652,6 +59005,13 @@ var ANALYTICS_COLLECTIONS = [
 			rootId: "ops-log"
 		}
 	},
+	{
+		collection: SUMMARIES_COLLECTION,
+		classification: {
+			kind: "retention-root",
+			rootId: "summary"
+		}
+	},
 	{
 		collection: IDENTITIES_COLLECTION,
 		classification: {
@@ -59212,12 +59572,14 @@ async function sweepTracklessRoots(deps) {
 				cutoffMs
 			});
 			const sensor = deps.evictSensorEvents ? await deps.evictSensorEvents(deviceId, cutoffMs) : 0;
+			const summaries = deps.evictSummaries ? await deps.evictSummaries(deviceId, cutoffMs) : 0;
 			const evicted = {
 				motion: events.motion,
 				audio: events.audio,
-				sensor
+				sensor,
+				summaries
 			};
-			if (evicted.motion.length + evicted.audio.length + evicted.sensor > 0) await deps.onEvicted(deviceId, evicted, cutoffs);
+			if (evicted.motion.length + evicted.audio.length + evicted.sensor + evicted.summaries > 0) await deps.onEvicted(deviceId, evicted, cutoffs);
 		} catch (err) {
 			deps.onError(deviceId, err);
 		}
@@ -64912,6 +65274,97 @@ function rowFromMetadata(id, metadata) {
 	};
 }
 //#endregion
+//#region src/pipeline-analytics/summary/summary-sealer.ts
+function errMsg(err) {
+	return err instanceof Error ? err.message : String(err);
+}
+var SummarySealer = class {
+	deps;
+	sweepInFlight = false;
+	constructor(deps) {
+		this.deps = deps;
+	}
+	async onTrackOpened(input) {
+		try {
+			await this.deps.summaries.openOrAbsorb({
+				deviceId: input.deviceId,
+				trackId: input.trackId,
+				at: this.deps.now()
+			});
+		} catch (err) {
+			this.deps.logger.warn("summary: could not open or absorb for a track", {
+				tags: { deviceId: input.deviceId },
+				meta: {
+					trackId: input.trackId,
+					error: errMsg(err)
+				}
+			});
+		}
+	}
+	/** One sweep at a time (THE latch). A tick that finds one in flight returns. */
+	async sweep() {
+		if (this.sweepInFlight) return;
+		this.sweepInFlight = true;
+		try {
+			const open = await this.deps.summaries.listOpen();
+			for (const summary of open) await this.sealIfDone(summary);
+		} catch (err) {
+			this.deps.logger.warn("summary sweep: could not list open summaries", { meta: { error: errMsg(err) } });
+		} finally {
+			this.sweepInFlight = false;
+		}
+	}
+	async sealIfDone(summary) {
+		const { id: summaryId, deviceId } = summary;
+		let openTracks;
+		try {
+			openTracks = await this.deps.openTrackIds(deviceId);
+		} catch (err) {
+			this.deps.logger.warn("summary sweep: could not read open tracks — seal aborted this sweep", {
+				tags: { deviceId },
+				meta: {
+					summaryId,
+					error: errMsg(err)
+				}
+			});
+			return;
+		}
+		if (openTracks.length > 0) return;
+		let quiet;
+		try {
+			quiet = await this.deps.isCameraQuiet(deviceId);
+		} catch (err) {
+			this.deps.logger.warn("summary sweep: could not read the stationary registry — seal aborted this sweep", {
+				tags: { deviceId },
+				meta: {
+					summaryId,
+					error: errMsg(err)
+				}
+			});
+			return;
+		}
+		if (!quiet) return;
+		const sealedAt = this.deps.now();
+		try {
+			if (await this.deps.summaries.seal(summary, sealedAt)) this.deps.logger.info("summary sealed", {
+				tags: { deviceId },
+				meta: {
+					summaryId,
+					sealedAt
+				}
+			});
+		} catch (err) {
+			this.deps.logger.warn("summary sweep: seal failed — the row stays open for the next sweep", {
+				tags: { deviceId },
+				meta: {
+					summaryId,
+					error: errMsg(err)
+				}
+			});
+		}
+	}
+};
+//#endregion
 //#region src/pipeline-analytics/store/settings-raw-mirror.ts
 /** How long a mirrored entry is served before a refresh is started behind the
 *  next reader. See the module doc for why this matches the per-kind caches'
@@ -66224,6 +66677,10 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 	storageMigrationLeaseId = null;
 	/** Per-camera history of LINKED-device sensor state changes (Part B). */
 	sensorEventStore = null;
+	/** The per-camera session envelope (D359). Bound with the other stores at boot. */
+	summaryStore = null;
+	/** The ONLY writer of a summary's lifecycle (D359). */
+	summarySealer = null;
 	/** Ingest-side reverse index (sensor device → linked camera ids), TTL-cached
 	*  so the DeviceStateChanged handler stays cheap. */
 	linkedCamerasCache = null;
@@ -67462,6 +67919,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 			MediaStore.declare(api.settingsStore),
 			EventStore.declare(api.settingsStore),
 			SensorEventStore.declare(api.settingsStore),
+			SummaryStore.declare(api.settingsStore),
 			IdentityStore.declare(api.settingsStore),
 			FaceStore.declare(api.settingsStore),
 			PlateStore.declare(api.settingsStore),
@@ -67723,6 +68181,17 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 			store: api.settingsStore,
 			logger: logger.child("SensorEventStore")
 		});
+		this.summaryStore = new SummaryStore({
+			store: api.settingsStore,
+			logger: this.ctx.logger.child("summary")
+		});
+		this.summarySealer = new SummarySealer({
+			summaries: this.summaryStore,
+			openTrackIds: async (deviceId) => this.residents.trackIdsForDevice(deviceId),
+			isCameraQuiet: async (deviceId) => (this.stationaryRegistry?.count(deviceId) ?? 0) === 0,
+			now: () => Date.now(),
+			logger: this.ctx.logger.child("summary-sealer")
+		});
 		this.packageDropDetector = new PackageDropDetector({
 			events: eventStore,
 			emit: {
@@ -69935,6 +70404,10 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 					className: t.className
 				}
 			});
+			this.summarySealer?.onTrackOpened({
+				deviceId,
+				trackId: id
+			});
 			const startPayload = buildTrackLifecyclePayload({
 				deviceId,
 				trackId: id,
@@ -71959,6 +72432,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 	async sweepExpiredTracks() {
 		if (this.shuttingDown || !this.trackStore) return;
 		await this.trackCloser.sweep();
+		await this.summarySealer?.sweep();
 	}
 	/** Unified retention (Phase 1): earliest retained footage per device — the
 	*  follow-recordings cutoff source. Cached 10 min: availability answers in
@@ -72055,6 +72529,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 			await this.runTrackRetentionSweep(deviceIds, now);
 			const eventStore = this.eventStore;
 			const sensorEventStore = this.sensorEventStore;
+			const summaryStore = this.summaryStore;
 			await sweepTracklessRoots({
 				deviceIds,
 				nowMs: now,
@@ -72064,15 +72539,16 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 					cutoffMs
 				}),
 				evictSensorEvents: sensorEventStore ? (deviceId, cutoffMs) => sensorEventStore.evictBefore(deviceId, cutoffMs) : null,
+				evictSummaries: summaryStore ? (deviceId, cutoffMs) => summaryStore.evictBefore(deviceId, cutoffMs) : null,
 				onEvicted: async (deviceId, evicted, cutoffs) => {
-					const total = evicted.motion.length + evicted.audio.length + evicted.sensor;
+					const total = evicted.motion.length + evicted.audio.length + evicted.sensor + evicted.summaries;
 					await this.eventsOpsLog?.append({
 						op: "prune",
 						reason: "retention",
 						deviceId,
 						itemsAffected: total,
 						bytesReclaimed: 0,
-						detail: `trackless age sweep (${cutoffs.effectiveMode}): ${evicted.motion.length} motion, ${evicted.audio.length} audio, ${evicted.sensor} sensor`
+						detail: `trackless age sweep (${cutoffs.effectiveMode}): ${evicted.motion.length} motion, ${evicted.audio.length} audio, ${evicted.sensor} sensor, ${evicted.summaries} summaries`
 					});
 					this.ctx.logger.info("analytics trackless event eviction (age sweep)", {
 						tags: { deviceId },
@@ -72080,6 +72556,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 							motion: evicted.motion.length,
 							audio: evicted.audio.length,
 							sensor: evicted.sensor,
+							summaries: evicted.summaries,
 							mode: cutoffs.effectiveMode,
 							cutoffMs: cutoffs.cutoffMs
 						}
@@ -74559,7 +75036,8 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 			mediaStore,
 			faceStore: this.faceStore,
 			plateStore: this.plateStore,
-			objectEmbeddingStore: this.objectEmbeddingStore
+			objectEmbeddingStore: this.objectEmbeddingStore,
+			summaryStore: this.summaryStore
 		};
 		const absent = absentCascadeLegs(stores);
 		if (absent.length > 0) this.ctx.logger.warn("track cascade is missing a leg — its rows will be left behind", { meta: {