@camstack/addon-post-analysis 1.1.32 → 1.1.34

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-DU_JRm-j.js");
+const require_dist = require("../dist-BeDNiKi6.js");
 let node_crypto = require("node:crypto");
 let sharp = require("sharp");
 sharp = require_dist.__toESM(sharp);
@@ -4398,6 +4398,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
@@ -4759,12 +4801,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)
 			};
 		});
 	}
@@ -4778,12 +4820,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)
 			};
 		});
 	}
@@ -4792,12 +4834,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)
 			};
 		});
 	}
@@ -4943,6 +4985,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`.
@@ -5217,12 +5276,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 } = require_dist.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 = require_dist.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 = [
@@ -5401,6 +5637,7 @@ var PERSON_COLOR = "#22c55e";
 var VEHICLE_COLOR = "#3b82f6";
 var ANIMAL_COLOR = "#f97316";
 var GENERIC_DETECTION_COLOR = "#64748b";
+var PACKAGE_COLOR = "#a855f7";
 var VEHICLE_CLASSES = new Set([
 	"vehicle",
 	"car",
@@ -5478,6 +5715,34 @@ async function composeEventKinds(deps, deviceId) {
 	} catch (err) {
 		deps.onError?.("observedClassNames", err);
 	}
+	try {
+		if (deps.packageZonesEnabled && await deps.packageZonesEnabled(deviceId)) {
+			out.push({
+				kind: "package-delivered",
+				label: "Package delivered",
+				color: PACKAGE_COLOR,
+				icon: "package",
+				category: "package",
+				source: {
+					capName: "pipeline-analytics",
+					deviceId
+				}
+			});
+			out.push({
+				kind: "package-picked-up",
+				label: "Package picked up",
+				color: PACKAGE_COLOR,
+				icon: "package",
+				category: "package",
+				source: {
+					capName: "pipeline-analytics",
+					deviceId
+				}
+			});
+		}
+	} catch (err) {
+		deps.onError?.("packageZonesEnabled", err);
+	}
 	try {
 		const { devices } = await deps.linkedDevices.getLinkedDevices({ deviceId });
 		const seen = /* @__PURE__ */ new Set();
@@ -7330,6 +7595,208 @@ function resolveMediaSettings(raw) {
 		snapshotMaxIdleMs: pick("snapshotMaxIdleMs")
 	};
 }
+//#endregion
+//#region src/pipeline-analytics/package-settings.ts
+/**
+* Per-device package-drop detector settings (surface C of the
+* detection-config-exposure plan — a per-device post-analysis section).
+* Cascade: a per-device override on top of the declared default, resolved
+* per field (an invalid/missing value falls back to its default — parse
+* never throws). Mirrors `media-settings` / `tracking-settings`.
+*
+* Keys are namespaced (`packageDrop*`) because the device store is a FLAT
+* blob shared across every post-analysis section — a bare `enabled` would
+* collide with another section.
+*
+* See docs/superpowers/specs/2026-07-17-package-zones-design.md §3.3 +
+* docs/superpowers/specs/2026-07-17-detection-config-exposure-design.md
+* (surface C). Dwell default is 15s per operator decision (the design's
+* §3.3 draft said 45s).
+*/
+var PackageDropSettingsSchema = require_dist.object({
+	/** Master switch — off by default; opt-in per camera (porch/door cams). */
+	packageDropEnabled: require_dist.boolean().default(false),
+	/**
+	* Minimum OBSERVED dwell (seconds, since first-seen) before a newly
+	* promoted stationary package counts as a delivery. Kills a bag briefly
+	* set down and snatched back. Operator default 15s. Values beyond the
+	* stationary promotion window (30s) are satisfied only once the entry
+	* has actually been observed that long.
+	*/
+	packageDropDwellSec: require_dist.number().int().min(0).max(3600).default(15),
+	/** Reject tiny far-field blobs: min bbox area as a fraction of the frame. */
+	packageDropMinBboxAreaFrac: require_dist.number().min(0).max(1).default(.004),
+	/** Emit `package-picked-up` when a delivered package's entry departs. */
+	packageDropPickupEnabled: require_dist.boolean().default(true),
+	/**
+	* Stationary classes that count as a package. MODEL-AGNOSTIC: defaults to
+	* the single `package` class a dedicated parcel model emits; the interim
+	* COCO vector (suitcase/backpack/handbag) already maps to `package`
+	* upstream, so this stays `['package']`.
+	*/
+	packageDropClassFilter: require_dist.array(require_dist.string()).default(["package"])
+});
+var PACKAGE_DROP_DEFAULTS = PackageDropSettingsSchema.parse({});
+/**
+* Resolve a per-device store blob into typed package-drop settings.
+* Unknown/invalid fields fall back to the default for that field (never
+* throws on a bad blob).
+*/
+function resolvePackageDropSettings(raw) {
+	const pick = (key) => {
+		const parsed = PackageDropSettingsSchema.shape[key].safeParse(raw[key]);
+		return parsed.success ? parsed.data : PACKAGE_DROP_DEFAULTS[key];
+	};
+	return {
+		packageDropEnabled: pick("packageDropEnabled"),
+		packageDropDwellSec: pick("packageDropDwellSec"),
+		packageDropMinBboxAreaFrac: pick("packageDropMinBboxAreaFrac"),
+		packageDropPickupEnabled: pick("packageDropPickupEnabled"),
+		packageDropClassFilter: pick("packageDropClassFilter")
+	};
+}
+//#endregion
+//#region src/pipeline-analytics/pipeline/package-drop-detector.ts
+/** The class every durable package event carries. */
+var PACKAGE_EVENT_CLASS = "package";
+/** Fixed high importance — package delivery is inherently high-signal (§6). */
+var PACKAGE_IMPORTANCE = 1;
+/** Object-event `state` used for a delivery (a parked package) / a pick-up
+*  (its departure). Both are valid `TrackState` enum members so the events
+*  stay `getObjectEvents`-output-valid. */
+var DELIVERED_STATE = "idle";
+var PICKED_UP_STATE = "left";
+/** Deterministic durable-event ids keyed on the stationary entry id. */
+function deliveredEventId(entryId) {
+	return `pa-pkg-${entryId}-delivered`;
+}
+function pickedUpEventId(entryId) {
+	return `pa-pkg-${entryId}-pickedup`;
+}
+var PackageDropDetector = class {
+	deps;
+	constructor(deps) {
+		this.deps = deps;
+	}
+	/** Single entrypoint — bridge the registry's `onChange` here. Never
+	*  throws (telemetry-lossy, D8): a failure only misses one package event. */
+	async onStationaryChange(change) {
+		try {
+			if (change.phase === "appeared") await this.onAppeared(change.entry, change.timestamp);
+			else await this.onDeparted(change.entry, change.timestamp);
+		} catch (err) {
+			this.deps.onError?.("onStationaryChange", err);
+			this.deps.logger.warn("package-drop detector failed on change", {
+				tags: { deviceId: change.entry.deviceId },
+				meta: {
+					phase: change.phase,
+					entryId: change.entry.id,
+					error: err instanceof Error ? err.message : String(err)
+				}
+			});
+		}
+	}
+	async onAppeared(entry, timestamp) {
+		const settings = await this.deps.resolveSettings(entry.deviceId);
+		if (!settings.packageDropEnabled) return;
+		if (!settings.packageDropClassFilter.includes(entry.className)) return;
+		const rules = (await this.deps.resolvePackageRules(entry.deviceId)).filter((r) => r.enabled !== false);
+		if (rules.length === 0) return;
+		const ruleZoneIds = new Set(rules.flatMap((r) => r.zoneIds));
+		const hitZones = computeStationaryEntryZones(entry, await this.deps.resolveZones(entry.deviceId)).filter((z) => ruleZoneIds.has(z));
+		if (hitZones.length === 0) return;
+		if (timestamp - entry.firstSeenAt < settings.packageDropDwellSec * 1e3) return;
+		const frameArea = entry.frameWidth * entry.frameHeight;
+		if (frameArea <= 0) return;
+		if (entry.bbox.w * entry.bbox.h / frameArea < settings.packageDropMinBboxAreaFrac) return;
+		const eventId = deliveredEventId(entry.id);
+		if ((await this.deps.events.queryObject({
+			deviceId: entry.deviceId,
+			classFilter: "package"
+		})).some((e) => e.id === eventId)) return;
+		const ev = {
+			id: eventId,
+			kind: "object",
+			deviceId: entry.deviceId,
+			timestamp,
+			source: "pipeline",
+			trackId: entry.sourceTrackId ?? entry.id,
+			className: PACKAGE_EVENT_CLASS,
+			...entry.label !== void 0 ? { label: entry.label } : {},
+			confidence: PACKAGE_IMPORTANCE,
+			bbox: {
+				x: entry.bbox.x,
+				y: entry.bbox.y,
+				w: entry.bbox.w,
+				h: entry.bbox.h
+			},
+			zones: hitZones,
+			state: DELIVERED_STATE,
+			frameWidth: entry.frameWidth,
+			frameHeight: entry.frameHeight,
+			...entry.keyFrameMediaKey !== void 0 ? { mediaKey: entry.keyFrameMediaKey } : {},
+			importance: PACKAGE_IMPORTANCE
+		};
+		await this.deps.events.insertObject(ev);
+		this.deps.emit.delivered({
+			deviceId: entry.deviceId,
+			entryId: entry.id,
+			eventId,
+			className: entry.className,
+			zoneIds: hitZones,
+			...entry.keyFrameMediaKey !== void 0 ? { keyFrameMediaKey: entry.keyFrameMediaKey } : {},
+			bbox: {
+				x: entry.bbox.x,
+				y: entry.bbox.y,
+				w: entry.bbox.w,
+				h: entry.bbox.h
+			},
+			timestamp
+		});
+	}
+	async onDeparted(entry, timestamp) {
+		if (!(await this.deps.resolveSettings(entry.deviceId)).packageDropPickupEnabled) return;
+		const deliveredId = deliveredEventId(entry.id);
+		const pickedUpId = pickedUpEventId(entry.id);
+		const rows = await this.deps.events.queryObject({
+			deviceId: entry.deviceId,
+			classFilter: PACKAGE_EVENT_CLASS
+		});
+		const delivered = rows.find((e) => e.id === deliveredId);
+		if (delivered === void 0) return;
+		if (rows.some((e) => e.id === pickedUpId)) return;
+		const ev = {
+			id: pickedUpId,
+			kind: "object",
+			deviceId: entry.deviceId,
+			timestamp,
+			source: "pipeline",
+			trackId: entry.sourceTrackId ?? entry.id,
+			className: PACKAGE_EVENT_CLASS,
+			...entry.label !== void 0 ? { label: entry.label } : {},
+			confidence: PACKAGE_IMPORTANCE,
+			bbox: {
+				x: entry.bbox.x,
+				y: entry.bbox.y,
+				w: entry.bbox.w,
+				h: entry.bbox.h
+			},
+			...delivered.zones !== void 0 ? { zones: delivered.zones } : {},
+			state: PICKED_UP_STATE,
+			frameWidth: entry.frameWidth,
+			frameHeight: entry.frameHeight,
+			importance: PACKAGE_IMPORTANCE
+		};
+		await this.deps.events.insertObject(ev);
+		this.deps.emit.pickedUp({
+			deviceId: entry.deviceId,
+			entryId: entry.id,
+			deliveredEventId: deliveredId,
+			className: entry.className,
+			timestamp
+		});
+	}
+};
 function centroidOf(b) {
 	return {
 		x: b.x + b.w / 2,
@@ -10733,6 +11200,8 @@ var PipelineAnalyticsAddon = class extends require_dist.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
@@ -10810,6 +11279,9 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 	/** GLOBAL face-recognition master switch (addon store), TTL-cached. */
 	faceGlobalEnabledCache = null;
 	mediaCacheByDevice = /* @__PURE__ */ new Map();
+	packageDropCacheByDevice = /* @__PURE__ */ new Map();
+	/** Turns stationary appear/depart into package-delivered/picked-up events. */
+	packageDropDetector = null;
 	/** Consecutive detector-dropout frames skipped per (deviceId, source) key. */
 	dropoutSkipsByKey = /* @__PURE__ */ new Map();
 	/** Best (highest-confidence) frame per track — drives the single overwrite
@@ -10892,11 +11364,12 @@ var PipelineAnalyticsAddon = class extends require_dist.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();
 		if (mediaRoot) {
-			const { FilesystemStorageProvider } = await Promise.resolve().then(() => require("../node-K1C_KC3d.js"));
+			const { FilesystemStorageProvider } = await Promise.resolve().then(() => require("../node-DYa6O693.js"));
 			storage = new FilesystemStorageProvider(mediaRoot);
 			logger.info("pipeline-analytics: event media rooted at CAMSTACK_MEDIA_ROOT", { meta: { mediaRoot } });
 		}
@@ -10927,6 +11400,11 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 						timestamp
 					}
 				});
+				this.packageDropDetector?.onStationaryChange({
+					phase,
+					entry,
+					timestamp
+				});
 			}
 		});
 		await this.stationaryRegistry.load();
@@ -10935,15 +11413,55 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 			store: api.settingsStore,
 			logger: logger.child("MediaStore")
 		});
-		this.eventStore = new EventStore({
+		const eventStore = new EventStore({
 			store: api.settingsStore,
 			logger: logger.child("EventStore"),
 			media: this.mediaStore
 		});
+		this.eventStore = eventStore;
 		this.sensorEventStore = new SensorEventStore({
 			store: api.settingsStore,
 			logger: logger.child("SensorEventStore")
 		});
+		this.packageDropDetector = new PackageDropDetector({
+			events: eventStore,
+			emit: {
+				delivered: (payload) => {
+					this.ctx.eventBus.emit({
+						id: `pa-package-delivered-${payload.entryId}`,
+						timestamp: new Date(payload.timestamp),
+						source: {
+							type: "addon",
+							id: "pipeline-analytics",
+							addonId: "pipeline-analytics"
+						},
+						category: require_dist.EventCategory.PipelineAnalyticsPackageDelivered,
+						data: { ...payload }
+					});
+				},
+				pickedUp: (payload) => {
+					this.ctx.eventBus.emit({
+						id: `pa-package-pickedup-${payload.entryId}`,
+						timestamp: new Date(payload.timestamp),
+						source: {
+							type: "addon",
+							id: "pipeline-analytics",
+							addonId: "pipeline-analytics"
+						},
+						category: require_dist.EventCategory.PipelineAnalyticsPackagePickedUp,
+						data: { ...payload }
+					});
+				}
+			},
+			logger: logger.child("PackageDropDetector"),
+			resolveZones: (deviceId) => this.resolveDeviceZones(deviceId),
+			resolvePackageRules: (deviceId) => this.resolveDevicePackageRules(deviceId),
+			resolveSettings: (deviceId) => this.resolveDevicePackageDropSettings(deviceId),
+			onError: (scope, err) => logger.warn("package-drop detector error", { meta: {
+				scope,
+				error: require_dist.errMsg(err)
+			} })
+		});
 		this.linkedCamerasCache = new LinkedCamerasCache({
 			cameras: { listCameraIds: async () => {
 				return (await api.deviceManager.listAll.query({})).filter((d) => d.isCamera).map((d) => d.id);
@@ -10972,6 +11490,11 @@ var PipelineAnalyticsAddon = class extends require_dist.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;
@@ -11223,6 +11746,7 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 				this.trackingCacheByDevice.delete(data.deviceId);
 				this.faceCacheByDevice.delete(data.deviceId);
 				this.mediaCacheByDevice.delete(data.deviceId);
+				this.packageDropCacheByDevice.delete(data.deviceId);
 			}
 		});
 		this.unsubDeviceUnreg = this.ctx.eventBus.subscribe({ category: require_dist.EventCategory.DeviceUnregistered }, (ev) => {
@@ -11238,6 +11762,7 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 			this.trackingCacheByDevice.delete(deviceId);
 			this.faceCacheByDevice.delete(deviceId);
 			this.mediaCacheByDevice.delete(deviceId);
+			this.packageDropCacheByDevice.delete(deviceId);
 			this.bindingCache?.invalidate(deviceId);
 			this.zoneAnalytics?.forgetDevice(deviceId);
 			this.audioMetrics?.forgetDevice(deviceId);
@@ -11585,6 +12110,7 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 		this.faceCacheByDevice.clear();
 		this.faceGlobalEnabledCache = null;
 		this.mediaCacheByDevice.clear();
+		this.packageDropCacheByDevice.clear();
 		this.trackStore?.clearAll();
 		this.stationaryRegistry = null;
 		this.bindingCache?.clearAll();
@@ -12060,6 +12586,32 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 		});
 		return settings;
 	}
+	async resolveDevicePackageDropSettings(deviceId) {
+		const now = Date.now();
+		const cached = this.packageDropCacheByDevice.get(deviceId);
+		if (cached && now < cached.expiresAt) return cached.settings;
+		const settings = resolvePackageDropSettings(await this.ctx?.settings?.readDeviceStore(deviceId) ?? {});
+		this.packageDropCacheByDevice.set(deviceId, {
+			settings,
+			expiresAt: now + SETTINGS_CACHE_TTL_MS
+		});
+		return settings;
+	}
+	/**
+	* Resolve a device's ENABLED `package`-stage zone rules independent of the
+	* live frame path (mirrors `resolveDeviceZones`). Warms the proxy and,
+	* when the cached slice is empty, forces one refresh. The `package` slice
+	* is written by the orchestrator's package-stage provider (a later slice);
+	* until then this returns `[]` and no package events fire.
+	*/
+	async resolveDevicePackageRules(deviceId) {
+		const proxy = await this.ensureProxy(deviceId);
+		if (!proxy) return [];
+		const cached = proxy.state.zoneRules.value?.package;
+		if (cached && cached.length > 0) return cached;
+		await proxy.state.zoneRules.refresh().catch(() => void 0);
+		return proxy.state.zoneRules.value?.package ?? [];
+	}
 	/**
 	* Route one track's `runDetailSubtree` results (two-plane detail dispatch)
 	* into the EXISTING per-track consumers, discriminated by payload SHAPE:
@@ -13161,6 +13713,9 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 			linkedDevices: { getLinkedDevices: (i) => api.deviceManager.getLinkedDevices.query(i) },
 			bindings: { getBindings: (i) => api.deviceManager.getBindings.query(i) },
 			observedClassNames: async (deviceId) => this.trackStore?.observedClassNames(deviceId) ?? [],
+			packageZonesEnabled: async (deviceId) => {
+				return (await this.resolveDevicePackageRules(deviceId)).some((r) => r.enabled !== false);
+			},
 			onError: (scope, err) => this.ctx.logger.warn("listEventKinds: partial compose", {
 				tags: { deviceId: input.deviceId },
 				meta: {
@@ -13445,6 +14000,120 @@ var PipelineAnalyticsAddon = class extends require_dist.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
@@ -13824,6 +14493,51 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 					}
 				]
 			},
+			{
+				id: "package-drop",
+				title: "Package detection",
+				description: "Detect a delivered package (a package-class object left parked inside a package zone) and, symmetrically, its pick-up. Draw the package zone in the zone editor; enable the package class in the object-detection step. Per-device override.",
+				columns: 2,
+				fields: [
+					{
+						type: "boolean",
+						key: "packageDropEnabled",
+						label: "Enable package detection",
+						description: "Turn package delivered / picked-up detection on for this camera (off elsewhere).",
+						default: PACKAGE_DROP_DEFAULTS.packageDropEnabled
+					},
+					{
+						type: "boolean",
+						key: "packageDropPickupEnabled",
+						label: "Emit pick-up",
+						description: "Also emit a package-picked-up event when the delivered package leaves.",
+						default: PACKAGE_DROP_DEFAULTS.packageDropPickupEnabled
+					},
+					{
+						type: "slider",
+						key: "packageDropDwellSec",
+						label: "Minimum dwell",
+						description: "How long a package must stay parked before it counts as a delivery. Higher = fewer false positives from bags briefly set down.",
+						min: 0,
+						max: 300,
+						step: 5,
+						default: PACKAGE_DROP_DEFAULTS.packageDropDwellSec,
+						showValue: true,
+						unit: "s"
+					},
+					{
+						type: "slider",
+						key: "packageDropMinBboxAreaFrac",
+						label: "Minimum package size",
+						description: "Reject tiny far-field blobs: the package box must cover at least this fraction of the frame.",
+						min: 0,
+						max: .1,
+						step: .001,
+						default: PACKAGE_DROP_DEFAULTS.packageDropMinBboxAreaFrac,
+						showValue: true
+					}
+				]
+			},
 			{
 				id: "audio-detection",
 				title: "Audio detection",