@camstack/addon-pipeline 1.2.196 → 1.2.198

package/dist/pipeline-runner/index.js

@@ -2,12 +2,12 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-const require_dist = require("../dist-HG5geL9t.js");
-const require_node = require("../node--my8JTOW.js");
-const require_default_detection_model = require("../default-detection-model-CJdc8j83.js");
-const require_worker_protocol = require("../worker-protocol-DCsi4YS1.js");
+const require_dist = require("../dist-BxP0SvPz.js");
+const require_node = require("../node-BIKrNEtS.js");
+const require_default_detection_model = require("../default-detection-model-B5v8qEI0.js");
+const require_worker_protocol = require("../worker-protocol-D2mMjUXv.js");
 const require_hub_hostname = require("../hub-hostname-DAJXlOgV.js");
-const require_lazy_sharp = require("../lazy-sharp-DmAwZ0s9.js");
+const require_lazy_sharp = require("../lazy-sharp-VKOG3WW4.js");
 const require_restream_intent = require("../restream-intent-Cv9x3jmu.js");
 const require_event_loop_stall_monitor = require("../event-loop-stall-monitor-DaUBcb13.js");
 const require_remote_restream = require("../remote-restream-CO36Sr30.js");
@@ -1977,6 +1977,169 @@ function buildBenchRunPipelineInput(req) {
 		...req.plane ? { plane: req.plane } : {}
 	};
 }
