@camstack/addon-post-analysis 1.1.32 → 1.1.33

package/dist/pipeline-analytics/index.mjs

@@ -1,4 +1,4 @@
-import { C as EventCategory, S as string, _ as createEvent, a as cosineSimilarity, b as number, 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, x as object, y as boolean } from "../dist-CyyCe4TK.mjs";
+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 { randomUUID } from "node:crypto";
 import sharp from "sharp";
 //#region src/pipeline-analytics/videoclips-provider.ts
@@ -5396,6 +5396,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",
@@ -5473,6 +5474,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();
@@ -7325,6 +7354,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 = object({
+	/** Master switch — off by default; opt-in per camera (porch/door cams). */
+	packageDropEnabled: 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: number().int().min(0).max(3600).default(15),
+	/** Reject tiny far-field blobs: min bbox area as a fraction of the frame. */
+	packageDropMinBboxAreaFrac: number().min(0).max(1).default(.004),
+	/** Emit `package-picked-up` when a delivered package's entry departs. */
+	packageDropPickupEnabled: 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: array(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,
@@ -10805,6 +11036,9 @@ var PipelineAnalyticsAddon = class extends 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
@@ -10922,6 +11156,11 @@ var PipelineAnalyticsAddon = class extends BaseAddon {
 						timestamp
 					}
 				});
+				this.packageDropDetector?.onStationaryChange({
+					phase,
+					entry,
+					timestamp
+				});
 			}
 		});
 		await this.stationaryRegistry.load();
@@ -10930,15 +11169,55 @@ var PipelineAnalyticsAddon = class extends 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: 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: 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: errMsg(err)
+			} })
+		});
 		this.linkedCamerasCache = new LinkedCamerasCache({
 			cameras: { listCameraIds: async () => {
 				return (await api.deviceManager.listAll.query({})).filter((d) => d.isCamera).map((d) => d.id);
@@ -11218,6 +11497,7 @@ var PipelineAnalyticsAddon = class extends 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: EventCategory.DeviceUnregistered }, (ev) => {
@@ -11233,6 +11513,7 @@ var PipelineAnalyticsAddon = class extends 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);
@@ -11580,6 +11861,7 @@ var PipelineAnalyticsAddon = class extends BaseAddon {
 		this.faceCacheByDevice.clear();
 		this.faceGlobalEnabledCache = null;
 		this.mediaCacheByDevice.clear();
+		this.packageDropCacheByDevice.clear();
 		this.trackStore?.clearAll();
 		this.stationaryRegistry = null;
 		this.bindingCache?.clearAll();
@@ -12055,6 +12337,32 @@ var PipelineAnalyticsAddon = class extends 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:
@@ -13156,6 +13464,9 @@ var PipelineAnalyticsAddon = class extends 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: {
@@ -13819,6 +14130,51 @@ var PipelineAnalyticsAddon = class extends 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",

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-aNR1K97R.mjs")).catch((e) => {
+	return l ||= d(() => import("./_virtual_mf-localSharedImportMap___mfe_internal__addon_pipeline_analytics_widgets-BbAKLasA.mjs")).catch((e) => {
 		throw l = void 0, e;
 	}), l;
 }

package/package.json

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