@camstack/addon-post-analysis 1.2.9 → 1.2.11

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-Bezh0l-m.js");
+const require_dist = require("../dist-B5fLGGEF.js");
 let node_crypto = require("node:crypto");
 let sharp = require("sharp");
 sharp = require_dist.__toESM(sharp);
@@ -4347,17 +4347,25 @@ var NcDispatcher = class {
 };
 function buildTemplateVars(entry, deviceName) {
 	const subject = entry.payload.subject;
+	const occupancy = subject.occupancy;
 	return {
 		camera: deviceName,
 		class: subject.className,
 		label: subject.label ?? "",
 		zones: subject.zones.join(", "),
-		zone: subject.zones[0] ?? "",
+		zone: occupancy?.zone ?? subject.zones[0] ?? "",
 		confidence: subject.confidence !== void 0 ? `${Math.round(subject.confidence * 100)}%` : "",
 		time: new Date(subject.timestamp).toLocaleTimeString(),
-		rule: entry.payload.ruleName
+		rule: entry.payload.ruleName,
+		count: occupancy !== void 0 ? `${occupancy.count}` : "",
+		capacity: occupancy !== void 0 ? `${occupancy.capacity}` : "",
+		op: occupancy !== void 0 ? occupancyOpWord(occupancy.occupied) : ""
 	};
 }
