@camstack/addon-post-analysis 1.2.205 → 1.2.207

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-CJ0RJC87.js");
+const require_dist = require("../dist-sREZj0iq.js");
 let node_fs = require("node:fs");
 node_fs = require_dist.__toESM(node_fs, 1);
 let node_path = require("node:path");
@@ -27668,6 +27668,89 @@ function deliveredWideCentralSquareLayout(bbox, frame) {
 	if (centralSquareContainmentFraction(bbox, frame, layout) >= .5) return layout;
 	return wideCentralSquareLayout(bbox, frame, { containSubject: true });
 }
+/**
+* Fraction of the DELIVERED 16:9 canvas that is NOT real pixels — the lateral
+* fill the composer synthesizes because the window ran off a frame edge. 0 =
+* the whole canvas is scene; 0.21 = a fifth of the delivered image is fill.
+*
+* Measured on {@link deliveredWideCentralSquareLayout} — the layout the
+* persisted `thumbnail` is actually cut with — because the operator complains
+* about the image they were SHOWN, not about a hypothetical centred window.
+* The two differ exactly where it matters: the default layout slides fully
+* in-frame and carries no fill at all, while the delivery fallback re-imposes
+* the subject's slack bound (so the square still shows the subject) and pays
+* for it in padding.
+*
+* Upper bound: a window that can only show its central square delivers
+* `1 − 9/16 = 0.4375` fill; nothing can exceed that while the square itself is
+* in frame.
+*
+* Pure geometry (no I/O). Feeds the best-frame ranking as a BOUNDED
+* within-tier factor — see `edge-clear.ts#CANVAS_FILL_MAX_PENALTY` for why it
+* is deliberately not a tier.
+*/
+function canvasFillFraction(bbox, frame, layout = deliveredWideCentralSquareLayout(bbox, frame)) {
+	if (layout.canvasW <= 0) return 0;
+	return Math.max(0, Math.min(1, (layout.canvasW - layout.slabW) / layout.canvasW));
+}
+//#endregion
+//#region src/pipeline-analytics/pipeline/best-shot-promotion-log.ts
+function r3(value) {
+	return Math.round(value * 1e3) / 1e3;
+}
+/**
+* Build the attempt line's meta. Pure.
+*
+* `decidedBy` is `'first-sighting'` when there was no held peak: the track's
+* first observation is accepted unconditionally and nothing was compared, and
+* saying `'effective-score'` there would invent a comparison that never ran.
+*/
+function bestShotPromotionMeta(attempt) {
+	const { candidate, held, comparison } = attempt;
+	return {
+		trackId: attempt.trackId,
+		className: attempt.className,
+		timestamp: attempt.timestamp,
+		accepted: attempt.accepted,
+		decidedBy: comparison?.decidedBy ?? "first-sighting",
+		...comparison === void 0 ? {} : {
+			heldScore: r3(comparison.currentScore),
+			candidateScore: r3(comparison.candidateScore)
+		},
+		candConfidence: r3(candidate.confidence),
+		candEdgeClear: candidate.edgeClear,
+		...candidate.containment === void 0 ? {} : { candContainment: r3(candidate.containment) },
+		...candidate.sizeScore === void 0 ? {} : { candSizeScore: r3(candidate.sizeScore) },
+		...candidate.squareFraction === void 0 ? {} : { candSquareFraction: r3(candidate.squareFraction) },
+		...candidate.canvasFill === void 0 ? {} : { candCanvasFill: r3(candidate.canvasFill) },
+		candSemantic: candidate.semantic === true,
+		...held === void 0 ? {} : {
+			heldConfidence: r3(held.confidence),
+			heldEdgeClear: held.edgeClear,
+			...held.canvasFill === void 0 ? {} : { heldCanvasFill: r3(held.canvasFill) }
+		},
+		thumbnailRequested: attempt.thumbnailRequested,
+		keyFrameRequested: attempt.keyFrameRequested,
+		...attempt.suppressedBy === void 0 ? {} : { suppressedBy: attempt.suppressedBy }
+	};
+}
+/**
+* Is this attempt worth a line?
+*
+* Every ACCEPTED attempt is — it is the moment the operator's cover image
+* changes, or fails to. A REFUSED attempt is logged only while the track still
+* has NO picture at all, and then at most one line per
+* {@link PROMOTION_REFUSAL_LOG_GAP_MS}: "the best shot never moved off the birth
+* frame" is exactly the shape `5f5f0f6e` presented and could not be diagnosed,
+* while a track whose thumbnail already landed is refusing candidates normally
+* and has nothing to explain.
+*/
+function shouldLogPromotionAttempt(attempt, gate) {
+	if (attempt.accepted) return true;
+	if (gate.thumbnailLanded) return false;
+	const last = gate.lastRefusalLogAtMs;
+	return last === void 0 || attempt.timestamp - last >= 2e3;
+}
 var defaultScheduler = (tick, intervalMs) => {
 	const handle = setInterval(tick, intervalMs);
 	handle.unref?.();
@@ -30336,11 +30419,16 @@ function analyseDebugTrack(inventory) {
 	const out = [];
 	if (media.length === 0) out.push(finding("MEDIA_EVICTED_OR_NEVER", "error", "No media at all — either nothing was captured, or it was evicted (a debug mark does not pin retention)."));
 	else if (closed) {
-		if (!hasKind(media, "keyFrame")) out.push(finding("MISSING_KEYFRAME", "error", "No keyFrame — the best-shot frame is absent."));
+		const keyFrameMissing = !hasKind(media, "keyFrame");
+		const lastFrameCopySourceMissing = keyFrameMissing || !hasKind(media, "keyFrameSmall");
+		const noSnapshot = !hasKind(media, "snapshot");
+		if (keyFrameMissing) out.push(finding("MISSING_KEYFRAME", "error", "No keyFrame — the best-shot frame is absent."));
 		if (!hasKind(media, "firstFrame")) out.push(finding("MISSING_FIRSTFRAME", "warn", "No firstFrame for a closed track."));
-		if (!hasKind(media, "lastFrame")) out.push(finding("MISSING_LASTFRAME", "warn", "No lastFrame for a closed track."));
-		if (!hasKind(media, "thumbnail")) out.push(finding("MISSING_THUMBNAIL", "warn", "No thumbnail — every list surface renders blank."));
-		if (!hasKind(media, "crop") && !hasKind(media, "faceCrop") && !hasKind(media, "plateCrop")) out.push(finding("MISSING_BEST_CROP", "warn", "No crop of any kind — nothing was cut for a subject."));
+		if (!hasKind(media, "lastFrame")) out.push(finding("MISSING_LASTFRAME", "warn", noSnapshot && lastFrameCopySourceMissing ? `No lastFrame for a closed track — a CONSEQUENCE of ${keyFrameMissing ? "the missing keyFrame" : "the missing keyFrameSmall"}: with no snapshot to promote, the close can only copy keyFrameSmall, and there is none.` : "No lastFrame for a closed track."));
+		if (!hasKind(media, "thumbnail")) out.push(finding("MISSING_THUMBNAIL", "warn", keyFrameMissing ? "No thumbnail — every list surface renders blank; with no keyFrame the close-time derive had nothing to cut from." : "No thumbnail — every list surface renders blank."));
+		const cropExpected = facts.hasFace === true || facts.hasEmbeddedFace === true;
+		const noCrop = !hasKind(media, "crop") && !hasKind(media, "faceCrop") && !hasKind(media, "plateCrop");
+		if (cropExpected && noCrop) out.push(finding("MISSING_BEST_CROP", "warn", facts.hasEmbeddedFace === true ? "A gallery face row was recorded for this track but no crop of any kind survives — the row promises an image the media index does not have." : "A face detail ran on this track but no crop of any kind was cut for it."));
 	}
 	if (durationMs < 2e3) out.push(finding("SHORT_TRACK", "warn", `Track lasted ${String(durationMs)} ms, under the ${String(SHORT_TRACK_MS)} ms floor — likely a fragment.`));
 	if (eventCount === 0) out.push(finding("ZERO_EVENTS", "error", "No object events — the track exists but recorded nothing."));
@@ -30424,7 +30512,9 @@ function toFacts(track) {
 		snapshotCount: track.snapshots.length,
 		...track.importance === void 0 ? {} : { importance: track.importance },
 		...track.bestEventId === void 0 ? {} : { bestEventId: track.bestEventId },
-		...track.previewMissReason === void 0 ? {} : { previewMissReason: track.previewMissReason }
+		...track.previewMissReason === void 0 ? {} : { previewMissReason: track.previewMissReason },
+		...track.hasFace === void 0 ? {} : { hasFace: track.hasFace },
+		...track.hasEmbeddedFace === void 0 ? {} : { hasEmbeddedFace: track.hasEmbeddedFace }
 	};
 }
 /**
@@ -33512,6 +33602,33 @@ var CONTAINMENT_MAX_SIDE_PENALTY = .5;
 *  NO best frame at all). */
 var CONTAINMENT_MIN = .1;
 /**
+* Aspect at or above which a clipped subject reads as INTACT — no penalty. 2.5
+* = the box is two-and-a-half times longer along the clipped axis than across
+* it, which is what a whole upright person standing with their feet on the
+* bottom border looks like.
+*/
+var CLIP_ASPECT_NO_PENALTY = 2.5;
+/**
+* How much of a clipped subject is missing, from the SUBJECT'S OWN geometry.
+*
+* `alongClip` is the bbox's extent along the axis the border cut (height for a
+* top/bottom clip, width for a left/right clip); `acrossClip` is its extent on
+* the other axis. Returns the share of {@link CONTAINMENT_MAX_SIDE_PENALTY} to
+* apply, ramped linearly between {@link CLIP_ASPECT_FULL_PENALTY} and
+* {@link CLIP_ASPECT_NO_PENALTY}.
+*
+* Truncation COMPRESSES a box along the axis it was cut on, so the surviving
+* aspect is the signal: it is intrinsic to the subject, scale-invariant and
+* frame-invariant. Degenerate (`acrossClip <= 0`) reads as fully truncated.
+*/
+function clipPenaltyScale(alongClip, acrossClip) {
+	if (acrossClip <= 0) return 1;
+	const aspect = alongClip / acrossClip;
+	if (aspect <= 1) return 1;
+	if (aspect >= 2.5) return 0;
+	return 1 - (aspect - 1) / (CLIP_ASPECT_NO_PENALTY - 1);
+}
+/**
 * Edge-CONTAINMENT factor for a (clamped) bbox: an estimate in
 * `[CONTAINMENT_MIN, 1]` of the fraction of the subject that is actually in
 * frame. 1 = fully contained (no border clipping); lower = the subject is
@@ -33519,15 +33636,26 @@ var CONTAINMENT_MIN = .1;
 * walking out of view).
 *
 * Because detection bboxes are already CLAMPED to the frame, the true off-screen
-* extent is unknown, so this is a purely-geometric proxy: for each border the
-* bbox touches (within the {@link DEFAULT_EDGE_TOLERANCE} band), the penalty is
-* scaled by how much of that border the bbox spans on the perpendicular axis —
-* i.e. the subject's aspect against that edge. A wide bbox flush to the
-* top/bottom (a wide subject cut off top/bottom) or a tall bbox flush to the
-* left/right (a tall subject cut off at the side) is heavily penalised, whereas
-* a narrow subject whose feet merely graze the bottom border keeps most of its
-* score. Degenerate/unknown dims (≤ 0) return 1 (neutral — matches
-* {@link isEdgeClear}).
+* extent is unknown, so this is a purely-geometric proxy. For each border the
+* bbox touches (within the {@link DEFAULT_EDGE_TOLERANCE} band) the penalty is
+* scaled by {@link clipPenaltyScale} — the surviving remnant's own aspect
+* ALONG the cut axis. A wide bbox flush to the top/bottom (a wide subject cut
+* off top/bottom) or a tall bbox flush to the left/right (a tall subject cut
+* off at the side) is heavily penalised, whereas a narrow subject whose feet
+* merely graze the bottom border keeps its score. Degenerate/unknown dims
+* (≤ 0) return 1 (neutral — matches {@link isEdgeClear}).
+*
+* **Why the basis changed (2026-09-08, D400, track `841f9b8e`).** The penalty
+* used to be scaled by the bbox's SPAN across the touched border as a fraction
+* of the FRAME. That calibration was written for a wide subject cut off top or
+* bottom, and it is meaningless for an upright person: a 4K frame is 3840 px
+* wide, a person clipped at the head is ~400 px wide, so `spanX = 0.104` and a
+* decapitated person lost **5.2 %** of its score — the operator's "questi tagli
+* hanno uno score troppo alto, non si vedono il dorso e testa", with the number
+* attached. The frame's width is not a fact about the subject. The remnant's
+* own aspect is: the same person now loses 47.9 %, and the wide-subject case the
+* old shape existed for is penalised MORE than before (a 900×400 vehicle flush
+* to the bottom went from 0.88 to 0.50), not less.
 */
 function bboxContainment(bbox, frameWidth, frameHeight, tolerance = DEFAULT_EDGE_TOLERANCE) {
 	if (frameWidth <= 0 || frameHeight <= 0) return 1;
@@ -33537,16 +33665,16 @@ function bboxContainment(bbox, frameWidth, frameHeight, tolerance = DEFAULT_EDGE
 	const top = bbox.y;
 	const right = bbox.x + bbox.w;
 	const bottom = bbox.y + bbox.h;
-	const spanX = Math.max(0, Math.min(1, bbox.w / frameWidth));
-	const spanY = Math.max(0, Math.min(1, bbox.h / frameHeight));
+	const verticalBorderScale = clipPenaltyScale(bbox.w, bbox.h);
+	const horizontalBorderScale = clipPenaltyScale(bbox.h, bbox.w);
 	let containment = 1;
-	const penalize = (span) => {
-		containment *= 1 - CONTAINMENT_MAX_SIDE_PENALTY * span;
+	const penalize = (scale) => {
+		containment *= 1 - CONTAINMENT_MAX_SIDE_PENALTY * scale;
 	};
-	if (left <= tolX) penalize(spanY);
-	if (right >= frameWidth - tolX) penalize(spanY);
-	if (top <= tolY) penalize(spanX);
-	if (bottom >= frameHeight - tolY) penalize(spanX);
+	if (left <= tolX) penalize(verticalBorderScale);
+	if (right >= frameWidth - tolX) penalize(verticalBorderScale);
+	if (top <= tolY) penalize(horizontalBorderScale);
+	if (bottom >= frameHeight - tolY) penalize(horizontalBorderScale);
 	return Math.max(CONTAINMENT_MIN, Math.min(1, containment));
 }
 /** Fraction of the frame area at which a subject's size score saturates to 1.
@@ -33593,13 +33721,38 @@ var SQUARE_EVICTION_SCORE_FLOOR = .05;
 *  raw confidence — the ABSOLUTE hysteresis margin stays meaningful — while a
 *  bigger view still earns up to a 2× relative preference. */
 var SIZE_FACTOR_FLOOR = .5;
+/**
+* Maximum fraction of a candidate's effective score the DELIVERED-CANVAS fill
+* can subtract, at 100 % fill (D400).
+*
+* **Why this is a factor and not a tier.** Fill is anti-correlated with subject
+* size by construction: the 16:9 window is `side × 16/9` of the subject's
+* central square, so a big, close subject is far likelier to overflow the frame
+* than a small distant one — a small subject near the centre has zero fill
+* ALWAYS. A hard "no-fill beats fill" tier would therefore systematically
+* promote distant, tiny subjects over close ones, which is the exact defect
+* `bboxSizeScore` was added to fix (BEST_SHOT_STALE, 2026-07-22 / 2026-09-03).
+* So it enters as a bounded multiplicative factor in the same family as
+* `containment` and `sizeFactor`, strictly BELOW every tier, and as a near-
+* equal tie-break ranked ABOVE centeredness (a measurement of the delivered
+* image beats a proxy for it).
+*
+* **Bounded so it can only ever tie-break.** The real fill ceiling is 0.4375
+* (a window that can show no more than its own central square), so the largest
+* move this term can make is `0.15 × 0.4375 = 6.6 %` of the effective score. It
+* cannot overturn a lead of 7.1 % or more — and the metric that would say it
+* has stopped tie-breaking and started dominating is the share of accepted
+* best-shot promotions logged with `decidedBy: 'canvas-fill'`.
+*/
+var CANVAS_FILL_MAX_PENALTY = .15;
 /** The effective within-tier score: detector confidence scaled by the
-*  edge-containment and (floored) subject-size factors — each neutral at 1
-*  when absent. */
+*  edge-containment, (floored) subject-size and delivered-canvas-fill factors —
+*  each neutral at 1 when absent. */
 function effectiveScore(c) {
 	const sizeFactor = c.sizeScore === void 0 ? 1 : SIZE_FACTOR_FLOOR + (1 - SIZE_FACTOR_FLOOR) * c.sizeScore;
 	const squareFactor = isSquareContained(c) ? 1 : Math.max(c.squareFraction ?? 0, SQUARE_EVICTION_SCORE_FLOOR);
-	return c.confidence * (c.containment ?? 1) * sizeFactor * squareFactor;
+	const fillFactor = 1 - CANVAS_FILL_MAX_PENALTY * Math.max(0, Math.min(1, c.canvasFill ?? 0));
+	return c.confidence * (c.containment ?? 1) * sizeFactor * squareFactor * fillFactor;
 }
 /**
 * True when `candidate` beats `current` DECISIVELY — same-or-better edge tier
@@ -33617,48 +33770,51 @@ function isDecisiveImprovement(current, candidate) {
 	return effectiveScore(candidate) >= effectiveScore(current) * DECISIVE_IMPROVEMENT_RATIO;
 }
 /**
-* Edge-aware "is `candidate` a new best over `current`?" comparator.
-*
-* Tier order: edge-clear ALWAYS outranks edge-touching (a whole subject beats a
-* clipped one regardless of confidence). WITHIN the same tier, a strictly-higher
-* confidence past the `hysteresis` margin wins. The tier upgrade
-* (touching → clear) bypasses hysteresis — the first clear frame is always taken.
-*
-* EDGE-CONTAINMENT (#edge-clip): within the same tier the comparison is on the
-* EFFECTIVE score `confidence × containment` (see {@link bboxContainment}), not
-* raw confidence — so a fully-contained detection outranks a larger/higher-
-* confidence but border-CLIPPED one unless the confidence margin is decisive.
-* The binary edge-clear tier still gates first (a whole subject beats a clipped
-* one regardless), and within the CLEAR tier both frames have containment 1, so
-* this is a no-op there; it discriminates WITHIN the touching tier (feet merely
-* grazing the bottom vs half the body out the side). `containment` defaults to
-* 1 when omitted (legacy face / object-embedding callers) → identical behaviour.
-*
-* CENTERING TIE-BREAK (#27-D): within the same tier, when neither frame clearly
-* wins on the effective score (the two are within the `hysteresis` band) but the
-* candidate is meaningfully better CENTRED ({@link CENTER_TIE_BREAK_MARGIN}), the
-* candidate wins. This only engages when both sides carry a `centerScore` (the
-* best-frame path), so low-importance short tracks stop keeping an edge-of-frame
-* subject over an equally-confident, better-framed one. The face /
-* object-embedding callers omit `centerScore` → identical legacy behaviour.
-*
-* Time gating (`minGapMs`) is applied by the caller (`BestDetectionTracker`),
-* not here, so this stays a pure value comparison.
-*/
-function isEdgeAwareNewBest(current, candidate, hysteresis) {
-	if (isSquareContained(candidate) && !isSquareContained(current)) return true;
-	if (!isSquareContained(candidate) && isSquareContained(current)) return false;
-	if (isSemantic(candidate) && !isSemantic(current)) return true;
-	if (!isSemantic(candidate) && isSemantic(current)) return false;
-	if (candidate.edgeClear && !current.edgeClear) return true;
-	if (!candidate.edgeClear && current.edgeClear) return false;
-	const curEffective = effectiveScore(current);
-	const candEffective = effectiveScore(candidate);
-	if (candEffective > curEffective + hysteresis) return true;
+* The ONE best-frame comparison, decomposed. {@link isEdgeAwareNewBest} is this
+* function's `accepted` bit and nothing else — there is no second copy of the
+* ordering to drift.
+*
+* The tier order, highest first, and where the delivered-canvas term sits:
+*  1. **square-containment** — does the delivered SQUARE show the subject at all?
+*  2. **semantic** — did a recognition succeed on this frame?
+*  3. **edge-clear** — is the whole subject inside the frame?
+*  4. **effective-score** — `confidence × containment × size × square × canvasFill`.
+*  5. **canvas-fill** — near-equal tie-break: less synthesized lateral fill wins.
+*  6. **centeredness** — near-equal tie-break of last resort.
+*
+* Canvas fill enters at 4 (bounded, see {@link CANVAS_FILL_MAX_PENALTY}) and 5,
+* never as a tier: fill is anti-correlated with subject size, so a tier would
+* hand every camera's best shot to its most distant subject. It ranks ABOVE
+* centeredness because both answer "is this a well-framed delivery?" and fill
+* MEASURES the delivered canvas while centeredness only proxies it.
+*/
+function compareBestFrame(current, candidate, hysteresis) {
+	const currentScore = effectiveScore(current);
+	const candidateScore = effectiveScore(candidate);
+	const verdict = (accepted, decidedBy) => ({
+		accepted,
+		decidedBy,
+		currentScore,
+		candidateScore
+	});
+	return compareBestFrameTiers(current, candidate, hysteresis, currentScore, candidateScore, verdict);
+}
+function compareBestFrameTiers(current, candidate, hysteresis, curEffective, candEffective, verdict) {
+	if (isSquareContained(candidate) && !isSquareContained(current)) return verdict(true, "square-containment");
+	if (!isSquareContained(candidate) && isSquareContained(current)) return verdict(false, "square-containment");
+	if (isSemantic(candidate) && !isSemantic(current)) return verdict(true, "semantic");
+	if (!isSemantic(candidate) && isSemantic(current)) return verdict(false, "semantic");
+	if (candidate.edgeClear && !current.edgeClear) return verdict(true, "edge-clear");
+	if (!candidate.edgeClear && current.edgeClear) return verdict(false, "edge-clear");
+	if (candEffective > curEffective + hysteresis) return verdict(true, "effective-score");
+	const nearEqual = Math.abs(candEffective - curEffective) <= hysteresis;
+	if (candidate.canvasFill !== void 0 && current.canvasFill !== void 0) {
+		if (nearEqual && candidate.canvasFill + .05 < current.canvasFill) return verdict(true, "canvas-fill");
+	}
 	if (candidate.centerScore !== void 0 && current.centerScore !== void 0) {
-		if (Math.abs(candEffective - curEffective) <= hysteresis && candidate.centerScore > current.centerScore + .1) return true;
+		if (nearEqual && candidate.centerScore > current.centerScore + .1) return verdict(true, "centeredness");
 	}
-	return false;
+	return verdict(false, nearEqual ? "centeredness" : "effective-score");
 }
 //#endregion
 //#region src/pipeline-analytics/pipeline/first-frame-retry-bbox.ts
@@ -34077,6 +34233,74 @@ var LooseBindSampler = class {
 		this.counts.clear();
 	}
 };
+/**
+* Floor on the predictive-drift clamp, in box sides.
+*
+* The scaled term collapses at short intervals — at the 56 ms minimum measured
+* on camera 615 it is 0.11 sides — and a clamp that tight turns ordinary
+* detector box jitter into a refused match. A quarter of a side is slack, not
+* travel.
+*/
+var DRIFT_MIN_SIDES = .25;
+/**
+* Re-acquisition reach, in box DIAGONALS per second.
+*
+* Answers `267840a1` again, on the gate that actually refused it: 908.4 px of
+* centroid travel in 880 ms against a `hypot(513.6, 721.2)` = 885.5 px diagonal
+* is 1.166 diagonals per second. 1.5 clears it with ~29 % margin and is
+* physically bounded — 1.5 of a subject's own body-diagonal per second is a
+* brisk run, and being scale-free it means the same thing for a far-field
+* person with a 90-px box as for a near one with a 900-px box.
+*
+* The number it replaces (`rescueCentroidFactor` 0.75 × diagonal, flat) was
+* doing two jobs at once: at a 2135 ms poll gap it was far too tight to bridge
+* a walking subject, and at a 150 ms burst interval it was loose enough to hand
+* one subject's id to another 452 px away (track `27855a56`, a second car, at
+* IoU 0.058). One number, two opposite failures.
+*/
+var REACH_DIAGONALS_PER_SEC = 1.5;
+/**
+* Floor on the re-acquisition reach, in box diagonals.
+*
+* Deliberately TIGHTER than the 0.75 flat factor it replaces. At a 150 ms burst
+* interval the scaled term is 0.225 diagonals; the floor lifts it to 0.3, which
+* is 221 px on `27855a56`'s 738-px diagonal — comfortably below the 452 px that
+* bought that track a second car. A short gap is evidence that the subject
+* cannot have gone far, and the gate now says so.
+*/
+var REACH_MIN_DIAGONALS = .3;
+/**
+* Ceiling on the re-acquisition reach, in box diagonals.
+*
+* `REACH_DIAGONALS_PER_SEC × BUDGET_CEILING_MS`. A subject unseen for the full
+* `maxMissedMs` gets 1.5 diagonals of reach, not 6.
+*/
+var REACH_MAX_DIAGONALS = 1.5;
+function clampRange(value, min, max) {
+	return Math.max(min, Math.min(max, value));
+}
+/**
+* How far a coasting box's velocity extrapolation may carry it on one axis.
+*
+* `side` is the box's width for the x drift and its height for the y drift, so
+* the allowance keeps the same meaning for a tall person and a wide car.
+*/
+function driftAllowancePx(side, elapsedMs) {
+	const elapsed = Math.max(0, elapsedMs);
+	return clampRange(side * 2 * (elapsed / 1e3), side * DRIFT_MIN_SIDES, side * 2);
+}
+/**
+* How far from where a track is EXPECTED a detection may sit and still be
+* claimed as that track by the loose (rescue / resurrection) reach clause.
+*
+* Scale-free: the budget is a multiple of the track's own diagonal, so it does
+* not have to know the frame size, the camera, or how far away the subject is.
+*/
+function reacquireReachPx(bbox, elapsedMs) {
+	const diag = Math.hypot(bbox.w, bbox.h);
+	const elapsed = Math.max(0, elapsedMs);
+	return clampRange(diag * REACH_DIAGONALS_PER_SEC * (elapsed / 1e3), diag * REACH_MIN_DIAGONALS, diag * REACH_MAX_DIAGONALS);
+}
 //#endregion
 //#region src/pipeline-analytics/pipeline/tracker/rescue-growth.ts
 /**
@@ -34136,6 +34360,21 @@ function growthAdjacentMatch(track, det, ctx) {
 }
 /** Per-reason counter + sampling decision. One instance per tracker, so the
 *  counts are per camera and per detection source. */
+var SpawnBesideCoastingSampler = class {
+	counts = /* @__PURE__ */ new Map();
+	/** The running count when this report should be emitted, 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;
+	}
+	reset() {
+		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`. */
@@ -34160,6 +34399,7 @@ var DEFAULT_TRACKER_CONFIG = {
 	maxTrackLifetimeMs: 3e5,
 	rescueIouThreshold: .1,
 	rescueCentroidFactor: .75,
+	reacquireTimeScaled: true,
 	resurrectionWindowMs: 8e3,
 	resurrectionCrowdGuard: true,
 	resurrectionCrowdedIouThreshold: .3,
@@ -34234,6 +34474,10 @@ var SortTracker = class SortTracker {
 	refusalSampler = new SpawnRefusalSampler();
 	/** Sink for dropped-detection diagnostics — see {@link setSpawnRefusalObserver}. */
 	spawnRefusalObserver = null;
+	/** Per-reason counters behind the sampled spawn-beside-coasting diagnostics. */
+	spawnBesideSampler = new SpawnBesideCoastingSampler();
+	/** Sink for fragmentation diagnostics — see {@link setSpawnBesideCoastingObserver}. */
+	spawnBesideObserver = null;
 	constructor(config = {}) {
 		this.config = {
 			...DEFAULT_TRACKER_CONFIG,
@@ -34258,6 +34502,88 @@ var SortTracker = class SortTracker {
 	setSpawnRefusalObserver(observer) {
 		this.spawnRefusalObserver = observer;
 	}
+	/**
+	* Wire the diagnostics sink for the case the tracker does NOT act on: a new id
+	* minted beside a live, compatible, coasting track that could have claimed it.
+	* Same contract as the other two sinks — the tracker has no `deviceId`, the
+	* caller stamps it, and nothing is computed when no observer is wired.
+	*/
+	setSpawnBesideCoastingObserver(observer) {
+		this.spawnBesideObserver = observer;
+	}
+	/**
+	* Report a fresh id minted beside the nearest live coasting track of its
+	* association group, when there was one within
+	* {@link SPAWN_BESIDE_REPORT_REACH_FACTOR} × the reach the gate used.
+	*
+	* `coasting` is every track surviving this frame that did NOT match a real
+	* detection on it — the only ones a spawn can be the continuation of.
+	*/
+	reportSpawnBesideCoasting(spawnedId, det, coasting, detections, frameArea, timestamp) {
+		const observer = this.spawnBesideObserver;
+		if (!observer) return;
+		const group = this.assocGroup(det.class);
+		const dc = bboxCentroid(det.bbox);
+		let best;
+		let bestDist = Number.POSITIVE_INFINITY;
+		let bestReach = 0;
+		for (const track of coasting) {
+			if (this.assocGroup(track.class) !== group) continue;
+			const tc = bboxCentroid(track.bbox);
+			const dist = Math.hypot(tc.x - dc.x, tc.y - dc.y);
+			const reach = this.reacquireReach(track, timestamp, true);
+			if (dist > reach * 2) continue;
+			if (dist < bestDist) {
+				best = track;
+				bestDist = dist;
+				bestReach = reach;
+			}
+		}
+		if (!best) return;
+		const declinedBy = this.explainDecline(best, det, detections, frameArea, timestamp, bestDist);
+		const spawnCount = this.spawnBesideSampler.next(declinedBy);
+		if (spawnCount === void 0) return;
+		observer({
+			spawnedTrackId: spawnedId,
+			spawnedClass: det.class,
+			spawnedScore: det.score,
+			spawnedBbox: det.bbox,
+			spawnedNativeRecovery: det.nativeRecovery !== void 0,
+			coastingTrackId: best.id,
+			coastingClass: best.class,
+			iou: iou$3(best.bbox, det.bbox),
+			predictedIou: iou$3(this.predicted(best, timestamp), det.bbox),
+			centroidDistPx: bestDist,
+			reachPx: bestReach,
+			trackDiagPx: Math.hypot(best.bbox.w, best.bbox.h),
+			gapMs: timestamp - best.lastSeen,
+			trackAgeMs: timestamp - best.firstSeen,
+			declinedBy,
+			spawnCount,
+			sampledEvery: 10
+		});
+	}
+	/**
+	* Which gate turned `track` away from `det`, evaluated in the order the
+	* tracker itself evaluates them — the FIRST one that says no is the answer.
+	*
+	* Every clause here re-reads a fact about the frame rather than about the
+	* greedy pass's claim order, so the verdict is reproducible: the one case that
+	* cannot be re-derived is a pair nothing refused, which is exactly what
+	* `already-claimed` means.
+	*/
+	explainDecline(track, det, detections, frameArea, timestamp, centroidDist) {
+		if (!this.sameGroupAsMeasured(track.class, det)) return "native-measured-class";
+		if (this.assocGroup(track.class) !== this.assocGroup(det.class)) return "assoc-group";
+		if (iou$3(track.bbox, det.bbox) >= this.config.rescueIouThreshold) return "already-claimed";
+		if (centroidDist <= this.reacquireReach(track, timestamp, true)) {
+			if (!this.isPlausibleBirth(det, frameArea)) return "already-claimed";
+			if (!this.config.reacquireTimeScaled) return "plausible-birth-veto";
+			return this.isUnambiguousReach(track, det, detections) ? "already-claimed" : "crowd-guard";
+		}
+		if (growthAdjacentMatch(track.bbox, det.bbox, SortTracker.growthContext(track, timestamp))) return "already-claimed";
+		return "geometry";
+	}
 	/** Emit one dropped-detection record, subject to the refusal sampler. */
 	reportRefusal(reason, det, extra = {}) {
 		const observer = this.spawnRefusalObserver;
@@ -34526,21 +34852,39 @@ var SortTracker = class SortTracker {
 			if (a !== void 0 && dropIds.has(a) || b !== void 0 && dropIds.has(b)) this.dupStreaks.delete(key);
 		}
 	}
-	/** Where a track is expected this frame — extrapolated by velocity while
-	*  coasting (predictiveCoasting), else its last known bbox. A stationary
-	*  track (speed < stationarySpeedPx) is frozen so bbox jitter can't walk the
-	*  box off a sitting object; otherwise the drift is capped at one bbox size
-	*  so a stale velocity can't fling the box across the frame. Public so the
-	*  clamp is directly unit-testable. */
-	predicted(t) {
+	/**
+	* Where a track is expected at `nowMs` — extrapolated by velocity while
+	* coasting (`predictiveCoasting`), else its last known bbox.
+	*
+	* A stationary track (speed below `stationarySpeedPx`, measured in the
+	* px-per-update unit that setting is calibrated in) is frozen so bbox jitter
+	* cannot walk the box off a sitting object. Otherwise the drift is the
+	* velocity carried over the ELAPSED interval, capped by
+	* {@link driftAllowancePx} — which is itself a function of that interval, so
+	* a stale velocity cannot fling the box across the frame and a long, honest
+	* gap is no longer capped at the one box width a single frame would get
+	* (D399). Public so the clamp is directly unit-testable.
+	*/
+	predicted(t, nowMs) {
 		if (!this.config.predictiveCoasting) return t.bbox;
-		if (Math.hypot(t.velocity.dx, t.velocity.dy) < this.config.stationarySpeedPx) return t.bbox;
-		const f = t.age + 1;
-		const driftX = clamp(t.velocity.dx * f, -t.bbox.w, t.bbox.w);
-		const driftY = clamp(t.velocity.dy * f, -t.bbox.h, t.bbox.h);
+		if (Math.hypot(t.velocity.dx, t.velocity.dy) * t.emitIntervalMs < this.config.stationarySpeedPx) return t.bbox;
+		if (!this.config.reacquireTimeScaled) {
+			const f = t.age + 1;
+			const perFrameX = t.velocity.dx * t.emitIntervalMs;
+			const perFrameY = t.velocity.dy * t.emitIntervalMs;
+			return {
+				x: t.bbox.x + clamp(perFrameX * f, -t.bbox.w, t.bbox.w),
+				y: t.bbox.y + clamp(perFrameY * f, -t.bbox.h, t.bbox.h),
+				w: t.bbox.w,
+				h: t.bbox.h
+			};
+		}
+		const elapsedMs = Math.max(0, nowMs - t.lastSeen);
+		const allowX = driftAllowancePx(t.bbox.w, elapsedMs);
+		const allowY = driftAllowancePx(t.bbox.h, elapsedMs);
 		return {
-			x: t.bbox.x + driftX,
-			y: t.bbox.y + driftY,
+			x: t.bbox.x + clamp(t.velocity.dx * elapsedMs, -allowX, allowX),
+			y: t.bbox.y + clamp(t.velocity.dy * elapsedMs, -allowY, allowY),
 			w: t.bbox.w,
 			h: t.bbox.h
 		};
@@ -34583,19 +34927,64 @@ var SortTracker = class SortTracker {
 	* crouch→animal flip when `classGroupAssoc` is on, but never by an unrelated
 	* class.
 	*/
-	looseMatch(track, det, timestamp) {
+	looseMatch(track, det, timestamp, timeScaled = true) {
 		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);
 		const dc = bboxCentroid(det.bbox);
-		const dist = Math.hypot(tc.x - dc.x, tc.y - dc.y);
-		const diag = Math.hypot(track.bbox.w, track.bbox.h);
-		if (dist <= this.config.rescueCentroidFactor * diag) return "centroid";
+		if (Math.hypot(tc.x - dc.x, tc.y - dc.y) <= this.reacquireReach(track, timestamp, timeScaled)) return "centroid";
 		if (growthAdjacentMatch(track.bbox, det.bbox, SortTracker.growthContext(track, timestamp))) return "growth";
 		return null;
 	}
 	/**
+	* The proximity budget the `centroid` clause is measured against.
+	*
+	* On the RESCUE pass (`timeScaled`) it is {@link reacquireReachPx} — a
+	* multiple of the track's diagonal that grows with the elapsed gap and stops
+	* at a ceiling, because a live coasting track's whereabouts genuinely become
+	* less certain the longer it has gone unseen (D399).
+	*
+	* On the RESURRECTION pass it stays the flat `rescueCentroidFactor × diagonal`
+	* it always was. That pass re-attaches a CORPSE, and it exists for one thing:
+	* "a flickering stationary object keeps its identity". Elapsed time is not the
+	* variable there — a stationary subject does not travel further because it
+	* blinked for longer — and the corpse is strictly weaker evidence than a live
+	* track, which is the same reasoning `resurrectionCrowdedIouThreshold` already
+	* encodes.
+	*/
+	reacquireReach(track, timestamp, timeScaled) {
+		const diag = Math.hypot(track.bbox.w, track.bbox.h);
+		if (!timeScaled || !this.config.reacquireTimeScaled) return this.config.rescueCentroidFactor * diag;
+		return reacquireReachPx(track.bbox, timestamp - track.lastSeen);
+	}
+	/**
+	* Whether a REACH bind would be unambiguous: this coasting track is the only
+	* subject of its association group the scene holds, and `det` is the only box
+	* of that group on the frame.
+	*
+	* This is what lets a reach bind survive {@link isPlausibleBirth} (D399). That
+	* veto exists because "a spare track costs media; a stolen track corrupts the
+	* plate, the travelled distance and the last frame of the track it was taken
+	* from" — every word of which is about a scene with something to steal FROM.
+	* With one track and one box there is no second subject the id could be wrong
+	* about, and refusing the bind does not buy safety, it buys a fragment.
+	*
+	* Deliberately computed over the whole frame rather than over what is still
+	* unclaimed, so the answer is a fact about the scene and reads the same at
+	* bind time and at report time — the spawn-beside-coasting line has to be able
+	* to say which gate declined without re-running the greedy competition.
+	*/
+	isUnambiguousReach(track, det, detections) {
+		if (this.sameGroupPeerCount(track, this.tracks) > 0) return false;
+		const group = this.assocGroup(track.class);
+		for (const other of detections) {
+			if (other === det) continue;
+			if (this.assocGroup(other.class) === group) return false;
+		}
+		return true;
+	}
+	/**
 	* Whether `det` would mint a track of its own if no salvage branch claimed it:
 	* it clears BOTH spawn floors (per-class score, per-class bbox-area fraction).
 	*
@@ -34663,11 +35052,11 @@ var SortTracker = class SortTracker {
 	* gates) so the two-tier ByteTrack association stays a single implementation.
 	* Mutates `used` / `matchedTracks` / `matched` in place.
 	*/
-	greedyAssociate(detections, candidateIdxs, iouThreshold, used, matchedTracks, matched) {
+	greedyAssociate(detections, candidateIdxs, iouThreshold, timestamp, used, matchedTracks, matched) {
 		const pairs = [];
 		for (const track of this.tracks) {
 			if (matchedTracks.has(track)) continue;
-			const pbox = this.predicted(track);
+			const pbox = this.predicted(track, timestamp);
 			for (const di of candidateIdxs) {
 				if (used.has(di)) continue;
 				const det = detections[di];
@@ -34726,7 +35115,7 @@ var SortTracker = class SortTracker {
 		for (let di = 0; di < detections.length; di++) if (this.config.byteTrackEnabled && detections[di].score < this.config.byteTrackHighThreshold) lowIdxs.push(di);
 		else highIdxs.push(di);
 		const lowSet = new Set(lowIdxs);
-		this.greedyAssociate(detections, highIdxs, this.config.iouThreshold, used, matchedTracks, matched);
+		this.greedyAssociate(detections, highIdxs, this.config.iouThreshold, timestamp, used, matchedTracks, matched);
 		const rescuePairs = [];
 		for (const track of this.tracks) {
 			if (matchedTracks.has(track)) continue;
@@ -34735,7 +35124,7 @@ var SortTracker = class SortTracker {
 				const det = detections[di];
 				const gate = this.looseMatch(track, det, timestamp);
 				if (gate === null) continue;
-				if (gate === "centroid" && this.isPlausibleBirth(det, frameArea)) continue;
+				if (gate === "centroid" && this.isPlausibleBirth(det, frameArea) && !(this.config.reacquireTimeScaled && this.isUnambiguousReach(track, det, detections))) continue;
 				rescuePairs.push({
 					track,
 					detIdx: di,
@@ -34753,7 +35142,7 @@ var SortTracker = class SortTracker {
 			used.add(pair.detIdx);
 			this.reportBind("rescue", pair.gate, pair.track, det, timestamp);
 		}
-		if (this.config.byteTrackEnabled && lowIdxs.length > 0) this.greedyAssociate(detections, lowIdxs, this.config.byteTrackLowIouThreshold, used, matchedTracks, matched);
+		if (this.config.byteTrackEnabled && lowIdxs.length > 0) this.greedyAssociate(detections, lowIdxs, this.config.byteTrackLowIouThreshold, timestamp, 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({
@@ -34769,6 +35158,7 @@ var SortTracker = class SortTracker {
 				h: det.bbox.h
 			});
 			const frames = track.age + 1;
+			const dtMs = timestamp - track.lastSeen;
 			track.bbox = det.bbox;
 			track.class = det.class;
 			track.originalClass = det.originalClass;
@@ -34776,10 +35166,13 @@ var SortTracker = class SortTracker {
 			track.age = 0;
 			track.hits++;
 			track.lastSeen = timestamp;
-			track.velocity = {
-				dx: (newCenter.x - prevCenter.x) / frames,
-				dy: (newCenter.y - prevCenter.y) / frames
-			};
+			if (dtMs > 0) {
+				track.velocity = {
+					dx: (newCenter.x - prevCenter.x) / dtMs,
+					dy: (newCenter.y - prevCenter.y) / dtMs
+				};
+				track.emitIntervalMs = dtMs / frames;
+			}
 			track.path.push(det.bbox);
 			if (track.path.length > MAX_PATH_LENGTH) track.path.shift();
 			this.addClassVote(track, det);
@@ -34795,7 +35188,7 @@ var SortTracker = class SortTracker {
 				surviving.push(track);
 				continue;
 			}
-			const occluded = this.config.occlusionEnabled && occluders.some((ob) => containment(this.predicted(track), ob.bbox) >= this.config.occlusionContainment);
+			const occluded = this.config.occlusionEnabled && occluders.some((ob) => containment(this.predicted(track, timestamp), ob.bbox) >= this.config.occlusionContainment);
 			track.age++;
 			if (timestamp - track.lastSeen > (occluded ? this.config.occlusionMaxMissedMs : this.config.maxMissedMs)) {
 				track.lost = true;
@@ -34817,7 +35210,7 @@ var SortTracker = class SortTracker {
 			for (const lost of this.lostTracks) {
 				if (!lost.resurrectable) continue;
 				if (timestamp - lost.lostAt > this.config.resurrectionWindowMs) continue;
-				const gate = this.looseMatch(lost, det, timestamp);
+				const gate = this.looseMatch(lost, det, timestamp, false);
 				if (gate === null) continue;
 				if (gate === "centroid" && this.isPlausibleBirth(det, frameArea)) continue;
 				const score = iou$3(lost.bbox, det.bbox);
@@ -34897,8 +35290,10 @@ var SortTracker = class SortTracker {
 				used.add(di);
 				continue;
 			}
+			const spawnedId = (0, node_crypto.randomUUID)();
+			this.reportSpawnBesideCoasting(spawnedId, det, surviving.filter((t) => t.lastSeen !== timestamp), detections, frameArea, timestamp);
 			surviving.push({
-				id: (0, node_crypto.randomUUID)(),
+				id: spawnedId,
 				bbox: det.bbox,
 				class: det.class,
 				originalClass: det.originalClass,
@@ -34912,6 +35307,7 @@ var SortTracker = class SortTracker {
 					dx: 0,
 					dy: 0
 				},
+				emitIntervalMs: 0,
 				lost: false,
 				lostAt: 0,
 				resurrectable: true,
@@ -34932,7 +35328,10 @@ var SortTracker = class SortTracker {
 				bbox: t.bbox,
 				trackId: t.id,
 				trackAge: t.hits,
-				velocity: t.velocity,
+				velocity: {
+					dx: t.velocity.dx * t.emitIntervalMs,
+					dy: t.velocity.dy * t.emitIntervalMs
+				},
 				path: [...t.path],
 				matchedThisFrame: t.lastSeen === timestamp,
 				...scene !== void 0 ? { resurrectionScene: scene } : {}
@@ -34960,6 +35359,7 @@ var SortTracker = class SortTracker {
 		this.lostTracks = [];
 		this.dupStreaks.clear();
 		this.bindSampler.reset();
+		this.spawnBesideSampler.reset();
 	}
 };
 //#endregion
@@ -35394,6 +35794,12 @@ var FrameProcessor = class {
 	setBindObserver(observer) {
 		this.tracker.setBindObserver(observer);
 	}
+	/** Wire (or clear) the tracker's fragmentation sink — a new id minted beside a
+	*  live coasting track that could have claimed it (D399). Same `deviceId`
+	*  contract as the two sinks above. */
+	setSpawnBesideCoastingObserver(observer) {
+		this.tracker.setSpawnBesideCoastingObserver(observer);
+	}
 	/** Forget a track in the underlying tracker (used when the addon promotes it
 	*  to a stationary-object registry entry). */
 	dropTrack(trackId) {
@@ -35990,7 +36396,11 @@ function promoteSemanticBestFrame(deps, input) {
 			W: frameWidth,
 			H: frameHeight
 		}),
-		semantic: true
+		semantic: true,
+		canvasFill: canvasFillFraction(bbox, {
+			W: frameWidth,
+			H: frameHeight
+		})
 	})) {
 		deps.logger.debug("best-shot: semantic frame did not beat the held peak", {
 			tags: { deviceId },
@@ -36534,9 +36944,15 @@ function decideLastFramePromotion(media) {
 			snapshotKey: newestKeyFrameSmall.key,
 			snapshotTimestamp: newestKeyFrameSmall.timestamp
 		};
-		return { promote: false };
+		return {
+			promote: false,
+			declinedBecause: lastFrame === void 0 ? "no-key-frame" : "no-source"
+		};
 	}
-	if (lastFrame !== void 0 && newestSnapshot.timestamp <= lastFrame.timestamp) return { promote: false };
+	if (lastFrame !== void 0 && newestSnapshot.timestamp <= lastFrame.timestamp) return {
+		promote: false,
+		declinedBecause: "already-last"
+	};
 	return {
 		promote: true,
 		mode: "move",
@@ -36583,17 +36999,28 @@ function averageBboxDiagonal(boxes) {
 //#endregion
 //#region src/pipeline-analytics/pipeline/track-close.ts
 /**
-* Compose the persisted `previewMissReason` (D276/B2). One line, greppable
-* tokens: the derive's own miss branch (or what tile stands in), then the
-* capture-side failure with its count. Examples:
-*   `no-key-frame capture=keyframe:native-missx4`
+* Compose the persisted `previewMissReason` (D276/B2, extended by D400). One
+* line, greppable tokens: the derive's own miss branch (or what tile stands
+* in), then whether the NATIVE KEY FRAME landed, then the capture-side failure
+* with its count. Examples:
+*   `no-key-frame no-key-frame-at-close capture=keyframe:native-missx4`
 *   `derive-returned-null tile=standin`
-*   `no-key-frame tile=raster capture=thumbnail:overflowx12`
-*/
-function composePreviewMissReason(tile, deriveMiss, captureMiss) {
+*   `native-tile tile=native no-key-frame-at-close`
+*
+* **Why the key-frame token (D400).** The reason used to be written ONLY when
+* the best-shot TILE ranked below native, so a track whose thumbnail landed
+* natively while its key frame missed carried no reason at all — three of the
+* four `MISSING_KEYFRAME` tracks in the 2026-09-07 audit were exactly that, and
+* the operator's "niente ultimo" had no cause anywhere on the row. The key
+* frame IS the native best-shot FRAME, and its absence is the head of the
+* cascade (`keyFrame ⇒ keyFrameSmall ⇒ the lastFrame copy source`), so it
+* belongs on this line whatever the tile ended up being.
+*/
+function composePreviewMissReason(tile, deriveMiss, captureMiss, keyFrameLanded = true) {
 	const parts = [];
 	parts.push(deriveMiss ?? (tile === "none" ? "no-thumbnail" : `${tile}-tile`));
 	if (tile !== "none") parts.push(`tile=${tile}`);
+	if (!keyFrameLanded && deriveMiss !== "no-key-frame") parts.push("no-key-frame-at-close");
 	if (captureMiss !== void 0) parts.push(`capture=${captureMiss.reason}x${captureMiss.count}`);
 	return parts.join(" ");
 }
@@ -36689,9 +37116,10 @@ var TrackCloser = class {
 			await this.commitRasterFallback(t, closure.rasterFallback.jpeg, closure.rasterFallback.timestamp);
 			tile = "raster";
 		}
-		if (tile !== "native") {
+		const keyFrameLanded = ownedMedia.some((m) => m.kind === "keyFrame");
+		if (tile !== "native" || !keyFrameLanded) {
 			const captureMiss = this.deps.previewCaptureMiss?.(t.trackId);
-			const reason = composePreviewMissReason(tile, deriveMiss, captureMiss);
+			const reason = composePreviewMissReason(tile, deriveMiss, captureMiss, keyFrameLanded);
 			if (this.deps.setPreviewMiss !== void 0) try {
 				await this.deps.setPreviewMiss(t.deviceId, t.trackId, reason);
 			} catch (err) {
@@ -36704,8 +37132,8 @@ var TrackCloser = class {
 					}
 				});
 			}
-			const bestSeen = this.deps.residents.bestSeenBbox(t.trackId);
-			this.deps.recordPendingPreviewUpgrade?.({
+			const bestSeen = tile === "native" ? void 0 : this.deps.residents.bestSeenBbox(t.trackId);
+			if (tile !== "native") this.deps.recordPendingPreviewUpgrade?.({
 				deviceId: t.deviceId,
 				trackId: t.trackId,
 				...bestSeen !== void 0 ? { bestSeen: {
@@ -36974,9 +37402,32 @@ var TrackCloser = class {
 	*/
 	async maybePromoteLastFrame(t, ownedMedia) {
 		const promotion = decideLastFramePromotion(ownedMedia);
-		if (!promotion.promote) return;
+		if (!promotion.promote) {
+			if (promotion.declinedBecause !== "already-last") this.deps.logger.warn("no lastFrame at close", {
+				tags: { deviceId: t.deviceId },
+				meta: {
+					trackId: t.trackId,
+					declinedBecause: promotion.declinedBecause,
+					hasKeyFrame: ownedMedia.some((m) => m.kind === "keyFrame"),
+					hasKeyFrameSmall: ownedMedia.some((m) => m.kind === "keyFrameSmall"),
+					snapshots: ownedMedia.filter((m) => m.kind === "snapshot").length
+				}
+			});
+			return;
+		}
 		const snapshot = ownedMedia.find((m) => m.key === promotion.snapshotKey);
-		if (!snapshot) return;
+		if (!snapshot) {
+			this.deps.logger.warn("no lastFrame at close", {
+				tags: { deviceId: t.deviceId },
+				meta: {
+					trackId: t.trackId,
+					declinedBecause: "promotion-source-vanished",
+					sourceKey: promotion.snapshotKey,
+					mode: promotion.mode
+				}
+			});
+			return;
+		}
 		try {
 			await this.deps.mediaStore()?.promoteToLastFrame({
 				deviceId: t.deviceId,
@@ -37144,9 +37595,15 @@ var BestDetectionTracker = class {
 	*  `best`. Absent = the caller does not measure it → contained tier
 	*  (legacy behaviour). */
 	squareFraction = /* @__PURE__ */ new Map();
+	/** Held peak's DELIVERED-CANVAS fill fraction (0..1), PARALLEL to `best`.
+	*  Absent = the caller does not measure it → neutral (no fill). */
+	canvasFill = /* @__PURE__ */ new Map();
 	/** Held peak's SEMANTIC-tier bit (a recognition succeeded on that frame),
 	*  PARALLEL to `best`. Absent = non-semantic (legacy behaviour). */
 	semantic = /* @__PURE__ */ new Map();
+	/** The last comparison run for a track (D400 promotion log). Never read by
+	*  the ranking — a pure observation seam. */
+	lastComparison = /* @__PURE__ */ new Map();
 	constructor(options = {}) {
 		this.hysteresis = options.hysteresis ?? 0;
 		this.minGapMs = options.minGapMs ?? 0;
@@ -37166,12 +37623,13 @@ var BestDetectionTracker = class {
 	* the classic policy holds: a confidence past the `hysteresis` margin that also
 	* respects `minGapMs` wins. On acceptance the held peak advances.
 	*/
-	observe(trackId, confidence, timestamp, edgeClearIn, centerScoreIn, containmentIn, sizeScoreIn, squareFractionIn, semanticIn) {
+	observe(trackId, confidence, timestamp, edgeClearIn, centerScoreIn, containmentIn, sizeScoreIn, squareFractionIn, semanticIn, canvasFillIn) {
 		const edgeClear = this.edgeAware ? edgeClearIn : void 0;
 		const centerScore = this.edgeAware ? centerScoreIn : void 0;
 		const containment = this.edgeAware ? containmentIn : void 0;
 		const sizeScore = this.sizeAware ? sizeScoreIn : void 0;
 		const squareFraction = this.edgeAware ? squareFractionIn : void 0;
+		const canvasFill = this.edgeAware ? canvasFillIn : void 0;
 		const semanticBit = this.semanticAware ? semanticIn : void 0;
 		const cur = this.best.get(trackId);
 		if (cur === void 0) {
@@ -37184,6 +37642,7 @@ var BestDetectionTracker = class {
 			if (containment !== void 0) this.containment.set(trackId, containment);
 			if (sizeScore !== void 0) this.sizeScore.set(trackId, sizeScore);
 			if (squareFraction !== void 0) this.squareFraction.set(trackId, squareFraction);
+			if (canvasFill !== void 0) this.canvasFill.set(trackId, canvasFill);
 			if (semanticBit !== void 0) this.semantic.set(trackId, semanticBit);
 			return true;
 		}
@@ -37193,6 +37652,7 @@ var BestDetectionTracker = class {
 		const curContainment = this.containment.get(trackId);
 		const curSize = this.sizeScore.get(trackId);
 		const curSquareFraction = this.squareFraction.get(trackId);
+		const curCanvasFill = this.canvasFill.get(trackId);
 		const curSemantic = this.semantic.get(trackId) ?? false;
 		const candSemantic = semanticBit ?? false;
 		const held = {
@@ -37202,6 +37662,7 @@ var BestDetectionTracker = class {
 			...curContainment !== void 0 ? { containment: curContainment } : {},
 			...curSize !== void 0 ? { sizeScore: curSize } : {},
 			...curSquareFraction !== void 0 ? { squareFraction: curSquareFraction } : {},
+			...curCanvasFill !== void 0 ? { canvasFill: curCanvasFill } : {},
 			semantic: curSemantic
 		};
 		const cand = {
@@ -37211,6 +37672,7 @@ var BestDetectionTracker = class {
 			...containment !== void 0 ? { containment } : {},
 			...sizeScore !== void 0 ? { sizeScore } : {},
 			...squareFraction !== void 0 ? { squareFraction } : {},
+			...canvasFill !== void 0 ? { canvasFill } : {},
 			semantic: candSemantic
 		};
 		const squareTierUpgrade = isSquareContained(cand) && !isSquareContained(held);
@@ -37219,7 +37681,9 @@ var BestDetectionTracker = class {
 		const sameSemanticTier = isSemantic(cand) === isSemantic(held);
 		const tierUpgrade = squareTierUpgrade || semanticTierUpgrade || sameSquareTier && sameSemanticTier && candClear && !curClear;
 		const gapOk = timestamp - cur.atMs >= this.minGapMs || sizeScore !== void 0 && isDecisiveImprovement(held, cand);
-		const isNewBest = tierUpgrade ? true : isEdgeAwareNewBest(held, cand, this.hysteresis) && gapOk;
+		const comparison = compareBestFrame(held, cand, this.hysteresis);
+		this.lastComparison.set(trackId, comparison);
+		const isNewBest = tierUpgrade ? true : comparison.accepted && gapOk;
 		if (isNewBest) {
 			this.best.set(trackId, {
 				confidence,
@@ -37230,11 +37694,46 @@ var BestDetectionTracker = class {
 			if (containment !== void 0) this.containment.set(trackId, containment);
 			if (sizeScore !== void 0) this.sizeScore.set(trackId, sizeScore);
 			if (squareFraction !== void 0) this.squareFraction.set(trackId, squareFraction);
+			if (canvasFill !== void 0) this.canvasFill.set(trackId, canvasFill);
 			this.semantic.set(trackId, candSemantic);
 		}
 		return isNewBest;
 	}
 	/**
+	* The FULL candidate shape of the track's held peak — everything the ranking
+	* saw, not just `{confidence, atMs}`. Read BEFORE `observe` so a promotion
+	* attempt can be logged against the peak it actually competed with (D400).
+	* Undefined when the track holds no peak (the first sighting).
+	*/
+	heldCandidate(trackId) {
+		const cur = this.best.get(trackId);
+		if (cur === void 0) return void 0;
+		const centerScore = this.centerScore.get(trackId);
+		const containment = this.containment.get(trackId);
+		const sizeScore = this.sizeScore.get(trackId);
+		const squareFraction = this.squareFraction.get(trackId);
+		const canvasFill = this.canvasFill.get(trackId);
+		return {
+			confidence: cur.confidence,
+			edgeClear: this.edgeClear.get(trackId) ?? true,
+			...centerScore !== void 0 ? { centerScore } : {},
+			...containment !== void 0 ? { containment } : {},
+			...sizeScore !== void 0 ? { sizeScore } : {},
+			...squareFraction !== void 0 ? { squareFraction } : {},
+			...canvasFill !== void 0 ? { canvasFill } : {},
+			semantic: this.semantic.get(trackId) ?? false
+		};
+	}
+	/**
+	* The comparison the LAST {@link observe} ran for this track — which term
+	* decided, and both effective scores. Undefined on a first sighting (nothing
+	* was compared) and after {@link delete}. Feeds the promotion log line; it is
+	* never a ranking input.
+	*/
+	lastComparisonFor(trackId) {
+		return this.lastComparison.get(trackId);
+	}
+	/**
 	* Stamp the HELD peak as semantic — the attribution-time re-score for a
 	* recognition that arrived AFTER the frame was ranked (detail results are
 	* async). Use when the recognition's source frame IS the held peak: the
@@ -37260,7 +37759,9 @@ var BestDetectionTracker = class {
 		this.containment.delete(trackId);
 		this.sizeScore.delete(trackId);
 		this.squareFraction.delete(trackId);
+		this.canvasFill.delete(trackId);
 		this.semantic.delete(trackId);
+		this.lastComparison.delete(trackId);
 	}
 	clear() {
 		this.best.clear();
@@ -37269,7 +37770,9 @@ var BestDetectionTracker = class {
 		this.containment.clear();
 		this.sizeScore.clear();
 		this.squareFraction.clear();
+		this.canvasFill.clear();
 		this.semantic.clear();
+		this.lastComparison.clear();
 	}
 };
 //#endregion
@@ -37531,9 +38034,29 @@ var TrackResidentState = class {
 	}
 	/** Record a detection for the track's best-FRAME ranking (edge-aware §5
 	*  policy). Returns true when it becomes the track's new best. */
-	observeBestFrame(deviceId, trackId, confidence, timestamp, edgeClear, centerScore, containment, sizeScore, squareFraction, semantic) {
+	observeBestFrame(deviceId, trackId, confidence, timestamp, edgeClear, centerScore, containment, sizeScore, squareFraction, semantic, canvasFill) {
 		this.open(deviceId, trackId);
-		return this.bestFrameTracker.observe(trackId, confidence, timestamp, edgeClear, centerScore, containment, sizeScore, squareFraction, semantic);
+		return this.bestFrameTracker.observe(trackId, confidence, timestamp, edgeClear, centerScore, containment, sizeScore, squareFraction, semantic, canvasFill);
+	}
+	/** D400: frame instant of the track's last logged promotion REFUSAL
+	*  (undefined = none yet). */
+	bestShotRefusalLoggedAt(trackId) {
+		return this.residents.get(trackId)?.bestShotRefusalLoggedAt;
+	}
+	/** Stamp the track's last promotion-refusal log instant. */
+	noteBestShotRefusalLogged(deviceId, trackId, timestamp) {
+		this.ensure(deviceId, trackId).bestShotRefusalLoggedAt = timestamp;
+	}
+	/** The FULL held best-frame candidate (everything the ranking saw). Read
+	*  BEFORE `observeBestFrame` to log a promotion attempt against the peak it
+	*  competed with (D400). */
+	bestFrameHeld(trackId) {
+		return this.bestFrameTracker.heldCandidate(trackId);
+	}
+	/** Which term decided the LAST best-frame comparison for the track (D400).
+	*  Undefined on a first sighting. */
+	bestFrameLastComparison(trackId) {
+		return this.bestFrameTracker.lastComparisonFor(trackId);
 	}
 	/** The held best-frame peak for a track (undefined if never observed). */
 	bestFramePeak(trackId) {
@@ -39727,6 +40250,24 @@ var TRACK_CLOSE_REASONS = ["stationary-promotion"];
 function parseCloseReason(value) {
 	return TRACK_CLOSE_REASONS.find((reason) => reason === value);
 }
+/**
+* `positions` in TIME order (D399).
+*
+* The array is APPENDED in arrival order and the two detector passes interleave,
+* so it is not the same thing: seven of the fourteen tracks the 2026-09-08 audit
+* read had at least one position whose timestamp preceded its predecessor's, and
+* a consumer that draws the array as a polyline draws a path crossing back on
+* itself. Everything that reasons about a first, a last, or a velocity was
+* reading them as stored.
+*
+* Immutable — returns a new array; `toSorted` is stable, so positions sharing a
+* timestamp keep their arrival order relative to each other. Applied at the READ
+* boundaries only: the write path keeps arrival order on purpose, because that
+* is a fact about delivery and `totalDistance` has always been accumulated on it.
+*/
+function positionsInTimeOrder(positions) {
+	return positions.toSorted((a, b) => a.timestamp - b.timestamp);
+}
 var DEFAULT_CONFIG = {
 	ttlMs: 3e4,
 	maxPositionHistory: 300,
@@ -40093,7 +40634,7 @@ function cloneTrack(t) {
 		subLabelMeta: t.subLabelMeta,
 		firstSeen: t.firstSeen,
 		lastSeen: t.lastSeen,
-		positions: t.positions.map((p) => ({
+		positions: positionsInTimeOrder(t.positions).map((p) => ({
 			...p,
 			bbox: { ...p.bbox }
 		})),
@@ -41686,7 +42227,7 @@ var TrackStore = class {
 		*/
 		const storedObservations = data["observations"];
 		const observations = typeof storedObservations === "number" ? storedObservations : slim ? void 0 : storedPositions.length;
-		const positions = storedPositions;
+		const positions = positionsInTimeOrder(storedPositions);
 		const snapshots = slim ? [] : data["snapshots"] ?? [];
 		const zones = data["zonesVisited"] ?? [];
 		const classes = data["classes"];
@@ -71447,7 +71988,9 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 					x: center.x,
 					y: center.y,
 					timestamp: result.timestamp,
-					bbox: { ...t.bbox }
+					bbox: { ...t.bbox },
+					source: t.nativeRecovery !== void 0 ? "recovery" : "frame",
+					score: t.confidence
 				},
 				zones: t.zones,
 				state: t.state
@@ -71940,6 +72483,18 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 							mediaKey: s.mediaKey
 						});
 						for (const trackId of res.thumbnailTrackIds) this.residents.markThumbnailLanded(deviceId, trackId);
+						const landedThumbnails = new Set(res.thumbnailTrackIds);
+						for (const target of snapshotTargets) {
+							if (!target.bestThumbnail || landedThumbnails.has(target.trackId)) continue;
+							log.warn("best shot capture did not land", {
+								tags: { deviceId },
+								meta: {
+									trackId: target.trackId,
+									timestamp: target.timestamp,
+									keyFrameRequested: target.keyFrame !== "skip"
+								}
+							});
+						}
 						for (const trackId of res.firstFrameTrackIds) {
 							this.residents.clearFirstFramePending(trackId);
 							this.residents.markFirstFrameLanded(deviceId, trackId);
@@ -72980,7 +73535,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 		const ctx = this.ctxIfReady;
 		if (ctx === null) return;
 		promoteSemanticBestFrame({
-			observeBestFrame: (o) => this.residents.observeBestFrame(o.deviceId, o.trackId, o.confidence, o.timestamp, o.edgeClear, o.centerScore, o.containment, o.sizeScore, o.squareFraction, o.semantic),
+			observeBestFrame: (o) => this.residents.observeBestFrame(o.deviceId, o.trackId, o.confidence, o.timestamp, o.edgeClear, o.centerScore, o.containment, o.sizeScore, o.squareFraction, o.semantic, o.canvasFill),
 			recordBestSeenBbox: (deviceId, trackId, bbox) => this.residents.recordBestSeenBbox(deviceId, trackId, bbox),
 			captureBestShot: (request) => this.captureSemanticBestShot(request),
 			logger: ctx.logger
@@ -73185,13 +73740,20 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 				W: frameWidth,
 				H: frameHeight
 			});
+			const canvasFill = canvasFillFraction(t.bbox, {
+				W: frameWidth,
+				H: frameHeight
+			});
 			const firstBox = this.trackStore?.peekActive(t.trackId)?.positions[0]?.bbox;
-			const isNewBest = firstBox !== void 0 && thumbnailWouldShowParkedNotSubject({
+			const skipParkedThumb = firstBox !== void 0 && thumbnailWouldShowParkedNotSubject({
 				currentBbox: t.bbox,
 				firstBbox: firstBox,
 				className: t.className,
 				entries: this.stationaryRegistry?.listViews(deviceId) ?? []
-			}) ? false : this.residents.observeBestFrame(deviceId, t.trackId, t.confidence, timestamp, edgeClear, centerScore, containment, sizeScore, squareFraction, false);
+			});
+			const heldBest = this.residents.bestFrameHeld(t.trackId);
+			const isNewBest = skipParkedThumb ? false : this.residents.observeBestFrame(deviceId, t.trackId, t.confidence, timestamp, edgeClear, centerScore, containment, sizeScore, squareFraction, false, canvasFill);
+			const comparison = skipParkedThumb ? void 0 : this.residents.bestFrameLastComparison(t.trackId);
 			this.maybeEmitTrackLifecycleUpdate(deviceId, t, timestamp, isNewBest);
 			const plan = planPeriodicMedia({
 				debugMediaEnabled: media.debugMediaEnabled,
@@ -73224,6 +73786,46 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 				state: this.residents.keyFrameCapture(t.trackId),
 				now: timestamp
 			}).kind;
+			const suppressedBy = (() => {
+				if (skipParkedThumb) return "parked-thumbnail";
+				if (!isNewBest || bestThumbnail) return void 0;
+				if (!plan.bestThumbnail) return "not-planned";
+				if (!plausibleBox) return "implausible-box";
+				if (!retryBoxPlausible) return "retry-box-collapsed";
+				return "capture-in-flight";
+			})();
+			const promotionAttempt = {
+				trackId: t.trackId,
+				className: t.className,
+				timestamp,
+				candidate: {
+					confidence: t.confidence,
+					edgeClear,
+					centerScore,
+					containment,
+					sizeScore,
+					squareFraction,
+					canvasFill,
+					semantic: false
+				},
+				...heldBest !== void 0 ? { held: heldBest } : {},
+				...comparison !== void 0 ? { comparison } : {},
+				accepted: isNewBest,
+				...suppressedBy !== void 0 ? { suppressedBy } : {},
+				thumbnailRequested: bestThumbnail,
+				keyFrameRequested: keyFrame !== "skip"
+			};
+			const refusalLoggedAt = this.residents.bestShotRefusalLoggedAt(t.trackId);
+			if (shouldLogPromotionAttempt(promotionAttempt, {
+				thumbnailLanded: this.residents.isThumbnailLanded(t.trackId),
+				...refusalLoggedAt !== void 0 ? { lastRefusalLogAtMs: refusalLoggedAt } : {}
+			})) {
+				if (!isNewBest) this.residents.noteBestShotRefusalLogged(deviceId, t.trackId, timestamp);
+				this.ctx.logger.info("best shot promotion", {
+					tags: { deviceId },
+					meta: { ...bestShotPromotionMeta(promotionAttempt) }
+				});
+			}
 			if (!plan.appendSnapshot && !rollingLastFrame && !bestThumbnail && keyFrame === "skip") continue;
 			targets.push({
 				trackId: t.trackId,
@@ -74575,6 +75177,15 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 					}
 				});
 			});
+			p.setSpawnBesideCoastingObserver((record) => {
+				this.ctx.logger.info("tracker: new id minted beside a live coasting track", {
+					tags: { deviceId },
+					meta: {
+						source,
+						...record
+					}
+				});
+			});
 			p.setTrackLabelState((trackId) => {
 				const active = this.trackStore?.getActiveByTrack(trackId);
 				return active !== null && active !== void 0 ? {