@camstack/addon-post-analysis 1.2.245 → 1.2.247

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-CzmhHYgz.js");
+const require_dist = require("../dist-4yCJnUsG.js");
 let node_fs = require("node:fs");
 node_fs = require_dist.__toESM(node_fs, 1);
 let node_path = require("node:path");
@@ -59327,6 +59327,79 @@ var StationaryEvidenceLedger = class {
 	}
 };
 //#endregion
+//#region src/pipeline-analytics/pipeline/stationary/stationary-birth-guard.ts
+/**
+* The plausibility bar a stationary BIRTH must clear.
+*
+* ## Why a birth needs its own bar
+*
+* A birth was guarded by `isPlausibleThumbnailBox`, which only refuses a
+* NEAR-full-frame box (≥ 0.85 of the frame, or ≥ 0.95 of one dimension). That
+* is the right question for a thumbnail — "is this crop the whole washed-out
+* scene?" — and the wrong one for a parked object.
+*
+* Measured on device 617, 2026-09-14 08:33: an entry was born with a
+* 1669x1796 box in a 3840x2160 frame. That is 2,997,524 / 8,294,400 = **0.361
+* of the frame** — the dawn "envelope exploded" false positive, comfortably
+* under 0.85, so the thumbnail guard passed it. A third of the camera's view
+* is not a parked object.
+*
+* It did not stop at being wrong about itself. An entry that large reads as a
+* container: `entrySwallowsDetection` treats any much-smaller contained box as
+* a FRAGMENT of it, and the scene-sized escape hatch that exists for exactly
+* this (`SCENE_BOX_AREA_FRAC = 0.55`) sits ABOVE 0.361 — so the duplicate
+* collapse (D495) folded a genuinely different parked motorcycle into it and
+* deleted its row.
+*
+* ## The number
+*
+* {@link BIRTH_MAX_AREA_FRAC} = **0.30**, area fraction, refused at/above.
+*
+*  - The measured false birth is 0.361 — refused with ~20% of margin, so a
+*    slightly smaller explosion on the same camera is refused too.
+*  - It sits BELOW `SCENE_BOX_AREA_FRAC` (0.55) by design: no entry can be
+*    born into the band [0.30, 0.55) where it is large enough to swallow every
+*    small box in the frame as a "fragment" and not large enough for the
+*    scene-sized guard to disarm it. That band is the whole mechanism of the
+*    617 motorcycle loss.
+*  - `SCENE_BOX_AREA_FRAC` is NOT moved to do this. It was measured against
+*    device 3829's SUV at ~0.78 of 4K and it decides what the suppression
+*    MATCHER holds; changing it changes what every camera suppresses. This
+*    constant decides only what may be CREATED.
+*  - The cost, stated: a genuine parked object closer to the lens than 30% of
+*    the view no longer earns an entry on that camera (3829's SUV would not be
+*    re-born under this bar). That is the trade — such an object is already
+*    neutered as an entry by the scene-sized guard, while a false one at 0.36
+*    actively destroys neighbouring rows.
+*
+* The near-full-frame and full-dimension rules are kept, not replaced: a
+* 0.96-frame-wide, 0.3-frame-high band is 0.29 of the area and still an
+* artifact, and `isPlausibleThumbnailBox` is the one place that rule lives.
+*/
+/** Frame-area fraction at/above which a box may not be BORN as a parked
+*  object. See the file docblock for the measurements behind 0.30. */
+var BIRTH_MAX_AREA_FRAC = .3;
+/** Area of `bbox` as a fraction of the frame. 0 when the frame is unknown —
+*  a fraction of nothing is not a measurement (D393), and the caller that
+*  wants a decision asks {@link isPlausibleStationaryBirthBox}. */
+function boxAreaFraction(bbox, frameWidth, frameHeight) {
+	if (frameWidth <= 0 || frameHeight <= 0) return 0;
+	return bbox.w * bbox.h / (frameWidth * frameHeight);
+}
+/**
+* True when `bbox` may become a stationary entry.
+*
+* Stricter than the best-thumbnail guard and a superset of it: the
+* near-full-frame / full-dimension artifact rules still apply, plus the
+* birth-specific area bar. Degenerate frame dimensions (≤0) are plausible —
+* there is no measurement to refuse on.
+*/
+function isPlausibleStationaryBirthBox(bbox, frameWidth, frameHeight) {
+	if (frameWidth <= 0 || frameHeight <= 0) return true;
+	if (!isPlausibleThumbnailBox(bbox, frameWidth, frameHeight)) return false;
+	return boxAreaFraction(bbox, frameWidth, frameHeight) < BIRTH_MAX_AREA_FRAC;
+}
+//#endregion
 //#region src/pipeline-analytics/pipeline/stationary/stationary-registry.ts
 /**
 * @durable class=ledger owner=pipeline-analytics
@@ -59435,6 +59508,7 @@ var StationaryObjectRegistry = class {
 	warmUpMs;
 	ttlForDevice;
 	onChange;
+	requestConfirmationLook;
 	/** Latest processed-frame timestamp per device — expiry counts OBSERVED
 	*  time, not wall-clock. A session-dispatch camera produces no frames
 	*  between motion sessions; that silence is not evidence the object left,
@@ -59506,6 +59580,7 @@ var StationaryObjectRegistry = class {
 		this.warmUpMs = deps.warmUpMs ?? 2e3;
 		this.ttlForDevice = deps.ttlForDevice;
 		this.onChange = deps.onChange;
+		this.requestConfirmationLook = deps.requestConfirmationLook;
 	}
 	static declare(store) {
 		return DurableLedger.declare(store, STATIONARY_SPEC);
@@ -59675,7 +59750,8 @@ var StationaryObjectRegistry = class {
 			this.onChange?.({
 				phase: "departed",
 				entry: e,
-				timestamp: input.timestamp
+				timestamp: input.timestamp,
+				observedAt: input.timestamp - wake.strikeAgeMs
 			});
 		}
 	}
@@ -59700,7 +59776,7 @@ var StationaryObjectRegistry = class {
 	* has.
 	*/
 	async promote(entry, config) {
-		const occupant = findParkedOccupant(this.list(entry.deviceId), entry.className, entry.bbox, (config ?? this.matchConfig).suppressIou, (config ?? this.matchConfig).wakeAssocIou);
+		const occupant = findParkedOccupant(this.censusTenants(entry, this.list(entry.deviceId), config), 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", {
@@ -59725,13 +59801,44 @@ var StationaryObjectRegistry = class {
 		this.onChange?.({
 			phase: "appeared",
 			entry,
-			timestamp: entry.becameStationaryAt
+			timestamp: entry.becameStationaryAt,
+			observedAt: entry.becameStationaryAt
 		});
 		return {
 			outcome: "born",
 			entry
 		};
 	}
+	/**
+	* The entries allowed to ABSORB another row — a strict subset of `candidates`.
+	*
+	* An entry that could not be BORN today may not eat its neighbours. Device
+	* 617 held a 1669x1796 box (0.361 of a 4K frame) born before the birth bar
+	* existed; `entrySwallowsDetection` reads every much-smaller contained box as
+	* a fragment of it, and `SCENE_BOX_AREA_FRAC` (0.55) — the guard that exists
+	* to stop exactly this — sits ABOVE 0.361, so the collapse folded a genuinely
+	* different parked motorcycle into it and deleted the motorcycle's row.
+	*
+	* Absorbing is the only thing an oversized entry is refused. It keeps
+	* suppressing, keeps being confirmed and keeps its own row — see
+	* {@link sweep} for why it is not retired.
+	*/
+	censusTenants(candidate, candidates, config) {
+		const tenants = candidates.filter((e) => isPlausibleStationaryBirthBox(e.bbox, e.frameWidth, e.frameHeight));
+		if (tenants.length === candidates.length) return tenants;
+		const wouldHave = findParkedOccupant(candidates.filter((e) => !tenants.includes(e)), candidate.className, candidate.bbox, (config ?? this.matchConfig).suppressIou, (config ?? this.matchConfig).wakeAssocIou);
+		if (wouldHave !== void 0) this.logger.info("stationary row kept apart from an oversized entry", {
+			tags: { deviceId: candidate.deviceId },
+			meta: {
+				deviceId: candidate.deviceId,
+				oversizedEntryId: wouldHave.id,
+				oversizedBbox: wouldHave.bbox,
+				className: candidate.className,
+				candidateBbox: candidate.bbox
+			}
+		});
+		return tenants;
+	}
 	/** Fold a refused promotion into the entry that already holds its spot. */
 	absorbInto(occupant, refused) {
 		const merged = {
@@ -59745,9 +59852,44 @@ var StationaryObjectRegistry = class {
 		return merged;
 	}
 	/**
-	* Retire entries unconfirmed for longer than the TTL of OBSERVED time, and
-	* flush any advanced `lastConfirmedAt`s to the store. Returns retired
-	* entries (for logging).
+	* Does THIS node analyse `deviceId`?
+	*
+	* The registry's ownership signal, and the only one it has: a node receives
+	* inference frames for the cameras it analyses and for no others, so an
+	* observed clock ({@link noteFrame}) is the fact "this camera is mine". It is
+	* the same authority the summary sealer uses (`analysedDeviceIds` off
+	* `lastFrameDimsByDevice`, 2026-09-13, for the same defect on the same
+	* shared table), and it is never cleared per-device, so an idle camera stays
+	* ours and a camera we have never framed never becomes ours by accident.
+	*
+	* What it deliberately is NOT: a per-camera node assignment. `addon-post-
+	* analysis` has none — post-processing is a cluster singleton chosen by
+	* `postProcessingNodeState`, which the registry cannot see and which says
+	* nothing per camera. A node that analyses nothing observes nothing, so this
+	* predicate answers `false` for every row it hydrated, which is the outcome
+	* the singleton would have produced.
+	*/
+	analyses(deviceId) {
+		return this.lastFrameAtByDevice.has(deviceId);
+	}
+	/**
+	* Retire entries unconfirmed for longer than the TTL of OBSERVED time,
+	* collapse duplicate rows, and flush any advanced `lastConfirmedAt`s to the
+	* store. Returns retired entries (for logging).
+	*
+	* ONLY for the cameras this node analyses ({@link analyses}). Every node runs
+	* this addon and every node hydrates the SAME table in {@link load}, so a
+	* sweep over every hydrated device judges — and mutates — cameras it has no
+	* frames for. Measured 2026-09-14: the duplicate collapse for device 617 was
+	* logged by `MinidiGianluca.localdomain` and by `little-unraid`, the same
+	* rows, seven seconds apart.
+	*
+	* An OVERSIZED entry (one that could not be born under the birth bar) is
+	* deliberately NOT retired here. It has been confirmed by frames over time,
+	* which is evidence a birth never had; it cannot be re-born under the new
+	* bar, so the retirement would be permanent and would hand its object back
+	* to the tracker forever. It is refused one thing — absorbing a neighbour
+	* (see {@link censusTenants}) — and otherwise lives out its TTL.
 	*
 	* Expiry is measured against the device's latest processed-frame timestamp
 	* ({@link noteFrame}), NOT the wall clock: a session-dispatch camera emits
@@ -59759,9 +59901,13 @@ var StationaryObjectRegistry = class {
 	*/
 	async sweep(now) {
 		const retired = [];
+		let foreign = 0;
 		for (const [deviceId, ids] of this.idsByDevice) {
 			const observedAt = this.lastFrameAtByDevice.get(deviceId);
-			if (observedAt === void 0) continue;
+			if (observedAt === void 0) {
+				foreign += 1;
+				continue;
+			}
 			const ttl = this.ttlForDevice?.(deviceId) ?? this.entryTtlMs;
 			for (const id of [...ids]) {
 				const e = this.ledger.get(id);
@@ -59787,12 +59933,14 @@ var StationaryObjectRegistry = class {
 					this.onChange?.({
 						phase: "departed",
 						entry: e,
-						timestamp: now
+						timestamp: now,
+						observedAt: e.lastConfirmedAt
 					});
 				}
 			}
 			if (ids.size === 0) this.idsByDevice.delete(deviceId);
 		}
+		if (foreign > 0) this.logger.debug("stationary sweep skipped cameras this node does not analyse", { meta: { devices: foreign } });
 		const countedDevices = new Set([...this.absorbedSinceSweep.keys(), ...this.suppressedSinceSweep.keys()]);
 		for (const deviceId of countedDevices) {
 			const absorbed = this.absorbedSinceSweep.get(deviceId) ?? 0;
@@ -59830,7 +59978,10 @@ var StationaryObjectRegistry = class {
 			}
 		});
 		this.strikeCountersByDevice.clear();
-		for (const deviceId of [...this.idsByDevice.keys()]) this.collapseDuplicates(deviceId);
+		for (const deviceId of [...this.idsByDevice.keys()]) {
+			if (!this.analyses(deviceId)) continue;
+			this.collapseDuplicates(deviceId);
+		}
 		for (const id of [...this.dirty]) {
 			this.dirty.delete(id);
 			const entry = this.ledger.get(id);
@@ -59944,6 +60095,12 @@ var StationaryObjectRegistry = class {
 						confirmMinGapMs: this.departureConfig.confirmMinGapMs
 					}
 				});
+				this.requestConfirmationLook?.({
+					deviceId,
+					entryId: change.entryId,
+					afterMs: this.departureConfig.confirmMinGapMs,
+					frames: this.departureConfig.absenceMinReads
+				});
 			}
 		}
 		if (pending !== void 0 && pending.size === 0) this.departureStrikes.delete(deviceId);
@@ -59991,7 +60148,7 @@ var StationaryObjectRegistry = class {
 		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);
+			const occupant = findParkedOccupant(this.censusTenants(candidate, survivors), candidate.className, candidate.bbox, this.matchConfig.suppressIou, this.matchConfig.wakeAssocIou);
 			if (occupant === void 0) {
 				survivors.push(candidate);
 				continue;
@@ -75618,6 +75775,12 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 	* failure mode `observe` mode was already in). See `store/lts-store.ts`.
 	*/
 	lts = null;
+	/** The runner node that last produced a frame for a camera — see
+	*  `handleInferenceResult`. */
+	lastRunnerNodeByDevice = /* @__PURE__ */ new Map();
+	/** Pending out-of-band confirmation looks, keyed `deviceId:entryId`, so an
+	*  entry that re-arms while one is in flight does not stack timers. */
+	pendingConfirmationLooks = /* @__PURE__ */ new Map();
 	ltsFlushTimer = null;
 	/**
 	* `scene-monitor` — the operator's latched boolean over a reference region.
@@ -76181,7 +76344,8 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 			store: api.settingsStore,
 			logger: logger.child("StationaryRegistry"),
 			ttlForDevice: (deviceId) => this.stationarySettingsFromCache(deviceId).entryTtlMs,
-			onChange: ({ phase, entry, timestamp }) => {
+			requestConfirmationLook: (ask) => this.requestConfirmationLook(ask),
+			onChange: ({ phase, entry, timestamp, observedAt }) => {
 				this.ctx.eventBus.emit({
 					id: `pa-stationary-${entry.id}-${phase}`,
 					timestamp: new Date(timestamp),
@@ -76196,7 +76360,8 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 						entryId: entry.id,
 						className: entry.className,
 						phase,
-						timestamp
+						timestamp,
+						observedAt
 					}
 				});
 				this.packageDropDetector?.onStationaryChange({
@@ -78377,9 +78542,59 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 		this.ncArtifactIndex = null;
 		this.ncArtifactStore = null;
 	}
+	/**
+	* Ask the runner to look at a camera once more, shortly after a departure was
+	* armed — see `StationaryRegistryDeps.requestConfirmationLook` for why, and
+	* the cap's `requestOccupancyBurst` for the two numbers that shape the ask.
+	*
+	* Pinned to the node whose frames we have been analysing: an unpinned call
+	* would be served by whichever runner answers, and a runner that does not
+	* hold the camera refuses it — correctly, but uselessly.
+	*
+	* Fire-and-forget by construction. This is an OPTIMISATION of a path that
+	* already terminates on its own (the entry ages out), so a failure here must
+	* cost nothing but a log line.
+	*/
+	requestConfirmationLook(ask) {
+		const key = `${String(ask.deviceId)}:${ask.entryId}`;
+		if (this.pendingConfirmationLooks.has(key)) return;
+		const nodeId = this.lastRunnerNodeByDevice.get(ask.deviceId);
+		const runnerApi = this.ctx.api.pipelineRunner;
+		if (nodeId === void 0 || !runnerApi?.requestOccupancyBurst) return;
+		const timer = setTimeout(() => {
+			this.pendingConfirmationLooks.delete(key);
+			if (this.shuttingDown) return;
+			runnerApi.requestOccupancyBurst.mutate({
+				deviceId: ask.deviceId,
+				frames: ask.frames,
+				reason: "stationary-departure-confirm"
+			}, require_dist.nodePin(nodeId)).then((answer) => {
+				if (!answer.started) this.ctx.logger.debug("departure confirmation look refused", {
+					tags: { deviceId: ask.deviceId },
+					meta: {
+						entryId: ask.entryId,
+						nodeId,
+						refusedBecause: answer.refusedBecause
+					}
+				});
+			}).catch((err) => {
+				this.ctx.logger.debug("departure confirmation look failed", {
+					tags: { deviceId: ask.deviceId },
+					meta: {
+						entryId: ask.entryId,
+						nodeId,
+						error: String(err)
+					}
+				});
+			});
+		}, ask.afterMs);
+		timer.unref?.();
+		this.pendingConfirmationLooks.set(key, timer);
+	}
 	async handleInferenceResult(data) {
 		if (this.shuttingDown) return;
 		const { deviceId, frame } = data;
+		if (data.nodeId.length > 0) this.lastRunnerNodeByDevice.set(deviceId, data.nodeId);
 		const lag = this.frameLag.observe(deviceId, Date.now(), data.emittedAt, data.capturedAt);
 		if (lag !== null) {
 			const verdict = lagVerdict(lag);
@@ -81908,13 +82123,18 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 		const { deviceId, key, processor, track, row, firstSeen, frameWidth, frameHeight, timestamp } = input;
 		const label = row.label;
 		const keyFrameMediaId = row.keyFrameMediaId ?? this.residents.keyFrameMediaId(track.trackId);
-		const plausible = isPlausibleThumbnailBox(row.bestBbox, frameWidth, frameHeight);
-		if (!plausible) this.ctx.logger.info("stationary birth rejected (near-full-frame box)", {
+		const plausible = isPlausibleStationaryBirthBox(row.bestBbox, frameWidth, frameHeight);
+		if (!plausible) this.ctx.logger.info("stationary birth rejected — implausible box for a parked object", {
 			tags: { deviceId },
 			meta: {
+				deviceId,
 				trackId: track.trackId,
 				className: row.className,
 				bbox: row.bestBbox,
+				frameWidth,
+				frameHeight,
+				areaFrac: Number(boxAreaFraction(row.bestBbox, frameWidth, frameHeight).toFixed(3)),
+				maxAreaFrac: BIRTH_MAX_AREA_FRAC,
 				agreed: row.agreed,
 				seen: row.seen
 			}