@camstack/addon-post-analysis 1.1.33 → 1.1.34

package/dist/pipeline-analytics/index.mjs

@@ -1,4 +1,4 @@
-import { C as string, S as object, _ as createEvent, a as cosineSimilarity, b as boolean, d as plateGalleryCapability, f as videoclipsCapability, g as DeviceType, h as BaseAddon, i as audioMetricsCapability, l as nodePin, m as errMsg, n as EVENT_PAD_MS, p as zoneAnalyticsCapability, r as addonWidgetsSourceCapability, s as faceGalleryCapability, t as EVENT_KIND_BY_CAP, u as pipelineAnalyticsCapability, v as hydrateSchema, w as EventCategory, x as number, y as array } from "../dist-CA0GikiM.mjs";
+import { C as object, S as number, T as EventCategory, _ as DeviceType, a as audioMetricsCapability, b as array, c as faceGalleryCapability, d as pipelineAnalyticsCapability, f as plateGalleryCapability, g as BaseAddon, h as errMsg, i as addonWidgetsSourceCapability, m as zoneAnalyticsCapability, n as EVENT_PAD_MS, o as cosineSimilarity, p as videoclipsCapability, r as OpsLogEntrySchema, t as EVENT_KIND_BY_CAP, u as nodePin, v as createEvent, w as string, x as boolean, y as hydrateSchema } from "../dist-B1EgWJrr.mjs";
 import { randomUUID } from "node:crypto";
 import sharp from "sharp";
 //#region src/pipeline-analytics/videoclips-provider.ts
@@ -4393,6 +4393,48 @@ var MediaStore = class {
 		}
 		return removed;
 	}
