@camstack/addon-pipeline 1.2.101 → 1.2.103

package/dist/{addon-utils-eUS6n_Zj.js → addon-utils-CLc6yHCN.js}

@@ -1,4 +1,4 @@
-const require_dist = require("./dist-dm3t4BOt.js");
+const require_dist = require("./dist-C11WuNUP.js");
 require("node:crypto");
 let node_path = require("node:path");
 node_path = require_dist.__toESM(node_path, 1);

package/dist/audio-analyzer/index.js

@@ -2,9 +2,9 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-const require_dist = require("../dist-dm3t4BOt.js");
-const require_process_memory = require("../process-memory-vkFVOdkV.js");
-const require_addon_utils = require("../addon-utils-eUS6n_Zj.js");
+const require_dist = require("../dist-C11WuNUP.js");
+const require_process_memory = require("../process-memory-DOjQ3MgC.js");
+const require_addon_utils = require("../addon-utils-CLc6yHCN.js");
 let node_path = require("node:path");
 node_path = require_dist.__toESM(node_path);
 let node_fs = require("node:fs");

package/dist/audio-analyzer/index.mjs

@@ -1,6 +1,6 @@
 import { n as __require } from "../chunk-DnnnRqeS.mjs";
-import { D as audioAnalysisCapability, O as audioAnalyzerCapability, W as mapAudioLabelToMacro, ct as errMsg, h as HF_BASE_URL, mt as BaseAddon, n as AUDIO_BACKEND_CHOICES, s as DEFAULT_AUDIO_ANALYZER_CONFIG, tt as resolvePoolMemoryPolicy, y as PoolMemoryWatchdog, yt as hydrateSchema } from "../dist-gXdWP96z.mjs";
-import { n as pickNodePlatformArch, t as readProcessMemory } from "../process-memory-CKWh609B.mjs";
+import { D as audioAnalysisCapability, G as mapAudioLabelToMacro, O as audioAnalyzerCapability, bt as hydrateSchema, h as HF_BASE_URL, ht as BaseAddon, lt as errMsg, n as AUDIO_BACKEND_CHOICES, nt as resolvePoolMemoryPolicy, s as DEFAULT_AUDIO_ANALYZER_CONFIG, y as PoolMemoryWatchdog } from "../dist-Ccmt3fGJ.mjs";
+import { n as pickNodePlatformArch, t as readProcessMemory } from "../process-memory-D0zDmXLI.mjs";
 import { i as downloadFile } from "../addon-utils-A2S9D7pu.mjs";
 import * as path$1 from "node:path";
 import * as fs from "node:fs";

package/dist/detection-pipeline/index.js

@@ -2,11 +2,11 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-const require_dist = require("../dist-dm3t4BOt.js");
-const require_event_loop_stall_monitor = require("../event-loop-stall-monitor-Lki2_mYY.js");
-const require_lazy_sharp = require("../lazy-sharp-oYppDIZR.js");
-const require_process_memory = require("../process-memory-vkFVOdkV.js");
-const require_addon_utils = require("../addon-utils-eUS6n_Zj.js");
+const require_dist = require("../dist-C11WuNUP.js");
+const require_event_loop_stall_monitor = require("../event-loop-stall-monitor-Cq_NeC4o.js");
+const require_lazy_sharp = require("../lazy-sharp-RxUs6on_.js");
+const require_process_memory = require("../process-memory-DOjQ3MgC.js");
+const require_addon_utils = require("../addon-utils-CLc6yHCN.js");
 let sharp = require("sharp");
 sharp = require_dist.__toESM(sharp);
 let node_child_process = require("node:child_process");
