@camstack/addon-post-analysis 1.2.78 → 1.2.79

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-CFOT1Yoz.js");
+const require_dist = require("../dist-CWoaZE47.js");
 let node_fs = require("node:fs");
 node_fs = require_dist.__toESM(node_fs, 1);
 let node_path = require("node:path");
@@ -14144,12 +14144,15 @@ function dwellSeconds(candidate) {
 * branch that discards work silently reads as "it never happened".
 */
 function filterSummaryCandidates(candidates, filters, zoneOwner) {
+	const moving = filters?.includeStationary === true ? candidates : candidates.filter((candidate) => candidate.stationary !== true);
+	const droppedStationary = candidates.length - moving.length;
 	if (filters === void 0) return {
-		kept: [...candidates],
+		kept: [...moving],
 		droppedByClass: 0,
 		droppedByZone: 0,
 		droppedByImportance: 0,
-		droppedByDwell: 0
+		droppedByDwell: 0,
+		droppedStationary
 	};
 	const include = filters.classes;
 	const exclude = new Set(filters.classesExclude ?? []);
@@ -14158,7 +14161,7 @@ function filterSummaryCandidates(candidates, filters, zoneOwner) {
 	let droppedByZone = 0;
 	let droppedByImportance = 0;
 	let droppedByDwell = 0;
-	for (const candidate of candidates) {
+	for (const candidate of moving) {
 		const own = classesOf(candidate);
 		if (own.some((c) => exclude.has(c))) {
 			droppedByClass += 1;
@@ -14194,7 +14197,8 @@ function filterSummaryCandidates(candidates, filters, zoneOwner) {
 		droppedByClass,
 		droppedByZone,
 		droppedByImportance,
-		droppedByDwell
+		droppedByDwell,
+		droppedStationary
 	};
 }
 /**
@@ -14569,7 +14573,8 @@ var NcSummaryProducer = class {
 					droppedByClass: filtered.droppedByClass,
 					droppedByZone: filtered.droppedByZone,
 					droppedByImportance: filtered.droppedByImportance,
-					droppedByDwell: filtered.droppedByDwell
+					droppedByDwell: filtered.droppedByDwell,
+					droppedStationary: filtered.droppedStationary
 				} });
 				if (opts.stamp) await this.deps.store.markGenerated(rule.id, window.endMs);
 				return {
@@ -14577,7 +14582,8 @@ var NcSummaryProducer = class {
 					window,
 					tiles: 0,
 					cameras: 0,
-					matched: 0
+					matched: 0,
+					droppedStationary: filtered.droppedStationary
 				};
 			}
 			const loaded = await this.loadTiles(rule, selection.tiles);
@@ -14600,6 +14606,7 @@ var NcSummaryProducer = class {
 					produced: 0,
 					window,
 					tiles: loaded.length,
+					droppedStationary: filtered.droppedStationary,
 					skippedByAi: true,
 					...ai.aiFailure !== void 0 ? { aiFailure: ai.aiFailure } : {},
 					...ai.aiImages !== void 0 ? { aiImages: ai.aiImages } : {}
@@ -14630,6 +14637,8 @@ var NcSummaryProducer = class {
 				...meta,
 				scanned: candidates.length,
 				matched: filtered.kept.length,
+				droppedStationary: filtered.droppedStationary,
+				droppedByClass: filtered.droppedByClass,
 				tiles: loaded.length,
 				cameras: new Set(loaded.map((t) => t.candidate.deviceId)).size,
 				camerasDropped: selection.camerasDropped,
@@ -14648,6 +14657,7 @@ var NcSummaryProducer = class {
 				tiles: loaded.length,
 				cameras: new Set(loaded.map((t) => t.candidate.deviceId)).size,
 				matched: filtered.kept.length,
+				droppedStationary: filtered.droppedStationary,
 				enqueued,
 				...mosaic.bytes > 0 ? { mosaicBytes: mosaic.bytes } : {},
 				...mosaic.ref !== null ? { mosaicUrl: mosaic.ref.url } : {},
@@ -15020,7 +15030,26 @@ var NcSummaryFiltersSchema = require_dist.object({
 	classesExclude: require_dist.array(require_dist.string().min(1).max(40)).max(20).optional(),
 	zones: require_dist.array(require_dist.string()).max(40).optional(),
 	minImportance: require_dist.number().min(0).max(1).optional(),
-	minDwellSeconds: require_dist.number().min(0).max(3600).optional()
+	minDwellSeconds: require_dist.number().min(0).max(3600).optional(),
+	/**
+	* Put PARKED objects in the digest too. Off unless explicitly turned on, and
+	* an ABSENT field reads as off — the soft migration, no backfill.
+	*
+	* A digest is a record of PASSAGES: the operator's words are "the last
+	* summaries still include an enormous number of stationary tracks". Since
+	* D161 a track promoted to the stationary registry is persisted rather than
+	* dropped (it owns media the retention sweep has to reach), so the car parked
+	* in front of camera 617 now enters every window it overlaps and, ranked on
+	* importance and dwell, wins tiles from the passages the digest is about. The
+	* measured effect on the live hub was 1-2 tiles becoming 10.
+	*
+	* `.optional()` and NOT `.default(false)`: a `.default()` here would be
+	* materialised by `NcSummaryRulePatchSchema` on any patch that named
+	* `filters`, which is the `.partial()` trap this module's docblock describes.
+	* `filterSummaryCandidates` reads `=== true`, so absent and false are the
+	* same answer and neither needs a stored value.
+	*/
+	includeStationary: require_dist.boolean().optional()
 });
 /**
 * How tiles are chosen when the window holds more tracks than the budget.
@@ -21819,6 +21848,14 @@ var ncActions = require_dist.defineCustomActions({
 		tiles: require_dist.number().int().optional(),
 		cameras: require_dist.number().int().optional(),
 		matched: require_dist.number().int().optional(),
+		/**
+		* PARKED objects the window held and the rule dropped (`filters
+		* .includeStationary`). Without it a Test that returns two tiles out of
+		* forty tracks cannot tell the operator whether the night was quiet or
+		* whether it was the car park — and that is the exact question this
+		* option exists to answer.
+		*/
+		droppedStationary: require_dist.number().int().optional(),
 		enqueued: require_dist.number().int().optional(),
 		mosaicBytes: require_dist.number().int().optional(),
 		mosaicUrl: require_dist.string().optional(),
@@ -22285,6 +22322,7 @@ function makeNcActionHandlers(deps) {
 				...out.tiles !== void 0 ? { tiles: out.tiles } : {},
 				...out.cameras !== void 0 ? { cameras: out.cameras } : {},
 				...out.matched !== void 0 ? { matched: out.matched } : {},
+				...out.droppedStationary !== void 0 ? { droppedStationary: out.droppedStationary } : {},
 				...out.enqueued !== void 0 ? { enqueued: out.enqueued } : {},
 				...out.mosaicBytes !== void 0 ? { mosaicBytes: out.mosaicBytes } : {},
 				...out.mosaicUrl !== void 0 ? { mosaicUrl: out.mosaicUrl } : {},
@@ -26288,7 +26326,9 @@ var FrameProcessor = class {
 		}) : {
 			suppressedIndices: /* @__PURE__ */ new Set(),
 			confirmed: [],
-			wokenEntryIds: []
+			wokenEntryIds: [],
+			armedEntryIds: [],
+			disarmedEntryIds: []
 		};
 		const trackerInput = gate.suppressedIndices.size > 0 ? filteredDetections.filter((_, i) => !gate.suppressedIndices.has(i)) : filteredDetections;
 		const trackedDetections = this.tracker.update(trackerInput, timestamp, {
@@ -26498,6 +26538,8 @@ var FrameProcessor = class {
 			rawTrackedDetections: trackedDetections,
 			stationaryConfirmed: gate.confirmed,
 			stationaryWoken: gate.wokenEntryIds,
+			stationaryArmed: gate.armedEntryIds,
+			stationaryDisarmed: gate.disarmedEntryIds,
 			riderFolds
 		};
 	}
@@ -36062,20 +36104,38 @@ function centroidInside(b, p) {
 *    box → SUPPRESS (detector box jitter — the box shrank/grew around the same
 *    centre; still the parked object, must not spawn a duplicate track).
 *  - `wakeAssocIou` ≤ best IoU < `suppressIou`, centroid OUTSIDE the parked box
-*    → WAKE (the object's box slid off its spot → it is departing). Not
-*    suppressed, so it spawns a fresh moving track.
+*    → DEPARTING (the object's box slid off its spot).
 *  - best IoU < `wakeAssocIou` → MISS: no detection overlaps this entry (a
-*    different object, or the parked object is momentarily undetected). Neither
-*    suppress nor wake; the TTL sweep retires it only if the absence persists.
+*    different object, or the parked object is momentarily undetected). The TTL
+*    sweep retires it only if the absence persists.
+*
+* ## A departure is never acted on from ONE read (D49)
+*
+* Retiring an entry DESTROYS work: the object's registry identity, and with it
+* the suppression that stops it re-spawning a track every 30 s. So a single
+* departing read only ARMS the entry — the detection is still suppressed and
+* the entry survives. The entry is retired only when a SECOND read agrees:
+* departing again, or missing entirely (the object really has left the spot).
+* A confirming read DISARMS it.
+*
+* The caller owns the armed set and passes it back in; this function stays
+* pure. Cost of the extra read: a genuinely departing object spawns its track
+* one frame later. Cost of NOT having it, measured on the live hub over 24 h:
+* 65% of all stationary entries were retired within 300 s — below the TTL, so
+* by a wake — and 38% of the tracks that promotion then re-created had never
+* moved in their entire life. One bad box per parked object was enough.
 *
 * A detection can suppress at most one spawn even if it overlaps two entries
 * (`suppressedIndices` is a set).
 */
 function partitionDetectionsAgainstRegistry(input) {
 	const { entries, detections, config } = input;
+	const armed = input.armedEntryIds ?? EMPTY_ARMED;
 	const suppressed = /* @__PURE__ */ new Set();
 	const confirmed = [];
 	const woken = [];
+	const toArm = [];
+	const toDisarm = [];
 	for (const entry of entries) {
 		let bestIou = 0;
 		let bestIdx = -1;
@@ -36088,23 +36148,37 @@ function partitionDetectionsAgainstRegistry(input) {
 				bestIdx = di;
 			}
 		}
-		if (bestIdx < 0 || bestIou < config.wakeAssocIou) continue;
+		if (bestIdx < 0 || bestIou < config.wakeAssocIou) {
+			if (armed.has(entry.id)) woken.push(entry.id);
+			continue;
+		}
 		const detCentroid = centroid(detections[bestIdx].bbox);
-		if (bestIou >= config.suppressIou || centroidInside(entry.bbox, detCentroid)) {
+		const strong = bestIou >= config.suppressIou;
+		if (strong || centroidInside(entry.bbox, detCentroid)) {
 			suppressed.add(bestIdx);
 			confirmed.push({
 				entryId: entry.id,
 				className: entry.className,
-				bbox: { ...entry.bbox }
+				bbox: { ...entry.bbox },
+				observedBbox: { ...detections[bestIdx].bbox },
+				strong
 			});
-		} else woken.push(entry.id);
+			if (armed.has(entry.id)) toDisarm.push(entry.id);
+		} else if (armed.has(entry.id)) woken.push(entry.id);
+		else {
+			toArm.push(entry.id);
+			suppressed.add(bestIdx);
+		}
 	}
 	return {
 		suppressedIndices: suppressed,
 		confirmed,
-		wokenEntryIds: woken
+		wokenEntryIds: woken,
+		armedEntryIds: toArm,
+		disarmedEntryIds: toDisarm
 	};
 }
+var EMPTY_ARMED = /* @__PURE__ */ new Set();
 /**
 * A track is promoted when, over the recent `windowMs`, its centroid barely
 * moved (both net displacement and path span below the static thresholds) AND
@@ -36677,6 +36751,21 @@ var StationaryObjectRegistry = class {
 	*  between motion sessions; that silence is not evidence the object left,
 	*  so quiet minutes must not age the entries (see {@link sweep}). */
 	lastFrameAtByDevice = /* @__PURE__ */ new Map();
+	/**
+	* Entries carrying ONE unconfirmed departure read, per device (D49, D174).
+	*
+	* Retiring an entry destroys work — the object's registry identity and the
+	* suppression that keeps it from re-spawning a track every promotion window.
+	* A single frame whose box slid off the parked spot is a fallible read (a
+	* partial occlusion, a shadow, one bad box), so it only ARMS the entry here.
+	* The retirement happens on the next frame that AGREES; a confirming frame
+	* clears the strike.
+	*/
+	departureStrikes = /* @__PURE__ */ new Map();
+	/** Detections absorbed by an existing entry since the last sweep, per device.
+	*  Rolled up into ONE log line per sweep — this fires on every frame of every
+	*  parked object, so it can never be a line of its own. */
+	absorbedSinceSweep = /* @__PURE__ */ new Map();
 	constructor(deps) {
 		this.logger = deps.logger;
 		this.ledger = new DurableLedger({
@@ -36749,12 +36838,15 @@ var StationaryObjectRegistry = class {
 		if (entries.length === 0) return {
 			suppressedIndices: /* @__PURE__ */ new Set(),
 			confirmed: [],
-			wokenEntryIds: []
+			wokenEntryIds: [],
+			armedEntryIds: [],
+			disarmedEntryIds: []
 		};
 		return partitionDetectionsAgainstRegistry({
 			entries,
 			detections: input.detections,
-			config: config ?? this.matchConfig
+			config: config ?? this.matchConfig,
+			...this.departureStrikes.has(input.deviceId) ? { armedEntryIds: this.departureStrikes.get(input.deviceId) } : {}
 		});
 	}
 	/** Fold a frame's gate result back into state: advance confirmed entries'
@@ -36771,15 +36863,41 @@ var StationaryObjectRegistry = class {
 			if (!e) continue;
 			this.ledger.stage({
 				...e,
-				lastConfirmedAt: input.timestamp
+				lastConfirmedAt: input.timestamp,
+				...c.strong ? { bbox: { ...c.observedBbox } } : {}
 			});
 			this.dirty.add(c.entryId);
 		}
+		this.absorbedSinceSweep.set(input.deviceId, (this.absorbedSinceSweep.get(input.deviceId) ?? 0) + input.confirmed.length);
+		if (input.armedEntryIds && input.armedEntryIds.length > 0) {
+			let armed = this.departureStrikes.get(input.deviceId);
+			if (!armed) {
+				armed = /* @__PURE__ */ new Set();
+				this.departureStrikes.set(input.deviceId, armed);
+			}
+			for (const id of input.armedEntryIds) if (ids.has(id)) armed.add(id);
+		}
+		const armed = this.departureStrikes.get(input.deviceId);
+		if (armed && input.disarmedEntryIds) {
+			for (const id of input.disarmedEntryIds) armed.delete(id);
+			if (armed.size === 0) this.departureStrikes.delete(input.deviceId);
+		}
 		for (const id of input.wokenEntryIds) {
 			if (!ids.has(id)) continue;
 			const e = this.ledger.get(id);
 			if (!e) continue;
 			this.dropEntry(input.deviceId, id);
+			this.logger.info("stationary entry retired", {
+				tags: { deviceId: input.deviceId },
+				meta: {
+					deviceId: input.deviceId,
+					entryId: id,
+					className: e.className,
+					reason: "departed",
+					parkedForMs: input.timestamp - e.becameStationaryAt,
+					...e.sourceTrackId !== void 0 ? { sourceTrackId: e.sourceTrackId } : {}
+				}
+			});
 			this.onChange?.({
 				phase: "departed",
 				entry: e,
@@ -36826,6 +36944,18 @@ var StationaryObjectRegistry = class {
 				if (observedAt - e.lastConfirmedAt > ttl) {
 					this.dropEntry(deviceId, id);
 					retired.push(e);
+					this.logger.info("stationary entry retired", {
+						tags: { deviceId },
+						meta: {
+							deviceId,
+							entryId: id,
+							className: e.className,
+							reason: "ttl",
+							ttlMs: ttl,
+							unconfirmedForMs: observedAt - e.lastConfirmedAt,
+							parkedForMs: observedAt - e.becameStationaryAt
+						}
+					});
 					this.onChange?.({
 						phase: "departed",
 						entry: e,
@@ -36835,6 +36965,18 @@ var StationaryObjectRegistry = class {
 			}
 			if (ids.size === 0) this.idsByDevice.delete(deviceId);
 		}
+		for (const [deviceId, absorbed] of this.absorbedSinceSweep) {
+			if (absorbed === 0) continue;
+			this.logger.info("stationary registry absorbed detections", {
+				tags: { deviceId },
+				meta: {
+					deviceId,
+					absorbed,
+					entries: this.count(deviceId)
+				}
+			});
+		}
+		this.absorbedSinceSweep.clear();
 		for (const id of [...this.dirty]) {
 			this.dirty.delete(id);
 			const entry = this.ledger.get(id);
@@ -36847,6 +36989,8 @@ var StationaryObjectRegistry = class {
 	*  Used on device unbind; a rebind reloads from the store. */
 	forgetDevice(deviceId) {
 		this.lastFrameAtByDevice.delete(deviceId);
+		this.departureStrikes.delete(deviceId);
+		this.absorbedSinceSweep.delete(deviceId);
 		const ids = this.idsByDevice.get(deviceId);
 		if (!ids) return;
 		for (const id of ids) {
@@ -36858,6 +37002,8 @@ var StationaryObjectRegistry = class {
 	/** Delete every persisted + in-memory entry for a device (operator wipe). */
 	async clearDevice(deviceId) {
 		this.lastFrameAtByDevice.delete(deviceId);
+		this.departureStrikes.delete(deviceId);
+		this.absorbedSinceSweep.delete(deviceId);
 		const ids = this.idsByDevice.get(deviceId);
 		if (ids) {
 			for (const id of [...ids]) {
@@ -36875,10 +37021,17 @@ var StationaryObjectRegistry = class {
 		}
 		set.add(id);
 	}
-	/** Retire one entry: index, staged advance and durable row all go. */
+	/** Retire one entry: index, staged advance, pending strike and durable row
+	*  all go. A strike that outlived its entry would arm the NEXT entry to reuse
+	*  the id — the registry mints UUIDs, but the invariant is cheap to keep. */
 	dropEntry(deviceId, id) {
 		this.idsByDevice.get(deviceId)?.delete(id);
 		this.dirty.delete(id);
+		const armed = this.departureStrikes.get(deviceId);
+		if (armed) {
+			armed.delete(id);
+			if (armed.size === 0) this.departureStrikes.delete(deviceId);
+		}
 		this.ledger.forget(id);
 	}
 };
@@ -40922,6 +41075,26 @@ function isAfterCursor(row, cursor) {
 }
 //#endregion
 //#region src/pipeline-analytics/store/track-store.ts
+/**
+* WHY a track's row was written EARLY — i.e. by {@link TrackStore.closeActive}
+* rather than by the ordinary TTL expiry.
+*
+* `'stationary-promotion'` is the only member and means: the tracker decided
+* this subject had PARKED, handed it to the stationary registry, and the row
+* was written so its media, events and vector keep an owner (D161). It is not a
+* quality signal and it never hides the track — a parked car is still a track,
+* still on the events page, still swept by the same retention. It exists so a
+* consumer that wants PASSAGES can say so exactly, instead of re-deriving
+* "did it move" from a trajectory downstream and getting it wrong on the
+* subject that stood still for one honest reason.
+*
+* An ABSENT value means "expired normally, or written before this marker
+* existed". Never read an absence as a positive — same rule as `hasFace`.
+*/
+var TRACK_CLOSE_REASONS = ["stationary-promotion"];
+function parseCloseReason(value) {
+	return TRACK_CLOSE_REASONS.find((reason) => reason === value);
+}
 var DEFAULT_CONFIG = {
 	ttlMs: 3e4,
 	maxPositionHistory: 300
@@ -41144,6 +41317,10 @@ var TRACKS_COLUMNS = [
 	{
 		name: "frameHeight",
 		type: "INTEGER"
+	},
+	{
+		name: "closedReason",
+		type: "TEXT"
 	}
 ];
 var TRACKS_INDEXES = [{
@@ -41203,7 +41380,8 @@ function cloneTrack(t) {
 		} : {},
 		...t.debug !== void 0 ? { debug: t.debug } : {},
 		...t.hasFace !== void 0 ? { hasFace: t.hasFace } : {},
-		...t.hasRider !== void 0 ? { hasRider: t.hasRider } : {}
+		...t.hasRider !== void 0 ? { hasRider: t.hasRider } : {},
+		...t.closedReason !== void 0 ? { closedReason: t.closedReason } : {}
 	};
 }
 var TrackStore = class {
@@ -41772,13 +41950,22 @@ var TrackStore = class {
 	* nothing has been written under that id yet. It is never correct for a track
 	* that ran.
 	*
+	* **The row SAYS why it was closed early** (`reason` → the `closedReason`
+	* column). Persisting a promoted track put its footprint back under the
+	* retention sweep, and it also put the parked car back in front of every
+	* consumer that reads the window's tracks: the operator's nightly digest went
+	* from 1-2 tiles to 10, most of them the same stationary car. The marker is
+	* written HERE, at the one place that knows, so a consumer can ask for
+	* passages exactly instead of guessing at movement from a stored trajectory.
+	*
 	* Returns whether an active entry was found. THROWS if the persist fails: the
 	* caller must log it, because a swallowed failure here IS the leak.
 	*/
-	async closeActive(trackId) {
+	async closeActive(trackId, reason) {
 		const t = this.active.get(trackId);
 		if (t === void 0) return false;
 		t.active = false;
+		t.closedReason = reason;
 		const record = cloneTrack(t);
 		await this.persistCompleted(record);
 		this.active.delete(trackId);
@@ -42360,6 +42547,7 @@ var TrackStore = class {
 				...t.debug !== void 0 ? { debug: t.debug } : {},
 				...t.hasFace !== void 0 ? { hasFace: t.hasFace } : {},
 				...t.hasRider !== void 0 ? { hasRider: t.hasRider } : {},
+				...t.closedReason !== void 0 ? { closedReason: t.closedReason } : {},
 				...envelope !== null && dims !== void 0 ? {
 					envMinX: envelope.minX,
 					envMinY: envelope.minY,
@@ -42397,6 +42585,7 @@ var TrackStore = class {
 		const hasFace = data["hasFace"];
 		/** Same read as `hasFace` — NULL / missing stays ABSENT, never `false`. */
 		const hasRider = data["hasRider"];
+		const closedReason = parseCloseReason(data["closedReason"]);
 		const envMinX = data["envMinX"];
 		const envMinY = data["envMinY"];
 		const envMaxX = data["envMaxX"];
@@ -42434,6 +42623,7 @@ var TrackStore = class {
 			...typeof debug === "boolean" ? { debug } : {},
 			...typeof hasFace === "boolean" ? { hasFace } : {},
 			...typeof hasRider === "boolean" ? { hasRider } : {},
+			...closedReason !== void 0 ? { closedReason } : {},
 			...envelope !== null ? { envelope } : {}
 		};
 	}
@@ -50621,7 +50811,8 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 					lastSeen: t.lastSeen,
 					...t.importance !== void 0 ? { importance: t.importance } : {},
 					zones: [...t.zonesVisited],
-					...t.classes !== void 0 ? { classes: [...t.classes] } : {}
+					...t.classes !== void 0 ? { classes: [...t.classes] } : {},
+					...t.closedReason === "stationary-promotion" ? { stationary: true } : {}
 				}));
 			},
 			listMediaInfo: async (trackId) => {
@@ -51725,10 +51916,12 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 			this.trackStore?.markRiderFolded(fold.trackId);
 		}
 		if (source === "pipeline") this.stationaryRegistry?.noteFrame(deviceId, result.timestamp);
-		if (this.stationaryRegistry && (result.stationaryConfirmed.length > 0 || result.stationaryWoken.length > 0)) this.stationaryRegistry.applyFrameOutcome({
+		if (this.stationaryRegistry && (result.stationaryConfirmed.length > 0 || result.stationaryWoken.length > 0 || result.stationaryArmed.length > 0 || result.stationaryDisarmed.length > 0)) this.stationaryRegistry.applyFrameOutcome({
 			deviceId,
 			confirmed: result.stationaryConfirmed,
 			wokenEntryIds: result.stationaryWoken,
+			armedEntryIds: result.stationaryArmed,
+			disarmedEntryIds: result.stationaryDisarmed,
 			timestamp: result.timestamp
 		});
 		const stationaryViews = this.stationaryRegistry?.listViews(deviceId) ?? [];
@@ -53785,7 +53978,7 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 		};
 		if (plausible) this.stationaryRegistry?.promote(entry);
 		processor.dropTrack(track.trackId);
-		this.trackStore?.closeActive(track.trackId).catch((err) => {
+		this.trackStore?.closeActive(track.trackId, "stationary-promotion").catch((err) => {
 			this.ctx.logger.warn("stationary promotion: closing the source track failed — its media, events and vector are now unowned", {
 				tags: { deviceId },
 				meta: {
@@ -53888,7 +54081,9 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 					if (!s.enabled) return {
 						suppressedIndices: /* @__PURE__ */ new Set(),
 						confirmed: [],
-						wokenEntryIds: []
+						wokenEntryIds: [],
+						armedEntryIds: [],
+						disarmedEntryIds: []
 					};
 					const matchConfig = {
 						suppressIou: s.suppressIou,