+	/**
+	* On-demand footprint aggregation for the events-management UI: sum
+	* `sizeBytes` and count rows per device across the whole media collection.
+	* Pages by `id` (offset-based) so a large collection never loads at once.
+	* Metadata rows are small (no blob) — the image bytes live on the storage
+	* provider and are counted via the persisted `sizeBytes` column.
+	*/
+	async footprintByDevice() {
+		const PAGE = 1e3;
+		const out = /* @__PURE__ */ new Map();
+		let offset = 0;
+		for (;;) {
+			const rows = await this.store.query.query({
+				collection: MEDIA_COLLECTION,
+				filter: {
+					orderBy: {
+						field: "id",
+						direction: "asc"
+					},
+					limit: PAGE,
+					offset
+				}
+			});
+			if (rows.length === 0) break;
+			for (const row of rows) {
+				const data = row.data;
+				const deviceId = Number(data["deviceId"]);
+				const sizeBytes = Number(data["sizeBytes"]);
+				if (!Number.isFinite(deviceId)) continue;
+				const acc = out.get(deviceId) ?? {
+					bytes: 0,
+					rows: 0
+				};
+				acc.bytes += Number.isFinite(sizeBytes) ? sizeBytes : 0;
+				acc.rows += 1;
+				out.set(deviceId, acc);
+			}
+			if (rows.length < PAGE) break;
+			offset += PAGE;
+		}
+		return out;
+	}
 	/** Move a single media entry from one owner to another.
 	*  The new copy is written before the old one is removed.
 	*  The old-entry deletion is best-effort: on failure a warning is logged
@@ -4754,12 +4796,12 @@ var EventStore = class {
 			collection: MOTION_EVENTS_COLLECTION,
 			filter: this.buildFilter(q)
 		});
-		if (q.projection === "slim") return rows.map((r) => slimMotion(r.id, stripNulls(r.data)));
+		if (q.projection === "slim") return rows.map((r) => slimMotion(r.id, stripNulls$1(r.data)));
 		return rows.map((r) => {
 			return {
 				id: r.id,
 				kind: "motion",
-				...stripNulls(r.data)
+				...stripNulls$1(r.data)
 			};
 		});
 	}
@@ -4773,12 +4815,12 @@ var EventStore = class {
 			collection: OBJECT_EVENTS_COLLECTION,
 			filter
 		});
-		if (q.projection === "slim") return rows.map((r) => slimObject(r.id, stripNulls(r.data)));
+		if (q.projection === "slim") return rows.map((r) => slimObject(r.id, stripNulls$1(r.data)));
 		return rows.map((r) => {
 			return {
 				id: r.id,
 				kind: "object",
-				...stripNulls(r.data)
+				...stripNulls$1(r.data)
 			};
 		});
 	}
@@ -4787,12 +4829,12 @@ var EventStore = class {
 			collection: AUDIO_EVENTS_COLLECTION,
 			filter: this.buildFilter(q)
 		});
-		if (q.projection === "slim") return rows.map((r) => slimAudio(r.id, stripNulls(r.data)));
+		if (q.projection === "slim") return rows.map((r) => slimAudio(r.id, stripNulls$1(r.data)));
 		return rows.map((r) => {
 			return {
 				id: r.id,
 				kind: "audio",
-				...stripNulls(r.data)
+				...stripNulls$1(r.data)
 			};
 		});
 	}
@@ -4938,6 +4980,23 @@ var EventStore = class {
 		return updated;
 	}
 	/**
+	* Total persisted event rows (motion + object + audio) for a device — the
+	* "rows" figure in the events-management footprint. Uses the indexed `count`
+	* aggregate per collection, run in parallel.
+	*/
+	async countForDevice(deviceId) {
+		const one = (collection) => this.store.count.query({
+			collection,
+			filter: { where: { deviceId } }
+		});
+		const [motion, object, audio] = await Promise.all([
+			one(MOTION_EVENTS_COLLECTION),
+			one(OBJECT_EVENTS_COLLECTION),
+			one(AUDIO_EVENTS_COLLECTION)
+		]);
+		return motion + object + audio;
+	}
+	/**
 	* Return per-kind event counts in equal-width time buckets.
 	*
 	* Each bucket maps to a `bucketStart = since + i * bucketMs`.
@@ -5212,12 +5271,189 @@ function bboxAreaFrac(data) {
 	if (w <= 0 || h <= 0) return 0;
 	return w * h / (fw * fh);
 }
-function stripNulls(data) {
+function stripNulls$1(data) {
 	const out = {};
 	for (const [k, v] of Object.entries(data)) if (v !== null) out[k] = v;
 	return out;
 }
 //#endregion
+//#region src/pipeline-analytics/store/ops-log-store.ts
+/**
+* OpsLogStore — the EVENTS-domain operations audit for pipeline-analytics.
+*
+* pipeline-analytics already owns SQLite collections, so (unlike the recorder's
+* DurableState ring) the events ops-log is a DECLARED SQL-backed collection.
+* MUST be declared in `onInitialize` via `declare()` before the first insert —
+* an undeclared collection crash-loops the runner.
+*
+* Collection name: pipeline-analytics:ops-log
+*
+* Append is BEST-EFFORT (`append` catches + logs, never throws) — a failed
+* audit write must not fail the operation it records.
+*/
+var OPS_LOG_COLLECTION = "pipeline-analytics:ops-log";
+var OPS_LOG_COLUMNS = [
+	{
+		name: "id",
+		type: "TEXT",
+		primaryKey: true,
+		notNull: true
+	},
+	{
+		name: "at",
+		type: "INTEGER",
+		notNull: true
+	},
+	{
+		name: "domain",
+		type: "TEXT",
+		notNull: true
+	},
+	{
+		name: "op",
+		type: "TEXT",
+		notNull: true
+	},
+	{
+		name: "reason",
+		type: "TEXT",
+		notNull: true
+	},
+	{
+		name: "deviceId",
+		type: "INTEGER"
+	},
+	{
+		name: "nodeId",
+		type: "TEXT",
+		notNull: true
+	},
+	{
+		name: "itemsAffected",
+		type: "INTEGER",
+		notNull: true
+	},
+	{
+		name: "bytesReclaimed",
+		type: "INTEGER",
+		notNull: true
+	},
+	{
+		name: "detail",
+		type: "TEXT"
+	},
+	{
+		name: "actor",
+		type: "TEXT",
+		notNull: true
+	}
+];
+var OPS_LOG_INDEXES = [{
+	name: "idx_opslog_at",
+	columns: ["at"]
+}, {
+	name: "idx_opslog_device_at",
+	columns: ["deviceId", "at"]
+}];
+var OpsLogStore = class {
+	store;
+	logger;
+	nodeId;
+	now;
+	newId;
+	constructor(deps) {
+		this.store = deps.store;
+		this.logger = deps.logger;
+		this.nodeId = deps.nodeId;
+		this.now = deps.now ?? (() => Date.now());
+		this.newId = deps.newId ?? (() => globalThis.crypto.randomUUID());
+	}
+	static async declare(store) {
+		await store.declareCollection.mutate({
+			collection: OPS_LOG_COLLECTION,
+			columns: [...OPS_LOG_COLUMNS],
+			indexes: [...OPS_LOG_INDEXES]
+		});
+	}
+	/**
+	* Append one events-domain ops-log row. Best-effort — stamps
+	* `domain:'events'`, `nodeId`, `id`, `at`, validates, inserts, and swallows
+	* (logs) any failure so it can never fail the operation being audited.
+	*/
+	async append(input) {
+		const entry = {
+			id: this.newId(),
+			at: this.now(),
+			domain: "events",
+			op: input.op,
+			reason: input.reason,
+			deviceId: input.deviceId,
+			nodeId: this.nodeId,
+			itemsAffected: input.itemsAffected,
+			bytesReclaimed: input.bytesReclaimed,
+			detail: input.detail ?? null,
+			actor: input.actor ?? "operator"
+		};
+		try {
+			const { id, ...rest } = OpsLogEntrySchema.parse(entry);
+			await this.store.insert.mutate({
+				collection: OPS_LOG_COLLECTION,
+				record: {
+					id,
+					data: rest
+				}
+			});
+		} catch (err) {
+			this.logger.warn("OpsLogStore.append failed (best-effort)", {
+				tags: { deviceId: input.deviceId ?? void 0 },
+				meta: {
+					op: input.op,
+					error: String(err)
+				}
+			});
+		}
+	}
+	/**
+	* List events ops-log rows newest-first, optionally scoped to one device,
+	* capped at `limit` (default {@link OPS_LOG_DEFAULT_LIMIT}).
+	*/
+	async list(query) {
+		const filter = {
+			orderBy: {
+				field: "at",
+				direction: "desc"
+			},
+			limit: query.limit ?? 200
+		};
+		if (query.deviceId !== void 0) filter.where = { deviceId: query.deviceId };
+		const rows = await this.store.query.query({
+			collection: OPS_LOG_COLLECTION,
+			filter
+		});
+		const out = [];
+		for (const r of rows) {
+			const parsed = OpsLogEntrySchema.safeParse({
+				id: r.id,
+				...stripNulls(r.data)
+			});
+			if (parsed.success) out.push(parsed.data);
+			else this.logger.debug("OpsLogStore.list: skipped malformed row", { meta: { id: r.id } });
+		}
+		return out;
+	}
+};
+/** SQLite stores nullable columns as `null`; the row schema uses `.nullable()`
+*  for deviceId/detail (accepts null) but drop any stray null on required
+*  fields defensively before parse. */
+function stripNulls(data) {
+	const out = {};
+	for (const [k, v] of Object.entries(data)) {
+		if (v === null && k !== "deviceId" && k !== "detail") continue;
+		out[k] = v;
+	}
+	return out;
+}
+//#endregion
 //#region src/pipeline-analytics/store/sensor-event-store.ts
 var SENSOR_EVENTS_COLLECTION = "pipeline-analytics:sensor-events";
 var SENSOR_EVENT_COLUMNS = [
@@ -10959,6 +11195,8 @@ var PipelineAnalyticsAddon = class extends BaseAddon {
 	stationaryRegistry = null;
 	mediaStore = null;
 	eventStore = null;
+	/** Events-domain ops-log (footprint/prune/manual-delete audit). Null until onInitialize. */
+	eventsOpsLog = null;
 	/** Per-camera history of LINKED-device sensor state changes (Part B). */
 	sensorEventStore = null;
 	/** Ingest-side reverse index (sensor device → linked camera ids), TTL-cached
@@ -11121,6 +11359,7 @@ var PipelineAnalyticsAddon = class extends BaseAddon {
 		await VehicleStore.declare(api.settingsStore);
 		await ObjectEmbeddingStore.declare(api.settingsStore);
 		await StationaryObjectRegistry.declare(api.settingsStore);
+		await OpsLogStore.declare(api.settingsStore);
 		const logger = this.ctx.logger;
 		let storage = this.ctx.kernel.storage;
 		const mediaRoot = process.env.CAMSTACK_MEDIA_ROOT?.trim();
@@ -11246,6 +11485,11 @@ var PipelineAnalyticsAddon = class extends BaseAddon {
 		});
 		const rawNodeId = this.ctx.kernel.localNodeId ?? this.ctx.id;
 		const ownNodeId = rawNodeId.includes("/") ? rawNodeId.split("/")[0] : rawNodeId;
+		this.eventsOpsLog = new OpsLogStore({
+			store: api.settingsStore,
+			logger: logger.child("ops-log"),
+			nodeId: ownNodeId
+		});
 		{
 			const designated = await this.postProcessingNodeState.get();
 			this.isPostProcessingNode = ownNodeId === designated;
@@ -13751,6 +13995,120 @@ var PipelineAnalyticsAddon = class extends BaseAddon {
 		};
 	}
 	/**
+	* Durable event-store footprint for the events-management UI: event ROWS
+	* (motion + object + audio) counted per camera (indexed `count`) + total, and
+	* event-owned media BYTES on disk per camera (paged `sizeBytes` sum) + total.
+	* The device set is the union of cameras that have media OR persisted tracks;
+	* cameras with neither rows nor bytes are omitted.
+	*/
+	async getEventStoreFootprint() {
+		const eventStore = this.eventStore;
+		const mediaStore = this.mediaStore;
+		if (!eventStore || !mediaStore) return {
+			totalRows: 0,
+			totalBytes: 0,
+			devices: []
+		};
+		const mediaByDevice = await mediaStore.footprintByDevice();
+		const deviceIds = new Set(mediaByDevice.keys());
+		if (this.trackStore) for (const id of await this.trackStore.listDeviceIds()) deviceIds.add(id);
+		const devices = [];
+		let totalRows = 0;
+		let totalBytes = 0;
+		for (const deviceId of deviceIds) {
+			const rows = await eventStore.countForDevice(deviceId);
+			const bytes = mediaByDevice.get(deviceId)?.bytes ?? 0;
+			if (rows === 0 && bytes === 0) continue;
+			totalRows += rows;
+			totalBytes += bytes;
+			devices.push({
+				deviceId,
+				rows,
+				bytes
+			});
+		}
+		devices.sort((a, b) => b.bytes - a.bytes);
+		return {
+			totalRows,
+			totalBytes,
+			devices
+		};
+	}
+	/**
+	* Cluster-wide prune of events with `timestamp < olderThanMs` across every
+	* camera (via the device-agnostic `evictBefore`), deleting each pruned event's
+	* media in lockstep. Logs one global (`deviceId:null`) events ops-log row.
+	* `bytesReclaimed` is 0 (media deletion does not surface freed bytes).
+	*/
+	async pruneEvents(input) {
+		const eventStore = this.eventStore;
+		if (!eventStore) return {
+			motion: 0,
+			object: 0,
+			audio: 0
+		};
+		const cutoff = input.olderThanMs;
+		const evicted = await eventStore.evictBefore({
+			motionCutoffMs: cutoff,
+			objectCutoffMs: cutoff,
+			audioCutoffMs: cutoff
+		});
+		const ids = [
+			...evicted.motion,
+			...evicted.object,
+			...evicted.audio
+		];
+		if (ids.length > 0 && this.mediaStore) await this.mediaStore.deleteForEvents(ids);
+		const counts = {
+			motion: evicted.motion.length,
+			object: evicted.object.length,
+			audio: evicted.audio.length
+		};
+		const total = counts.motion + counts.object + counts.audio;
+		await this.eventsOpsLog?.append({
+			op: "prune",
+			reason: input.reason ?? "retention",
+			deviceId: null,
+			itemsAffected: total,
+			bytesReclaimed: 0,
+			detail: `pruned events older than ${cutoff}`
+		});
+		if (total > 0) this.ctx.logger.info("analytics events pruned (cluster)", { meta: {
+			cutoffMs: cutoff,
+			...counts
+		} });
+		return counts;
+	}
+	/**
+	* Manually delete EVERY event (motion + object + audio) for one camera and its
+	* event-owned media in lockstep. Logs a manual events ops-log row.
+	*/
+	async deleteDeviceEvents(input) {
+		if (!this.eventStore) return {
+			motion: 0,
+			object: 0,
+			audio: 0
+		};
+		const counts = await this.pruneEventsBefore({
+			deviceId: input.deviceId,
+			cutoffMs: Number.MAX_SAFE_INTEGER
+		});
+		const total = counts.motion + counts.object + counts.audio;
+		await this.eventsOpsLog?.append({
+			op: "manual-delete",
+			reason: "manual",
+			deviceId: input.deviceId,
+			itemsAffected: total,
+			bytesReclaimed: 0,
+			detail: "deleted all events for device"
+		});
+		return counts;
+	}
+	/** The events ops-log rows (newest-first), optionally scoped to one camera. */
+	async listOpsLog(input) {
+		return await this.eventsOpsLog?.list(input) ?? [];
+	}
+	/**
 	* Track-centric time-based retention (design §5.1). Drains every persisted
 	* track for the device whose `lastSeen < cutoffMs`, page by page, through the
 	* widened cascade — enrolled faces/plates + identity media are exempt (design

package/dist/pipeline-analytics/remoteEntry.js

@@ -30,7 +30,7 @@ async function d(e) {
 	}
 }
 async function f() {
-	return l ||= d(() => import("./_virtual_mf-localSharedImportMap___mfe_internal__addon_pipeline_analytics_widgets-BbAKLasA.mjs")).catch((e) => {
+	return l ||= d(() => import("./_virtual_mf-localSharedImportMap___mfe_internal__addon_pipeline_analytics_widgets-BuAr2V3O.mjs")).catch((e) => {
 		throw l = void 0, e;
 	}), l;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camstack/addon-post-analysis",
-  "version": "1.1.33",
+  "version": "1.1.34",
   "description": "CamStack Post-Analysis bundle — enrichment, embedding-encoder, pipeline-analytics. Multi-entry npm package shipping addons that consume pipeline output.",
   "keywords": [
     "camstack",