@@ -3040,7 +3040,9 @@ async function nativeChildCrop(provider, bbox, imageWidth, imageHeight, maxWidth
 *      peaky (a few high rows) rather than smeared across many rows.
 *   3. pick the angle maximising the score (coarse 2° sweep + a 0.5° local
 *      refinement); apply it to the full-resolution RGB tile only when it is
-*      meaningfully non-zero.
+*      meaningfully non-zero AND the optimum was BRACKETED by the sweep — an
+*      argmax sitting on the boundary means the profile never turned over and
+*      the "angle" is an artefact of where the search stopped.
 *
 * All of the geometry is pure functions over raw buffers, so the estimator is
 * fully deterministic and unit-testable without any image I/O.
@@ -3219,22 +3221,28 @@ function scoreAngle(gradient, angleRad) {
 		height: rotated.height
 	});
 }
+var DEFAULT_COARSE_STEP_DEG = 2;
+var NO_SKEW = {
+	angleDeg: 0,
+	score: 0
+};
 /**
 * Estimate the dominant text-baseline skew of a grayscale plate crop and return
 * the CORRECTION angle (degrees) that levels it. A coarse sweep over
 * ±`maxAngleDeg` in `coarseStepDeg` steps finds the best bucket; a `fineStepDeg`
 * local search refines it. Returns `0` when the flat (no-rotation) profile is
-* already the strongest response.
+* already the strongest response, and — critically — also when the coarse
+* winner is not BRACKETED by the sweep (see {@link BOUNDARY_REJECT_DEG}): an
+* optimum sitting on the edge of the searched interval is not a measurement,
+* it is the place the search ran out of road.
 */
 function estimateSkewAngle(gray, opts = {}) {
-	const maxAngleDeg = opts.maxAngleDeg ?? 30;
-	const coarseStepDeg = opts.coarseStepDeg ?? 2;
+	const maxAngleDeg = opts.maxAngleDeg ?? 16;
+	const coarseStepDeg = opts.coarseStepDeg ?? DEFAULT_COARSE_STEP_DEG;
 	const fineStepDeg = opts.fineStepDeg ?? .5;
 	const scoreMaxDim = opts.scoreMaxDim ?? 480;
-	if (gray.width < 4 || gray.height < 4) return {
-		angleDeg: 0,
-		score: 0
-	};
+	const boundaryRejectDeg = Math.max(0, maxAngleDeg - coarseStepDeg);
+	if (gray.width < 4 || gray.height < 4) return NO_SKEW;
 	const gradient = sobelMagnitude(downscaleGray(gray, scoreMaxDim));
 	let bestAngle = 0;
 	let bestScore = scoreAngle(gradient, 0);
@@ -3246,6 +3254,7 @@ function estimateSkewAngle(gray, opts = {}) {
 			bestAngle = deg;
 		}
 	}
+	if (Math.abs(bestAngle) >= boundaryRejectDeg) return NO_SKEW;
 	const lo = bestAngle - coarseStepDeg;
 	const hi = bestAngle + coarseStepDeg;
 	for (let deg = lo; deg <= hi + 1e-9; deg += fineStepDeg) {
@@ -3261,6 +3270,50 @@ function estimateSkewAngle(gray, opts = {}) {
 		score: bestScore
 	};
 }