+/** The human-readable edge polarity used by `{{op}}` and the default body. */
+function occupancyOpWord(occupied) {
+	return occupied ? "occupied" : "free";
+}
 /** `{{var}}` interpolation; missing vars render empty. Null template → null. */
 function renderTemplate(template, vars) {
 	if (template === void 0 || template.trim().length === 0) return null;
@@ -4365,6 +4373,8 @@ function renderTemplate(template, vars) {
 }
 function defaultBody(entry, deviceName) {
 	const subject = entry.payload.subject;
+	const occupancy = subject.occupancy;
+	if (occupancy !== void 0) return `${occupancy.zone ?? deviceName} ${occupancyOpWord(occupancy.occupied)} (${occupancy.count}/${occupancy.capacity})`;
 	const label = subject.label !== void 0 ? ` (${subject.label})` : "";
 	const zones = subject.zones.length > 0 ? ` in ${subject.zones.join(", ")}` : "";
 	const suffix = entry.recordKind === "track-end" ? " — visit ended" : "";
@@ -4387,63 +4397,236 @@ function clampPriority(priority) {
 	return Math.max(1, Math.min(5, Math.round(priority)));
 }
 //#endregion
-//#region src/notification-center/outbox.ts
-var NC_OUTBOX_COLLECTION = "notification-center:outbox";
-var NC_META_COLLECTION = "notification-center:meta";
-var NC_WATERMARK_KEY = "watermark";
-var NC_OUTBOX_COLUMNS = [
+//#region src/notification-center/occupancy-watcher.ts
+/** Sentinel key segments for the "no zone" (whole-frame) and "no class" scopes. */
+var FRAME_SCOPE = "@frame";
+var ALL_CLASSES = "@all";
+/** Prefix marking the trailing threshold segment (`t<n>`) — makes the grammar
+*  self-describing so a legacy three-segment key can never be mis-parsed as a
+*  four-segment one (the last segment of a legacy key is a className, never a
+*  `t<digits>` token). */
+var THRESHOLD_PREFIX = "t";
+var THRESHOLD_SEGMENT = /^t(\d+)$/;
+function occupancyKey(deviceId, zoneId, className, threshold) {
+	return `${deviceId}|${zoneId ?? FRAME_SCOPE}|${className ?? ALL_CLASSES}|${THRESHOLD_PREFIX}${threshold}`;
+}
+/**
+* Inverse of {@link occupancyKey} — the ONE place the key grammar is decoded, so
+* the durable store (whose column schema drops the derivable
+* `zoneId`/`className`/`threshold`) can reconstruct the full scope on reseed.
+*
+* The four-segment grammar is asserted EXACTLY: at least four segments AND a
+* trailing `t<digits>` threshold marker. A legacy three-segment key (no marker)
+* is REJECTED (`null`) rather than positionally mis-parsed — the durable store
+* then SKIPS that row, so a pre-amendment persisted row cold-re-observes instead
+* of hydrating a corrupt scope (className←threshold, zoneId←class). `deviceId`
+* is the leading numeric segment, `threshold` the trailing `t<n>`, `className`
+* the segment before it, and the (possibly `|`-containing) `zoneId` everything
+* between. Exact per-segment count is impossible because a `zoneId` may itself
+* contain `|`; the trailing marker is the unambiguous grammar discriminator.
+*/
+function parseOccupancyKey(key) {
+	const parts = key.split("|");
+	if (parts.length < 4) return null;
+	const deviceId = Number(parts[0]);
+	if (!Number.isFinite(deviceId)) return null;
+	const thresholdMatch = THRESHOLD_SEGMENT.exec(parts[parts.length - 1] ?? "");
+	if (thresholdMatch === null) return null;
+	const threshold = Number(thresholdMatch[1]);
+	const className = parts[parts.length - 2] ?? ALL_CLASSES;
+	const zoneId = parts.slice(1, -2).join("|");
+	return {
+		deviceId,
+		...zoneId !== FRAME_SCOPE ? { zoneId } : {},
+		...className !== ALL_CLASSES ? { className } : {},
+		threshold
+	};
+}
+/** Device-agnostic partial key (`zone|class|t<threshold>`) — the merge/watch
+*  granularity. Distinct thresholds are distinct partial keys (per-threshold). */
+function partialKey(zoneId, className, threshold) {
+	return `${zoneId ?? FRAME_SCOPE}|${className ?? ALL_CLASSES}|${THRESHOLD_PREFIX}${threshold}`;
+}
+/** The device-agnostic partial key of a full state/edge key — everything after
+*  the leading `deviceId|` segment. */
+function partialKeyOf(key) {
+	const idx = key.indexOf("|");
+	return idx < 0 ? key : key.slice(idx + 1);
+}
+var OccupancyWatcher = class {
+	/** Watched specs, keyed by their device-agnostic partial key. */
+	watched = /* @__PURE__ */ new Map();
+	/** Confirmed + pending state, keyed by the full {@link OccupancyKey}. */
+	states = /* @__PURE__ */ new Map();
+	/**
+	* Replace the watched key set (rule-driven — recomputed on rule change).
+	* Each distinct `(zone, class, threshold)` is its OWN watched partial key
+	* (per-threshold edges — NO min-threshold merge). Specs that collide on the
+	* SAME `(zone, class, threshold)` merge to the MAX sustain (longest debounce),
+	* so one watcher serves those co-threshold rules. Confirmed state for a key
+	* that is no longer watched is DROPPED (bounds the RAM map + lets the caller
+	* prune the durable row to the active set); a still-watched key retains its
+	* level (re-evaluated on the next `observe`).
+	*/
+	setWatchedKeys(specs) {
+		this.watched.clear();
+		for (const spec of specs) {
+			const pk = partialKey(spec.zoneId, spec.className, spec.threshold);
+			const existing = this.watched.get(pk);
+			if (existing === void 0) {
+				this.watched.set(pk, {
+					...spec.zoneId !== void 0 ? { zoneId: spec.zoneId } : {},
+					...spec.className !== void 0 ? { className: spec.className } : {},
+					threshold: spec.threshold,
+					sustainSeconds: spec.sustainSeconds
+				});
+				continue;
+			}
+			this.watched.set(pk, {
+				...existing,
+				sustainSeconds: Math.max(existing.sustainSeconds, spec.sustainSeconds)
+			});
+		}
+		for (const key of [...this.states.keys()]) if (!this.watched.has(partialKeyOf(key))) this.states.delete(key);
+	}
+	/**
+	* Feed one camera snapshot at time `now`, returning the edges that COMMIT on
+	* this tick (usually none). Every watched key is evaluated for `deviceId`;
+	* fail-closed keys (absent zone) are skipped and hold no state.
+	*/
+	observe(deviceId, snapshot, now) {
+		const edges = [];
+		for (const spec of this.watched.values()) {
+			const resolved = resolveScope(snapshot, spec);
+			if (resolved === null) continue;
+			const key = occupancyKey(deviceId, spec.zoneId, spec.className, spec.threshold);
+			const edge = step(this.stateFor(key, deviceId, spec, now), spec, resolved, now);
+			if (edge !== null) edges.push(edge);
+		}
+		return edges;
+	}
+	/** Reseed confirmed state from durable rows (boot). Only rows whose key is
+	*  currently WATCHED are restored — an orphaned durable row (its rule gone)
+	*  is dropped, keeping the RAM map bounded to the active set. Pending edges
+	*  are not restored (fail-closed — they re-open on the next snapshots). */
+	hydrate(rows) {
+		for (const row of rows) {
+			if (!this.watched.has(partialKeyOf(row.key))) continue;
+			this.states.set(row.key, {
+				deviceId: row.deviceId,
+				...row.zoneId !== void 0 ? { zoneId: row.zoneId } : {},
+				...row.className !== void 0 ? { className: row.className } : {},
+				threshold: row.threshold,
+				confirmedCount: row.confirmedCount,
+				occupied: row.occupied,
+				lastChangeAt: row.lastChangeAt
+			});
+		}
+	}
+	/** Snapshot the CONFIRMED state for durable persistence (pending excluded). */
+	snapshotState() {
+		const rows = [];
+		for (const [key, state] of this.states) rows.push({
+			key,
+			deviceId: state.deviceId,
+			...state.zoneId !== void 0 ? { zoneId: state.zoneId } : {},
+			...state.className !== void 0 ? { className: state.className } : {},
+			threshold: state.threshold,
+			confirmedCount: state.confirmedCount,
+			occupied: state.occupied,
+			lastChangeAt: state.lastChangeAt,
+			updatedAt: state.lastChangeAt
+		});
+		return rows;
+	}
+	stateFor(key, deviceId, spec, now) {
+		const existing = this.states.get(key);
+		if (existing !== void 0) return existing;
+		const fresh = {
+			deviceId,
+			...spec.zoneId !== void 0 ? { zoneId: spec.zoneId } : {},
+			...spec.className !== void 0 ? { className: spec.className } : {},
+			threshold: spec.threshold,
+			confirmedCount: 0,
+			occupied: false,
+			lastChangeAt: now
+		};
+		this.states.set(key, fresh);
+		return fresh;
+	}
+};
+/** Read the count (+ zone name) for a spec, or `null` when fail-closed. */
+function resolveScope(snapshot, spec) {
+	if (spec.zoneId === void 0) return { count: spec.className === void 0 ? snapshot.frame.totalObjects : snapshot.frame.byClass[spec.className] ?? 0 };
+	const zone = snapshot.zones.find((z) => z.zoneId === spec.zoneId);
+	if (zone === void 0) return null;
+	return {
+		count: spec.className === void 0 ? zone.totalObjects : zone.byClass[spec.className] ?? 0,
+		zoneName: zone.zoneName
+	};
+}
+/**
+* Advance one key's state by one observation. Mutates `state` in place (the
+* watcher owns it) and returns a committed edge, or `null`.
+*/
+function step(state, spec, resolved, now) {
+	const rawOccupied = resolved.count >= spec.threshold;
+	const sustainMs = spec.sustainSeconds * 1e3;
+	if (rawOccupied === state.occupied) {
+		state.pendingTargetOccupied = void 0;
+		state.pendingSince = void 0;
+		return null;
+	}
+	if (state.pendingTargetOccupied !== rawOccupied) {
+		state.pendingTargetOccupied = rawOccupied;
+		state.pendingSince = now;
+	}
+	if (now - (state.pendingSince ?? now) < sustainMs) return null;
+	const previousCount = state.confirmedCount;
+	state.confirmedCount = resolved.count;
+	state.occupied = rawOccupied;
+	state.lastChangeAt = now;
+	state.pendingTargetOccupied = void 0;
+	state.pendingSince = void 0;
+	return {
+		deviceId: state.deviceId,
+		...spec.zoneId !== void 0 ? { zoneId: spec.zoneId } : {},
+		...resolved.zoneName !== void 0 ? { zoneName: resolved.zoneName } : {},
+		...spec.className !== void 0 ? { className: spec.className } : {},
+		count: resolved.count,
+		previousCount,
+		occupied: rawOccupied,
+		threshold: spec.threshold,
+		timestamp: now
+	};
+}
+//#endregion
+//#region src/notification-center/occupancy-store.ts
+var NC_OCCUPANCY_COLLECTION = "notification-center:occupancy";
+var NC_OCCUPANCY_COLUMNS = [
 	{
-		name: "id",
+		name: "key",
 		type: "TEXT",
 		primaryKey: true,
 		notNull: true
 	},
-	{
-		name: "ruleId",
-		type: "TEXT",
-		notNull: true
-	},
-	{
-		name: "targetId",
-		type: "TEXT",
-		notNull: true
-	},
 	{
 		name: "deviceId",
 		type: "INTEGER",
 		notNull: true
 	},
 	{
-		name: "recordKind",
-		type: "TEXT",
-		notNull: true
-	},
-	{
-		name: "recordId",
-		type: "TEXT",
-		notNull: true
-	},
-	{
-		name: "trackId",
-		type: "TEXT"
-	},
-	{
-		name: "status",
-		type: "TEXT",
-		notNull: true
-	},
-	{
-		name: "attempts",
+		name: "confirmedCount",
 		type: "INTEGER",
 		notNull: true
 	},
 	{
-		name: "nextAttemptAt",
-		type: "INTEGER",
+		name: "occupied",
+		type: "BOOLEAN",
 		notNull: true
 	},
 	{
-		name: "createdAt",
+		name: "lastChangeAt",
 		type: "INTEGER",
 		notNull: true
 	},
@@ -4451,10 +4634,216 @@ var NC_OUTBOX_COLUMNS = [
 		name: "updatedAt",
 		type: "INTEGER",
 		notNull: true
-	},
-	{
-		name: "lastError",
-		type: "TEXT"
+	}
+];
+var NC_OCCUPANCY_INDEXES = [{
+	name: "idx_nc_occupancy_device",
+	columns: ["deviceId"]
+}];
+/** Query cap — a per-(device, zone, class) key set is small; this is a
+*  generous ceiling that still bounds a pathological read. */
+var LOAD_LIMIT = 1e5;
+var OccupancyStore = class {
+	cache = /* @__PURE__ */ new Map();
+	store;
+	logger;
+	constructor(deps) {
+		this.store = deps.store;
+		this.logger = deps.logger;
+	}
+	static async declare(store) {
+		await store.declareCollection.mutate({
+			collection: NC_OCCUPANCY_COLLECTION,
+			columns: [...NC_OCCUPANCY_COLUMNS],
+			indexes: [...NC_OCCUPANCY_INDEXES]
+		});
+	}
+	/**
+	* Reseed the confirmed edge-state from the store (boot) — replaces the cache
+	* wholesale and returns the rows for {@link OccupancyWatcher.hydrate}. A row
+	* whose scalars/key no longer parse is skipped with a warning (a degraded row
+	* must never crash the reseed). Best-effort: a store error yields `[]` and a
+	* cold watcher, never a throw into boot.
+	*/
+	async load() {
+		try {
+			const records = await this.store.query.query({
+				collection: NC_OCCUPANCY_COLLECTION,
+				filter: { limit: LOAD_LIMIT }
+			});
+			this.cache.clear();
+			let skipped = 0;
+			for (const record of records) {
+				const row = recordToRow(record.id, record.data);
+				if (row === null) {
+					skipped += 1;
+					continue;
+				}
+				this.cache.set(row.key, row);
+			}
+			this.logger.debug("occupancy state loaded", { meta: {
+				keys: this.cache.size,
+				...skipped > 0 ? { skippedInvalid: skipped } : {}
+			} });
+			return [...this.cache.values()];
+		} catch (err) {
+			this.logger.warn("occupancy state load failed", { meta: { error: String(err) } });
+			return [];
+		}
+	}
+	/** The in-RAM confirmed-state mirror (post-{@link load}/{@link persist}). */
+	snapshot() {
+		return [...this.cache.values()];
+	}
+	/**
+	* Durably upsert one confirmed edge-state row (write-through: the store FIRST,
+	* then the cache — a failed persist never leaves a phantom in-RAM level). The
+	* `key` is the PK, so re-persisting a key advances it in place.
+	*/
+	async persist(row) {
+		await this.store.set.mutate({
+			collection: NC_OCCUPANCY_COLLECTION,
+			key: row.key,
+			value: rowToValue(row)
+		});
+		this.cache.set(row.key, row);
+	}
+	/**
+	* Prune every persisted key NOT in `activeKeys` (the currently watched set) —
+	* the bounded-row-count guarantee when rules stop watching a key. Returns the
+	* number of rows dropped. Best-effort per row: a failed delete is logged and
+	* the key retained (retried next prune) rather than aborting the sweep.
+	*/
+	async pruneExcept(activeKeys) {
+		let pruned = 0;
+		for (const key of [...this.cache.keys()]) {
+			if (activeKeys.has(key)) continue;
+			try {
+				await this.store.delete.mutate({
+					collection: NC_OCCUPANCY_COLLECTION,
+					key
+				});
+				this.cache.delete(key);
+				pruned += 1;
+			} catch (err) {
+				this.logger.debug("occupancy prune delete failed", { meta: {
+					key,
+					error: String(err)
+				} });
+			}
+		}
+		return pruned;
+	}
+};
+/** The persisted column map for a row (the `key` PK is passed separately). */
+function rowToValue(row) {
+	return {
+		deviceId: row.deviceId,
+		confirmedCount: row.confirmedCount,
+		occupied: row.occupied,
+		lastChangeAt: row.lastChangeAt,
+		updatedAt: row.updatedAt
+	};
+}
+/**
+* Structurally validate a persisted record and reconstruct the full
+* {@link OccupancyStateRow} (deriving `zoneId`/`className`/`threshold` from the
+* key). Returns `null` for any malformed row — including a legacy
+* three-segment key with no `t<n>` threshold marker, which
+* {@link parseOccupancyKey} rejects — so the caller skips it (cold re-observe)
+* rather than hydrating a mis-parsed scope.
+*/
+function recordToRow(key, data) {
+	const scope = parseOccupancyKey(key);
+	if (scope === null) return null;
+	const deviceId = Number(data["deviceId"]);
+	const confirmedCount = Number(data["confirmedCount"]);
+	const lastChangeAt = Number(data["lastChangeAt"]);
+	const updatedAt = Number(data["updatedAt"]);
+	if (!Number.isFinite(deviceId) || !Number.isFinite(confirmedCount) || !Number.isFinite(lastChangeAt) || !Number.isFinite(updatedAt)) return null;
+	const rawOccupied = data["occupied"];
+	const occupied = rawOccupied === true || rawOccupied === 1;
+	return {
+		key,
+		deviceId,
+		...scope.zoneId !== void 0 ? { zoneId: scope.zoneId } : {},
+		...scope.className !== void 0 ? { className: scope.className } : {},
+		threshold: scope.threshold,
+		confirmedCount,
+		occupied,
+		lastChangeAt,
+		updatedAt
+	};
+}
+//#endregion
+//#region src/notification-center/outbox.ts
+var NC_OUTBOX_COLLECTION = "notification-center:outbox";
+var NC_META_COLLECTION = "notification-center:meta";
+var NC_WATERMARK_KEY = "watermark";
+var NC_OUTBOX_COLUMNS = [
+	{
+		name: "id",
+		type: "TEXT",
+		primaryKey: true,
+		notNull: true
+	},
+	{
+		name: "ruleId",
+		type: "TEXT",
+		notNull: true
+	},
+	{
+		name: "targetId",
+		type: "TEXT",
+		notNull: true
+	},
+	{
+		name: "deviceId",
+		type: "INTEGER",
+		notNull: true
+	},
+	{
+		name: "recordKind",
+		type: "TEXT",
+		notNull: true
+	},
+	{
+		name: "recordId",
+		type: "TEXT",
+		notNull: true
+	},
+	{
+		name: "trackId",
+		type: "TEXT"
+	},
+	{
+		name: "status",
+		type: "TEXT",
+		notNull: true
+	},
+	{
+		name: "attempts",
+		type: "INTEGER",
+		notNull: true
+	},
+	{
+		name: "nextAttemptAt",
+		type: "INTEGER",
+		notNull: true
+	},
+	{
+		name: "createdAt",
+		type: "INTEGER",
+		notNull: true
+	},
+	{
+		name: "updatedAt",
+		type: "INTEGER",
+		notNull: true
+	},
+	{
+		name: "lastError",
+		type: "TEXT"
 	},
 	{
 		name: "payload",
@@ -4659,586 +5048,207 @@ var NcOutbox = class {
 						field: "createdAt",
 						direction: "desc"
 					},
-					limit: query.limit
-				}
-			});
-			const out = [];
-			for (const row of rows) {
-				const entry = rowToEntry$1(row.id, row.data);
-				if (entry !== null) out.push(entry);
-			}
-			return out;
-		} catch (err) {
-			this.logger.debug("outbox history query failed", { meta: { error: String(err) } });
-			return [];
-		}
-	}
-	async getWatermark() {
-		try {
-			const row = await this.store.get.query({
-				collection: NC_META_COLLECTION,
-				key: NC_WATERMARK_KEY
-			});
-			if (row === null || row === void 0 || typeof row !== "object") return null;
-			const value = row["value"];
-			if (value === null || typeof value !== "object") return null;
-			const ts = value["ts"];
-			return typeof ts === "number" && Number.isFinite(ts) ? ts : null;
-		} catch {
-			return null;
-		}
-	}
-	async setWatermark(ts) {
-		try {
-			await this.store.set.mutate({
-				collection: NC_META_COLLECTION,
-				key: NC_WATERMARK_KEY,
-				value: { value: { ts } }
-			});
-		} catch (err) {
-			this.logger.debug("outbox watermark write failed", { meta: { error: String(err) } });
-		}
-	}
-	/** Drop terminal rows older than `cutoffMs` (retention hygiene). */
-	async pruneBefore(cutoffMs) {
-		let pruned = 0;
-		try {
-			const rows = await this.store.query.query({
-				collection: NC_OUTBOX_COLLECTION,
-				filter: {
-					whereBetween: { createdAt: [0, cutoffMs] },
-					limit: 5e3
-				}
-			});
-			for (const row of rows) {
-				const status = row.data["status"];
-				if (status !== "sent" && status !== "dead") continue;
-				await this.store.delete.mutate({
-					collection: NC_OUTBOX_COLLECTION,
-					key: row.id
-				});
-				this.knownIds.delete(row.id);
-				pruned += 1;
-			}
-		} catch (err) {
-			this.logger.debug("outbox prune failed", { meta: { error: String(err) } });
-		}
-		return pruned;
-	}
-	backoffMs(attempts) {
-		return Math.min(this.backoffBaseMs * 2 ** Math.max(0, attempts - 1), this.backoffCapMs);
-	}
-	async attempt(entry) {
-		let result;
-		try {
-			result = await this.deliver(entry);
-		} catch (err) {
-			result = {
-				ok: false,
-				error: String(err),
-				permanent: false
-			};
-		}
-		const now = this.now();
-		if (result.ok) {
-			const sent = {
-				...entry,
-				status: "sent",
-				updatedAt: now
-			};
-			this.pending.delete(entry.id);
-			await this.mutate(sent);
-			return;
-		}
-		const attempts = entry.attempts + 1;
-		const exhausted = attempts >= this.maxAttempts;
-		if (result.permanent || exhausted) {
-			const dead = {
-				...entry,
-				status: "dead",
-				attempts,
-				updatedAt: now,
-				lastError: result.error
-			};
-			this.pending.delete(entry.id);
-			await this.mutate(dead);
-			this.logger.warn("outbox entry dead-lettered", {
-				tags: { deviceId: entry.deviceId },
-				meta: {
-					id: entry.id,
-					ruleId: entry.ruleId,
-					targetId: entry.targetId,
-					attempts,
-					permanent: result.permanent,
-					error: result.error
-				}
-			});
-			return;
-		}
-		const retry = {
-			...entry,
-			attempts,
-			nextAttemptAt: now + this.backoffMs(attempts),
-			updatedAt: now,
-			lastError: result.error
-		};
-		this.pending.set(entry.id, retry);
-		await this.mutate(retry);
-	}
-	async persist(entry) {
-		await this.store.set.mutate({
-			collection: NC_OUTBOX_COLLECTION,
-			key: entry.id,
-			value: entryToRow(entry)
-		});
-	}
-	async mutate(entry) {
-		try {
-			await this.store.update.mutate({
-				collection: NC_OUTBOX_COLLECTION,
-				id: entry.id,
-				data: entryToRow(entry)
-			});
-		} catch (err) {
-			this.logger.debug("outbox row update failed", { meta: {
-				id: entry.id,
-				error: String(err)
-			} });
-		}
-	}
-};
-function entryToRow(entry) {
-	return {
-		ruleId: entry.ruleId,
-		targetId: entry.targetId,
-		deviceId: entry.deviceId,
-		recordKind: entry.recordKind,
-		recordId: entry.recordId,
-		...entry.trackId !== void 0 ? { trackId: entry.trackId } : {},
-		status: entry.status,
-		attempts: entry.attempts,
-		nextAttemptAt: entry.nextAttemptAt,
-		createdAt: entry.createdAt,
-		updatedAt: entry.updatedAt,
-		...entry.lastError !== void 0 ? { lastError: entry.lastError } : {},
-		payload: entry.payload
-	};
-}
-var OUTBOX_RECORD_KINDS = new Set([
-	"object-event",
-	"track-end",
-	"device-event",
-	"package-event",
-	"audio-event"
-]);
-function isOutboxRecordKind(x) {
-	return typeof x === "string" && OUTBOX_RECORD_KINDS.has(x);
-}
-function rowToEntry$1(id, data) {
-	const ruleId = data["ruleId"];
-	const targetId = data["targetId"];
-	const deviceId = Number(data["deviceId"]);
-	const recordKind = data["recordKind"];
-	const recordId = data["recordId"];
-	const status = data["status"];
-	const payload = data["payload"];
-	if (typeof ruleId !== "string" || typeof targetId !== "string" || !Number.isFinite(deviceId) || !isOutboxRecordKind(recordKind) || typeof recordId !== "string" || status !== "pending" && status !== "sent" && status !== "dead" || payload === null || typeof payload !== "object") return null;
-	const trackId = data["trackId"];
-	const lastError = data["lastError"];
-	return {
-		id,
-		ruleId,
-		targetId,
-		deviceId,
-		recordKind,
-		recordId,
-		...typeof trackId === "string" ? { trackId } : {},
-		status,
-		attempts: Number(data["attempts"] ?? 0),
-		nextAttemptAt: Number(data["nextAttemptAt"] ?? 0),
-		createdAt: Number(data["createdAt"] ?? 0),
-		updatedAt: Number(data["updatedAt"] ?? 0),
-		...typeof lastError === "string" ? { lastError } : {},
-		payload
-	};
-}
-//#endregion
-//#region src/notification-center/occupancy-watcher.ts
-/** Sentinel key segments for the "no zone" (whole-frame) and "no class" scopes. */
-var FRAME_SCOPE = "@frame";
-var ALL_CLASSES = "@all";
-/** Prefix marking the trailing threshold segment (`t<n>`) — makes the grammar
-*  self-describing so a legacy three-segment key can never be mis-parsed as a
-*  four-segment one (the last segment of a legacy key is a className, never a
-*  `t<digits>` token). */
-var THRESHOLD_PREFIX = "t";
-var THRESHOLD_SEGMENT = /^t(\d+)$/;
-function occupancyKey(deviceId, zoneId, className, threshold) {
-	return `${deviceId}|${zoneId ?? FRAME_SCOPE}|${className ?? ALL_CLASSES}|${THRESHOLD_PREFIX}${threshold}`;
-}
-/**
-* Inverse of {@link occupancyKey} — the ONE place the key grammar is decoded, so
-* the durable store (whose column schema drops the derivable
-* `zoneId`/`className`/`threshold`) can reconstruct the full scope on reseed.
-*
-* The four-segment grammar is asserted EXACTLY: at least four segments AND a
-* trailing `t<digits>` threshold marker. A legacy three-segment key (no marker)
-* is REJECTED (`null`) rather than positionally mis-parsed — the durable store
-* then SKIPS that row, so a pre-amendment persisted row cold-re-observes instead
-* of hydrating a corrupt scope (className←threshold, zoneId←class). `deviceId`
-* is the leading numeric segment, `threshold` the trailing `t<n>`, `className`
-* the segment before it, and the (possibly `|`-containing) `zoneId` everything
-* between. Exact per-segment count is impossible because a `zoneId` may itself
-* contain `|`; the trailing marker is the unambiguous grammar discriminator.
-*/
-function parseOccupancyKey(key) {
-	const parts = key.split("|");
-	if (parts.length < 4) return null;
-	const deviceId = Number(parts[0]);
-	if (!Number.isFinite(deviceId)) return null;
-	const thresholdMatch = THRESHOLD_SEGMENT.exec(parts[parts.length - 1] ?? "");
-	if (thresholdMatch === null) return null;
-	const threshold = Number(thresholdMatch[1]);
-	const className = parts[parts.length - 2] ?? ALL_CLASSES;
-	const zoneId = parts.slice(1, -2).join("|");
-	return {
-		deviceId,
-		...zoneId !== FRAME_SCOPE ? { zoneId } : {},
-		...className !== ALL_CLASSES ? { className } : {},
-		threshold
-	};
-}
-/** Device-agnostic partial key (`zone|class|t<threshold>`) — the merge/watch
-*  granularity. Distinct thresholds are distinct partial keys (per-threshold). */
-function partialKey(zoneId, className, threshold) {
-	return `${zoneId ?? FRAME_SCOPE}|${className ?? ALL_CLASSES}|${THRESHOLD_PREFIX}${threshold}`;
-}
-/** The device-agnostic partial key of a full state/edge key — everything after
-*  the leading `deviceId|` segment. */
-function partialKeyOf(key) {
-	const idx = key.indexOf("|");
-	return idx < 0 ? key : key.slice(idx + 1);
-}
-var OccupancyWatcher = class {
-	/** Watched specs, keyed by their device-agnostic partial key. */
-	watched = /* @__PURE__ */ new Map();
-	/** Confirmed + pending state, keyed by the full {@link OccupancyKey}. */
-	states = /* @__PURE__ */ new Map();
-	/**
-	* Replace the watched key set (rule-driven — recomputed on rule change).
-	* Each distinct `(zone, class, threshold)` is its OWN watched partial key
-	* (per-threshold edges — NO min-threshold merge). Specs that collide on the
-	* SAME `(zone, class, threshold)` merge to the MAX sustain (longest debounce),
-	* so one watcher serves those co-threshold rules. Confirmed state for a key
-	* that is no longer watched is DROPPED (bounds the RAM map + lets the caller
-	* prune the durable row to the active set); a still-watched key retains its
-	* level (re-evaluated on the next `observe`).
-	*/
-	setWatchedKeys(specs) {
-		this.watched.clear();
-		for (const spec of specs) {
-			const pk = partialKey(spec.zoneId, spec.className, spec.threshold);
-			const existing = this.watched.get(pk);
-			if (existing === void 0) {
-				this.watched.set(pk, {
-					...spec.zoneId !== void 0 ? { zoneId: spec.zoneId } : {},
-					...spec.className !== void 0 ? { className: spec.className } : {},
-					threshold: spec.threshold,
-					sustainSeconds: spec.sustainSeconds
-				});
-				continue;
-			}
-			this.watched.set(pk, {
-				...existing,
-				sustainSeconds: Math.max(existing.sustainSeconds, spec.sustainSeconds)
-			});
-		}
-		for (const key of [...this.states.keys()]) if (!this.watched.has(partialKeyOf(key))) this.states.delete(key);
-	}
-	/**
-	* Feed one camera snapshot at time `now`, returning the edges that COMMIT on
-	* this tick (usually none). Every watched key is evaluated for `deviceId`;
-	* fail-closed keys (absent zone) are skipped and hold no state.
-	*/
-	observe(deviceId, snapshot, now) {
-		const edges = [];
-		for (const spec of this.watched.values()) {
-			const resolved = resolveScope(snapshot, spec);
-			if (resolved === null) continue;
-			const key = occupancyKey(deviceId, spec.zoneId, spec.className, spec.threshold);
-			const edge = step(this.stateFor(key, deviceId, spec, now), spec, resolved, now);
-			if (edge !== null) edges.push(edge);
-		}
-		return edges;
-	}
-	/** Reseed confirmed state from durable rows (boot). Only rows whose key is
-	*  currently WATCHED are restored — an orphaned durable row (its rule gone)
-	*  is dropped, keeping the RAM map bounded to the active set. Pending edges
-	*  are not restored (fail-closed — they re-open on the next snapshots). */
-	hydrate(rows) {
-		for (const row of rows) {
-			if (!this.watched.has(partialKeyOf(row.key))) continue;
-			this.states.set(row.key, {
-				deviceId: row.deviceId,
-				...row.zoneId !== void 0 ? { zoneId: row.zoneId } : {},
-				...row.className !== void 0 ? { className: row.className } : {},
-				threshold: row.threshold,
-				confirmedCount: row.confirmedCount,
-				occupied: row.occupied,
-				lastChangeAt: row.lastChangeAt
-			});
-		}
-	}
-	/** Snapshot the CONFIRMED state for durable persistence (pending excluded). */
-	snapshotState() {
-		const rows = [];
-		for (const [key, state] of this.states) rows.push({
-			key,
-			deviceId: state.deviceId,
-			...state.zoneId !== void 0 ? { zoneId: state.zoneId } : {},
-			...state.className !== void 0 ? { className: state.className } : {},
-			threshold: state.threshold,
-			confirmedCount: state.confirmedCount,
-			occupied: state.occupied,
-			lastChangeAt: state.lastChangeAt,
-			updatedAt: state.lastChangeAt
-		});
-		return rows;
-	}
-	stateFor(key, deviceId, spec, now) {
-		const existing = this.states.get(key);
-		if (existing !== void 0) return existing;
-		const fresh = {
-			deviceId,
-			...spec.zoneId !== void 0 ? { zoneId: spec.zoneId } : {},
-			...spec.className !== void 0 ? { className: spec.className } : {},
-			threshold: spec.threshold,
-			confirmedCount: 0,
-			occupied: false,
-			lastChangeAt: now
-		};
-		this.states.set(key, fresh);
-		return fresh;
-	}
-};
-/** Read the count (+ zone name) for a spec, or `null` when fail-closed. */
-function resolveScope(snapshot, spec) {
-	if (spec.zoneId === void 0) return { count: spec.className === void 0 ? snapshot.frame.totalObjects : snapshot.frame.byClass[spec.className] ?? 0 };
-	const zone = snapshot.zones.find((z) => z.zoneId === spec.zoneId);
-	if (zone === void 0) return null;
-	return {
-		count: spec.className === void 0 ? zone.totalObjects : zone.byClass[spec.className] ?? 0,
-		zoneName: zone.zoneName
-	};
-}
-/**
-* Advance one key's state by one observation. Mutates `state` in place (the
-* watcher owns it) and returns a committed edge, or `null`.
-*/
-function step(state, spec, resolved, now) {
-	const rawOccupied = resolved.count >= spec.threshold;
-	const sustainMs = spec.sustainSeconds * 1e3;
-	if (rawOccupied === state.occupied) {
-		state.pendingTargetOccupied = void 0;
-		state.pendingSince = void 0;
-		return null;
-	}
-	if (state.pendingTargetOccupied !== rawOccupied) {
-		state.pendingTargetOccupied = rawOccupied;
-		state.pendingSince = now;
-	}
-	if (now - (state.pendingSince ?? now) < sustainMs) return null;
-	const previousCount = state.confirmedCount;
-	state.confirmedCount = resolved.count;
-	state.occupied = rawOccupied;
-	state.lastChangeAt = now;
-	state.pendingTargetOccupied = void 0;
-	state.pendingSince = void 0;
-	return {
-		deviceId: state.deviceId,
-		...spec.zoneId !== void 0 ? { zoneId: spec.zoneId } : {},
-		...resolved.zoneName !== void 0 ? { zoneName: resolved.zoneName } : {},
-		...spec.className !== void 0 ? { className: spec.className } : {},
-		count: resolved.count,
-		previousCount,
-		occupied: rawOccupied,
-		threshold: spec.threshold,
-		timestamp: now
-	};
-}
-//#endregion
-//#region src/notification-center/occupancy-store.ts
-var NC_OCCUPANCY_COLLECTION = "notification-center:occupancy";
-var NC_OCCUPANCY_COLUMNS = [
-	{
-		name: "key",
-		type: "TEXT",
-		primaryKey: true,
-		notNull: true
-	},
-	{
-		name: "deviceId",
-		type: "INTEGER",
-		notNull: true
-	},
-	{
-		name: "confirmedCount",
-		type: "INTEGER",
-		notNull: true
-	},
-	{
-		name: "occupied",
-		type: "BOOLEAN",
-		notNull: true
-	},
-	{
-		name: "lastChangeAt",
-		type: "INTEGER",
-		notNull: true
-	},
-	{
-		name: "updatedAt",
-		type: "INTEGER",
-		notNull: true
-	}
-];
-var NC_OCCUPANCY_INDEXES = [{
-	name: "idx_nc_occupancy_device",
-	columns: ["deviceId"]
-}];
-/** Query cap — a per-(device, zone, class) key set is small; this is a
-*  generous ceiling that still bounds a pathological read. */
-var LOAD_LIMIT = 1e5;
-var OccupancyStore = class {
-	cache = /* @__PURE__ */ new Map();
-	store;
-	logger;
-	constructor(deps) {
-		this.store = deps.store;
-		this.logger = deps.logger;
-	}
-	static async declare(store) {
-		await store.declareCollection.mutate({
-			collection: NC_OCCUPANCY_COLLECTION,
-			columns: [...NC_OCCUPANCY_COLUMNS],
-			indexes: [...NC_OCCUPANCY_INDEXES]
-		});
-	}
-	/**
-	* Reseed the confirmed edge-state from the store (boot) — replaces the cache
-	* wholesale and returns the rows for {@link OccupancyWatcher.hydrate}. A row
-	* whose scalars/key no longer parse is skipped with a warning (a degraded row
-	* must never crash the reseed). Best-effort: a store error yields `[]` and a
-	* cold watcher, never a throw into boot.
-	*/
-	async load() {
-		try {
-			const records = await this.store.query.query({
-				collection: NC_OCCUPANCY_COLLECTION,
-				filter: { limit: LOAD_LIMIT }
-			});
-			this.cache.clear();
-			let skipped = 0;
-			for (const record of records) {
-				const row = recordToRow(record.id, record.data);
-				if (row === null) {
-					skipped += 1;
-					continue;
+					limit: query.limit
 				}
-				this.cache.set(row.key, row);
+			});
+			const out = [];
+			for (const row of rows) {
+				const entry = rowToEntry$1(row.id, row.data);
+				if (entry !== null) out.push(entry);
 			}
-			this.logger.debug("occupancy state loaded", { meta: {
-				keys: this.cache.size,
-				...skipped > 0 ? { skippedInvalid: skipped } : {}
-			} });
-			return [...this.cache.values()];
+			return out;
 		} catch (err) {
-			this.logger.warn("occupancy state load failed", { meta: { error: String(err) } });
+			this.logger.debug("outbox history query failed", { meta: { error: String(err) } });
 			return [];
 		}
 	}
