@camstack/addon-post-analysis 1.2.242 → 1.2.244

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-DjW7k4lv.js");
+const require_dist = require("../dist-DxZAf0Hs.js");
 let node_fs = require("node:fs");
 node_fs = require_dist.__toESM(node_fs, 1);
 let node_path = require("node:path");
@@ -55625,7 +55625,8 @@ function buildOverlayDetections(input) {
 			...det,
 			track: {
 				trackId: t.trackId,
-				zones: t.zones
+				zones: t.zones,
+				...t.state !== void 0 ? { movementState: t.state } : {}
 			},
 			labels: hasName && !alreadyLabeled ? [...det.labels, {
 				label: name,
@@ -57583,6 +57584,10 @@ function centroidInside(b, p) {
 }
 /** Parked-box coverage (intersection / entry area) that counts as swallowed. */
 var SWALLOW_MIN_COVERAGE = .5;
+/** Fraction of a detection's OWN area that must lie inside a parked entry for
+*  the entry to swallow it. Deliberately near-total: a fragment of a parked
+*  object does not stick out of it. */
+var FRAGMENT_MIN_CONTAINMENT = .9;
 function isSceneSizedBox(bbox, frameWidth, frameHeight) {
 	const frame = frameWidth * frameHeight;
 	return frame > 0 && bbox.w * bbox.h / frame >= .55;
@@ -57602,6 +57607,29 @@ function detectionSwallowsEntry(det, parked) {
 	if (!centroidInside(det, centroid(parked))) return false;
 	return intersectionArea$2(parked, det) / entryArea >= SWALLOW_MIN_COVERAGE;
 }
+/**
+* True when `det` is a FRAGMENT of the parked object — much smaller than the
+* entry and sitting (almost) wholly inside it.
+*
+* The mirror of {@link detectionSwallowsEntry}, and the case neither IoU
+* threshold can see. Measured on 617: a 34x137 box inside a 452x420 parked
+* motorcycle scores IoU 0.024 — BELOW `wakeAssocIou` (0.1), so the filter read
+* it as "no detection overlaps this entry" and let it open a track, accumulate
+* its own evidence and promote into a registry entry of its own. The camera
+* then reported two parked vehicles where there was one motorcycle.
+*
+* The size bound is the reciprocal of {@link SWALLOW_AREA_RATIO}, so the two
+* swallow rules meet without overlapping: a box between 1/1.35 and 1.35 of the
+* entry's area, contained, already scores IoU >= 0.74 and is answered by
+* `suppressIou`. Nothing is a fragment and a near-identical box at once.
+*/
+function entrySwallowsDetection(parked, det) {
+	const entryArea = parked.w * parked.h;
+	const detArea = det.w * det.h;
+	if (entryArea <= 0 || detArea <= 0) return false;
+	if (detArea > entryArea / 1.35) return false;
+	return intersectionArea$2(parked, det) / detArea >= FRAGMENT_MIN_CONTAINMENT;
+}
 function parkedEntryHoldsDetection(entry, detBbox, config) {
 	const overlap = iou(entry.bbox, detBbox);
 	if (overlap >= config.suppressIou) return {
@@ -57616,6 +57644,10 @@ function parkedEntryHoldsDetection(entry, detBbox, config) {
 		strong: false,
 		holds: false
 	};
+	if (entrySwallowsDetection(entry.bbox, detBbox)) return {
+		strong: false,
+		holds: true
+	};
 	return {
 		strong: false,
 		holds: overlap >= config.wakeAssocIou && centroidInside(entry.bbox, centroid(detBbox))
@@ -57634,6 +57666,34 @@ function bboxMatchesParkedEntry(bbox, className, entries, suppressIou = SUPPRESS
 	}
 	return false;
 }
+/**
+* The live entry already censusing this spot, if any — the ONE answer to "is
+* this place taken?", asked at BIRTH.
+*
+* It is deliberately the same predicate the per-frame filter uses
+* ({@link parkedEntryHoldsDetection}): a box the filter would suppress as a
+* parked object's own must not be able to become a second parked object. Device
+* 617 held four rows for one car and a fifth for a fragment of a motorcycle
+* because the birth path asked nothing at all.
+*/
+function findParkedOccupant(entries, className, bbox, suppressIou = SUPPRESS_IOU, wakeAssocIou = WAKE_ASSOC_IOU) {
+	const cls = normaliseStationaryClass(className);
+	const config = {
+		suppressIou,
+		wakeAssocIou
+	};
+	let best;
+	for (const e of entries) {
+		if (normaliseStationaryClass(e.className) !== cls) continue;
+		if (!parkedEntryHoldsDetection(e, bbox, config).holds) continue;
+		const overlap = iou(e.bbox, bbox);
+		if (best === void 0 || overlap > best.overlap) best = {
+			entry: e,
+			overlap
+		};
+	}
+	return best?.entry;
+}
 /** Best-shot veto: current crop is a parked object the trail did not start on. */
 function thumbnailWouldShowParkedNotSubject(input) {
 	if (!bboxMatchesParkedEntry(input.currentBbox, input.className, input.entries)) return false;
@@ -58619,85 +58679,6 @@ var StartedBirthRegistry = class {
 //#endregion
 //#region src/pipeline-analytics/pipeline/stationary/stationary-evidence.ts
 /**
-* stationary-evidence — how a parked object EARNS a registry entry.
-*
-* ## The criterion this replaces, and why it was measuring the wrong thing
-*
-* Until 2026-08-28 an object became stationary by TRACK CONTINUITY: one track
-* had to stay alive and barely move for `PROMOTION_WINDOW_MS` (30 s). That
-* rewards an object that is *seen well and often* — precisely the opposite of
-* what the operator needs. Measured on device 617 (the parking lot), 24 h:
-*
-*   - three cars are parked in view; the registry held exactly ONE entry;
-*   - the two it missed were re-discovered as **140 and 112 separate tracks**,
-*     median life **6.8 s**, p90 29 s. Not one of them could ever reach 30 s.
-*   - those two objects alone produced **13 494 of 18 402** vehicle
-*     observations (73%) — the whole re-spawn flood the registry exists to stop.
-*
-* The track dies; the OBJECT does not. So the evidence must outlive the track.
-*
-* ## The new criterion: a RATIO, not a count
-*
-* "The same thing, in the same place, most of the times it was seen."
-*
-*   N — observations that AGREED with the candidate's anchor box (IoU ≥
-*       {@link StationaryEvidencePolicy.agreeIou}).
-*   M — observations OFFERED by a track once it bound to this candidate,
-*       agreeing or not.
-*
-* A count would rescue nothing: a badly-lit car at night is seen rarely, and
-* any floor high enough to exclude a passer-by would exclude it too. A RATIO
-* asks a question a rarely-seen object can still answer well — 8 sightings out
-* of 10 in the same spot is stationary even though 10 is a small number.
-*
-* The dilution is the whole point, and it is why M counts a bound track's
-* observations even after it walks away: a car that drives THROUGH a spot binds
-* for a few frames and then contributes dozens of disagreeing ones. Measured on
-* 617 the two populations do not overlap:
-*
-*   | candidate                    | N / M       | ratio |
-*   | ---------------------------- | ----------- | ----- |
-*   | parked car A (missed today)  | 6405 / 6467 | 0.99  |
-*   | parked car B (missed today)  |  343 /  343 | 1.00  |
-*   | car crossing the lot         |    5 /   70 | 0.07  |
-*   | car turning through the lot  |   14 /   91 | 0.15  |
-*   | car manoeuvring              |   12 /   41 | 0.29  |
-*
-* The threshold sits in the empty band between 0.29 and 0.99.
-*
-* ## The span is what a ratio cannot say
-*
-* A ratio alone promotes a car that paused for four seconds — its handful of
-* observations all agree. So evidence must also STRETCH: the agreeing
-* observations must span {@link StationaryEvidencePolicy.minSpanMs}. Measured
-* on 617, real parked cars span 2 min to 24 h; the two momentary stops in the
-* same day spanned 4.2 s and 8.0 s. Setting the span to
-* `DEFAULT_MAX_SESSION_HOLD_MS` also buys a structural guarantee: no single
-* motion session, however long it is held open, can promote on its own.
-*
-* ## ONE ledger, two producers
-*
-* Evidence is anchored to a BOX, not to a track and not to a session, so an
-* object confirmed half by an active motion session and half by a periodic
-* burst still promotes. Occasion A (the session) is implemented and is
-* sufficient on its own — it is free, because the pipeline is already decoding
-* and already inferring. Occasion B (the burst) is a precaution for the cases
-* where A could not have fired at all (hub restarted, camera offline, motion
-* detection failed, object already parked at boot); it is NOT implemented yet,
-* and {@link StationaryEvidenceSource} is the seam it will arrive through.
-*
-* ## Identity is IoU. There is no grid.
-*
-* The predecessor mechanism (`phantom-cells.ts`) quantises a point to a 32 px
-* cell, and its write path passes a CENTROID while its read path passes a
-* top-left CORNER — at 32 px every box bigger than 32 px lands in a different
-* cell on read, and its unit test never crosses that boundary because it calls
-* both halves with the same literal coordinates. This module has no such
-* boundary to get wrong: a candidate is found by overlap against the boxes a
-* device already holds, bounded by {@link EVIDENCE_MAX_CANDIDATES_PER_DEVICE}.
-* Device 617 — the busiest lot in the fleet — holds 8.
-*/
-/**
 * `vehicle` and its kin. Every number below is read off device 617 over 24 h
 * (18 402 vehicle observations, 290 tracks) with the three parked cars the
 * operator can see out of the window as the bench.
@@ -58719,11 +58700,11 @@ var VEHICLE_EVIDENCE_POLICY = {
 	agreeIou: .5,
 	minAgreed: 8,
 	minAgreementRatio: .6,
-	minSpanMs: 12e4,
-	promotesByDefault: true
+	minSpanMs: 12e4
 };
 /**
-* `person`, and it ships OFF.
+* `person`, promoted like every other class since 2026-09-14 — and still the
+* strictest numbers in the file, because these are MEASURED, not cautious.
 *
 * This is not caution, it is a measurement. Replaying 24 h of person
 * observations from devices 617, 1443, 590 and 592 through this exact ledger:
@@ -58742,17 +58723,24 @@ var VEHICLE_EVIDENCE_POLICY = {
 *
 * Promoting a person is a BLINDING decision (D49 read in the direction that
 * destroys work: for a car the destructive read is the RETIREMENT — the flood
-* comes back; for a person it is the BIRTH — we stop seeing them). So the
-* class is available, tuned as strictly as the data allows, and switched off
-* until an operator turns it on for a camera where they know what is standing
-* there.
+* comes back; for a person it is the BIRTH — we stop seeing them). It used to
+* ship OFF behind a per-camera switch for that reason; the switch is gone —
+* an opt-in nobody turns on produces nothing, and it was producing nothing.
+*
+* What makes that affordable now is that agreement is no longer overlap alone:
+* `observationAgrees` requires the TRACKER to call the subject still, so a
+* person who merely pauses inside the anchor no longer feeds the candidate.
+* The statue and the poster still promote — which is what you want, they ARE
+* furniture — while the real person who stops for a moment no longer does.
+*
+* The thresholds stay where the measurement put them. They are the difference
+* between 22 promotions a day and 10.
 */
 var PERSON_EVIDENCE_POLICY = {
 	agreeIou: .5,
 	minAgreed: 40,
 	minAgreementRatio: .95,
-	minSpanMs: 18e5,
-	promotesByDefault: false
+	minSpanMs: 18e5
 };
 /** Classes with no policy of their own fall back to the vehicle numbers —
 *  `animal`, `package` and friends are all "an object that ended up somewhere",
@@ -58771,7 +58759,7 @@ function stationaryEvidenceKey(deviceId, className, anchorId) {
 * Pure, and ordered cheapest-question-first so the reason a candidate was
 * refused is the FIRST thing it failed, not the last.
 */
-function evaluateStationaryEvidence(row, policy, classEnabled) {
+function evaluateStationaryEvidence(row, policy) {
 	const windowSeen = row.windowSeen + row.prevWindowSeen;
 	const windowAgreed = row.windowAgreed + row.prevWindowAgreed;
 	const ratio = windowSeen > 0 ? windowAgreed / windowSeen : 0;
@@ -58782,11 +58770,6 @@ function evaluateStationaryEvidence(row, policy, classEnabled) {
 		ratio,
 		spanMs
 	};
-	if (!classEnabled) return {
-		kind: "accumulating",
-		shortfall: "class-not-promoted",
-		...base
-	};
 	if (row.agreed < policy.minAgreed) return {
 		kind: "accumulating",
 		shortfall: "too-few-agreements",
@@ -58861,6 +58844,32 @@ function matchEvidenceCandidate(rows, className, bbox, agreeIou) {
 	};
 }
 /**
+* Does this observation count as EVIDENCE that the object is parked?
+*
+* Two questions, deliberately kept apart:
+*
+*  - IDENTITY — is this the same object in the same place? That is the IoU,
+*    and it is the only notion of sameness in this module.
+*  - STILLNESS — is it going anywhere? That is the TRACKER's verdict, and
+*    nothing here re-derives it.
+*
+* Before this, `agrees` was the IoU alone, so a long run of overlaps WAS the
+* stillness argument — a second derivation of a fact `StateAnalyzer` already
+* computes per track, slower and able to disagree with it. Now the ledger adds
+* only what the analyzer cannot know: that the same still object has been here
+* across a succession of tracks.
+*
+* `entering` is the tracker's undecided window — five frames that begin EVERY
+* track, including a parked car's re-detection. It is not disagreement, and
+* counting it as such would punish a candidate for the tracker's own warm-up.
+* An ABSENT verdict likewise falls back to overlap alone: a path that never had
+* an opinion must not be silently reclassified.
+*/
+function observationAgrees(overlap, agreeIou, movementState) {
+	if (overlap < agreeIou) return false;
+	return movementState !== "moving" && movementState !== "left";
+}
+/**
 * Fold one observation into a candidate.
 *
 * `agrees` is decided by the CALLER, because M is what makes the ratio mean
@@ -59163,7 +59172,7 @@ var StationaryEvidenceLedger = class {
 	* slow or failing store can never change what this frame decides. The
 	* durable half is fired behind the verdict.
 	*/
-	observe(observation, classEnabled) {
+	observe(observation) {
 		const policy = evidencePolicyFor(observation.className);
 		this.expire(observation.deviceId, observation.timestamp);
 		const bindKey = observation.trackId === void 0 ? void 0 : `${observation.deviceId}:${observation.trackId}`;
@@ -59211,18 +59220,18 @@ var StationaryEvidenceLedger = class {
 				this.capDevice(observation.deviceId);
 				return {
 					row,
-					verdict: evaluateStationaryEvidence(row, policy, classEnabled),
+					verdict: evaluateStationaryEvidence(row, policy),
 					promoted: false
 				};
 			}
 			if (bindKey !== void 0) this.binding.set(bindKey, row.key);
 		}
-		const agrees = overlap >= policy.agreeIou;
+		const agrees = observationAgrees(overlap, policy.agreeIou, observation.movementState);
 		const next = foldObservation(row, observation, agrees, overlap);
 		this.ledger.stage(next);
 		this.dirty.add(next.key);
 		if (created) this.capDevice(observation.deviceId);
-		const verdict = evaluateStationaryEvidence(next, policy, classEnabled);
+		const verdict = evaluateStationaryEvidence(next, policy);
 		if (verdict.kind !== "promote") return {
 			row: next,
 			verdict,
@@ -59670,8 +59679,46 @@ var StationaryObjectRegistry = class {
 			});
 		}
 	}
-	/** Promote a parked track into a persisted stationary entry. */
-	async promote(entry) {
+	/**
+	* Promote a parked track into a persisted stationary entry — or, when the
+	* spot is already censused, CONFIRM the entry sitting on it.
+	*
+	* The occupancy question is asked here and nowhere else, with the same
+	* predicate the per-frame filter uses (`findParkedOccupant`): a box the
+	* filter would suppress as a parked object's own can never become a second
+	* parked object. Until 2026-09-14 this method minted whatever it was handed,
+	* and device 617 reported EIGHT parked vehicles — four of them one car, the
+	* same box to the decimal, promoted again roughly once an hour because the
+	* weak-continuation path (D410) keeps feeding the ledger from a track riding
+	* a parked object. The re-promotion is not the anomaly and is not worth
+	* suppressing: it is a fresh, independent confirmation that the thing is
+	* still there. It just must not produce a neighbour.
+	*
+	* A merge never DOWNGRADES the tenant: it advances the clock and adopts an
+	* identity the tenant lacks (the 617 duplicates arrived unlabelled while the
+	* row they belonged to was already `Car`), and it never overwrites one it
+	* has.
+	*/
+	async promote(entry, config) {
+		const occupant = findParkedOccupant(this.list(entry.deviceId), entry.className, entry.bbox, (config ?? this.matchConfig).suppressIou, (config ?? this.matchConfig).wakeAssocIou);
+		if (occupant !== void 0) {
+			const merged = this.absorbInto(occupant, entry);
+			this.logger.info("stationary promotion absorbed — the spot is already censused", {
+				tags: { deviceId: occupant.deviceId },
+				meta: {
+					deviceId: occupant.deviceId,
+					entryId: occupant.id,
+					className: occupant.className,
+					refusedTrackId: entry.sourceTrackId,
+					parkedForMs: entry.becameStationaryAt - occupant.becameStationaryAt,
+					gainedLabel: occupant.label === void 0 && entry.label !== void 0
+				}
+			});
+			return {
+				outcome: "merged",
+				entry: merged
+			};
+		}
 		this.indexEntry(entry.deviceId, entry.id);
 		this.dirty.delete(entry.id);
 		await this.ledger.put(entry);
@@ -59680,6 +59727,22 @@ var StationaryObjectRegistry = class {
 			entry,
 			timestamp: entry.becameStationaryAt
 		});
+		return {
+			outcome: "born",
+			entry
+		};
+	}
+	/** Fold a refused promotion into the entry that already holds its spot. */
+	absorbInto(occupant, refused) {
+		const merged = {
+			...occupant,
+			lastConfirmedAt: Math.max(occupant.lastConfirmedAt, refused.becameStationaryAt),
+			...occupant.label === void 0 && refused.label !== void 0 ? { label: refused.label } : {},
+			...occupant.keyFrameMediaId === void 0 && refused.keyFrameMediaId !== void 0 ? { keyFrameMediaId: refused.keyFrameMediaId } : {}
+		};
+		this.ledger.stage(merged);
+		this.dirty.add(merged.id);
+		return merged;
 	}
 	/**
 	* Retire entries unconfirmed for longer than the TTL of OBSERVED time, and
@@ -59767,6 +59830,7 @@ var StationaryObjectRegistry = class {
 			}
 		});
 		this.strikeCountersByDevice.clear();
+		for (const deviceId of [...this.idsByDevice.keys()]) this.collapseDuplicates(deviceId);
 		for (const id of [...this.dirty]) {
 			this.dirty.delete(id);
 			const entry = this.ledger.get(id);
@@ -59908,6 +59972,46 @@ var StationaryObjectRegistry = class {
 	/** 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. */
+	/**
+	* Fold every row that holds another row's spot into the OLDEST of them.
+	*
+	* The survivor is the oldest because it is the one carrying the object's real
+	* `becameStationaryAt` — "parked since 14:30" is the fact the operator reads,
+	* and the duplicates are all later re-discoveries of the same thing. It
+	* inherits any identity the losers carry and that it lacks, and the losers'
+	* rows are deleted outright: a retirement would announce a departure that
+	* never happened.
+	*
+	* Uses the same predicate as the filter and the birth guard, so a collapse
+	* can only ever remove a row that could not have been independently confirmed
+	* anyway.
+	*/
+	collapseDuplicates(deviceId) {
+		const entries = [...this.list(deviceId)].sort((a, b) => a.becameStationaryAt - b.becameStationaryAt);
+		if (entries.length < 2) return;
+		const survivors = [];
+		for (const candidate of entries) {
+			const occupant = findParkedOccupant(survivors, candidate.className, candidate.bbox, this.matchConfig.suppressIou, this.matchConfig.wakeAssocIou);
+			if (occupant === void 0) {
+				survivors.push(candidate);
+				continue;
+			}
+			const merged = this.absorbInto(occupant, candidate);
+			survivors[survivors.indexOf(occupant)] = merged;
+			this.dropEntry(deviceId, candidate.id);
+			this.logger.info("stationary duplicate collapsed — two rows, one spot", {
+				tags: { deviceId },
+				meta: {
+					deviceId,
+					keptEntryId: occupant.id,
+					droppedEntryId: candidate.id,
+					className: candidate.className,
+					keptSinceMs: occupant.becameStationaryAt,
+					droppedSinceMs: candidate.becameStationaryAt
+				}
+			});
+		}
+	}
 	dropEntry(deviceId, id) {
 		this.idsByDevice.get(deviceId)?.delete(id);
 		this.dirty.delete(id);
@@ -69950,18 +70054,6 @@ var StationarySettingsSchema = require_dist.object({
 	*  session open (also the minimum track age). Creates nothing — birth is
 	*  decided by repeated evidence. `SESSION_STILLNESS_WINDOW_MS`. */
 	sessionStillnessWindowMs: require_dist.number().int().min(5e3).max(12e4).default(SESSION_STILLNESS_WINDOW_MS),
-	/**
-	* Let a motionless PERSON become a stationary entry on this camera.
-	*
-	* Off, and it is a measurement rather than caution. Replaying 24 h of person
-	* observations from devices 617/1443/590/592 through the evidence ledger
-	* produces 6-22 entries a day depending on how strictly it is tuned, and none
-	* of them can be tuned to zero: device 592 alone yielded eleven candidates at
-	* a perfect agreement ratio between 02:00 and 05:00. A stationary entry
-	* SUPPRESSES its object, so a wrong one makes the camera blind to a person —
-	* turn this on only for a camera where you know what is standing there.
-	*/
-	promotePersons: require_dist.boolean().default(false),
 	/** Observed-time TTL: retire an entry unconfirmed for this long (measured on
 	*  frames-flowing time, not wall-clock). `ENTRY_TTL_MS`. */
 	entryTtlMs: require_dist.number().int().min(6e4).max(18e5).default(ENTRY_TTL_MS)
@@ -69981,7 +70073,6 @@ function resolveStationarySettings(raw) {
 		suppressIou: pick("suppressIou"),
 		wakeAssocIou: pick("wakeAssocIou"),
 		sessionStillnessWindowMs: pick("sessionStillnessWindowMs"),
-		promotePersons: pick("promotePersons"),
 		entryTtlMs: pick("entryTtlMs")
 	};
 }
@@ -70517,13 +70608,6 @@ function buildDetectionSettingsSections() {
 					unit: "s",
 					displayScale: 1e3
 				},
-				{
-					type: "boolean",
-					key: "promotePersons",
-					label: "Also park motionless people",
-					description: "Off by default. A stationary entry SUPPRESSES its object, so a wrong one makes this camera blind to a person standing there. Replaying a day of real person detections produced entries on every camera tried, at every threshold tried — turn this on only where you know what is standing still.",
-					default: STATIONARY_DEFAULTS.promotePersons
-				},
 				{
 					type: "slider",
 					key: "entryTtlMs",
@@ -73867,11 +73951,7 @@ var ZoneAnalyticsProvider = class {
 			});
 		}
 		this.snapshots.set(input.deviceId, snapshot);
-		const noteOccupancy = this.ctx.onOccupancySample;
-		if (noteOccupancy !== void 0) {
-			noteOccupancy(input.deviceId, total, input.timestamp);
-			for (const zone of snapshot.zones) noteOccupancy(input.deviceId, zone.totalObjects, input.timestamp, zone.zoneId);
-		}
+		this.noteLtsSamples(input.deviceId, snapshot, input.timestamp);
 		this.appendHistory(input.deviceId, snapshot);
 		this.emitSnapshot(input.deviceId, snapshot);
 		this.sliceThrottle.push(input.deviceId, snapshot);
@@ -73938,11 +74018,30 @@ var ZoneAnalyticsProvider = class {
 			});
 			if (snapshot) {
 				this.appendHistory(deviceId, snapshot);
+				this.noteLtsSamples(deviceId, snapshot, now);
 				this.emitSnapshot(deviceId, snapshot);
 				this.sliceThrottle.push(deviceId, snapshot);
 			}
 		}
 	}
+	/**
+	* Append this snapshot to the long-term occupancy series — frame-wide first
+	* (`scope: ''`), then one sample per zone.
+	*
+	* Shared by BOTH producers on purpose. It used to live inline in
+	* `recordFrame`, so the baseline sampler — the only producer a camera with no
+	* frames flowing has — wrote the RAM ring, the NC watcher and the state slice
+	* but never LTS. The long-term series therefore had a hole exactly where the
+	* scene was nothing but parked objects: the one span an occupancy history is
+	* asked about. The RAM ring showed a flat line over the same minutes, which
+	* is what made the gap invisible.
+	*/
+	noteLtsSamples(deviceId, snapshot, timestamp) {
+		const note = this.ctx.onOccupancySample;
+		if (note === void 0) return;
+		note(deviceId, snapshot.frame.totalObjects, timestamp);
+		for (const zone of snapshot.zones) note(deviceId, zone.totalObjects, timestamp, zone.zoneId);
+	}
 	/** Push one snapshot to the occupancy tap, isolating any consumer throw from
 	*  the frame path (occupancy notifications must never break analytics). */
 	emitSnapshot(deviceId, snapshot) {
@@ -78277,7 +78376,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 				}
 			});
 		}
-		await this.processFrame(deviceId, frame, data.source ?? "pipeline", data.frameHandle, data.detailSteps);
+		await this.processFrame(deviceId, frame, data.source ?? "pipeline", data.frameHandle, data.detailSteps, data.occasion ?? "session");
 	}
 	/**
 	* Run one detection frame through the analysis layers for a given
@@ -78287,7 +78386,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 	* tracking/zone/event state never crosses between sources. Emits the
 	* SAME canonical events, distinguished only by `source`.
 	*/
-	async processFrame(deviceId, frame, source, rawFrameHandle, detailSteps) {
+	async processFrame(deviceId, frame, source, rawFrameHandle, detailSteps, occasion = "session") {
 		if (this.shuttingDown) return;
 		if (!await this.bindingCache.isActive(deviceId)) {
 			const now = Date.now();
@@ -78695,7 +78794,6 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 			const evidence = this.stationaryEvidence;
 			for (const t of result.tracked) {
 				if (packageClasses.has(t.className)) continue;
-				const classEnabled = t.className === "person" ? stationarySettings.promotePersons : evidencePolicyFor(t.className).promotesByDefault;
 				const active = this.trackStore?.peekActive(t.trackId) ?? null;
 				const observedLabel = active === null ? void 0 : displayLabel(active);
 				const observedKeyFrame = this.residents.keyFrameMediaId(t.trackId);
@@ -78704,12 +78802,13 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 					className: t.className,
 					bbox: { ...t.bbox },
 					timestamp: result.timestamp,
-					source: "session",
+					source: occasion,
 					trackId: t.trackId,
 					...observedKeyFrame !== void 0 ? { keyFrameMediaId: observedKeyFrame } : {},
-					...observedLabel !== void 0 ? { label: observedLabel } : {}
+					...observedLabel !== void 0 ? { label: observedLabel } : {},
+					movementState: t.state
 				};
-				const outcome = evidence.observe(observation, classEnabled);
+				const outcome = evidence.observe(observation);
 				if (outcome === void 0 || !outcome.promoted) continue;
 				this.birthStationaryFromEvidence({
 					deviceId,
@@ -81812,7 +81911,13 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 			...label !== void 0 ? { label } : {},
 			...keyFrameMediaId !== void 0 ? { keyFrameMediaId } : {}
 		};
-		if (plausible) this.stationaryRegistry?.promote(entry);
+		if (plausible) {
+			const gate = this.stationarySettingsFromCache(deviceId);
+			this.stationaryRegistry?.promote(entry, {
+				suppressIou: gate.suppressIou,
+				wakeAssocIou: gate.wakeAssocIou
+			});
+		}
 		processor.dropTrack(track.trackId);
 		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", {