+function toSharpChannels(channels) {
+	switch (channels) {
+		case 1: return 1;
+		case 2: return 2;
+		case 4: return 4;
+		default: return 3;
+	}
+}
+/**
+* Cut an expand-rotated canvas back to the LEVELLED SOURCE BAND.
+*
+* `rotateRaw(expand: true)` grows the canvas to `w·|cos| + h·|sin|` ×
+* `w·|sin| + h·|cos|` so no corner is clipped — but the `|sin|` terms are pure
+* corner spread: flat fill above/below (and left/right of) the plate. Handing
+* that to OCR is not free. The recognizer letterboxes the whole tile into a
+* fixed 64px-tall input, so a 155px crop returned at 194px shrinks every glyph
+* by ~20% before a single character is read — the warp paying back part of what
+* it just won.
+*
+* The band kept is the source rectangle scaled by `|cos angle|`, centred: a
+* source edge of length L, once levelled, spans `L·|cos|` along its own axis.
+* Everything outside is the fill the rotation introduced.
+*/
+function cropLevelledBand(rotated, srcWidth, srcHeight, angleRad) {
+	const c = Math.abs(Math.cos(angleRad));
+	const bw = Math.max(1, Math.min(rotated.width, Math.round(srcWidth * c)));
+	const bh = Math.max(1, Math.min(rotated.height, Math.round(srcHeight * c)));
+	if (bw === rotated.width && bh === rotated.height) return rotated;
+	const ch = rotated.channels;
+	const x0 = Math.max(0, Math.floor((rotated.width - bw) / 2));
+	const y0 = Math.max(0, Math.floor((rotated.height - bh) / 2));
+	const out = new Uint8Array(bw * bh * ch);
+	const rowBytes = bw * ch;
+	for (let y = 0; y < bh; y++) {
+		const srcOff = ((y0 + y) * rotated.width + x0) * ch;
+		out.set(rotated.data.subarray(srcOff, srcOff + rowBytes), y * rowBytes);
+	}
+	return {
+		data: out,
+		width: bw,
+		height: bh,
+		channels: ch
+	};
+}
 /**
 * Rectify an oblique plate crop: decode the JPEG, estimate the baseline skew,
 * and — only when it exceeds {@link MIN_RECTIFY_ANGLE_DEG} — rotate the
@@ -3288,19 +3341,20 @@ async function rectifyPlateJpeg(jpeg, opts = {}) {
 	let mean = 0;
 	for (let i = 0; i < gray.data.length; i++) mean += gray.data[i];
 	const fill = gray.data.length > 0 ? mean / gray.data.length | 0 : 0;
-	const rotated = rotateRaw(rgb, angleDeg * DEG2RAD, {
+	const angleRad = angleDeg * DEG2RAD;
+	const band = cropLevelledBand(rotateRaw(rgb, angleRad, {
 		expand: true,
 		fill
-	});
+	}), rgb.width, rgb.height, angleRad);
 	try {
 		return {
-			jpeg: await (0, sharp.default)(Buffer.from(rotated.data), { raw: {
-				width: rotated.width,
-				height: rotated.height,
-				channels: rotated.channels
+			jpeg: await (0, sharp.default)(Buffer.from(band.data), { raw: {
+				width: band.width,
+				height: band.height,
+				channels: toSharpChannels(band.channels)
 			} }).jpeg({ quality: opts.quality ?? 90 }).toBuffer(),
-			width: rotated.width,
-			height: rotated.height,
+			width: band.width,
+			height: band.height,
 			angleDeg
 		};
 	} catch {
@@ -3309,6 +3363,12 @@ async function rectifyPlateJpeg(jpeg, opts = {}) {
 }
 //#endregion
 //#region src/detection-pipeline/pipeline/result-assembler.ts
+/** L2 norm of a raw embedding vector. */
+function vectorMagnitude(v) {
+	let sum = 0;
+	for (const x of v) sum += x * x;
+	return Math.sqrt(sum);
+}
 /**
 * Small deterministic id generator scoped to a single frame. Each call
 * returns the next `d{n}` id so detail parentId references can be set
@@ -3402,6 +3462,7 @@ function applyChildOutput(parent, childStep, output, stepLatencyMs, ctx) {
 		case "embedding":
 			parent.embedding = output.embeddingNorm;
 			parent.embeddingModelId = childStep.modelId;
+			parent.embeddingMagnitude = vectorMagnitude(output.embedding);
 			parent.ownLabels.push({
 				label: `embedding:${output.embedding.length}d`,
 				score: 1
@@ -3624,20 +3685,50 @@ var MIN_FACE_DETECTION_FLOOR_PX = 6;
 */
 var NATIVE_FACE_CROP_MAX_WIDTH = 320;
 /**
-* Minimum short side (px) of the ACTUAL crop fed to the plate-OCR (`ctc`) leaf
-* — the plate analogue of the face path's min-face-size gate. Below ~20px the
-* CTC logit map collapses toward the blank and the surviving timesteps emit
-* symbol junk ("[miv4o)", "6ou.2" — live-observed 2026-07-22). Measured on the
-* NATIVE crop when the native ROI fetch succeeded (its dimensions ARE the
-* plate's real native size — `nativeChildCrop`'s 1920 cap never binds for a
-* plate), else on the fallback detection-space tile — which IS the input OCR
-* would read, so the same floor applies honestly in both cases.
+* Minimum LONG side (px) of the ACTUAL crop fed to the plate-OCR (`ctc`) leaf —
+* the plate analogue of the face path's min-face-size gate.
+*
+* The long side, not the short one. A plate's information lives along its text
+* run: the recognizer resizes the tile to a fixed 64px height and reads left to
+* right, so what decides whether a glyph survives is how many horizontal pixels
+* each character got. The previous 20px SHORT-side floor measured the wrong
+* axis and passed essentially everything.
+*
+* The number comes from the 2026-08 audit of 11 cam-617 plate tracks with
+* ground truth. Native long side vs read:
+*
+*   117px → "DNRO3O9"  (truth DNRO309 — one glyph out, the only near-miss)
+*    82px → "VONND9592" (truth DNDS597)
+*    77px → "DEPNOQ1"   (truth DNP1091)
+*    76px → "VDHPXOE8"  (truth DNPK838)
+*    73px → "DAEOR2D8"  (truth DNDR298)
+*    ≤62px → "I0IAZ", "EUSM9", "0IA3", "DYAGI2", "I0AA", "IC1E"
+*
+* Not one read under 100px resembled its plate, and the gap between 82 and 117
+* is empty — 100 sits in it. Below this floor the OCR call is pure cost: it
+* produces a label that is wrong, and a wrong plate label is worse than none.
+*
+* Measured on the NATIVE crop when the native ROI fetch succeeded (its
+* dimensions ARE the plate's real native size — `nativeChildCrop`'s 1920 cap
+* never binds for a plate), else on the fallback detection-space tile — which
+* IS the input OCR would read, so the same floor applies honestly in both cases.
 */
