@camstack/addon-post-analysis 1.2.193 → 1.2.195

package/dist/pipeline-analytics/{hostInit-qRtMpIyP.mjs → hostInit-D-5Zg6MO.mjs}

@@ -36,7 +36,7 @@ async function r() {
 				}
 			},
 			"@camstack/types": {
-				version: "1.2.158",
+				version: "1.2.160",
 				scope: "default",
 				shareConfig: {
 					singleton: !0,
@@ -45,7 +45,7 @@ async function r() {
 				}
 			},
 			"@camstack/sdk": {
-				version: "1.2.78",
+				version: "1.2.80",
 				scope: "default",
 				shareConfig: {
 					singleton: !0,
@@ -81,7 +81,7 @@ async function r() {
 				}
 			},
 			"@camstack/ui-library": {
-				version: "1.2.126",
+				version: "1.2.128",
 				scope: "default",
 				shareConfig: {
 					singleton: !0,

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-CJKdyCag.js");
+const require_dist = require("../dist-C15zOWA2.js");
 let node_fs = require("node:fs");
 node_fs = require_dist.__toESM(node_fs, 1);
 let node_path = require("node:path");
@@ -35241,6 +35241,7 @@ var FrameProcessor = class {
 		const plateByBbox = /* @__PURE__ */ new Map();
 		const maskByBbox = /* @__PURE__ */ new Map();
 		const nativeRecoveryByBbox = /* @__PURE__ */ new Map();
+		const birthEvidenceByBbox = /* @__PURE__ */ new Map();
 		const flatDetections = frame.detections.filter((d) => d.kind === "first-level").map((det) => {
 			const bbox = {
 				x: det.bbox.x,
@@ -35256,6 +35257,7 @@ var FrameProcessor = class {
 				...det.nativeRecovery !== void 0 ? { nativeRecovery: det.nativeRecovery } : {}
 			};
 			if (det.nativeRecovery !== void 0) nativeRecoveryByBbox.set(bbox, det.nativeRecovery);
+			if (det.birthEvidence !== void 0) birthEvidenceByBbox.set(bbox, det.birthEvidence);
 			if (det.labels.length > 0) labelsByBbox.set(bbox, det.labels);
 			if (det.debug?.originalClassTier !== void 0) originalClassTierByBbox.set(bbox, det.debug.originalClassTier);
 			if (det.embedding !== void 0) embeddingByBbox.set(bbox, {
@@ -35481,6 +35483,7 @@ var FrameProcessor = class {
 			const plate = plateByBbox.get(td.bbox);
 			const sourceDetectionId = sourceIdByBbox.get(td.bbox);
 			const nativeRecovery = td.matchedThisFrame !== false ? nativeRecoveryByBbox.get(td.bbox) : void 0;
+			const birthEvidence = td.matchedThisFrame !== false ? birthEvidenceByBbox.get(td.bbox) : void 0;
 			return {
 				trackId: td.trackId,
 				...sourceDetectionId !== void 0 ? { sourceDetectionId } : {},
@@ -35504,7 +35507,8 @@ var FrameProcessor = class {
 					plateScore: plate.score,
 					plateBbox: plate.bbox
 				} : {},
-				...nativeRecovery !== void 0 ? { nativeRecovery } : {}
+				...nativeRecovery !== void 0 ? { nativeRecovery } : {},
+				...birthEvidence !== void 0 ? { birthEvidence } : {}
 			};
 		});
 		this.lastLabelWriteRefusals = refusals;
@@ -45355,9 +45359,28 @@ function withTimeout$2(promise, timeoutMs) {
 	});
 }
 async function runConfirmation(candidate, config, deps, exhausted) {
+	const carried = candidate.evidenceCrop ?? null;
+	if (carried) {
+		const verdict = await measure(candidate, carried, config, deps, "carried");
+		if (verdict.verdict === "confirmed" || verdict.reason === "redetect-error") return verdict;
+	}
 	let crop = await deps.fetchCrop(candidate);
-	if (!crop && exhausted && deps.fetchFallbackCrop) crop = await deps.fetchFallbackCrop(candidate);
+	let cropSource = "native";
+	if (!crop && exhausted && deps.fetchFallbackCrop) {
+		crop = await deps.fetchFallbackCrop(candidate);
+		cropSource = "fallback";
+	}
 	if (!crop) return undecided(candidate, "no-crop");
+	return measure(candidate, crop, config, deps, cropSource);
+}
+/**
+* Re-detect on ONE crop and turn the result into a verdict.
+*
+* Shared by all three sources so a crop can never be judged by two slightly
+* different rules depending on where it came from — the `cropSource` argument
+* is the ONLY thing that varies, and it varies in exactly one place below.
+*/
+async function measure(candidate, crop, config, deps, cropSource) {
 	const detections = await deps.redetect(crop);
 	if (detections === null) return undecided(candidate, "redetect-error");
 	let best;
@@ -45367,6 +45390,7 @@ async function runConfirmation(candidate, config, deps, exhausted) {
 	} else if (!bestIncompatible || d.score > bestIncompatible.score) bestIncompatible = d;
 	const bar = barFor(candidate, config, deps);
 	const confirmed = best !== void 0 && best.score >= bar;
+	if (!confirmed && cropSource !== "native") return undecided(candidate, cropSource === "fallback" ? "fallback-inconclusive" : "carried-inconclusive");
 	const secondary = bestIncompatible ? promoteSecondary(candidate, bestIncompatible, bar, deps) : null;
 	return {
 		trackId: candidate.trackId,
@@ -45374,6 +45398,7 @@ async function runConfirmation(candidate, config, deps, exhausted) {
 		reason: confirmed ? "confirmed" : "suppressed",
 		className: candidate.className,
 		appliedMinConfidence: bar,
+		cropSource,
 		...best ? { bestScore: best.score } : {},
 		...bestIncompatible ? {
 			bestIncompatibleClass: bestIncompatible.macroClass,
@@ -51886,6 +51911,97 @@ async function normalizePhotoOrientation(photo) {
 	if (orientation === void 0 || orientation === EXIF_UPRIGHT) return photo;
 	return (0, sharp.default)(photo).rotate().jpeg({ quality: 95 }).toBuffer();
 }
+/**
+* How long one birth's evidence is kept. Twice `confirmationGateMaxDeferralMs`
+* (2 000 ms default) — the longest a deferred birth can still be re-offered.
+*/
+var BIRTH_EVIDENCE_TTL_MS = 4e3;
+var BirthEvidenceStore = class {
+	slotsPerCamera;
+	ttlMs;
+	byDevice = /* @__PURE__ */ new Map();
+	constructor(slotsPerCamera = 8, ttlMs = BIRTH_EVIDENCE_TTL_MS) {
+		this.slotsPerCamera = slotsPerCamera;
+		this.ttlMs = ttlMs;
+	}
+	/**
+	* Keep this birth's crop.
+	*
+	* The FIRST crop for an id wins. A later frame's crop of the same track is a
+	* different instant, and this store exists precisely to preserve the instant
+	* the birth was measured on — overwriting it would quietly reintroduce the
+	* defect the fallback asymmetry exists to distrust.
+	*/
+	remember(deviceKey, trackId, crop, nowMs) {
+		let slots = this.byDevice.get(deviceKey);
+		if (!slots) {
+			slots = /* @__PURE__ */ new Map();
+			this.byDevice.set(deviceKey, slots);
+		}
+		if (slots.has(trackId)) return;
+		slots.set(trackId, {
+			crop,
+			atMs: nowMs
+		});
+		this.evict(deviceKey, slots, nowMs);
+	}
+	/** This birth's crop, or `null` when it was never kept or has aged out. */
+	get(deviceKey, trackId, nowMs) {
+		const entry = this.byDevice.get(deviceKey)?.get(trackId);
+		if (!entry) return null;
+		if (nowMs - entry.atMs > this.ttlMs) {
+			this.resolve(deviceKey, trackId);
+			return null;
+		}
+		return entry.crop;
+	}
+	/** A verdict finally arrived — the crop is dead weight from here. */
+	resolve(deviceKey, trackId) {
+		const slots = this.byDevice.get(deviceKey);
+		if (!slots) return;
+		slots.delete(trackId);
+		if (slots.size === 0) this.byDevice.delete(deviceKey);
+	}
+	/**
+	* Forget every id the tracker is no longer carrying — the same per-frame
+	* contract as `DeferredBirthRegistry.retain`. An id the tracker dropped can
+	* never be decided, so holding its pixels only leaks.
+	*/
+	retain(deviceKey, currentTrackIds) {
+		const slots = this.byDevice.get(deviceKey);
+		if (!slots) return;
+		for (const id of [...slots.keys()]) if (!currentTrackIds.has(id)) slots.delete(id);
+		if (slots.size === 0) this.byDevice.delete(deviceKey);
+	}
+	/** Crops held for one camera (diagnostics and tests). */
+	size(deviceKey) {
+		return this.byDevice.get(deviceKey)?.size ?? 0;
+	}
+	/** Bytes held across every camera — the declared budget, checkable. */
+	totalBytes() {
+		let total = 0;
+		for (const slots of this.byDevice.values()) for (const entry of slots.values()) total += entry.crop.byteLength;
+		return total;
+	}
+	/** Drop a camera's reserve wholesale (device removed / pipeline reset). */
+	clearDevice(deviceKey) {
+		this.byDevice.delete(deviceKey);
+	}
+	/**
+	* Age first, then the quota — and only ever inside THIS camera's slots.
+	* `Map` keeps insertion order and a crop is inserted once, so the first key
+	* is always the oldest.
+	*/
+	evict(deviceKey, slots, nowMs) {
+		for (const [id, entry] of [...slots]) if (nowMs - entry.atMs > this.ttlMs) slots.delete(id);
+		while (slots.size > this.slotsPerCamera) {
+			const oldest = slots.keys().next().value;
+			if (oldest === void 0) break;
+			slots.delete(oldest);
+		}
+		if (slots.size === 0) this.byDevice.delete(deviceKey);
+	}
+};
 //#endregion
 //#region src/pipeline-analytics/pipeline/deferred-births.ts
 var DeferredBirthRegistry = class {
@@ -54042,6 +54158,77 @@ function personOverVehicle(person, neighbours, threshold = CONTAINMENT_THRESHOLD
 	return best >= threshold ? best : null;
 }
 //#endregion
+//#region src/pipeline-analytics/pipeline/started-births.ts
+/**
+* Memory of births whose ritual has already RUN, per device+source.
+*
+* A birth is a decision, and a decision is taken once. Until 2026-09-07 it
+* could be taken twice, on camera 615 it routinely was, and the second vote
+* won:
+*
+*   04:59:38.335Z  confirmation gate: birth confirmed  {trackId=f585b2ee…
+*                  className=animal bestScore=0.7068}
+*   04:59:38.335Z  track started                       {trackId=f585b2ee…}
+*   04:59:38.821Z  confirmation gate: birth suppressed (false positive)
+*                  {trackId=f585b2ee… className=animal}     ← no bestScore:
+*                  the second crop held no compatible detection AT ALL
+*   04:59:38.821Z  birth suppressed — track record retracted
+*
+* TWO conditions have to meet, and both are structural:
+*
+*  1. `processFrame` reads `lastActiveTrackIds` at the top and writes it at the
+*     bottom, and AWAITS the confirmation gate in between (a crop round trip to
+*     the frame's node plus a re-detection: 130–490 ms measured on this camera,
+*     against 100 ms frame spacing). Several frames are therefore in flight at
+*     once and each of them sees the same fresh id as unjudged.
+*  2. The other birth discriminator, `positionsCount > 1`, does not close the
+*     gap either: a COASTED frame deliberately appends no position
+*     (`TrackStore.upsert`, `matched: false`), so a track the full-frame pass
+*     cannot see — which is the entire premise of the small-subject recovery —
+*     keeps exactly one position for as long as it coasts, and
+*     `classifyTrackAppearance` keeps answering `birth`.
+*
+* So the id that has already been born is remembered HERE, and both halves of
+* the birth path consult it: it is not offered to the gate again, and a verdict
+* that arrives for it anyway cannot retract it. Same lifetime discipline as
+* {@link SuppressedBirthRegistry} — held while the tracker still carries the
+* id, forgotten the frame it stops.
+*/
+var StartedBirthRegistry = class {
+	byDevice = /* @__PURE__ */ new Map();
+	/** Record that this id's birth ritual ran — `start`, firstFrame, the lot. */
+	markStarted(deviceKey, trackId) {
+		let ids = this.byDevice.get(deviceKey);
+		if (!ids) {
+			ids = /* @__PURE__ */ new Set();
+			this.byDevice.set(deviceKey, ids);
+		}
+		ids.add(trackId);
+	}
+	hasStarted(deviceKey, trackId) {
+		return this.byDevice.get(deviceKey)?.has(trackId) === true;
+	}
+	/**
+	* Forget every started id the tracker is no longer carrying. Called once per
+	* frame with the ids present THIS frame — an id the tracker has dropped can
+	* never be re-offered as a birth, so holding it serves nothing.
+	*/
+	retain(deviceKey, currentTrackIds) {
+		const ids = this.byDevice.get(deviceKey);
+		if (!ids) return;
+		for (const id of ids) if (!currentTrackIds.has(id)) ids.delete(id);
+		if (ids.size === 0) this.byDevice.delete(deviceKey);
+	}
+	/** Started ids currently held for a device — diagnostics and tests. */
+	size(deviceKey) {
+		return this.byDevice.get(deviceKey)?.size ?? 0;
+	}
+	/** Drop a device's memory wholesale (device removed / pipeline reset). */
+	clearDevice(deviceKey) {
+		this.byDevice.delete(deviceKey);
+	}
+};
+//#endregion
 //#region src/pipeline-analytics/pipeline/stationary/stationary-evidence.ts
 /**
 * stationary-evidence — how a parked object EARNS a registry entry.
@@ -55314,77 +55501,6 @@ function rowToEntry(id, data) {
 	};
 }
 //#endregion
-//#region src/pipeline-analytics/pipeline/started-births.ts
-/**
-* Memory of births whose ritual has already RUN, per device+source.
-*
-* A birth is a decision, and a decision is taken once. Until 2026-09-07 it
-* could be taken twice, on camera 615 it routinely was, and the second vote
-* won:
-*
-*   04:59:38.335Z  confirmation gate: birth confirmed  {trackId=f585b2ee…
-*                  className=animal bestScore=0.7068}
-*   04:59:38.335Z  track started                       {trackId=f585b2ee…}
-*   04:59:38.821Z  confirmation gate: birth suppressed (false positive)
-*                  {trackId=f585b2ee… className=animal}     ← no bestScore:
-*                  the second crop held no compatible detection AT ALL
-*   04:59:38.821Z  birth suppressed — track record retracted
-*
-* TWO conditions have to meet, and both are structural:
-*
-*  1. `processFrame` reads `lastActiveTrackIds` at the top and writes it at the
-*     bottom, and AWAITS the confirmation gate in between (a crop round trip to
-*     the frame's node plus a re-detection: 130–490 ms measured on this camera,
-*     against 100 ms frame spacing). Several frames are therefore in flight at
-*     once and each of them sees the same fresh id as unjudged.
-*  2. The other birth discriminator, `positionsCount > 1`, does not close the
-*     gap either: a COASTED frame deliberately appends no position
-*     (`TrackStore.upsert`, `matched: false`), so a track the full-frame pass
-*     cannot see — which is the entire premise of the small-subject recovery —
-*     keeps exactly one position for as long as it coasts, and
-*     `classifyTrackAppearance` keeps answering `birth`.
-*
-* So the id that has already been born is remembered HERE, and both halves of
-* the birth path consult it: it is not offered to the gate again, and a verdict
-* that arrives for it anyway cannot retract it. Same lifetime discipline as
-* {@link SuppressedBirthRegistry} — held while the tracker still carries the
-* id, forgotten the frame it stops.
-*/
-var StartedBirthRegistry = class {
-	byDevice = /* @__PURE__ */ new Map();
-	/** Record that this id's birth ritual ran — `start`, firstFrame, the lot. */
-	markStarted(deviceKey, trackId) {
-		let ids = this.byDevice.get(deviceKey);
-		if (!ids) {
-			ids = /* @__PURE__ */ new Set();
-			this.byDevice.set(deviceKey, ids);
-		}
-		ids.add(trackId);
-	}
-	hasStarted(deviceKey, trackId) {
-		return this.byDevice.get(deviceKey)?.has(trackId) === true;
-	}
-	/**
-	* Forget every started id the tracker is no longer carrying. Called once per
-	* frame with the ids present THIS frame — an id the tracker has dropped can
-	* never be re-offered as a birth, so holding it serves nothing.
-	*/
-	retain(deviceKey, currentTrackIds) {
-		const ids = this.byDevice.get(deviceKey);
-		if (!ids) return;
-		for (const id of ids) if (!currentTrackIds.has(id)) ids.delete(id);
-		if (ids.size === 0) this.byDevice.delete(deviceKey);
-	}
-	/** Started ids currently held for a device — diagnostics and tests. */
-	size(deviceKey) {
-		return this.byDevice.get(deviceKey)?.size ?? 0;
-	}
-	/** Drop a device's memory wholesale (device removed / pipeline reset). */
-	clearDevice(deviceKey) {
-		this.byDevice.delete(deviceKey);
-	}
-};
-//#endregion
 //#region src/pipeline-analytics/pipeline/suppressed-births.ts
 /**
 * Memory of births the confirmation gate rejected, per device.
@@ -67750,6 +67866,17 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 	/** Births the gate could not MEASURE, awaiting another look on a later frame. */
 	deferredBirths = new DeferredBirthRegistry();
 	/**
+	* The pixels each deferred birth arrived with — a RESERVE per camera, evicted
+	* by age inside that camera's own quota (D379).
+	*
+	* Not a shared cap. The path this replaces was one node-wide 4 096-entry LRU
+	* measured pinned full in 6 814 of 6 849 samples over three hours, in which a
+	* busy camera evicted a quiet one's proof and every camera added shortened
+	* every other camera's window. See `pipeline/birth-evidence-store.ts` for the
+	* two measurements the slot count and the TTL are taken from.
+	*/
+	birthEvidence = new BirthEvidenceStore();
+	/**
 	* Subjects the confirmation gate found in a birth's crop BESIDES the birth
 	* itself (a dog in a person's crop), waiting to ride the next frame of the
 	* same (device, source) as detections — `pipeline/secondary-subjects.ts`.
@@ -71003,12 +71130,20 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 		const exhaustionNowMs = Date.now();
 		const exhaustedIds = /* @__PURE__ */ new Set();
 		for (const { id } of bornCandidates) if (this.deferredBirths.exhausted(key, id, exhaustionNowMs, gateSettings.maxAttempts, gateSettings.maxDeferralMs)) exhaustedIds.add(id);
-		const outcome = await this.confirmTrackBirths(bornCandidates.map(({ id, t }) => ({
-			trackId: id,
-			className: t.className,
-			bbox: t.bbox,
-			...t.nativeRecovery !== void 0 ? { nativeRecovery: t.nativeRecovery } : {}
-		})), {
+		for (const { id, t } of bornCandidates) {
+			if (t.birthEvidence === void 0) continue;
+			this.birthEvidence.remember(key, id, Buffer.from(t.birthEvidence.jpegBase64, "base64"), exhaustionNowMs);
+		}
+		const outcome = await this.confirmTrackBirths(bornCandidates.map(({ id, t }) => {
+			const evidenceCrop = this.birthEvidence.get(key, id, exhaustionNowMs);
+			return {
+				trackId: id,
+				className: t.className,
+				bbox: t.bbox,
+				...t.nativeRecovery !== void 0 ? { nativeRecovery: t.nativeRecovery } : {},
+				...evidenceCrop !== null ? { evidenceCrop } : {}
+			};
+		}), {
 			deviceId,
 			source,
 			frameHandle,
@@ -71032,6 +71167,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 			const deferredForMs = this.deferredBirths.elapsedMs(key, id, gateNowMs);
 			const deferredAttempts = this.deferredBirths.attemptsFor(key, id);
 			this.deferredBirths.resolve(key, id);
+			this.birthEvidence.resolve(key, id);
 			if (this.startedBirths.hasStarted(key, id)) {
 				this.deferredBirths.resolve(key, id);
 				log.info("late birth verdict ignored — the track was already born", { meta: {
@@ -71149,6 +71285,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 		this.suppressedBirths.retain(key, currentTrackIds);
 		this.startedBirths.retain(key, currentTrackIds);
 		this.deferredBirths.retain(key, currentTrackIds);
+		this.birthEvidence.retain(key, currentTrackIds);
 		this.lastActiveTrackIds.set(key, currentTrackIds);
 		if (currentTrackIds.size > 0) this.lastTrackActivityMs.set(deviceId, Date.now());
 		const stationarySettings = this.stationarySettingsFromCache(deviceId);
@@ -71778,6 +71915,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 						bestIncompatibleScore: decision.bestIncompatibleScore
 					} : {},
 					minConfidence: config.minConfidence,
+					...decision.cropSource !== void 0 ? { cropSource: decision.cropSource } : {},
 					...decision.reason === "native-pass" ? {
 						nativeRecoveryCropSidePx: candidateNativeRecovery.get(decision.trackId)?.cropSidePx,
 						nativeRecoveryViewPx: candidateNativeRecovery.get(decision.trackId)?.viewPx