+/**
+* How long a box stays "seen".
+*
+* Sized on the gate's own clock, not on a guess: `maxDeferralMs` defaults to
+* 2 000 ms, so a birth's whole life as a candidate is 2 s. A window shorter
+* than that would re-cut the same subject inside one deferral; a much longer
+* one would stop a subject that genuinely left and returned from being cut
+* again. 3 000 ms is the deferral budget plus one 1 s margin.
+*/
+var BIRTH_EVIDENCE_NOVELTY_WINDOW_MS = 3e3;
+/**
+* Padding around the box, as a fraction of its size.
+*
+* 0.15 deliberately equals `CONFIRMATION_CROP_PADDING` in post-analysis: the
+* gate promotes a secondary subject by mapping a crop-space box back into the
+* frame through the rectangle the crop was cut from, and the two derivations
+* disagreeing is how a promoted box lands somewhere the pixels never were.
+*/
+var BIRTH_EVIDENCE_PADDING = .15;
+/**
+* Boxes remembered per camera. A frame with more subjects than this keeps the
+* most recent — the cap is about bounding a crowd, and a box that fell out is
+* merely eligible for a cut it will not get twice (the encode budget above is
+* the real spend). 64 is 16x the tile tier's per-frame subject cap.
+*/
+var REMEMBERED_BOXES_PER_DEVICE = 64;
+/**
+* Per-camera memory of the boxes recently on screen.
+*
+* Per CAMERA and never global: a box on 617 says nothing about 615, and a
+* shared structure would make one camera's traffic decide another's cuts —
+* which is the exact shape of the node-wide sharing this whole change moves
+* away from.
+*
+* Judged per CLASS. A dog at its owner's knee is 100% contained in the person's
+* box; a class-blind test would call it "already seen" and it would reach the
+* gate with no pixels — the failure D372, D377 and D378 each fought at a
+* different layer.
+*/
+var BirthNoveltyMemory = class {
+	byDevice = /* @__PURE__ */ new Map();
+	/**
+	* Is this box a subject the camera has not been showing?
+	*
+	* Pure: it does not record anything. The caller records the whole frame with
+	* {@link note}, once, so a box that lost the encode budget is still counted
+	* as seen — otherwise the cap turns into a permanent re-cut of the same
+	* subjects.
+	*/
+	isNovel(deviceId, box, macroClass, nowMs) {
+		const boxes = this.byDevice.get(deviceId);
+		if (!boxes) return true;
+		for (const remembered of boxes) {
+			if (nowMs - remembered.atMs > 3e3) continue;
+			if (remembered.macroClass !== macroClass) continue;
+			if (iou(remembered.rect, box) >= .3) return false;
+		}
+		return true;
+	}
+	/** Record a frame's detections and drop everything past the window / the cap. */
+	note(deviceId, detections, nowMs) {
+		const kept = (this.byDevice.get(deviceId) ?? []).filter((b) => nowMs - b.atMs <= BIRTH_EVIDENCE_NOVELTY_WINDOW_MS);
+		for (const d of detections) {
+			if (!isUsable$1(d.bbox)) continue;
+			kept.push({
+				rect: d.bbox,
+				macroClass: d.macroClass,
+				atMs: nowMs
+			});
+		}
+		this.byDevice.set(deviceId, kept.length > REMEMBERED_BOXES_PER_DEVICE ? kept.slice(kept.length - REMEMBERED_BOXES_PER_DEVICE) : kept);
+	}
+	/** How many boxes this camera currently remembers (tests / diagnostics). */
+	rememberedCount(deviceId) {
+		return this.byDevice.get(deviceId)?.length ?? 0;
+	}
+	/** Forget a camera wholesale (detach, pipeline reset). */
+	clearDevice(deviceId) {
+		this.byDevice.delete(deviceId);
+	}
+};
+/**
+* The cuts worth taking on this frame, highest confidence first, capped.
+*
+* Records EVERY usable detection in `memory` — including the ones the cap
+* refused — so the budget bounds the spend without turning into a leak.
+*/
+function planBirthEvidence(deviceId, detections, frame, memory, nowMs, maxPerFrame = 2) {
+	if (frame.width <= 0 || frame.height <= 0) return [];
+	const usable = detections.map((d, index) => ({
+		d,
+		index
+	})).filter(({ d }) => isUsable$1(d.bbox));
+	const novel = usable.filter(({ d }) => memory.isNovel(deviceId, d.bbox, d.macroClass, nowMs));
+	memory.note(deviceId, usable.map(({ d }) => ({
+		bbox: d.bbox,
+		macroClass: d.macroClass
+	})), nowMs);
+	const plan = [];
+	for (const { d, index } of [...novel].sort((a, b) => b.d.score - a.d.score)) {
+		if (plan.length >= maxPerFrame) break;
+		const rect = padAndClamp(d.bbox, frame);
+		if (rect === null) continue;
+		plan.push({
+			index,
+			rect,
+			target: targetFor(rect)
+		});
+	}
+	return plan.sort((a, b) => a.index - b.index);
+}
+/**
+* The padded, clamped source rectangle — or `null` for a box that is not worth
+* an encode. A degenerate box is DROPPED rather than clamped: a zero-area crop
+* serves nothing and a NaN one would poison the encoder's geometry.
+*/
+function padAndClamp(box, frame) {
+	if (Math.min(box.width, box.height) < 128) return null;
+	const padX = box.width * BIRTH_EVIDENCE_PADDING;
+	const padY = box.height * BIRTH_EVIDENCE_PADDING;
+	const left = Math.max(0, Math.floor(box.x - padX));
+	const top = Math.max(0, Math.floor(box.y - padY));
+	const right = Math.min(frame.width, Math.ceil(box.x + box.width + padX));
+	const bottom = Math.min(frame.height, Math.ceil(box.y + box.height + padY));
+	const width = right - left;
+	const height = bottom - top;
+	if (width <= 0 || height <= 0) return null;
+	return {
+		x: left,
+		y: top,
+		width,
+		height
+	};
+}
+/** Encoded size: capped, aspect-preserving, never upscaled. */
+function targetFor(rect) {
+	if (rect.width <= 320) return {
+		width: rect.width,
+		height: rect.height
+	};
+	const scale = 320 / rect.width;
+	return {
+		width: 320,
+		height: Math.max(1, Math.round(rect.height * scale))
+	};
+}
+/** A box with finite, positive extent. */
+function isUsable$1(box) {
+	return Number.isFinite(box.x) && Number.isFinite(box.y) && Number.isFinite(box.width) && Number.isFinite(box.height) && box.width > 0 && box.height > 0;
+}
+/** Intersection over union of two absolute-pixel rectangles. */
+function iou(a, b) {
+	const left = Math.max(a.x, b.x);
+	const top = Math.max(a.y, b.y);
+	const right = Math.min(a.x + a.width, b.x + b.width);
+	const bottom = Math.min(a.y + a.height, b.y + b.height);
+	const w = right - left;
+	const h = bottom - top;
+	if (w <= 0 || h <= 0) return 0;
+	const intersection = w * h;
+	const union = a.width * a.height + b.width * b.height - intersection;
+	return union <= 0 ? 0 : intersection / union;
+}
 //#endregion
 //#region src/pipeline-runner/capacity/capacity-runner.ts
 /**
@@ -5539,6 +5702,15 @@ var PACKAGE_ZONE_UNION_TTL_MS = 6e4;
 var MAX_BOUND_FRAME_CUTTERS = 256;
 /** How often a camera reports its undispatched cuts. */
 var TILE_CUT_DROP_LOG_INTERVAL_MS = 6e4;
