@camstack/addon-post-analysis 1.2.192 → 1.2.194

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-DMnyp081.js");
 let node_fs = require("node:fs");
 node_fs = require_dist.__toESM(node_fs, 1);
 let node_path = require("node:path");
@@ -34017,6 +34017,18 @@ var LooseBindSampler = class {
 		this.counts.clear();
 	}
 };
+/** Per-reason counter + sampling decision. One instance per tracker, so the
+*  counts are per camera and per detection source. */
+var SpawnRefusalSampler = class {
+	counts = /* @__PURE__ */ new Map();
+	/** The running count when this refusal should be reported, else `undefined`. */
+	next(reason) {
+		const count = (this.counts.get(reason) ?? 0) + 1;
+		this.counts.set(reason, count);
+		if (count <= 10) return count;
+		return count % 10 === 0 ? count : void 0;
+	}
+};
 //#endregion
 //#region src/pipeline-analytics/pipeline/tracker/sort-tracker.ts
 var DEFAULT_TRACKER_CONFIG = {
@@ -34101,6 +34113,10 @@ var SortTracker = class SortTracker {
 	/** Sink for salvage-bind diagnostics. Null until an owner that knows the
 	*  `deviceId` wires one — see {@link setBindObserver}. */
 	bindObserver = null;
+	/** Per-reason counters behind the sampled dropped-detection diagnostics. */
+	refusalSampler = new SpawnRefusalSampler();
+	/** Sink for dropped-detection diagnostics — see {@link setSpawnRefusalObserver}. */
+	spawnRefusalObserver = null;
 	constructor(config = {}) {
 		this.config = {
 			...DEFAULT_TRACKER_CONFIG,
@@ -34116,6 +34132,37 @@ var SortTracker = class SortTracker {
 	setBindObserver(observer) {
 		this.bindObserver = observer;
 	}
+	/**
+	* Wire the diagnostics sink for detections the tracker DROPS — a spawn a
+	* gate refused, or a box a track of another class absorbed. Same contract as
+	* {@link setBindObserver}: the tracker has no `deviceId`, the caller stamps
+	* it. Nothing is computed when no observer is wired.
+	*/
+	setSpawnRefusalObserver(observer) {
+		this.spawnRefusalObserver = observer;
+	}
+	/** Emit one dropped-detection record, subject to the refusal sampler. */
+	reportRefusal(reason, det, extra = {}) {
+		const observer = this.spawnRefusalObserver;
+		if (!observer) return;
+		const refusalCount = this.refusalSampler.next(reason);
+		if (refusalCount === void 0) return;
+		observer({
+			reason,
+			detClass: det.class,
+			detScore: det.score,
+			bbox: det.bbox,
+			...det.nativeRecovery !== void 0 ? { nativeRecoveryScore: det.nativeRecovery.score } : {},
+			...extra.threshold !== void 0 ? { threshold: extra.threshold } : {},
+			...extra.measured !== void 0 ? { measured: extra.measured } : {},
+			...extra.against !== void 0 ? {
+				againstTrackId: extra.against.id,
+				againstTrackClass: extra.against.class
+			} : {},
+			refusalCount,
+			sampledEvery: 10
+		});
+	}
 	/** Emit one salvage decision, subject to {@link LOOSE_BIND_LOG_SAMPLE_EVERY}.
 	*  Nothing is computed when no observer is wired. */
 	reportBind(stage, gate, track, det, timestamp) {
@@ -34175,9 +34222,49 @@ var SortTracker = class SortTracker {
 	*  exact class when `classGating` is off (no gate at all) — matching the legacy
 	*  contract — otherwise same association group (group == exact class unless
 	*  `classGroupAssoc` widened it to {person,animal}). */
-	associable(trackClass, detClass) {
+	associable(trackClass, det) {
+		if (!this.sameGroupAsMeasured(trackClass, det)) return false;
 		if (!this.config.classGating) return true;
-		return this.assocGroup(trackClass) === this.assocGroup(detClass);
+		return this.assocGroup(trackClass) === this.assocGroup(det.class);
+	}
+	/**
+	* A NATIVE-MEASURED BOX IS ITS OWN SUBJECT ACROSS CLASSES (D378).
+	*
+	* `classGroupAssoc` collapses {person, animal} into one association group for
+	* one failure of the COARSE full-frame pass: a bending person re-labelled
+	* `animal` for a frame, over the person's own box. Letting that box re-match
+	* the person track is strictly better than minting a concurrent id.
+	*
+	* The runner's second pass makes the opposite measurement — the same detector
+	* on a 640-800 px native square around a motion region the full-frame boxes
+	* do NOT account for. Such a box is, by construction, not the subject the
+	* full pass already has; absorbing it into a person track means the animal is
+	* never seen at all, which on 2026-09-07 07:51:33 is exactly what happened to
+	* an `animal` at `nativeRecoveryScore=0.833`.
+	*
+	* So the widening does not apply to a detection carrying `nativeRecovery`:
+	* it associates to its OWN class or it spawns. Every other guard on that
+	* spawn still runs — the per-class score floor, the area floor, the
+	* `dedupSpawnIou` overlap, and `resolveDuplicates` afterwards, where a person
+	* still beats a cross-class animal.
+	*/
+	sameGroupAsMeasured(trackClass, det) {
+		if (det.nativeRecovery === void 0) return true;
+		return trackClass === det.class;
+	}
+	/**
+	* Whether a matched track's box refuses `det` a birth. The gate exists for a
+	* detector double-firing INSIDE a subject it already has, so it is a
+	* same-subject claim: for a box the native pass measured (D378), a
+	* cross-class occluder is not that claim — a dog at its owner's knee is 100%
+	* contained in the person's box and is not the person. 2026-09-07 07:56:37,
+	* an `animal` at `nativeRecoveryScore=0.5143` refused on `threshold=0.6`.
+	* A SAME-class occluder still refuses it: that is the torso the crop cut out
+	* of a person the full pass already has.
+	*/
+	occludesSpawn(det, occluder) {
+		if (!this.sameGroupAsMeasured(occluder.class, det)) return false;
+		return containment(det.bbox, occluder.bbox) >= this.config.occlusionContainment;
 	}
 	/** Whether a spawn candidate clears its per-class minimum bbox-area floor
 	*  (fraction of frame area). Ungated when disabled, when the class has no floor,
@@ -34199,14 +34286,30 @@ var SortTracker = class SortTracker {
 	isDuplicateSpawn(det, live, timestamp) {
 		for (const t of live) {
 			if (!this.dedupCompatible(t.class, det.class)) continue;
-			if (iou$3(det.bbox, t.bbox) >= this.config.dedupSpawnIou) return true;
+			const overlap = iou$3(det.bbox, t.bbox);
+			if (overlap >= this.config.dedupSpawnIou) {
+				this.reportRefusal("dedup-iou", det, {
+					threshold: this.config.dedupSpawnIou,
+					measured: overlap,
+					against: t
+				});
+				return true;
+			}
 			if (t.class === det.class && growthAdjacentMatch(t.bbox, det.bbox, SortTracker.growthContext(t, timestamp))) {
 				this.reportBind("spawn-dedup", "growth", t, det, timestamp);
 				return true;
 			}
 		}
-		if (this.config.personAnimalDedup && det.class === ANIMAL_CLASS && det.score < this.config.animalOverPersonMaxScore) {
-			for (const t of live) if (t.class === PERSON_CLASS && iou$3(det.bbox, t.bbox) >= this.config.animalOverPersonIou) return true;
+		if (this.config.personAnimalDedup && det.class === ANIMAL_CLASS && det.nativeRecovery === void 0 && det.score < this.config.animalOverPersonMaxScore) for (const t of live) {
+			const overlap = iou$3(det.bbox, t.bbox);
+			if (t.class === PERSON_CLASS && overlap >= this.config.animalOverPersonIou) {
+				this.reportRefusal("animal-over-person", det, {
+					threshold: this.config.animalOverPersonMaxScore,
+					measured: overlap,
+					against: t
+				});
+				return true;
+			}
 		}
 		return false;
 	}
@@ -34321,6 +34424,7 @@ var SortTracker = class SortTracker {
 	* class.
 	*/
 	looseMatch(track, det, timestamp) {
+		if (!this.sameGroupAsMeasured(track.class, det)) return null;
 		if (this.assocGroup(track.class) !== this.assocGroup(det.class)) return null;
 		if (iou$3(track.bbox, det.bbox) >= this.config.rescueIouThreshold) return "iou";
 		const tc = bboxCentroid(track.bbox);
@@ -34407,7 +34511,7 @@ var SortTracker = class SortTracker {
 			for (const di of candidateIdxs) {
 				if (used.has(di)) continue;
 				const det = detections[di];
-				if (!this.associable(track.class, det.class)) continue;
+				if (!this.associable(track.class, det)) continue;
 				const score = iou$3(pbox, det.bbox);
 				if (score >= iouThreshold) pairs.push({
 					track,
@@ -34486,6 +34590,7 @@ var SortTracker = class SortTracker {
 		}
 		if (this.config.byteTrackEnabled && lowIdxs.length > 0) this.greedyAssociate(detections, lowIdxs, this.config.byteTrackLowIouThreshold, used, matchedTracks, matched);
 		for (const [track, det] of matched) {
+			if (track.class !== det.class) this.reportRefusal("cross-class-absorbed", det, { against: track });
 			const prevCenter = bboxCentroid({
 				x: track.bbox.x,
 				y: track.bbox.y,
@@ -34514,15 +34619,18 @@ var SortTracker = class SortTracker {
 			if (track.path.length > MAX_PATH_LENGTH) track.path.shift();
 			this.addClassVote(track, det);
 		}
-		const occluderBoxes = [];
-		for (const track of matchedTracks) occluderBoxes.push(track.bbox);
+		const occluders = [];
+		for (const track of matchedTracks) occluders.push({
+			bbox: track.bbox,
+			class: track.class
+		});
 		const surviving = [];
 		for (const track of this.tracks) {
 			if (matchedTracks.has(track)) {
 				surviving.push(track);
 				continue;
 			}
-			const occluded = this.config.occlusionEnabled && occluderBoxes.some((ob) => containment(this.predicted(track), ob) >= this.config.occlusionContainment);
+			const occluded = this.config.occlusionEnabled && occluders.some((ob) => containment(this.predicted(track), ob.bbox) >= this.config.occlusionContainment);
 			track.age++;
 			if (timestamp - track.lastSeen > (occluded ? this.config.occlusionMaxMissedMs : this.config.maxMissedMs)) {
 				track.lost = true;
@@ -34601,14 +34709,25 @@ var SortTracker = class SortTracker {
 		for (const di of unmatchedIdx) {
 			const det = detections[di];
 			if (!this.meetsClassScoreFloor(det)) {
+				this.reportRefusal("score-floor", det, {
+					threshold: this.config.classMinScores[det.class] ?? 0,
+					measured: det.score
+				});
 				used.add(di);
 				continue;
 			}
 			if (!this.meetsSpawnAreaFloor(det, frameArea)) {
+				this.reportRefusal("area-floor", det, {
+					threshold: this.config.classSpawnAreaFracs[det.class] ?? 0,
+					measured: frameArea > 0 ? det.bbox.w * det.bbox.h / frameArea : 0
+				});
 				used.add(di);
 				continue;
 			}
-			if (this.config.occlusionEnabled && occluderBoxes.some((ob) => containment(det.bbox, ob) >= this.config.occlusionContainment)) continue;
+			if (this.config.occlusionEnabled && occluders.some((ob) => this.occludesSpawn(det, ob))) {
+				this.reportRefusal("occlusion", det, { threshold: this.config.occlusionContainment });
+				continue;
+			}
 			if (this.config.dedupEnabled && this.isDuplicateSpawn(det, surviving, timestamp)) {
 				used.add(di);
 				continue;
@@ -35096,6 +35215,9 @@ var FrameProcessor = class {
 	* Only the rescue / resurrection / growth branches report, and they report
 	* sampled: stage 1 runs per track per frame at frame-rate.
 	*/
+	setSpawnRefusalObserver(observer) {
+		this.tracker.setSpawnRefusalObserver(observer);
+	}
 	setBindObserver(observer) {
 		this.tracker.setBindObserver(observer);
 	}
@@ -35118,6 +35240,8 @@ var FrameProcessor = class {
 		const faceAlignedCropByBbox = /* @__PURE__ */ new Map();
 		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,
@@ -35129,8 +35253,11 @@ var FrameProcessor = class {
 				class: det.macroClass,
 				originalClass: det.debug?.originalClass ?? det.macroClass,
 				score: det.score,
-				bbox
+				bbox,
+				...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, {
@@ -35355,6 +35482,8 @@ var FrameProcessor = class {
 			const faceAlignedCrop = faceAlignedCropByBbox.get(td.bbox);
 			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 } : {},
@@ -35377,7 +35506,9 @@ var FrameProcessor = class {
 					plateText: plate.text,
 					plateScore: plate.score,
 					plateBbox: plate.bbox
-				} : {}
+				} : {},
+				...nativeRecovery !== void 0 ? { nativeRecovery } : {},
+				...birthEvidence !== void 0 ? { birthEvidence } : {}
 			};
 		});
 		this.lastLabelWriteRefusals = refusals;
@@ -45228,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;
@@ -45238,8 +45388,9 @@ async function runConfirmation(candidate, config, deps, exhausted) {
 	for (const d of detections) if (isConfirmationCompatible(candidate.className, d.macroClass)) {
 		if (!best || d.score > best.score) best = d;
 	} else if (!bestIncompatible || d.score > bestIncompatible.score) bestIncompatible = d;
-	const bar = Math.max(config.minConfidence, deps.minConfidenceFor?.(candidate) ?? 0);
+	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,
@@ -45247,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,
@@ -45277,7 +45429,27 @@ function promoteSecondary(candidate, detection, bar, deps) {
 		}
 	};
 }
+/**
+* The bar this candidate faces. Never below the configured one: the
+* `minConfidenceFor` hook is monotonic by construction, and clamping here says
+* so at the point of use rather than trusting the caller to have been careful.
+*/
+function barFor(candidate, config, deps) {
+	return Math.max(config.minConfidence, deps.minConfidenceFor?.(candidate) ?? 0);
+}
 async function confirmOne(candidate, config, deps, exhausted) {
+	const native = candidate.nativeRecovery;
+	if (native !== void 0) {
+		const bar = barFor(candidate, config, deps);
+		if (native.score >= bar) return {
+			trackId: candidate.trackId,
+			verdict: "confirmed",
+			reason: "native-pass",
+			className: candidate.className,
+			bestScore: native.score,
+			appliedMinConfidence: bar
+		};
+	}
 	const cropPx = Math.max(candidate.bbox.w, candidate.bbox.h);
 	if (config.minCropPx > 0 && cropPx < config.minCropPx) return undecided(candidate, "below-min-crop");
 	try {
@@ -51739,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 {
@@ -53895,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.
@@ -67527,9 +67861,22 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 	/** See `pipeline/suppressed-births.ts` — rejected births must not be
 	*  re-upserted, and must be forgotten when the tracker drops the id. */
 	suppressedBirths = new SuppressedBirthRegistry();
+	/** Ids whose birth ritual has already run — a birth is decided ONCE (D377). */
+	startedBirths = new StartedBirthRegistry();
 	/** 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`.
@@ -70745,10 +71092,12 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 			if (prevIds.has(id)) continue;
 			const t = result.tracked.find((x) => x.trackId === id);
 			if (!t) continue;
-			if (classifyTrackAppearance({
+			const appearance = classifyTrackAppearance({
 				inPrevActive: false,
 				positionsCount: positionsCountById.get(id) ?? 1
-			}) === "resurrection") {
+			});
+			if (this.startedBirths.hasStarted(key, id)) continue;
+			if (appearance === "resurrection") {
 				log.info("track resumed", {
 					tags: { deviceId },
 					meta: {
@@ -70781,11 +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
-		})), {
+		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,
@@ -70809,6 +71167,17 @@ 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: {
+					trackId: id,
+					className: t.className,
+					source,
+					verdict: outcome.confirmed.has(id) ? "confirmed" : "suppressed"
+				} });
+				continue;
+			}
 			if (!outcome.confirmed.has(id)) {
 				this.suppressedBirths.reject(key, id);
 				this.trackStore?.dropActive(id);
@@ -70846,6 +71215,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 				})));
 				this.failureReport.notePersonBirth(deviceId, overlap === null ? void 0 : REASON_PERSON_OVER_VEHICLE);
 			}
+			this.startedBirths.markStarted(key, id);
 			log.info("track started", { meta: {
 				trackId: id,
 				className: t.className,
@@ -70913,7 +71283,9 @@ 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);
@@ -71492,6 +71864,8 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 			return allConfirmed();
 		}
 		const nodeId = frameHandle.nodeId;
+		const candidateNativeRecovery = /* @__PURE__ */ new Map();
+		for (const c of candidates) if (c.nativeRecovery !== void 0) candidateNativeRecovery.set(c.trackId, c.nativeRecovery);
 		return confirmBirths(candidates, config, {
 			fetchCrop: (candidate) => this.captureScheduler.request({
 				deviceId,
@@ -71541,6 +71915,11 @@ 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
+					} : {},
 					...decision.appliedMinConfidence !== void 0 && decision.appliedMinConfidence > config.minConfidence ? {
 						appliedMinConfidence: decision.appliedMinConfidence,
 						barRaisedByPhantomCell: true
@@ -73802,6 +74181,15 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 					}
 				});
 			});
+			p.setSpawnRefusalObserver((record) => {
+				this.ctx.logger.info("tracker: detection dropped — no track was born from it", {
+					tags: { deviceId },
+					meta: {
+						source,
+						...record
+					}
+				});
+			});
 			p.setTrackLabelState((trackId) => {
 				const active = this.trackStore?.getActiveByTrack(trackId);
 				return active !== null && active !== void 0 ? {