@camstack/addon-post-analysis 1.2.213 → 1.2.216

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-DA1sJKXM.js");
+const require_dist = require("../dist-B_6UZCut.js");
 let node_fs = require("node:fs");
 node_fs = require_dist.__toESM(node_fs, 1);
 let node_path = require("node:path");
@@ -10,6 +10,7 @@ let node_path$1 = require_dist.__toESM(node_path, 1);
 node_path = require_dist.__toESM(node_path);
 let node_crypto = require("node:crypto");
 let node_child_process = require("node:child_process");
+let _camstack_system_addon_utils = require("@camstack/system/addon-utils");
 let sharp = require("sharp");
 sharp = require_dist.__toESM(sharp);
 let node_os = require("node:os");
@@ -3223,8 +3224,8 @@ async function raceTimeout(call, timeoutMs) {
 * detail the encoder can see.
 */
 async function downscaleJpeg(bytes, maxPx) {
-	const { default: sharp$15 } = await import("sharp");
-	const out = await sharp$15(Buffer.from(bytes)).resize({
+	const { default: sharp$16 } = await import("sharp");
+	const out = await sharp$16(Buffer.from(bytes)).resize({
 		width: maxPx,
 		height: maxPx,
 		fit: "inside",
@@ -11740,8 +11741,8 @@ var NcDispatcher = class {
 		try {
 			const points = (await this.deps.getZonePolygons?.(deviceId, zoneIds) ?? []).flat();
 			if (points.length === 0) return null;
-			const { default: sharp$14 } = await import("sharp");
-			const img = sharp$14(Buffer.from(jpeg));
+			const { default: sharp$15 } = await import("sharp");
+			const img = sharp$15(Buffer.from(jpeg));
 			const meta = await img.metadata();
 			const W = meta.width ?? 0;
 			const H = meta.height ?? 0;
@@ -14920,7 +14921,7 @@ function buildOccupancyStatus(input) {
 * `this.byId.clear()` happened to sit AFTER the `await` that threw. Nothing
 * said so, and hoisting one line would have silently turned every transient
 * store error into a hub that stops notifying — the reversal behind the D130
-* flood and the `3f9345fc3` occupancy cold-seed loss. The ledger's contract
+* flood and the occupancy cold-seed loss. The ledger's contract
 * rule 2 (a failed load NEVER clears the mirror, deliberately no knob) makes
 * that reversal unexpressible here. `rule-store-load-failure-direction.spec.ts`
 * holds the direction and records what was removed to make it red.
@@ -18137,7 +18138,7 @@ function clockOf$2(atMs) {
 *
 * ## The `.partial()` trap this file exists to avoid
 *
-* Commit `e0921ac6e`, found in production 2026-08-12: `NcRulePatchSchema` was
+* Found in production 2026-08-12: `NcRulePatchSchema` was
 * `NcRuleInputSchema.partial()`, and Zod 4 `.partial()` KEEPS the inner
 * `.default()`. Parsing `{ name: 'x' }` therefore materialised every defaulted
 * key, and `{ ...existing, ...patch }` wrote them over the rule — a camera- and
@@ -19032,8 +19033,8 @@ async function deriveSyntheticMedia(jpeg, bbox, timestamp) {
 	];
 	if (bbox === void 0) return files;
 	try {
-		const { default: sharp$13 } = await import("sharp");
-		const meta = await sharp$13(Buffer.from(jpeg)).metadata();
+		const { default: sharp$14 } = await import("sharp");
+		const meta = await sharp$14(Buffer.from(jpeg)).metadata();
 		const W = meta.width ?? 0;
 		const H = meta.height ?? 0;
 		if (W === 0 || H === 0) return files;
@@ -19041,7 +19042,7 @@ async function deriveSyntheticMedia(jpeg, bbox, timestamp) {
 		const top = Math.max(0, Math.min(H - 1, Math.floor(bbox.y * H)));
 		const width = Math.max(1, Math.min(W - left, Math.ceil(bbox.w * W)));
 		const height = Math.max(1, Math.min(H - top, Math.ceil(bbox.h * H)));
-		const cropBuf = await sharp$13(Buffer.from(jpeg)).extract({
+		const cropBuf = await sharp$14(Buffer.from(jpeg)).extract({
 			left,
 			top,
 			width,
@@ -19063,7 +19064,7 @@ async function deriveSyntheticMedia(jpeg, bbox, timestamp) {
 		});
 		const stroke = Math.max(2, Math.round(Math.min(W, H) / 240));
 		const overlay = Buffer.from(`<svg width="${W}" height="${H}"><rect x="${left}" y="${top}" width="${width}" height="${height}" fill="none" stroke="#22d3ee" stroke-width="${stroke}"/></svg>`);
-		const boxedBuf = await sharp$13(Buffer.from(jpeg)).composite([{
+		const boxedBuf = await sharp$14(Buffer.from(jpeg)).composite([{
 			input: overlay,
 			top: 0,
 			left: 0
@@ -34905,6 +34906,8 @@ var SortTracker = class SortTracker {
 	refusalSampler = new SpawnRefusalSampler();
 	/** Sink for dropped-detection diagnostics — see {@link setSpawnRefusalObserver}. */
 	spawnRefusalObserver = null;
+	/** Unsampled copy for the frame path — see `setSpawnRefusalSink`. */
+	refusalSink = null;
 	/** Per-reason counters behind the sampled spawn-beside-coasting diagnostics. */
 	spawnBesideSampler = new SpawnBesideCoastingSampler();
 	/** Sink for fragmentation diagnostics — see {@link setSpawnBesideCoastingObserver}. */
@@ -35017,11 +35020,7 @@ var SortTracker = class SortTracker {
 	}
 	/** 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({
+		const base = {
 			reason,
 			detClass: det.class,
 			detScore: det.score,
@@ -35033,13 +35032,31 @@ var SortTracker = class SortTracker {
 				againstTrackId: extra.against.id,
 				againstTrackClass: extra.against.class
 			} : {},
-			refusalCount,
-			sampledEvery: 10,
 			...extra.droppedTrackId !== void 0 ? { droppedTrackId: extra.droppedTrackId } : {},
 			...extra.trackLifeMs !== void 0 ? { trackLifeMs: extra.trackLifeMs } : {}
+		};
+		this.refusalSink?.(base);
+		const observer = this.spawnRefusalObserver;
+		if (!observer) return;
+		const refusalCount = this.refusalSampler.next(reason);
+		if (refusalCount === void 0) return;
+		observer({
+			...base,
+			refusalCount,
+			sampledEvery: 10
 		});
 	}
 	/**
+	* Wire the UNSAMPLED refusal sink — the frame path's copy.
+	*
+	* Separate from {@link setSpawnRefusalObserver} because the two want
+	* different things from the same record: the observer wants a readable log
+	* and accepts a sample; this decides whether an EVENT exists.
+	*/
+	setSpawnRefusalSink(sink) {
+		this.refusalSink = sink;
+	}
+	/**
 	* Report a TRACK that ends having emitted nothing — the last silent branch
 	* on the detection→position path (D391).
 	*
@@ -36133,6 +36150,20 @@ var FrameProcessor = class {
 	/** Sink + sampler for the drops this stage owns (the detection-stage zone
 	*  filter). Shares the tracker's vocabulary — see {@link SpawnRefusalReason}. */
 	spawnRefusalObserver = null;
+	/** Where a collected refusal is forwarded for LOGGING, when anyone asked. */
+	spawnRefusalForward = null;
+	/**
+	* The spawn refusals of the frame being processed.
+	*
+	* Filled by the same sink that feeds the diagnostic log, and drained at the
+	* end of `process`. It exists because a refused detection inside a watched
+	* zone still has to become an EVENT: an immediate zone rule asks "is there an
+	* animal in the flowerbed now?", which does not need "is it the same animal
+	* as before?" answered first. See `zone-detection-emits-without-a-track`.
+	*/
+	refusalsThisFrame = [];
+	/** Running count of events this path has produced — the volume measure. */
+	zoneRefusalEventCount = 0;
 	zoneRefusalSampler = new SpawnRefusalSampler();
 	/** Optional stationary-object gate (parked-object suppression). Null until
 	*  the addon wires it via {@link setStationaryGate}. */
@@ -36147,6 +36178,9 @@ var FrameProcessor = class {
 		this.deviceId = deviceId;
 		this.source = source;
 		this.tracker = new SortTracker(trackerConfig);
+		this.tracker.setSpawnRefusalSink((record) => {
+			this.refusalsThisFrame.push(record);
+		});
 		this.stateAnalyzer = new StateAnalyzer(stateConfig);
 		this.eventEmitter = new DetectionEventEmitter(emitterConfig);
 		this.zones = [];
@@ -36253,6 +36287,55 @@ var FrameProcessor = class {
 	* ate it. Sampled like every other refusal: an excluded box is excluded on
 	* every frame of a passage.
 	*/
+	/**
+	* Turn this frame's refused spawns into events, but only those inside a zone.
+	*
+	* Drains {@link refusalsThisFrame}. Each surviving record becomes an
+	* `object.detected` event with NO track — carrying the zones it fell in, the
+	* percentage of the box inside each, and the refusal reason so a consumer can
+	* tell it apart from a track whose media went missing.
+	*
+	* `zone-filtered` refusals are excluded on purpose: that reason means the
+	* operator's own detection rules already said the box does not count on this
+	* camera, and re-admitting it here would overrule a decision they made.
+	*/
+	eventsForRefusedDetectionsInZones(timestamp, frame, frameWidth, frameHeight) {
+		const refusals = this.refusalsThisFrame;
+		this.refusalsThisFrame = [];
+		if (refusals.length === 0 || this.zones.length === 0) return [];
+		const out = [];
+		for (const r of refusals) {
+			if (r.reason === "zone-filtered") continue;
+			const { memberships } = this.zoneEngine.splitDetectionZones(r.bbox, this.zones, frameWidth, frameHeight, void 0, void 0, void 0, this.zoneMembershipMinOverlap);
+			if (memberships.length === 0) continue;
+			this.zoneRefusalEventCount += 1;
+			out.push({
+				id: (0, node_crypto.randomUUID)(),
+				kind: "object",
+				deviceId: this.deviceId,
+				timestamp,
+				frameId: frame.frameId,
+				className: r.detClass,
+				confidence: r.detScore,
+				bbox: r.bbox,
+				frameWidth,
+				frameHeight,
+				zones: memberships.map((m) => m.zoneId),
+				zoneOverlaps: memberships.map((m) => ({
+					zoneId: m.zoneId,
+					...m.zoneName === void 0 ? {} : { zoneName: m.zoneName },
+					overlapPct: Math.round(m.overlap * 1e3) / 10
+				})),
+				spawnRefused: r.reason
+			});
+		}
+		return out;
+	}
+	/** How many zone-refusal events this processor has emitted — the measure that
+	*  says whether this path is a trickle or a storm. Read by the addon. */
+	zoneRefusalEventsEmitted() {
+		return this.zoneRefusalEventCount;
+	}
 	reportZoneFiltered(excluded) {
 		const observer = this.spawnRefusalObserver;
 		if (!observer || excluded.length === 0) return;
@@ -36654,9 +36737,11 @@ var FrameProcessor = class {
 				frameHeight
 			};
 		};
+		const zoneRefusalEvents = this.eventsForRefusedDetectionsInZones(timestamp, frame, frameWidth, frameHeight);
 		const withTrackId = rawEvents.filter((e) => e.detection.trackId);
 		const objectEvents = withTrackId.filter((e) => e.type !== "object.detected").map((e) => toObjectEvent(e));
 		const appearanceEvents = withTrackId.filter((e) => e.type === "object.detected").map((e) => toObjectEvent(e, "entered"));
+		objectEvents.push(...zoneRefusalEvents);
 		return {
 			deviceId: this.deviceId,
 			timestamp,
@@ -47319,6 +47404,7 @@ var TrackDetailDispatcher = class {
 		if (!dev) return;
 		dev.scheduler.onTrackEnded(trackId);
 		dev.tracks.delete(trackId);
+		dev.parcelEnriched.delete(trackId);
 		dev.candidateBest.delete(trackId);
 		if (dev.tracks.size === 0) this.clearTimer(dev);
 	}
@@ -47328,6 +47414,7 @@ var TrackDetailDispatcher = class {
 			this.clearTimer(dev);
 			dev.queue.length = 0;
 			dev.tracks.clear();
+			dev.parcelEnriched.clear();
 			dev.candidateBest.clear();
 		}
 		this.devices.clear();
@@ -47338,6 +47425,7 @@ var TrackDetailDispatcher = class {
 			dev = {
 				scheduler: new DetailScheduler(),
 				tracks: /* @__PURE__ */ new Map(),
+				parcelEnriched: /* @__PURE__ */ new Map(),
 				candidateBest: new BestDetectionTracker(CANDIDATE_IMPROVE_POLICY),
 				queue: [],
 				coastedFramesIgnored: 0,
@@ -47454,19 +47542,21 @@ var TrackDetailDispatcher = class {
 	*
 	* 1. `frameHandle` — cheapest when it hits: no payload moves and the runner's
 	*    leaf children re-cut their ROI at native resolution. Tried first, always.
-	* 2. `frameJpeg` — the freshest frame's FULL raster, fetched from the node that
-	*    owns the handle and handed to the runner UNCUT, so the rectangle still
-	*    comes from the single derivation (D52). This rung exists because rung 1 is
-	*    structurally unreachable for most dispatches: the decode worker's native
-	*    lease is 1.2 s and a tick + inference routinely lands outside it, while
-	*    the retained store holds the frame for 3 s.
+	* 2. `frameJpeg` — the track's PARKED key frame (D422): the full native frame
+	*    the owning node copied at the best instant, retrieved by track and handed
+	*    to the runner UNCUT, so the rectangle still comes from the single
+	*    derivation (D52). This rung exists because rung 1 is structurally
+	*    unreachable for most dispatches — a tick + inference routinely lands
+	*    outside the lease — and it cannot miss on age. It runs ONCE per parcel
+	*    per step; a dispatch that finds the same parcel already enriched skips
+	*    it, so a coasting track does not re-embed the same image every second.
 	* 3. `cropJpeg` — the pre-cut tile. Last, because the caller decided its
 	*    rectangle and because in practice the same native miss that emptied rung 1
 	*    empties this one too.
 	*
-	* On D9/D18: the payload that crosses in rung 2 is a COMPRESSED JPEG fetched on
-	* demand, per TRACK per dispatch (≤2 in flight per device, ~1 Hz) and only after
-	* rung 1 missed — never a frame-rate stream, and never raw pixels.
+	* On D9/D18: the payload that crosses in rung 2 is a COMPRESSED JPEG retrieved
+	* on demand, per TRACK per dispatch (≤2 in flight per device, ~1 Hz) and only
+	* after rung 1 missed — never a frame-rate stream, and never raw pixels.
 	*
 	* ONE outcome stops the ladder cold: the runner's typed `not-attached`
 	* refusal (`detail-refusal.ts`). It names the camera's SESSION state, not
@@ -47504,34 +47594,39 @@ var TrackDetailDispatcher = class {
 				}
 			});
 		}
-		if (this.deps.captureFullFrameBase64 !== void 0 && frame.frameHandle !== void 0) try {
-			const full = await this.deps.captureFullFrameBase64(frame);
-			if (full !== null) if (full.width !== frame.frameWidth || full.height !== frame.frameHeight) this.deps.logger.warn("detail full-frame fallback refused — frame is not the bbox scale", {
+		if (this.deps.captureParkedFrame !== void 0) try {
+			const parked = await this.deps.captureParkedFrame(deviceId, req.trackId);
+			if (parked !== null) if (dev.parcelEnriched.get(req.trackId)?.get(req.stepId) === parked.timestamp) this.deps.logger.debug("detail parcel already enriched for this step — skipping", {
 				tags: { deviceId },
 				meta: {
 					trackId: req.trackId,
 					stepId: req.stepId,
-					frameWidth: full.width,
-					frameHeight: full.height,
-					bboxFrameWidth: frame.frameWidth,
-					bboxFrameHeight: frame.frameHeight
+					parkedTimestamp: parked.timestamp
 				}
 			});
 			else {
 				const derived = await this.deps.runDetailSubtree({
 					deviceId,
-					frameJpeg: full.base64,
-					parent,
+					frameJpeg: parked.base64,
+					parent: {
+						bbox: { ...parked.bbox },
+						className: frame.className
+					},
 					steps
-				}, frame.nodeId);
-				if (derived !== null) return derived.details;
+				}, parked.nodeId);
+				if (derived !== null) {
+					const perStep = dev.parcelEnriched.get(req.trackId) ?? /* @__PURE__ */ new Map();
+					perStep.set(req.stepId, parked.timestamp);
+					dev.parcelEnriched.set(req.trackId, perStep);
+					return derived.details;
+				}
 			}
 		} catch (err) {
 			if (isDetailNotAttachedRefusal(err)) {
 				this.warnNotAttachedThrottled(deviceId, dev, req);
 				return null;
 			}
-			this.deps.logger.debug("detail full-frame fallback call failed", {
+			this.deps.logger.debug("detail parked-frame rung failed", {
 				tags: { deviceId },
 				meta: {
 					trackId: req.trackId,
@@ -47598,7 +47693,7 @@ var TrackDetailDispatcher = class {
 				trackId: req.trackId,
 				stepId: req.stepId,
 				reason: req.reason,
-				triedFullFrame: this.deps.captureFullFrameBase64 !== void 0,
+				triedParkedFrame: this.deps.captureParkedFrame !== void 0,
 				triedCropJpeg: this.deps.captureCropBase64 !== void 0
 			}
 		});
@@ -49560,6 +49655,87 @@ var FaceRecognizer = class {
 		}
 	}
 };
+/** Read the window. Pure — this is the judgement the module exists to make. */
+function lagVerdict(report) {
+	const bus = report.busLagMaxMs;
+	if (bus === null) return "unknown";
+	return bus >= 5e3 ? "starved" : "delivered-on-time";
+}
+/** Does this window need an operator's eyes? Unknown never counts as alarming
+*  — that is the fabricated verdict D8 forbids. */
+function isAlarmingLagReport(report) {
+	const bus = report.busLagMaxMs;
+	const capture = report.captureLagMaxMs;
+	return bus !== null && bus >= 5e3 || capture !== null && capture >= 5e3;
+}
+/**
+* Folds per-frame delivery lag into per-device windows.
+*
+* Not a logger: it returns the line to write (or null) and the caller decides
+* level and tags. That keeps the throttle — the part that can wreck the frame
+* path — testable without a logger fake.
+*/
+var FrameLagObserver = class {
+	windows = /* @__PURE__ */ new Map();
+	/**
+	* Fold one inference result into `deviceId`'s window.
+	*
+	* @param now Receipt time, read by the caller once at handler entry.
+	* @param emittedAt Runner-side emit stamp; undefined ⇒ unknown (D8).
+	* @param capturedAt Frame shm-commit stamp; undefined ⇒ unknown.
+	* @returns The closed window when this frame ends one, else null.
+	*/
+	observe(deviceId, now, emittedAt, capturedAt) {
+		const existing = this.windows.get(deviceId);
+		const w = existing ?? {
+			startedAt: now,
+			frames: 0,
+			busMax: null,
+			busMin: null,
+			busUnknown: 0,
+			captureMax: null,
+			captureUnknown: 0
+		};
+		if (existing === void 0) this.windows.set(deviceId, w);
+		w.frames += 1;
+		if (typeof emittedAt === "number") {
+			const busLag = now - emittedAt;
+			if (w.busMax === null || busLag > w.busMax) w.busMax = busLag;
+			if (w.busMin === null || busLag < w.busMin) w.busMin = busLag;
+		} else w.busUnknown += 1;
+		if (typeof capturedAt === "number") {
+			const captureLag = now - capturedAt;
+			if (w.captureMax === null || captureLag > w.captureMax) w.captureMax = captureLag;
+		} else w.captureUnknown += 1;
+		if (existing !== void 0 && now - w.startedAt < 3e4) return null;
+		const report = {
+			deviceId,
+			frames: w.frames,
+			busLagMaxMs: w.busMax,
+			busLagMinMs: w.busMin,
+			busLagUnknownFrames: w.busUnknown,
+			captureLagMaxMs: w.captureMax,
+			captureLagUnknownFrames: w.captureUnknown,
+			windowMs: now - w.startedAt
+		};
+		w.startedAt = now;
+		w.frames = 0;
+		w.busMax = null;
+		w.busMin = null;
+		w.busUnknown = 0;
+		w.captureMax = null;
+		w.captureUnknown = 0;
+		return report;
+	}
+	/** Drop a device's window (unbound camera, shutdown). */
+	forget(deviceId) {
+		this.windows.delete(deviceId);
+	}
+	/** Drop every window. */
+	clear() {
+		this.windows.clear();
+	}
+};
 //#endregion
 //#region src/pipeline-analytics/location-aware-media-storage.ts
 /**
@@ -53882,6 +54058,17 @@ async function encodeKeyFrameVariants(native) {
 		})
 	};
 }
+/**
+* The web companion from the PARKED key frame's own JPEG (D422): the parcel is
+* stored verbatim as `keyFrame`, and `keyFrameSmall` is this — the same bytes
+* downscaled to {@link KEYFRAME_SMALL_MAX_WIDTH}. One decode, one encode,
+* never a second fetch; `withoutEnlargement` never upscales a sub-960 frame.
+* The by-handle twin ({@link encodeKeyFrameVariants}) remains for the
+* summary group shot, which still fetches a native surface by handle.
+*/
+async function deriveKeyFrameSmall(keyFrameJpeg) {
+	return (0, sharp.default)(keyFrameJpeg).resize(960, null, { withoutEnlargement: true }).jpeg({ quality: 88 }).toBuffer();
+}
 //#endregion
 //#region src/pipeline-analytics/pipeline/key-frame-metrics.ts
 var DEFAULT_FLUSH_INTERVAL_MS = 6e4;
@@ -53907,11 +54094,8 @@ var KeyFrameCaptureLog = class {
 					w.landed += 1;
 					if (sample.retry) w.retryLanded += 1;
 					break;
-				case "native-miss":
-					w.nativeMiss += 1;
-					break;
-				case "ram-tier":
-					w.ramTier += 1;
+				case "parcel-missing":
+					w.parcelMissing += 1;
 					break;
 				case "error":
 					w.error += 1;
@@ -53940,8 +54124,7 @@ var KeyFrameCaptureLog = class {
 			landed: 0,
 			retryAttempts: 0,
 			retryLanded: 0,
-			nativeMiss: 0,
-			ramTier: 0,
+			parcelMissing: 0,
 			error: 0,
 			skippedNodeOffline: 0
 		};
@@ -53956,8 +54139,7 @@ var KeyFrameCaptureLog = class {
 			landed: w.landed,
 			retryAttempts: w.retryAttempts,
 			retryLanded: w.retryLanded,
-			nativeMiss: w.nativeMiss,
-			ramTier: w.ramTier,
+			parcelMissing: w.parcelMissing,
 			error: w.error,
 			skippedNodeOffline: w.skippedNodeOffline
 		};
@@ -53966,63 +54148,44 @@ var KeyFrameCaptureLog = class {
 //#endregion
 //#region src/pipeline-analytics/pipeline/key-frame-persist.ts
 /**
-* Fetch, encode and store one track's key frame + its 960 companion.
+* Read, derive and store one track's key frame + its web companion.
 *
-* NATIVE-OR-NOTHING: a miss writes nothing and the caller's bounded retry
-* re-fires later. The `keyFrame` write lands FIRST and its key is what the
-* outcome carries — a `keyFrameSmall` failure afterwards must not re-arm a
+* PARCEL-OR-NOTHING: no parcel writes nothing and the caller's bounded retry
+* parks a later frame. The `keyFrame` write lands FIRST and its key is what
+* the outcome carries — a `keyFrameSmall` failure afterwards must not re-arm a
 * retry that would re-shoot a key frame the rebuild can already read.
 */
 async function persistTrackKeyFrame(deps, input) {
-	const { deviceId, trackId, frameHandle, retry } = input;
+	const { deviceId, trackId, retry } = input;
 	const drop = {
 		tags: { deviceId },
 		meta: {
 			trackId,
-			nodeId: frameHandle.nodeId,
 			retry
 		}
 	};
 	try {
-		const result = await deps.fetchNativeFullFrame(frameHandle, input.maxWidth);
-		const native = result?.frame;
-		if (!native || native.format !== "rgb" || native.width <= 0 || native.height <= 0) {
-			deps.logger.error("key-frame native miss — no upscale, will retry while budget remains", {
-				...drop,
-				meta: {
-					...drop.meta,
-					shmId: frameHandle.shmId
-				}
-			});
-			return { kind: "native-miss" };
+		const parcel = await deps.fetchParkedKeyFrame(deviceId, trackId);
+		if (parcel === null || parcel.jpeg.byteLength === 0) {
+			deps.logger.error("key-frame parcel missing — nothing to write, retry parks a later frame", { ...drop });
+			return { kind: "parcel-missing" };
 		}
-		if (!keyFrameAcceptsTier(result.tier)) {
-			deps.logger.warn("keyFrame native miss — RAM tier rejected, will retry while budget remains", {
-				...drop,
-				meta: {
-					...drop.meta,
-					shmId: frameHandle.shmId,
-					tier: result.tier
-				}
-			});
-			return { kind: "ram-tier" };
-		}
-		const { keyFrame, keyFrameSmall } = await deps.encodeVariants(native);
 		const keyFrameKey = await deps.media.putReplacing({
 			deviceId,
 			ownerKind: "track",
 			ownerId: trackId,
 			kind: "keyFrame",
-			timestamp: input.timestamp,
-			data: keyFrame
+			timestamp: parcel.timestamp,
+			data: parcel.jpeg
 		});
 		try {
+			const keyFrameSmall = await deps.deriveSmall(parcel.jpeg);
 			await deps.media.putReplacing({
 				deviceId,
 				ownerKind: "track",
 				ownerId: trackId,
 				kind: "keyFrameSmall",
-				timestamp: input.timestamp,
+				timestamp: parcel.timestamp,
 				data: keyFrameSmall
 			});
 		} catch (err) {
@@ -54030,17 +54193,29 @@ async function persistTrackKeyFrame(deps, input) {
 				...drop,
 				meta: {
 					...drop.meta,
+					nodeId: parcel.nodeId,
 					error: require_dist.errMsg(err)
 				}
 			});
 		}
+		deps.logger.debug("key frame written from the parked parcel", {
+			...drop,
+			meta: {
+				...drop.meta,
+				nodeId: parcel.nodeId,
+				width: parcel.width,
+				height: parcel.height,
+				bytes: parcel.jpeg.byteLength,
+				parkedTimestamp: parcel.timestamp
+			}
+		});
 		return {
 			kind: "landed",
 			keyFrameKey
 		};
 	} catch (err) {
 		const error = require_dist.errMsg(err);
-		deps.logger.warn("key-frame capture failed", {
+		deps.logger.warn("key-frame write failed", {
 			...drop,
 			meta: {
 				...drop.meta,
@@ -54227,6 +54402,61 @@ function createKeyFrameCrop(deps) {
 	};
 }
 //#endregion
+//#region src/pipeline-analytics/pipeline/track-park.ts
+/** The whole frame — what a `keyFrame` park cuts. */
+var FULL_FRAME = {
+	x: 0,
+	y: 0,
+	w: 1,
+	h: 1
+};
+/** The two parcels a best-frame decision orders, in a fixed order. */
+function buildParkOrders(decision) {
+	const subject = {
+		bbox: { ...decision.bbox },
+		frameWidth: decision.frameWidth,
+		frameHeight: decision.frameHeight
+	};
+	const layout = deliveredWideCentralSquareLayout(decision.bbox, {
+		W: decision.frameWidth,
+		H: decision.frameHeight
+	});
+	const base = {
+		deviceId: decision.deviceId,
+		trackId: decision.trackId,
+		handle: decision.frameHandle,
+		timestamp: decision.timestamp,
+		subject
+	};
+	return [{
+		...base,
+		kind: "keyFrame",
+		bbox: FULL_FRAME,
+		maxWidth: KEYFRAME_NATIVE_MAX_WIDTH
+	}, {
+		...base,
+		kind: "thumbnail",
+		bbox: layout.fetch,
+		layout
+	}];
+}
+/**
+* The subject's box in the PARCEL's pixel space. The box was measured on the
+* ≤640 detection raster; the parcel is native-resolution. Both show the same
+* scene at the same aspect, so a uniform per-axis scale places the box on the
+* parcel — the runner then derives the crop rectangle from it (D52).
+*/
+function scaleSubjectIntoParcel(subject, parcelWidth, parcelHeight) {
+	const sx = parcelWidth / subject.frameWidth;
+	const sy = parcelHeight / subject.frameHeight;
+	return {
+		x: subject.bbox.x * sx,
+		y: subject.bbox.y * sy,
+		w: subject.bbox.w * sx,
+		h: subject.bbox.h * sy
+	};
+}
+//#endregion
 //#region src/pipeline-analytics/pipeline/native-detection.ts
 /**
 * Nominal frame size used to denormalize native `[0,1]` boxes when a
@@ -58757,7 +58987,28 @@ async function reconcileGallerySamples(deps, options) {
 }
 //#endregion
 //#region src/pipeline-analytics/summary/summary-store.ts
+/**
+* @durable class=ledger owner=pipeline-analytics
+*   write="one row per SUMMARY — a window of co-present tracks on one camera
+*     group. Opened by `openOrAbsorb` when the first member arrives, updated
+*     in place while the window absorbs more, and finalised by `seal` when the
+*     window closes. Per WINDOW, never per frame or per track: the sealed
+*     summary is what a notification rule reads."
+*   retention="age-keyed on `sealedAt`, swept with the rest of the analytics
+*     retention. An unsealed row belongs to a window still open and is never
+*     swept by age — it is closed or cascaded away with its members."
+*/
 var SUMMARIES_COLLECTION = "pipeline-analytics:summaries";
+/**
+* @durable class=ledger owner=pipeline-analytics
+*   write="one row per (summary, track) membership, written as a window
+*     absorbs a track. The join that lets a sealed summary name its subjects
+*     without re-reading the track store."
+*   retention="cascaded — a member dies with its summary (`delete-track-cascade`
+*     counts them as leaves) or with the track it names. It carries no clock of
+*     its own: an age sweep here could outlive or predecease the summary the
+*     row only means anything inside of."
+*/
 var SUMMARY_MEMBERS_COLLECTION = "pipeline-analytics:summary-members";
 var SUMMARIES_COLUMNS = [
 	{
@@ -63585,35 +63836,6 @@ function createNativeFrameTransport(deps) {
 	const getRemoteFrame = async (handle) => requestNativeCrop(handle, FULL_FRAME_BBOX, handle.width, replyToFullFrame);
 	const fetchNativeFullFrameTiered = async (handle, maxWidth) => requestNativeCrop(handle, FULL_FRAME_BBOX, maxWidth, replyToTieredFullFrame);
 	const getNativeFullFrameRgb = async (handle, maxWidth) => (await fetchNativeFullFrameTiered(handle, maxWidth))?.frame ?? null;
-	const getFullFrameJpegBase64 = async (handle, maxWidth) => {
-		if (!pipelineRunnerApi?.getNativeCrop) return null;
-		try {
-			const full = await pipelineRunnerApi.getNativeCrop.query({
-				handle,
-				bbox: {
-					x: 0,
-					y: 0,
-					w: 1,
-					h: 1
-				},
-				maxWidth,
-				encodeJpeg: true
-			}, require_dist.nodePin(handle.nodeId));
-			if (!full?.jpeg || full.width <= 0 || full.height <= 0) return null;
-			return {
-				base64: full.jpeg,
-				width: full.width,
-				height: full.height,
-				tier: full.tier === "ram-fullframe" ? "ram-fullframe" : "native"
-			};
-		} catch (err) {
-			logger.debug("full-frame jpeg fetch failed", { meta: {
-				nodeId: handle.nodeId,
-				error: require_dist.errMsg(err)
-			} });
-			return null;
-		}
-	};
 	const cropMetricLogger = logger.child("NativeCrop");
 	let nativeHits = 0;
 	let nativeFallbacks = 0;
@@ -63693,7 +63915,6 @@ function createNativeFrameTransport(deps) {
 		getRemoteFrame,
 		getNativeFullFrameRgb,
 		getNativeKeyFrameRgb: fetchNativeFullFrameTiered,
-		getFullFrameJpegBase64,
 		getNativeCropJpeg,
 		captureCrop: createCaptureCrop({
 			tryNativeCrop,
@@ -63804,6 +64025,233 @@ function parseTopologySnapshotNodes(data) {
 	return parsed;
 }
 //#endregion
+//#region src/pipeline-analytics/runtime/parked-frame-client.ts
+/**
+* Bound on the mirror. A track's record leaves at release; this is the
+* backstop for a lost close. At the busiest measured hub (~12 sessions,
+* a few tracks each) 4 096 is an hour of tracks, past which the OLDEST record
+* is forgotten — its parcel still ages out on the node on its own.
+*/
+var MAX_MIRRORED_TRACKS = 4096;
+/** One "runner has no park method" line per camera per minute. */
+var SKEW_WARN_THROTTLE_MS = 6e4;
+function inFlightKey(trackId, kind) {
+	return `${trackId} ${kind}`;
+}
+/** Strip the hub-side context off an order: only the wire fields travel. */
+function toWireInput(order) {
+	return {
+		deviceId: order.deviceId,
+		trackId: order.trackId,
+		kind: order.kind,
+		handle: order.handle,
+		bbox: order.bbox,
+		...order.maxWidth !== void 0 ? { maxWidth: order.maxWidth } : {},
+		timestamp: order.timestamp
+	};
+}
+function createParkedFrameClient(deps) {
+	const { api, logger } = deps;
+	const now = deps.now ?? Date.now;
+	/** trackId → kind → what the hub kept beside the parcel. */
+	const mirror = /* @__PURE__ */ new Map();
+	const inFlight = /* @__PURE__ */ new Map();
+	const skewWarnedAt = /* @__PURE__ */ new Map();
+	const remember = (order, answer) => {
+		let kinds = mirror.get(order.trackId);
+		if (kinds === void 0) {
+			kinds = /* @__PURE__ */ new Map();
+			mirror.set(order.trackId, kinds);
+			while (mirror.size > MAX_MIRRORED_TRACKS) {
+				const oldest = mirror.keys().next().value;
+				if (oldest === void 0) break;
+				mirror.delete(oldest);
+			}
+		}
+		kinds.set(order.kind, {
+			nodeId: answer.nodeId,
+			deviceId: order.deviceId,
+			kind: order.kind,
+			timestamp: order.timestamp,
+			width: answer.width,
+			height: answer.height,
+			subject: order.subject,
+			...order.layout !== void 0 ? { layout: order.layout } : {}
+		});
+	};
+	const warnSkew = (order) => {
+		const at = skewWarnedAt.get(order.deviceId) ?? 0;
+		if (now() - at < SKEW_WARN_THROTTLE_MS) return;
+		skewWarnedAt.set(order.deviceId, now());
+		logger.warn("track frame park impossible — the runner api has no park method (version skew)", {
+			tags: { deviceId: order.deviceId },
+			meta: {
+				trackId: order.trackId,
+				kind: order.kind,
+				nodeId: order.handle.nodeId
+			}
+		});
+	};
+	const sendPark = async (order) => {
+		if (api === void 0) {
+			warnSkew(order);
+			return false;
+		}
+		if (deps.isNodeOffline?.(order.handle.nodeId) === true) {
+			logger.debug("track frame park skipped — the owning node is offline in the registry", {
+				tags: { deviceId: order.deviceId },
+				meta: {
+					trackId: order.trackId,
+					kind: order.kind,
+					nodeId: order.handle.nodeId
+				}
+			});
+			return false;
+		}
+		const meta = {
+			trackId: order.trackId,
+			kind: order.kind,
+			nodeId: order.handle.nodeId,
+			handle: `${order.handle.shmId}#${order.handle.slot}#${order.handle.seq}`
+		};
+		try {
+			const answer = await api.parkTrackFrame.mutate(toWireInput(order), require_dist.nodePin(order.handle.nodeId));
+			if (answer.parked) {
+				remember(order, answer);
+				logger.debug("track frame parked", {
+					tags: { deviceId: order.deviceId },
+					meta: {
+						...meta,
+						bytes: answer.bytes,
+						replaced: answer.replaced
+					}
+				});
+				return true;
+			}
+			logger.warn("track frame park refused by the owning node", {
+				tags: { deviceId: order.deviceId },
+				meta: {
+					...meta,
+					reason: answer.reason,
+					handleAgeMs: answer.handleAgeMs,
+					...answer.detail !== void 0 ? { detail: answer.detail } : {}
+				}
+			});
+			return false;
+		} catch (err) {
+			logger.warn("track frame park failed — the order did not reach the node", {
+				tags: { deviceId: order.deviceId },
+				meta: {
+					...meta,
+					error: require_dist.errMsg(err)
+				}
+			});
+			return false;
+		}
+	};
+	const park = (order) => {
+		const key = inFlightKey(order.trackId, order.kind);
+		const pending = inFlight.get(key);
+		if (pending !== void 0) return pending;
+		const run = sendPark(order).finally(() => {
+			if (inFlight.get(key) === run) inFlight.delete(key);
+		});
+		inFlight.set(key, run);
+		return run;
+	};
+	const awaitPark = async (trackId, kind) => {
+		const pending = inFlight.get(inFlightKey(trackId, kind));
+		if (pending !== void 0) await pending;
+	};
+	const info = (trackId, kind) => mirror.get(trackId)?.get(kind);
+	const fetch = async (trackId, kind) => {
+		const known = info(trackId, kind);
+		if (known === void 0 || api === void 0) return null;
+		if (deps.isNodeOffline?.(known.nodeId) === true) {
+			logger.warn("parked frame retrieval skipped — the holding node is offline in the registry", {
+				tags: { deviceId: known.deviceId },
+				meta: {
+					trackId,
+					kind,
+					nodeId: known.nodeId
+				}
+			});
+			return null;
+		}
+		try {
+			const parcel = await api.getParkedTrackFrame.query({
+				deviceId: known.deviceId,
+				trackId,
+				kind
+			}, require_dist.nodePin(known.nodeId));
+			if (parcel === null) {
+				logger.warn("parked frame gone at retrieval — the node no longer holds it", {
+					tags: { deviceId: known.deviceId },
+					meta: {
+						trackId,
+						kind,
+						nodeId: known.nodeId,
+						parkedTimestamp: known.timestamp
+					}
+				});
+				return null;
+			}
+			return {
+				jpeg: Buffer.from(parcel.jpeg, "base64"),
+				width: parcel.width,
+				height: parcel.height,
+				timestamp: parcel.timestamp,
+				info: known
+			};
+		} catch (err) {
+			logger.warn("parked frame retrieval failed", {
+				tags: { deviceId: known.deviceId },
+				meta: {
+					trackId,
+					kind,
+					nodeId: known.nodeId,
+					error: require_dist.errMsg(err)
+				}
+			});
+			return null;
+		}
+	};
+	const release = (trackId) => {
+		const kinds = mirror.get(trackId);
+		if (kinds === void 0) return;
+		mirror.delete(trackId);
+		if (api === void 0) return;
+		const targets = /* @__PURE__ */ new Map();
+		for (const record of kinds.values()) targets.set(record.nodeId, record.deviceId);
+		for (const [nodeId, deviceId] of targets) api.releaseParkedTrackFrames.mutate({
+			deviceId,
+			trackId
+		}, require_dist.nodePin(nodeId)).catch((err) => {
+			logger.debug("parked frame release did not reach the node", {
+				tags: { deviceId },
+				meta: {
+					trackId,
+					nodeId,
+					error: require_dist.errMsg(err)
+				}
+			});
+		});
+	};
+	const dispose = () => {
+		mirror.clear();
+		inFlight.clear();
+		skewWarnedAt.clear();
+	};
+	return {
+		park,
+		awaitPark,
+		info,
+		fetch,
+		release,
+		dispose
+	};
+}
+//#endregion
 //#region src/pipeline-analytics/runtime/widget-manifest.ts
 /** The remote-module coordinates shared by every analytics widget. */
 var REMOTE_NAME = "addon_pipeline_analytics_widgets";
@@ -64905,7 +65353,8 @@ function isUniformRgbFrame(data, width, height) {
 * frame downscaled to {@link SNAPSHOT_MAX_WIDTH} (960) with ONLY the track's own
 * box burned in, falling back to the ≤640 detection frame (honest lower res,
 * never an upscale) on a native miss. The best `thumbnail` stays a clean,
-* uncapped native subject crop (native-or-nothing).
+* uncapped native subject crop — read from the track's PARKED slab, by track
+* (D422), never by handle.
 *
 * The detection frame is resolved ONCE per call (blank-frame guard); native full
 * frames + subject crops are fetched per target by handle. Frames recycle in
@@ -65173,10 +65622,10 @@ var EventMediaDispatcher = class {
 		if (sn.rollingLastFrame && boxed) lastFrameWritten = await this.replaceKind(deviceId, sn.trackId, "lastFrame", sn.timestamp, boxed);
 		let thumbnailWritten = false;
 		if (sn.bestThumbnail) {
-			const variants = await this.cropSubjectVariants(deviceId, sn.trackId, frameHandle, fw, fh, sn.bbox);
+			const variants = await this.cropSubjectVariants(deviceId, sn.trackId);
 			if (variants) {
-				thumbnailWritten = await this.replaceKind(deviceId, sn.trackId, "thumbnail", sn.timestamp, variants.thumbnail, "native");
-				await this.replaceKind(deviceId, sn.trackId, "thumbnailSmall", sn.timestamp, variants.thumbnailSmall, "native");
+				thumbnailWritten = await this.replaceKind(deviceId, sn.trackId, "thumbnail", variants.timestamp, variants.thumbnail, "native");
+				await this.replaceKind(deviceId, sn.trackId, "thumbnailSmall", variants.timestamp, variants.thumbnailSmall, "native");
 			}
 		}
 		return {
@@ -65254,81 +65703,49 @@ var EventMediaDispatcher = class {
 	}
 	/**
 	* The best-shot subject crop as its TWO persisted variants (best-crop
-	* fast-load, 2026-07-21; 16:9 central-square reframe, 2026-07-22). ONE native
-	* fetch: the in-frame slab of the 16:9 central-square WINDOW
-	* ({@link wideCentralSquareLayout} — a `side × 16/9` window whose middle square
-	* of side `max(w,h)×1.2` fully contains the subject, clamped/anchored so the
-	* subject stays in that central square at every frame edge) is requested from
-	* the runner's retained native surface with NO `maxWidth` (uncapped TRUE
-	* native). It is composed into the full 16:9 window (lateral letterbox only for
-	* the part outside the frame) → the `thumbnail`. The `thumbnailSmall` is
-	* DERIVED by downscaling that SAME window to the 480 long-side cap (480×270) —
-	* never a second `getNativeCropJpeg`, never upscaled ({@link deriveThumbnailSmall}
-	* never upscales a smaller window).
-	*
-	* Both variants share the SAME framing + central-square containment guarantee:
-	* wide consumers use the 16:9 image as-is (subject centered, no cut); square
-	* consumers center-crop the middle square (subject always inside it).
-	*
-	* NATIVE-OR-NOTHING: any miss/error (or a runner without the method) returns
-	* `null` after a loud `logger.warn`; the caller SKIPS the write and the
-	* per-frame retry lands a real native crop later. Never a local resize
-	* upscale of a ≤640 tile (a blurred lie).
-	*/
-	async cropSubjectVariants(deviceId, trackId, frameHandle, fw, fh, bbox) {
-		if (!this.deps.getNativeCropJpeg) {
-			this.deps.logger.warn("native subject crop miss — will retry, no upscale", {
-				tags: { deviceId },
-				meta: {
-					shmId: frameHandle.shmId,
-					reason: "no-native-cap"
-				}
-			});
-			this.deps.onSubjectCropMiss?.(deviceId, trackId, "no-native-cap");
-			return null;
-		}
+	* fast-load, 2026-07-21; 16:9 central-square reframe, 2026-07-22), from the
+	* track's PARKED slab (D422). ONE read, by `(deviceId, trackId)`: the
+	* in-frame slab of the 16:9 central-square WINDOW
+	* ({@link wideCentralSquareLayout}) the runner cut at uncapped native
+	* resolution the instant the track's best was decided. It is composed into
+	* the full 16:9 window (lateral letterbox only for the part outside the
+	* frame) → the `thumbnail`. The `thumbnailSmall` is DERIVED by downscaling
+	* that SAME window to the 480 long-side cap — never a second read, never
+	* upscaled ({@link deriveThumbnailSmall} never upscales a smaller window).
+	*
+	* Both variants share the SAME framing + central-square containment
+	* guarantee: wide consumers use the 16:9 image as-is; square consumers
+	* center-crop the middle square (subject always inside it).
+	*
+	* PARCEL-OR-NOTHING: no parcel (or a throw) returns `null` after a loud
+	* `logger.warn`; the caller SKIPS the write and the per-frame retry parks a
+	* later frame. Never a by-handle crop, never a local upscale of a ≤640 tile.
+	*/
+	async cropSubjectVariants(deviceId, trackId) {
 		try {
-			const layout = deliveredWideCentralSquareLayout(bbox, {
-				W: fw,
-				H: fh
-			});
-			if (centralSquareContainmentFraction(bbox, {
-				W: fw,
-				H: fh
-			}) < .5) this.deps.logger.info("best-shot delivered via contained square layout (edge subject)", {
-				tags: { deviceId },
-				meta: {
-					bbox,
-					frameW: fw,
-					frameH: fh
-				}
-			});
-			const askedAt = Date.now();
-			const slab = await this.deps.getNativeCropJpeg(frameHandle, layout.fetch, void 0, deviceId);
-			if (!slab) {
-				this.deps.logger.warn("native subject crop miss — will retry, no upscale", {
+			const parked = await this.deps.getParkedSubjectSlab(deviceId, trackId);
+			if (!parked) {
+				this.deps.logger.warn("best-shot parcel missing — no thumbnail this frame, will retry", {
 					tags: { deviceId },
 					meta: {
-						shmId: frameHandle.shmId,
-						handle: `${frameHandle.shmId}#${frameHandle.slot}#${frameHandle.seq}`,
-						handleNodeId: frameHandle.nodeId,
-						roundTripMs: Date.now() - askedAt,
-						reason: "native-miss"
+						trackId,
+						reason: "parcel-missing"
 					}
 				});
-				this.deps.onSubjectCropMiss?.(deviceId, trackId, "native-miss");
+				this.deps.onSubjectCropMiss?.(deviceId, trackId, "parcel-missing");
 				return null;
 			}
-			const thumbnail = await composeWideCentralSquareThumbnail(slab, layout);
+			const thumbnail = await composeWideCentralSquareThumbnail(parked.slab, parked.layout);
 			return {
 				thumbnail,
-				thumbnailSmall: await deriveThumbnailSmall(thumbnail)
+				thumbnailSmall: await deriveThumbnailSmall(thumbnail),
+				timestamp: parked.timestamp
 			};
 		} catch (err) {
-			this.deps.logger.warn("native subject crop miss — will retry, no upscale", {
+			this.deps.logger.warn("best-shot parcel read failed — no thumbnail this frame, will retry", {
 				tags: { deviceId },
 				meta: {
-					shmId: frameHandle.shmId,
+					trackId,
 					reason: "threw",
 					error: err instanceof Error ? err.message : String(err)
 				}
@@ -70619,7 +71036,17 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 	*  the FULL cleanup litany on every teardown path (and cancels the track's
 	*  queued captures via the onClose hook) and `closeDevice` finally clears
 	*  per-track state on device removal (the two documented leaks). */
-	residents = new TrackResidentState({ onClose: (trackId) => this.captureScheduler.cancelForTrack(trackId) });
+	residents = new TrackResidentState({ onClose: (trackId) => {
+		this.captureScheduler.cancelForTrack(trackId);
+		this.parkedFrames?.release(trackId);
+	} });
+	/**
+	* The hub's side of a PARK (D422): orders the owning node to keep a track's
+	* best frame the instant `BestDetectionTracker` accepts it, and answers the
+	* keyFrame writer, the best-shot thumbnail and the detail plane's full-frame
+	* rung by `(deviceId, trackId, kind)` — never by handle. Null until init.
+	*/
+	parkedFrames = null;
 	/** Defence in depth for the 2026-08-21 `b50e09f7` incident: a row the track
 	*  store has already CLOSED never earns another media target, whatever the
 	*  tracker keeps handing back. Reads the store's in-RAM close record only —
@@ -70729,6 +71156,22 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 	*  a ≤640 RAM fallback (`tier: 'ram-fullframe'`). Null until init completes. */
 	getNativeKeyFrameRgb = null;
 	shuttingDown = false;
+	/**
+	* Per-device delivery-lag windows, folded at `handleInferenceResult` entry.
+	* The instrument that tells a late DELIVERY (starved) apart from a slow
+	* `processFrame` (waiting) — see `frame-lag-observer.ts`. Costs one map read
+	* and ~10 numeric ops per frame, and writes one line per device per 30 s.
+	*/
+	frameLag = new FrameLagObserver();
+	/**
+	* Stops the GC-attributing stall monitor armed in {@link onInitialize}.
+	*
+	* The other half of the frame-lag line: that one says whether the events
+	* arrived late, this one says whether THIS loop was blocked while they did.
+	* The 5-minute `[mem]` heartbeat cannot see a 10 s freeze — it fired at
+	* dt = 300020 / 300066 / 299991 ms straight through the 2026-09-09 silences.
+	*/
+	stopStallMonitor = null;
 	/** True only on the cluster's designated post-processing node. When false the
 	*  addon subscribes to NOTHING — fully inert (no event/media generation). */
 	isPostProcessingNode = true;
@@ -70947,6 +71390,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 		super({});
 	}
 	async onInitialize() {
+		this.stopStallMonitor = (0, _camstack_system_addon_utils.startEventLoopStallMonitor)(this.ctx.logger);
 		const rawApi = this.ctx.api;
 		if (!rawApi) throw new Error("pipeline-analytics requires ctx.api (device-manager + settings-store)");
 		const api = censusApi(rawApi, this.readCensus);
@@ -70997,17 +71441,23 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 			noteCropOutcome: (deviceId, reason) => this.failureReport.noteEnrichmentCrop(deviceId, reason)
 		});
 		this.getNativeKeyFrameRgb = transport.getNativeKeyFrameRgb;
+		this.parkedFrames = createParkedFrameClient({
+			api: api.pipelineRunner,
+			logger: logger.child("ParkedFrames"),
+			isNodeOffline: (nodeId) => this.nodeLiveness.isKnownOffline(nodeId, Date.now())
+		});
 		this.captureCrop = transport.captureCrop;
 		this.eventMediaDispatcher = new EventMediaDispatcher({
 			getRemoteFrame: transport.getRemoteFrame,
 			getNativeCropJpeg: transport.getNativeCropJpeg,
 			getNativeFullFrameRgb: transport.getNativeFullFrameRgb,
+			getParkedSubjectSlab: (deviceId, trackId) => this.fetchParkedSubjectSlab(deviceId, trackId),
 			mediaStore: stores.mediaStore,
 			logger: logger.child("EventMediaDispatcher"),
 			onSubjectCropMiss: (deviceId, trackId, reason) => this.residents.notePreviewCaptureMiss(deviceId, trackId, `thumbnail:${reason}`)
 		});
 		this.buildRecognizers(api, logger, stores, transport);
-		this.buildDetailDispatcher(api, logger, transport);
+		this.buildDetailDispatcher(api, logger);
 		const capProviders = this.buildAnalyticsProviders(api, logger);
 		await step("buildNotificationCenter", () => this.buildNotificationCenter(api, logger, stores));
 		await step("serveEventMediaDataPlane", () => this.serveEventMediaDataPlane());
@@ -71837,7 +72287,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 	*  demand via `pipelineRunner.runDetailSubtree`. The dispatcher owns the
 	*  per-device schedulers, concurrency cap, and 1 s tick; result routing +
 	*  the pinned call + crop fallback are injected here. */
-	buildDetailDispatcher(api, logger, transport) {
+	buildDetailDispatcher(api, logger) {
 		const runnerApi = api.pipelineRunner;
 		this.detailDispatcher = new TrackDetailDispatcher({
 			logger: logger.child("DetailDispatcher"),
@@ -71847,13 +72297,16 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 				return runnerApi.runDetailSubtree.mutate(input);
 			},
 			routeResults: (deviceId, trackId, details, frame) => this.routeDetailResults(deviceId, trackId, details, frame),
-			captureFullFrameBase64: async (frame) => {
-				if (frame.frameHandle === void 0) return null;
-				const full = await transport.getFullFrameJpegBase64(frame.frameHandle, frame.frameWidth);
-				return full === null ? null : {
-					base64: full.base64,
-					width: full.width,
-					height: full.height
+			captureParkedFrame: async (_deviceId, trackId) => {
+				const parcel = await this.fetchParkedParcel(trackId, "keyFrame");
+				if (parcel === null) return null;
+				return {
+					base64: parcel.jpeg.toString("base64"),
+					width: parcel.width,
+					height: parcel.height,
+					bbox: scaleSubjectIntoParcel(parcel.info.subject, parcel.width, parcel.height),
+					nodeId: parcel.info.nodeId,
+					timestamp: parcel.timestamp
 				};
 			},
 			captureCropBase64: async (frame) => {
@@ -73451,6 +73904,10 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 	}
 	async onShutdown() {
 		this.shuttingDown = true;
+		if (this.stopStallMonitor) {
+			this.stopStallMonitor();
+			this.stopStallMonitor = null;
+		}
 		this.sceneEngine?.stop();
 		this.sceneEngine = null;
 		if (this.sceneReloadTimer !== null) {
@@ -73491,10 +73948,12 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 		this.audioMarkers?.flush(Date.now());
 		this.detailDispatcher?.dispose();
 		this.detailDispatcher = null;
+		this.parkedFrames?.dispose();
 		this.overlayState.clear();
 		this.overlaySynthesisWarnAt.clear();
 		this.processors.clear();
 		this.lastActiveTrackIds.clear();
+		this.frameLag.clear();
 		this.lastFrameDimsByDevice.clear();
 		this.dropoutSkipsByKey.clear();
 		this.residents.clearAll();
@@ -73534,6 +73993,23 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 	async handleInferenceResult(data) {
 		if (this.shuttingDown) return;
 		const { deviceId, frame } = data;
+		const lag = this.frameLag.observe(deviceId, Date.now(), data.emittedAt, data.capturedAt);
+		if (lag !== null) {
+			const verdict = lagVerdict(lag);
+			(isAlarmingLagReport(lag) ? this.ctx.logger.warn.bind(this.ctx.logger) : this.ctx.logger.info.bind(this.ctx.logger))("pipeline-analytics frame lag", {
+				tags: { deviceId },
+				meta: {
+					verdict,
+					frames: lag.frames,
+					windowMs: lag.windowMs,
+					busLagMaxMs: lag.busLagMaxMs,
+					busLagMinMs: lag.busLagMinMs,
+					busLagUnknownFrames: lag.busLagUnknownFrames,
+					captureLagMaxMs: lag.captureLagMaxMs,
+					captureLagUnknownFrames: lag.captureLagUnknownFrames
+				}
+			});
+		}
 		await this.processFrame(deviceId, frame, "pipeline", data.frameHandle, data.detailSteps);
 	}
 	/**
@@ -74131,7 +74607,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 			let plateCrops = 0;
 			for (const crops of childCropsByEvent.values()) for (const c of crops) if (c.kind === "faceCrop") faceCrops += 1;
 			else plateCrops += 1;
-			const snapshotTargets = this.buildSnapshotTargets(deviceId, result.tracked, result.timestamp, mediaSettings, result.frameWidth, result.frameHeight);
+			const snapshotTargets = this.buildSnapshotTargets(deviceId, result.tracked, result.timestamp, mediaSettings, result.frameWidth, result.frameHeight, frameHandle);
 			this.offerGroupShot(deviceId, result, frameHandle);
 			for (const retry of this.collectFirstFrameRetries(deviceId, result.tracked, result.timestamp, firstFrameTargets)) firstFrameTargets.push(retry);
 			const targetedThisFrame = new Set([...firstFrameTargets.map((t) => t.trackId), ...snapshotTargets.map((s) => s.trackId)]);
@@ -74250,7 +74726,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 				}).catch(() => {});
 			}
 			const keyFrameCaptures = selectKeyFrameCaptures(snapshotTargets);
-			if (keyFrameCaptures.length > 0) this.persistKeyFrames(deviceId, result.timestamp, keyFrameCaptures, frameHandle);
+			if (keyFrameCaptures.length > 0) this.persistKeyFrames(deviceId, result.timestamp, keyFrameCaptures);
 		}
 		if (this.faceRecognizer && faceGloballyEnabled && faceSettings) this.faceRecognizer.processFrame({
 			deviceId,
@@ -75180,10 +75656,46 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 			});
 		}).catch(() => {});
 	}
-	async persistKeyFrames(deviceId, timestamp, captures, frameHandle) {
-		const getNative = this.getNativeKeyFrameRgb;
+	/**
+	* Order the parcels a best-frame decision wants (D422). Skipped entirely at
+	* a node the registry already called offline (D58) — logged on the
+	* transition by `noteCapturesGated`, counted in the key-frame window.
+	* `onlyIfMissing` is the retry rule: a later frame may fill a kind that has
+	* no parcel, never replace one the ranking preferred.
+	*/
+	issueParkOrders(decision, kinds, onlyIfMissing) {
+		const client = this.parkedFrames;
+		if (client === null) return;
+		if (this.nodeLiveness.isKnownOffline(decision.frameHandle.nodeId, Date.now())) {
+			this.noteCapturesGated(decision.deviceId, decision.frameHandle.nodeId);
+			return;
+		}
+		for (const order of buildParkOrders(decision)) {
+			if (!kinds.includes(order.kind)) continue;
+			if (onlyIfMissing && client.info(order.trackId, order.kind) !== void 0) continue;
+			client.park(order);
+		}
+	}
+	/** A parcel by track, after any park in flight for it has landed. */
+	async fetchParkedParcel(trackId, kind) {
+		const client = this.parkedFrames;
+		if (client === null) return null;
+		await client.awaitPark(trackId, kind);
+		return client.fetch(trackId, kind);
+	}
+	/** The best-shot slab for the dispatcher: the parcel plus the layout the hub kept. */
+	async fetchParkedSubjectSlab(_deviceId, trackId) {
+		const parcel = await this.fetchParkedParcel(trackId, "thumbnail");
+		if (parcel === null || parcel.info.layout === void 0) return null;
+		return {
+			slab: parcel.jpeg,
+			layout: parcel.info.layout,
+			timestamp: parcel.timestamp
+		};
+	}
+	async persistKeyFrames(deviceId, timestamp, captures) {
 		const mediaStore = this.mediaStore;
-		if (!getNative || !mediaStore) return;
+		if (this.parkedFrames === null || !mediaStore) return;
 		await Promise.all(captures.map((capture) => this.captureScheduler.request({
 			deviceId,
 			trackId: capture.trackId,
@@ -75193,16 +75705,23 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 			exec: async () => {
 				this.residents.noteKeyFrameAttempt(deviceId, capture.trackId, timestamp, capture.retry);
 				const outcome = await persistTrackKeyFrame({
-					fetchNativeFullFrame: getNative,
-					encodeVariants: encodeKeyFrameVariants,
+					fetchParkedKeyFrame: async (parcelDeviceId, trackId) => {
+						const parcel = await this.fetchParkedParcel(trackId, "keyFrame");
+						if (parcel === null || parcel.info.deviceId !== parcelDeviceId) return null;
+						return {
+							jpeg: parcel.jpeg,
+							width: parcel.width,
+							height: parcel.height,
+							timestamp: parcel.timestamp,
+							nodeId: parcel.info.nodeId
+						};
+					},
+					deriveSmall: deriveKeyFrameSmall,
 					media: mediaStore,
 					logger: this.ctx.logger
 				}, {
 					deviceId,
 					trackId: capture.trackId,
-					timestamp,
-					frameHandle,
-					maxWidth: KEYFRAME_NATIVE_MAX_WIDTH,
 					retry: capture.retry
 				});
 				if (outcome.kind === "landed") {
@@ -75282,10 +75801,19 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 			isKeyFrameLanded: (trackId) => this.residents.keyFrameCapture(trackId).landed,
 			captureBodyThumbnail: (req) => this.captureHierarchyBodyThumbnail(req),
 			captureKeyFrame: async (req) => {
+				this.issueParkOrders({
+					deviceId: req.deviceId,
+					trackId: req.trackId,
+					timestamp: req.timestamp,
+					frameHandle: req.frameHandle,
+					bbox: { ...req.bodyBbox },
+					frameWidth: req.frameWidth,
+					frameHeight: req.frameHeight
+				}, ["keyFrame"], true);
 				await this.persistKeyFrames(req.deviceId, req.timestamp, [{
 					trackId: req.trackId,
 					retry: false
-				}], req.frameHandle);
+				}]);
 			}
 		}, input);
 	}
@@ -75339,10 +75867,19 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 	*  (coalescing, per-device budget and land-only bookkeeping identical). */
 	captureSemanticBestShot(request) {
 		const { deviceId, trackId, timestamp, bbox, frameHandle } = request;
+		this.issueParkOrders({
+			deviceId,
+			trackId,
+			timestamp,
+			frameHandle,
+			bbox: { ...bbox },
+			frameWidth: request.frameWidth,
+			frameHeight: request.frameHeight
+		}, ["keyFrame", "thumbnail"], false);
 		this.persistKeyFrames(deviceId, timestamp, [{
 			trackId,
 			retry: false
-		}], frameHandle);
+		}]);
 		const dispatcher = this.eventMediaDispatcher;
 		if (!dispatcher) return;
 		if (this.captureScheduler.isKeyActive(captureCoalesceKey(deviceId, "thumbnail", trackId))) {
@@ -75493,7 +76030,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 		}
 		return retries;
 	}
-	buildSnapshotTargets(deviceId, tracked, timestamp, media, frameWidth, frameHeight) {
+	buildSnapshotTargets(deviceId, tracked, timestamp, media, frameWidth, frameHeight, frameHandle) {
 		const targets = [];
 		for (const t of tracked) {
 			if (t.matchedThisFrame === false) continue;
@@ -75579,6 +76116,29 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 				state: this.residents.keyFrameCapture(t.trackId),
 				now: timestamp
 			}).kind;
+			if (frameHandle !== void 0 && plausibleBox) {
+				const decision = {
+					deviceId,
+					trackId: t.trackId,
+					timestamp,
+					frameHandle,
+					bbox: {
+						x: t.bbox.x,
+						y: t.bbox.y,
+						w: t.bbox.w,
+						h: t.bbox.h
+					},
+					frameWidth,
+					frameHeight
+				};
+				if (isNewBest) this.issueParkOrders(decision, ["keyFrame", "thumbnail"], false);
+				else {
+					const retryKinds = [];
+					if (keyFrame === "retry") retryKinds.push("keyFrame");
+					if (bestThumbnail) retryKinds.push("thumbnail");
+					if (retryKinds.length > 0) this.issueParkOrders(decision, retryKinds, true);
+				}
+			}
 			const suppressedBy = (() => {
 				if (skipParkedThumb) return "parked-thumbnail";
 				if (!isNewBest || bestThumbnail) return void 0;