+/**
+* How often a camera reports what carrying its birth evidence COST (D379).
+*
+* The cost of this change is the one thing that must be measured rather than
+* estimated, so the report is per camera, states encodes / bytes / encode-ms
+* over the window, and drains its counters — a camera that cut nothing says
+* nothing until it does.
+*/
+var BIRTH_EVIDENCE_REPORT_INTERVAL_MS = 6e5;
 var DEFAULT_CONFIG = {
 	maxQueueDepth: 30,
 	maxConcurrentInferences: 16,
@@ -5900,6 +6072,15 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 	tileCutDrops = /* @__PURE__ */ new Map();
 	tileCutDropLoggedAt = /* @__PURE__ */ new Map();
 	/**
+	* Per-camera memory of the boxes recently on screen — what decides whether a
+	* detection is worth cutting its own evidence for (D379). Per CAMERA, never
+	* global: one camera's traffic must never decide another's cuts.
+	*/
+	birthNovelty = new BirthNoveltyMemory();
+	/** Per-camera cost of the carried evidence, drained by its report line. */
+	birthEvidenceCost = /* @__PURE__ */ new Map();
+	birthEvidenceReportedAt = /* @__PURE__ */ new Map();
+	/**
 	* Node-level RAM store of retained rgb detection frames, keyed by the
 	* `FrameHandle` that rides the inference-result event (shm-ring removal
 	* 2026-07-16 — replaces the `csr.` shm retention ring). Backs the
@@ -6177,7 +6358,8 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 		this.runner.onResult(async (deviceId, frame, result, _streamType, handle) => {
 			this.retention?.noteInferenceResult(deviceId, handle, result);
 			this.cutSubjectTiles(deviceId, result, handle);
-			this.emitInferenceResult(deviceId, frame, result, handle);
+			const carried = await this.attachBirthEvidence(deviceId, frame, result);
+			this.emitInferenceResult(deviceId, frame, carried, handle);
 			const detectionCount = result.detections?.length ?? 0;
 			this.runner?.noteDetectionResult(deviceId, detectionCount);
 			if (detectionCount > 0 && this.occupancyBurstInFlight.has(deviceId)) this.occupancyBurstFound.add(deviceId);
@@ -7165,6 +7347,178 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 	* stays at debug; a miss the caller is handed as `null` is lost work and is a
 	* warn, carrying the numbers that decide the fix.
 	*/
+	/**
+	* Cut each candidate birth's own pixels from the frame that produced it, and
+	* return a result carrying them (D379).
+	*
+	* Returns the SAME result object when there is nothing to cut, which is the
+	* overwhelming majority of frames: a subject already on screen is not a
+	* birth, so it costs a novelty lookup and no encode. A new result object is
+	* built when there is — never a mutation of the one the executor produced.
+	*
+	* Every drop is counted and reported per camera. A branch that silently
+	* dropped the evidence would be indistinguishable from a camera with no
+	* births at all, which is the shape of failure this whole change exists to
+	* remove.
+	*/
+	async attachBirthEvidence(deviceId, frame, result) {
+		const detections = result.detections;
+		if (detections.length === 0) return result;
+		const plan = planBirthEvidence(deviceId, detections.map((d) => ({
+			bbox: d.bbox,
+			score: d.score,
+			macroClass: d.macroClass
+		})), {
+			width: result.width,
+			height: result.height
+		}, this.birthNovelty, Date.now());
+		if (plan.length === 0) return result;
+		const cost = this.birthEvidenceCost.get(deviceId) ?? {
+			cut: 0,
+			failed: 0,
+			skippedNoPixels: 0,
+			bytes: 0,
+			encodeMs: 0
+		};
+		this.birthEvidenceCost.set(deviceId, cost);
+		const byIndex = /* @__PURE__ */ new Map();
+		if (!(frame.frameRef !== void 0 || frame.format === "rgb" && frame.data.byteLength >= result.width * result.height * 3)) {
+			cost.skippedNoPixels += plan.length;
+			this.reportBirthEvidenceCost(deviceId);
+			return result;
+		}
+		for (const entry of plan) {
+			const startedAt = Date.now();
+			const jpeg = await this.encodeEvidenceCrop(frame, result, entry);
+			if (jpeg === null) {
+				cost.failed += 1;
+				continue;
+			}
+			cost.cut += 1;
+			cost.bytes += jpeg.byteLength;
+			cost.encodeMs += Date.now() - startedAt;
+			byIndex.set(entry.index, {
+				jpegBase64: jpeg.toString("base64"),
+				rect: entry.rect,
+				tier: "analysis"
+			});
+		}
+		this.reportBirthEvidenceCost(deviceId);
+		if (byIndex.size === 0) return result;
+		return {
+			...result,
+			detections: detections.map((d, i) => {
+				const evidence = byIndex.get(i);
+				return evidence === void 0 ? d : {
+					...d,
+					birthEvidence: evidence
+				};
+			})
+		};
+	}
+	/**
+	* One evidence crop, or `null` when neither raster can serve it.
+	*
+	* The process-local frame LEASE is tried first. On the co-located path
+	* `DecodedFrame.data` is deliberately empty and the pixels live only behind
+	* `frameRef` — reading `data` there produced `skippedNoPixels` on roughly half
+	* the cluster's cameras in the first minutes after this shipped, which is
+	* exactly the silent gap this whole change exists to close. It is also the
+	* same lease the recovery pass resolves its views from, so it costs no new
+	* mechanism and no new copy of the frame.
+	*
+	* The raw buffer is the fallback for a frame delivered inline. `format` is
+	* checked rather than assumed: a planar frame read as RGB would produce a crop
+	* of noise that re-detects as nothing — a false SUPPRESSION, the one error
+	* this path must never make.
+	*/
+	async encodeEvidenceCrop(frame, result, entry) {
+		const fromLease = frame.frameRef ? await this.encodeEvidenceFromLease(frame.frameRef, entry) : null;
+		if (fromLease !== null) return fromLease;
+		const expectedBytes = result.width * result.height * 3;
+		if (frame.format !== "rgb" || frame.data.byteLength < expectedBytes) return null;
+		try {
+			let pipeline = (await require_lazy_sharp.getSharp())(frame.data, { raw: {
+				width: result.width,
+				height: result.height,
+				channels: 3
+			} }).extract({
+				left: entry.rect.x,
+				top: entry.rect.y,
+				width: entry.rect.width,
+				height: entry.rect.height
+			});
+			if (entry.target.width !== entry.rect.width) pipeline = pipeline.resize(entry.target.width, entry.target.height, { fit: "fill" });
+			return await pipeline.jpeg({ quality: 85 }).toBuffer();
+		} catch {
+			return null;
+		}
+	}
+	/** The evidence crop from the process-local lease, JPEG-encoded by the view. */
+	async encodeEvidenceFromLease(ref, entry) {
+		const lease = require_default_detection_model.localFrameRegistry.acquire(ref);
+		if (!lease) return null;
+		let reason = "error";
+		try {
+			const view = await lease.resolve({
+				crop: {
+					left: entry.rect.x,
+					top: entry.rect.y,
+					width: entry.rect.width,
+					height: entry.rect.height
+				},
+				content: {
+					width: entry.target.width,
+					height: entry.target.height
+				},
+				fit: "stretch",
+				format: "jpeg"
+			});
+			if (view.kind !== "view") {
+				reason = "drop";
+				return null;
+			}
+			reason = "success";
+			return Buffer.from(view.data);
+		} catch {
+			return null;
+		} finally {
+			lease.release(reason);
+		}
+	}
+	/**
+	* State, per camera, what carrying the evidence cost over the window — and
+	* drain it. The operator's acceptance condition for D379 is that the runner's
+	* memory and the frame path do not grow beyond a declared budget, and a
+	* budget nobody measures is an estimate.
+	*/
+	reportBirthEvidenceCost(deviceId) {
+		const cost = this.birthEvidenceCost.get(deviceId);
+		if (!cost) return;
+		const now = Date.now();
+		const lastAt = this.birthEvidenceReportedAt.get(deviceId) ?? 0;
+		if (lastAt !== 0 && now - lastAt < BIRTH_EVIDENCE_REPORT_INTERVAL_MS) return;
+		const windowMs = lastAt === 0 ? BIRTH_EVIDENCE_REPORT_INTERVAL_MS : now - lastAt;
+		this.birthEvidenceReportedAt.set(deviceId, now);
+		this.ctx.logger.info("birth evidence carried", {
+			tags: { deviceId },
+			meta: {
+				cut: cost.cut,
+				failed: cost.failed,
+				skippedNoPixels: cost.skippedNoPixels,
+				kb: Math.round(cost.bytes / 1024),
+				encodeMs: cost.encodeMs,
+				meanKb: cost.cut > 0 ? Math.round(cost.bytes / cost.cut / 1024) : 0,
+				meanEncodeMs: cost.cut > 0 ? Math.round(cost.encodeMs / cost.cut) : 0,
+				windowMs
+			}
+		});
+		cost.cut = 0;
+		cost.failed = 0;
+		cost.skippedNoPixels = 0;
+		cost.bytes = 0;
+		cost.encodeMs = 0;
+	}
 	async resolveNativeCropPixels(input) {
 		const b = input.bbox;
 		const isFullFrame = b.x <= .001 && b.y <= .001 && b.w >= .999 && b.h >= .999;
@@ -7688,6 +8042,9 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 		this.lastMotionAt.delete(deviceId);
 		this.lastEmittedCameraMetrics.delete(deviceId);
 		this.retention?.forgetDevice(deviceId);
+		this.birthNovelty.clearDevice(deviceId);
+		this.birthEvidenceCost.delete(deviceId);
+		this.birthEvidenceReportedAt.delete(deviceId);
 		this.runner?.unregisterCamera(deviceId);
 		this.ctx?.logger.info("detachCamera", {
 			tags: { deviceId },