-	/** The in-RAM confirmed-state mirror (post-{@link load}/{@link persist}). */
-	snapshot() {
-		return [...this.cache.values()];
+	async getWatermark() {
+		try {
+			const row = await this.store.get.query({
+				collection: NC_META_COLLECTION,
+				key: NC_WATERMARK_KEY
+			});
+			if (row === null || row === void 0 || typeof row !== "object") return null;
+			const value = row["value"];
+			if (value === null || typeof value !== "object") return null;
+			const ts = value["ts"];
+			return typeof ts === "number" && Number.isFinite(ts) ? ts : null;
+		} catch {
+			return null;
+		}
 	}
-	/**
-	* Durably upsert one confirmed edge-state row (write-through: the store FIRST,
-	* then the cache — a failed persist never leaves a phantom in-RAM level). The
-	* `key` is the PK, so re-persisting a key advances it in place.
-	*/
-	async persist(row) {
-		await this.store.set.mutate({
-			collection: NC_OCCUPANCY_COLLECTION,
-			key: row.key,
-			value: rowToValue(row)
-		});
-		this.cache.set(row.key, row);
+	async setWatermark(ts) {
+		try {
+			await this.store.set.mutate({
+				collection: NC_META_COLLECTION,
+				key: NC_WATERMARK_KEY,
+				value: { value: { ts } }
+			});
+		} catch (err) {
+			this.logger.debug("outbox watermark write failed", { meta: { error: String(err) } });
+		}
 	}
-	/**
-	* Prune every persisted key NOT in `activeKeys` (the currently watched set) —
-	* the bounded-row-count guarantee when rules stop watching a key. Returns the
-	* number of rows dropped. Best-effort per row: a failed delete is logged and
-	* the key retained (retried next prune) rather than aborting the sweep.
-	*/
-	async pruneExcept(activeKeys) {
+	/** Drop terminal rows older than `cutoffMs` (retention hygiene). */
+	async pruneBefore(cutoffMs) {
 		let pruned = 0;
-		for (const key of [...this.cache.keys()]) {
-			if (activeKeys.has(key)) continue;
-			try {
+		try {
+			const rows = await this.store.query.query({
+				collection: NC_OUTBOX_COLLECTION,
+				filter: {
+					whereBetween: { createdAt: [0, cutoffMs] },
+					limit: 5e3
+				}
+			});
+			for (const row of rows) {
+				const status = row.data["status"];
+				if (status !== "sent" && status !== "dead") continue;
 				await this.store.delete.mutate({
-					collection: NC_OCCUPANCY_COLLECTION,
-					key
+					collection: NC_OUTBOX_COLLECTION,
+					key: row.id
 				});
-				this.cache.delete(key);
+				this.knownIds.delete(row.id);
 				pruned += 1;
-			} catch (err) {
-				this.logger.debug("occupancy prune delete failed", { meta: {
-					key,
-					error: String(err)
-				} });
 			}
+		} catch (err) {
+			this.logger.debug("outbox prune failed", { meta: { error: String(err) } });
 		}
 		return pruned;
 	}
+	backoffMs(attempts) {
+		return Math.min(this.backoffBaseMs * 2 ** Math.max(0, attempts - 1), this.backoffCapMs);
+	}
+	async attempt(entry) {
+		let result;
+		try {
+			result = await this.deliver(entry);
+		} catch (err) {
+			result = {
+				ok: false,
+				error: String(err),
+				permanent: false
+			};
+		}
+		const now = this.now();
+		if (result.ok) {
+			const sent = {
+				...entry,
+				status: "sent",
+				updatedAt: now
+			};
+			this.pending.delete(entry.id);
+			await this.mutate(sent);
+			return;
+		}
+		const attempts = entry.attempts + 1;
+		const exhausted = attempts >= this.maxAttempts;
+		if (result.permanent || exhausted) {
+			const dead = {
+				...entry,
+				status: "dead",
+				attempts,
+				updatedAt: now,
+				lastError: result.error
+			};
+			this.pending.delete(entry.id);
+			await this.mutate(dead);
+			this.logger.warn("outbox entry dead-lettered", {
+				tags: { deviceId: entry.deviceId },
+				meta: {
+					id: entry.id,
+					ruleId: entry.ruleId,
+					targetId: entry.targetId,
+					attempts,
+					permanent: result.permanent,
+					error: result.error
+				}
+			});
+			return;
+		}
+		const retry = {
+			...entry,
+			attempts,
+			nextAttemptAt: now + this.backoffMs(attempts),
+			updatedAt: now,
+			lastError: result.error
+		};
+		this.pending.set(entry.id, retry);
+		await this.mutate(retry);
+	}
+	async persist(entry) {
+		await this.store.set.mutate({
+			collection: NC_OUTBOX_COLLECTION,
+			key: entry.id,
+			value: entryToRow(entry)
+		});
+	}
+	async mutate(entry) {
+		try {
+			await this.store.update.mutate({
+				collection: NC_OUTBOX_COLLECTION,
+				id: entry.id,
+				data: entryToRow(entry)
+			});
+		} catch (err) {
+			this.logger.debug("outbox row update failed", { meta: {
+				id: entry.id,
+				error: String(err)
+			} });
+		}
+	}
 };
-/** The persisted column map for a row (the `key` PK is passed separately). */
-function rowToValue(row) {
+function entryToRow(entry) {
 	return {
-		deviceId: row.deviceId,
-		confirmedCount: row.confirmedCount,
-		occupied: row.occupied,
-		lastChangeAt: row.lastChangeAt,
-		updatedAt: row.updatedAt
+		ruleId: entry.ruleId,
+		targetId: entry.targetId,
+		deviceId: entry.deviceId,
+		recordKind: entry.recordKind,
+		recordId: entry.recordId,
+		...entry.trackId !== void 0 ? { trackId: entry.trackId } : {},
+		status: entry.status,
+		attempts: entry.attempts,
+		nextAttemptAt: entry.nextAttemptAt,
+		createdAt: entry.createdAt,
+		updatedAt: entry.updatedAt,
+		...entry.lastError !== void 0 ? { lastError: entry.lastError } : {},
+		payload: entry.payload
 	};
 }
-/**
-* Structurally validate a persisted record and reconstruct the full
-* {@link OccupancyStateRow} (deriving `zoneId`/`className`/`threshold` from the
-* key). Returns `null` for any malformed row — including a legacy
-* three-segment key with no `t<n>` threshold marker, which
-* {@link parseOccupancyKey} rejects — so the caller skips it (cold re-observe)
-* rather than hydrating a mis-parsed scope.
-*/
-function recordToRow(key, data) {
-	const scope = parseOccupancyKey(key);
-	if (scope === null) return null;
+var OUTBOX_RECORD_KINDS = new Set([
+	"object-event",
+	"track-end",
+	"device-event",
+	"package-event",
+	"audio-event"
+]);
+function isOutboxRecordKind(x) {
+	return typeof x === "string" && OUTBOX_RECORD_KINDS.has(x);
+}
+function rowToEntry$1(id, data) {
+	const ruleId = data["ruleId"];
+	const targetId = data["targetId"];
 	const deviceId = Number(data["deviceId"]);
-	const confirmedCount = Number(data["confirmedCount"]);
-	const lastChangeAt = Number(data["lastChangeAt"]);
-	const updatedAt = Number(data["updatedAt"]);
-	if (!Number.isFinite(deviceId) || !Number.isFinite(confirmedCount) || !Number.isFinite(lastChangeAt) || !Number.isFinite(updatedAt)) return null;
-	const rawOccupied = data["occupied"];
-	const occupied = rawOccupied === true || rawOccupied === 1;
+	const recordKind = data["recordKind"];
+	const recordId = data["recordId"];
+	const status = data["status"];
+	const payload = data["payload"];
+	if (typeof ruleId !== "string" || typeof targetId !== "string" || !Number.isFinite(deviceId) || !isOutboxRecordKind(recordKind) || typeof recordId !== "string" || status !== "pending" && status !== "sent" && status !== "dead" || payload === null || typeof payload !== "object") return null;
+	const trackId = data["trackId"];
+	const lastError = data["lastError"];
 	return {
-		key,
+		id,
+		ruleId,
+		targetId,
 		deviceId,
-		...scope.zoneId !== void 0 ? { zoneId: scope.zoneId } : {},
-		...scope.className !== void 0 ? { className: scope.className } : {},
-		threshold: scope.threshold,
-		confirmedCount,
-		occupied,
-		lastChangeAt,
-		updatedAt
+		recordKind,
+		recordId,
+		...typeof trackId === "string" ? { trackId } : {},
+		status,
+		attempts: Number(data["attempts"] ?? 0),
+		nextAttemptAt: Number(data["nextAttemptAt"] ?? 0),
+		createdAt: Number(data["createdAt"] ?? 0),
+		updatedAt: Number(data["updatedAt"] ?? 0),
+		...typeof lastError === "string" ? { lastError } : {},
+		payload
 	};
 }
 //#endregion
@@ -5478,6 +5488,25 @@ function occupancySpecFromCondition(occ) {
 		sustainSeconds: occ.sustainSeconds
 	};
 }
+/**
+* Freeze the matched occupancy edge onto the outbox payload subject (A5) — the
+* source of the dispatcher's `{{zone}}`/`{{count}}`/`{{capacity}}` vars.
+*
+* `capacity` is the RULE's configured `occupancy.count`, NOT the edge's key
+* threshold: a `<=C` rule keys on threshold `C+1`, so the threshold would
+* misreport the operator's capacity by one. The rule condition is present by
+* construction (the engine's occupancy branch fires only when it is); the
+* threshold fallback keeps the freeze total without a cast, and is exact for
+* every op but `<=`.
+*/
+function frozenOccupancy(rule, occ) {
+	return {
+		...occ.zoneName !== void 0 ? { zone: occ.zoneName } : {},
+		count: occ.count,
+		capacity: rule.conditions.occupancy?.count ?? occ.threshold,
+		occupied: occ.occupied
+	};
+}
 /** Classify an object-event row as a package delivery / pick-up, or `null` when
 *  it is an ordinary detection. */
 function packagePhaseOf(ev) {
@@ -5869,7 +5898,8 @@ var NotificationCenter = class {
 					...subject.label !== void 0 ? { label: subject.label } : {},
 					...subject.confidence !== void 0 ? { confidence: subject.confidence } : {},
 					zones: subject.zones,
-					timestamp: subject.timestamp
+					timestamp: subject.timestamp,
+					...subject.occupancy !== void 0 ? { occupancy: frozenOccupancy(rule, subject.occupancy) } : {}
 				}
 			};
 			return {
@@ -18695,7 +18725,7 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 		let storage = this.ctx.kernel.storage;
 		const mediaRoot = process.env.CAMSTACK_MEDIA_ROOT?.trim();
 		if (mediaRoot) {
-			const { FilesystemStorageProvider } = await Promise.resolve().then(() => require("../node-DsYWuKgE.js"));
+			const { FilesystemStorageProvider } = await Promise.resolve().then(() => require("../node-PvutBRd4.js"));
 			storage = new FilesystemStorageProvider(mediaRoot);
 			logger.info("pipeline-analytics: event media rooted at CAMSTACK_MEDIA_ROOT", { meta: { mediaRoot } });
 		}