-var MIN_PLATE_OCR_SHORT_SIDE_PX = 20;
+var MIN_PLATE_OCR_LONG_SIDE_PX = 100;
 function isEnrichmentOutput(output) {
 	return output.kind === "classifications" || output.kind === "embedding" || output.kind === "text";
 }
 /**
+* Read a numeric step setting, falling back to `fallback` when the key is
+* absent or not a finite number. A type guard rather than a cast — a step's
+* `settings` bag is `Record<string, unknown>` because it is operator data, and
+* asserting `as number` over it is how a string from a form becomes a silent
+* NaN comparison that admits everything.
+*/
+function numericSetting(settings, key, fallback) {
+	const raw = settings?.[key];
+	return typeof raw === "number" && Number.isFinite(raw) ? raw : fallback;
+}
+/**
 * Stamp the camera onto an inference input so a failure inside the SHARED pool
 * can name it (`InferenceInput.deviceId` — diagnostic only, it selects
 * nothing). Immutable, and a no-op for a caller with no real camera: the
@@ -4078,12 +4169,27 @@ var PipelineExecutor = class {
 				let cropW;
 				let cropH;
 				if (modelEntry?.faceAlignment) {
-					const minFaceSize = typeof child.settings?.["minFaceSize"] === "number" ? child.settings["minFaceSize"] : DEFAULT_MIN_FACE_SIZE_PX;
+					const minFaceSize = numericSetting(child.settings, "minFaceSize", DEFAULT_MIN_FACE_SIZE_PX);
 					const detShortSide = bboxShortSide(parentDetection.bbox);
 					if (detShortSide < MIN_FACE_DETECTION_FLOOR_PX) {
 						this.warnFaceTooSmall(child, detShortSide, minFaceSize, void 0, deviceId);
 						continue;
 					}
+					const precision = require_event_loop_stall_monitor.landmarkPrecisionVerdict({
+						detectionShortSidePx: detShortSide,
+						floorPx: numericSetting(child.settings, "minLandmarkFaceSize", 24)
+					});
+					if (precision !== null) {
+						this.throttledWarn(`face-landmark-floor:${child.stepId}:${deviceId}`, 3e4, "face detected but its landmarks are below the precision floor — no embedding", {
+							step: child.stepId,
+							model: child.modelId,
+							detectionShortSidePx: Math.round(precision.detectionShortSidePx),
+							minLandmarkFaceSizePx: precision.floorPx,
+							tileW: imageWidth,
+							tileH: imageHeight
+						}, deviceId);
+						continue;
+					}
 					const lms = parentDetection.landmarks;
 					if (lms && lms.length >= 5) {
 						if (!nativeCropProvider && detShortSide < minFaceSize) {
@@ -4147,15 +4253,16 @@ var PipelineExecutor = class {
 						cropH = crop.height;
 					}
 					if (child.definition.postprocessor === "ctc") {
-						const plateShortSidePx = Math.min(cropW, cropH);
-						if (plateShortSidePx < MIN_PLATE_OCR_SHORT_SIDE_PX) {
-							this.opts.logger?.debug("plate ROI too small for OCR — skipping", {
+						const plateLongSidePx = Math.max(cropW, cropH);
+						if (plateLongSidePx < MIN_PLATE_OCR_LONG_SIDE_PX) {
+							this.opts.logger?.info("plate ROI too small for OCR — skipping", {
 								tags: { deviceId },
 								meta: {
 									step: child.stepId,
 									model: child.modelId,
-									plateShortSidePx: Math.round(plateShortSidePx),
-									minPlateShortSidePx: MIN_PLATE_OCR_SHORT_SIDE_PX,
+									plateLongSidePx: Math.round(plateLongSidePx),
+									plateShortSidePx: Math.round(Math.min(cropW, cropH)),
+									minPlateLongSidePx: MIN_PLATE_OCR_LONG_SIDE_PX,
 									source: nativeChild ? "native" : "detection-tile"
 								}
 							});
@@ -4168,12 +4275,15 @@ var PipelineExecutor = class {
 							cropJpegBuf = rectified.jpeg;
 							cropW = rectified.width;
 							cropH = rectified.height;
-							this.opts.logger?.debug("Plate crop deskewed before OCR", { meta: {
-								stepId: child.definition.id,
-								angleDeg: Number(rectified.angleDeg.toFixed(2)),
-								width: cropW,
-								height: cropH
-							} });
+							this.opts.logger?.info("plate crop deskewed before OCR", {
+								tags: { deviceId },
+								meta: {
+									step: child.stepId,
+									angleDeg: Number(rectified.angleDeg.toFixed(2)),
+									width: cropW,
+									height: cropH
+								}
+							});
 						}
 					} catch {}
 				}
@@ -4183,6 +4293,17 @@ var PipelineExecutor = class {
 				}, deviceId), cropW, cropH, "crop-roi", parentDetection.bbox, parentDetection.macroClass, traceBuilder, stepTimings, poolAgg);
 				const childMs = Date.now() - childStart;
 				if (childOutput === null) continue;
+				if (child.definition.postprocessor === "ctc" && childOutput.kind === "text") this.opts.logger?.info("plate OCR read", {
+					tags: { deviceId },
+					meta: {
+						step: child.stepId,
+						model: child.modelId,
+						text: childOutput.text,
+						confidence: Number(childOutput.confidence.toFixed(3)),
+						formatValid: childOutput.formatValid ?? null,
+						tilePx: `${cropW}x${cropH}`
+					}
+				});
 				const detailsBefore = ctx.details.length;
 				applyChildOutput(parentDetection, child, childOutput, childMs, ctx);
 				if (childOutput.kind === "detections" && child.children.length > 0) {