@camstack/addon-pipeline 1.2.5 → 1.2.6

package/dist/detection-pipeline/index.js

@@ -3,8 +3,8 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 const require_chunk = require("../chunk-D6vf50IK.js");
-const require_dist = require("../dist-CtQsET1Q.js");
-const require_step_definitions = require("../step-definitions-DrRnEQPM.js");
+const require_dist = require("../dist-Bh0H8jM6.js");
+const require_step_definitions = require("../step-definitions-xxdpJX9-.js");
 const require_node_topology_platform = require("../node-topology-platform-CFZ7F4xW.js");
 const require_model_download_service_Cp9f4dk6 = require("../model-download-service-Cp9f4dk6-Dv-oFwjN.js");
 let node_child_process = require("node:child_process");
@@ -221,6 +221,43 @@ function normalizeEngineNodeId(rawNodeId) {
 	return raw.includes("/") ? raw.split("/")[0] ?? "hub" : raw;
 }
 //#endregion
+//#region src/detection-pipeline/pipeline/native-crop-compose.ts
+/** Clamp `v` into `[lo, hi]`. */
+function clamp(v, lo, hi) {
+	if (v < lo) return lo;
+	if (v > hi) return hi;
+	return v;
+}
+/**
+* Compose a child `roi` given in the parent CROP's normalized space into the
+* FRAME's normalized space, given the crop's frame-space pixel rectangle and the
+* frame dimensions. The result is clamped to the unit square (origin in
+* `[0,1]`, extent bounded so `x + w ≤ 1` and `y + h ≤ 1`). Returns `null` for
+* degenerate inputs (non-finite frame dims, empty crop rect, or an ROI that
+* clamps to zero area) so the caller falls back to the downscaled tile crop.
+*
+* Pure — never mutates its arguments.
+*/
+function composeCropRoiToFrameNorm(roi, cropFrameSpace, frameWidth, frameHeight) {
+	if (!(frameWidth > 0) || !(frameHeight > 0)) return null;
+	if (!(cropFrameSpace.w > 0) || !(cropFrameSpace.h > 0)) return null;
+	const fx = (cropFrameSpace.x + roi.x * cropFrameSpace.w) / frameWidth;
+	const fy = (cropFrameSpace.y + roi.y * cropFrameSpace.h) / frameHeight;
+	const fw = roi.w * cropFrameSpace.w / frameWidth;
+	const fh = roi.h * cropFrameSpace.h / frameHeight;
+	const x = clamp(fx, 0, 1);
+	const y = clamp(fy, 0, 1);
+	const w = clamp(fw, 0, 1 - x);
+	const h = clamp(fh, 0, 1 - y);
+	if (!(w > 0) || !(h > 0)) return null;
+	return {
+		x,
+		y,
+		w,
+		h
+	};
+}
+//#endregion
 //#region src/detection-pipeline/default-detection-model.ts
 /** The object-detection step id — the only slot this resolver applies to. */
 var OBJECT_DETECTION_STEP_ID$1 = "object-detection";
@@ -909,6 +946,9 @@ function serializeModelConfig(config) {
 	if (config.inputChannels !== void 0) result["inputChannels"] = config.inputChannels;
 	if (config.labels) result["labels"] = config.labels;
 	if (config.charset) result["charset"] = config.charset;
+	if (config.plateRegion !== void 0) result["plateRegion"] = config.plateRegion;
+	if (config.minTextLength !== void 0) result["minTextLength"] = config.minTextLength;
+	if (config.minTextConfidence !== void 0) result["minTextConfidence"] = config.minTextConfidence;
 	if (config.numClasses) result["numClasses"] = config.numClasses;
 	if (config.strides) result["strides"] = config.strides;
 	if (config.maskThreshold !== void 0) result["maskThreshold"] = config.maskThreshold;
@@ -1443,6 +1483,9 @@ var EngineFactory = class {
 			nmsIouThreshold: this.opts.nmsIouThreshold ?? .45,
 			labels,
 			charset: def.charset,
+			plateRegion: def.plateRegion,
+			minTextLength: def.minTextLength,
+			minTextConfidence: def.minTextConfidence,
 			numClasses: labels?.length,
 			strides: def.postprocessor === "scrfd" ? [
 				8,
@@ -1647,6 +1690,14 @@ var EngineProvisioner = class {
 /** Detector NMS IoU fallback — the historical hardcoded literal, used when the
 *  step carries no `nmsIouThreshold` setting (unset == today). */
 var DEFAULT_NMS_IOU = .45;
+/**
+* Region plate grammars for the TS fallback CTC decoder (nodejs+onnx path).
+* VALIDATION-ONLY: this mirror annotates `formatValid` but does NOT rescore
+* confusables — the confusable repair needs the aligned per-timestep softmax
+* that only the Python path retains (see `python/postprocessors/ctc.py`). Keep
+* the pattern set in sync with `PLATE_GRAMMARS` there. `'off'`/unset disables it.
+*/
+var TS_PLATE_GRAMMARS = { DE: /^[A-ZÄÖÜ]{1,3}[- ]?[A-Z]{1,2}[- ]?[0-9]{1,4}[EH]?$/ };
 var VALID_KINDS = new Set([
 	"detections",
 	"classifications",
@@ -1923,9 +1974,20 @@ function postprocessCtc(output, stepDef) {
 		if (bestIdx !== 0 && bestIdx !== prev) chars.push(charset[bestIdx] ?? "");
 		prev = bestIdx;
 	}
+	const text = chars.join("");
+	const region = stepDef.plateRegion;
+	if (region !== void 0 && region !== "off") {
+		const grammar = TS_PLATE_GRAMMARS[region];
+		if (grammar) return {
+			kind: "text",
+			text,
+			confidence: seqLen > 0 ? totalScore / seqLen : 0,
+			formatValid: grammar.test(text)
+		};
+	}
 	return {
 		kind: "text",
-		text: chars.join(""),
+		text,
 		confidence: seqLen > 0 ? totalScore / seqLen : 0
 	};
 }
@@ -2568,6 +2630,353 @@ async function alignFaceCrop(fullFrameJpeg, faceBbox, landmarksImageSpace, image
 	};
 }
 //#endregion
+//#region src/detection-pipeline/pipeline/native-child-crop.ts
+/**
+* NATIVE-resolution crop of a LEAF crop-child ROI (plate-ocr, leaf classifiers)
+* — the plate-side mirror of the face path's {@link ./face-align.buildAlignedFaceCrop}.
+*
+* On the detail plane the executor runs a child model against a parent crop
+* (e.g. the native vehicle crop). A leaf child's ROI (`parentDetection.bbox`,
+* in the parent crop's PIXEL space) is what the child model reads. Cutting it
+* from the parent tile with {@link ./crop-utils.cropJpeg} bounds the child input
+* to the tile's resolution — fatal for OCR on a small, distant plate. When a
+* native-crop provider is bound to the frame, we instead resolve the SAME ROI
+* straight from the frame's retained NATIVE surface (the provider re-composes
+* the crop-normalized ROI into frame space — see {@link ./native-crop-compose}),
+* giving the model native pixels. A miss/degenerate returns `null` so the caller
+* falls back to the existing tile crop (never an upscale — native or the tile).
+*/
+/**
+* Generous native-width cap for a leaf child crop. A plate ROI is a few hundred
+* native pixels wide, so this never binds for plates (effectively uncapped —
+* the quality path the task requires); it only bounds a pathologically large
+* whole-object classifier ROI so the in-process native fetch/encode stays cheap.
+*/
+var NATIVE_CHILD_CROP_MAX_WIDTH = 1920;
+/**
+* Resolve `bbox` (a parent-crop PIXEL rectangle `[x1,y1,x2,y2]`) at native
+* resolution via `provider`, returning a JPEG crop + its native dimensions.
+* Returns `null` on a degenerate ROI or any provider miss (so the caller uses
+* the downscaled tile crop instead). Pure w.r.t. its inputs; the only effect is
+* the sharp encode of the returned pixels.
+*/
+async function nativeChildCrop(provider, bbox, imageWidth, imageHeight, maxWidth) {
+	if (!(imageWidth > 0) || !(imageHeight > 0)) return null;
+	const x1 = Math.max(0, bbox[0]);
+	const y1 = Math.max(0, bbox[1]);
+	const x2 = Math.min(imageWidth, bbox[2]);
+	const y2 = Math.min(imageHeight, bbox[3]);
+	const w = x2 - x1;
+	const h = y2 - y1;
+	if (w < 1 || h < 1) return null;
+	const native = await provider({
+		x: x1 / imageWidth,
+		y: y1 / imageHeight,
+		w: w / imageWidth,
+		h: h / imageHeight
+	}, maxWidth);
+	if (!native || native.width < 2 || native.height < 2 || native.bytes.length < native.width * native.height * 3) return null;
+	return {
+		jpeg: await (0, sharp.default)(Buffer.from(native.bytes), { raw: {
+			width: native.width,
+			height: native.height,
+			channels: 3
+		} }).jpeg({ quality: 90 }).toBuffer(),
+		width: native.width,
+		height: native.height
+	};
+}
+//#endregion
+//#region src/detection-pipeline/pipeline/plate-deskew.ts
+/**
+* Plate-crop DESKEW — rotation rectification for oblique licence-plate crops.
+*
+* Plate crops reach the CTC recognizer as an axis-aligned bbox tile with NO
+* geometric correction. On steeply oblique cameras (cam 617) the plate text is
+* skewed, and CTC collapses beyond ~10-15° of baseline tilt. This module
+* estimates the plate's dominant rotation from the crop ALONE (no plate quad is
+* available) and rotates the tile so the text baseline is horizontal before OCR.
+*
+* Approach (classic projection-profile deskew, pure TS — no OpenCV, no new
+* native deps; sharp is used only to decode/encode JPEG, mirroring the sibling
+* `native-child-crop.ts` / `face-align.ts`):
+*   1. grayscale → isotropic Sobel gradient magnitude (an orientation-agnostic
+*      "ink/edge" map, robust to plate polarity and lighting).
+*   2. for a small set of candidate CORRECTION angles, rotate the gradient map
+*      (bilinear, same primitive family as the face warp) and score the
+*      horizontal projection profile by its energy `Σ rowSum²`. That energy is
+*      MAXIMISED when the text edges land on horizontal rows — the profile is
+*      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.
+*
+* All of the geometry is pure functions over raw buffers, so the estimator is
+* fully deterministic and unit-testable without any image I/O.
+*/
+var DEG2RAD = Math.PI / 180;
+/** Convert an interleaved RGB/RGBA buffer to single-channel luma. */
+function toGrayscale(rgb) {
+	const { data, width, height, channels } = rgb;
+	const out = new Uint8Array(width * height);
+	for (let i = 0, p = 0; i < out.length; i++, p += channels) out[i] = data[p] * 77 + data[p + 1] * 150 + data[p + 2] * 29 >> 8;
+	return {
+		data: out,
+		width,
+		height
+	};
+}
+/**
+* Isotropic Sobel gradient magnitude of a grayscale image, clamped to [0,255].
+* Border pixels are 0 (no valid 3×3 neighbourhood) — they carry no baseline
+* signal anyway. The magnitude is polarity-agnostic, so it responds to both
+* dark-on-light and light-on-dark plates.
+*/
+function sobelMagnitude(gray) {
+	const { data, width, height } = gray;
+	const out = new Uint8Array(width * height);
+	for (let y = 1; y < height - 1; y++) for (let x = 1; x < width - 1; x++) {
+		const i = y * width + x;
+		const tl = data[i - width - 1];
+		const tc = data[i - width];
+		const tr = data[i - width + 1];
+		const ml = data[i - 1];
+		const mr = data[i + 1];
+		const bl = data[i + width - 1];
+		const bc = data[i + width];
+		const br = data[i + width + 1];
+		const gx = tr + 2 * mr + br - (tl + 2 * ml + bl);
+		const gy = bl + 2 * bc + br - (tl + 2 * tc + tr);
+		const mag = Math.sqrt(gx * gx + gy * gy);
+		out[i] = mag > 255 ? 255 : mag;
+	}
+	return {
+		data: out,
+		width,
+		height
+	};
+}
+/**
+* Rotate a raw image (any channel count) about its centre by `angleRad`
+* (positive = counter-clockwise) using bilinear interpolation — the same
+* resampling family as the face-alignment warp. When `expand` is true the
+* output canvas grows to contain the whole rotated rectangle (no corner
+* clipping); otherwise it keeps the source dimensions. Out-of-bounds samples
+* take the `fill` value (default 0), so an expanded canvas gets a flat border.
+*/
+function rotateRaw(src, angleRad, opts = {}) {
+	const { data, width: w, height: h, channels: ch } = src;
+	const expand = opts.expand ?? false;
+	const fill = opts.fill ?? 0;
+	const c = Math.cos(angleRad);
+	const s = Math.sin(angleRad);
+	let ow = w;
+	let oh = h;
+	if (expand) {
+		ow = Math.max(1, Math.ceil(Math.abs(w * c) + Math.abs(h * s)));
+		oh = Math.max(1, Math.ceil(Math.abs(w * s) + Math.abs(h * c)));
+	}
+	const cx = (w - 1) / 2;
+	const cy = (h - 1) / 2;
+	const ocx = (ow - 1) / 2;
+	const ocy = (oh - 1) / 2;
+	const out = new Uint8Array(ow * oh * ch);
+	const maxX = w - 1;
+	const maxY = h - 1;
+	for (let oy = 0; oy < oh; oy++) {
+		const dyo = oy - ocy;
+		for (let ox = 0; ox < ow; ox++) {
+			const dxo = ox - ocx;
+			const sx = c * dxo + s * dyo + cx;
+			const sy = -s * dxo + c * dyo + cy;
+			const o = (oy * ow + ox) * ch;
+			if (sx < 0 || sx > maxX || sy < 0 || sy > maxY) {
+				for (let k = 0; k < ch; k++) out[o + k] = fill;
+				continue;
+			}
+			const x0 = Math.floor(sx);
+			const y0 = Math.floor(sy);
+			const x1 = x0 < maxX ? x0 + 1 : x0;
+			const y1 = y0 < maxY ? y0 + 1 : y0;
+			const fx = sx - x0;
+			const fy = sy - y0;
+			const w00 = (1 - fx) * (1 - fy);
+			const w10 = fx * (1 - fy);
+			const w01 = (1 - fx) * fy;
+			const w11 = fx * fy;
+			const i00 = (y0 * w + x0) * ch;
+			const i10 = (y0 * w + x1) * ch;
+			const i01 = (y1 * w + x0) * ch;
+			const i11 = (y1 * w + x1) * ch;
+			for (let k = 0; k < ch; k++) out[o + k] = data[i00 + k] * w00 + data[i10 + k] * w10 + data[i01 + k] * w01 + data[i11 + k] * w11 + .5 | 0;
+		}
+	}
+	return {
+		data: out,
+		width: ow,
+		height: oh,
+		channels: ch
+	};
+}
+/**
+* Horizontal-projection-profile ENERGY of a single-channel map: `Σ_row rowSum²`.
+* Higher when the map's mass is concentrated in a few rows (aligned text) rather
+* than smeared across many (skewed text). Total mass is ~conserved by the
+* bilinear rotation, so this energy cleanly ranks candidate rotations.
+*/
+function projectionEnergy(gray) {
+	const { data, width, height } = gray;
+	let energy = 0;
+	for (let y = 0; y < height; y++) {
+		let rowSum = 0;
+		const base = y * width;
+		for (let x = 0; x < width; x++) rowSum += data[base + x];
+		energy += rowSum * rowSum;
+	}
+	return energy;
+}
+/** Area-average downscale of a gray map so its longest side ≤ `maxDim` (never upscales). */
+function downscaleGray(gray, maxDim) {
+	const { data, width, height } = gray;
+	const longest = Math.max(width, height);
+	if (longest <= maxDim) return gray;
+	const scale = maxDim / longest;
+	const nw = Math.max(1, Math.round(width * scale));
+	const nh = Math.max(1, Math.round(height * scale));
+	const out = new Uint8Array(nw * nh);
+	const fx = width / nw;
+	const fy = height / nh;
+	for (let y = 0; y < nh; y++) {
+		const sy0 = Math.floor(y * fy);
+		const sy1 = Math.min(height, Math.floor((y + 1) * fy));
+		for (let x = 0; x < nw; x++) {
+			const sx0 = Math.floor(x * fx);
+			const sx1 = Math.min(width, Math.floor((x + 1) * fx));
+			let sum = 0;
+			let n = 0;
+			for (let yy = sy0; yy < Math.max(sy0 + 1, sy1); yy++) {
+				const base = yy * width;
+				for (let xx = sx0; xx < Math.max(sx0 + 1, sx1); xx++) {
+					sum += data[base + xx];
+					n++;
+				}
+			}
+			out[y * nw + x] = n > 0 ? sum / n | 0 : 0;
+		}
+	}
+	return {
+		data: out,
+		width: nw,
+		height: nh
+	};
+}
+/** Score one correction angle: rotate the gradient map and take its profile energy. */
+function scoreAngle(gradient, angleRad) {
+	if (angleRad === 0) return projectionEnergy(gradient);
+	const rotated = rotateRaw({
+		data: gradient.data,
+		width: gradient.width,
+		height: gradient.height,
+		channels: 1
+	}, angleRad, {
+		expand: true,
+		fill: 0
+	});
+	return projectionEnergy({
+		data: rotated.data,
+		width: rotated.width,
+		height: rotated.height
+	});
+}
+/**
+* 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.
+*/
+function estimateSkewAngle(gray, opts = {}) {
+	const maxAngleDeg = opts.maxAngleDeg ?? 30;
+	const coarseStepDeg = opts.coarseStepDeg ?? 2;
+	const fineStepDeg = opts.fineStepDeg ?? .5;
+	const scoreMaxDim = opts.scoreMaxDim ?? 480;
+	if (gray.width < 4 || gray.height < 4) return {
+		angleDeg: 0,
+		score: 0
+	};
+	const gradient = sobelMagnitude(downscaleGray(gray, scoreMaxDim));
+	let bestAngle = 0;
+	let bestScore = scoreAngle(gradient, 0);
+	for (let deg = -maxAngleDeg; deg <= maxAngleDeg + 1e-9; deg += coarseStepDeg) {
+		if (deg === 0) continue;
+		const score = scoreAngle(gradient, deg * DEG2RAD);
+		if (score > bestScore) {
+			bestScore = score;
+			bestAngle = deg;
+		}
+	}
+	const lo = bestAngle - coarseStepDeg;
+	const hi = bestAngle + coarseStepDeg;
+	for (let deg = lo; deg <= hi + 1e-9; deg += fineStepDeg) {
+		if (deg < -maxAngleDeg || deg > maxAngleDeg) continue;
+		const score = scoreAngle(gradient, deg * DEG2RAD);
+		if (score > bestScore) {
+			bestScore = score;
+			bestAngle = deg;
+		}
+	}
+	return {
+		angleDeg: bestAngle,
+		score: bestScore
+	};
+}
+/**
+* Rectify an oblique plate crop: decode the JPEG, estimate the baseline skew,
+* and — only when it exceeds {@link MIN_RECTIFY_ANGLE_DEG} — rotate the
+* full-resolution RGB tile to level the text and re-encode. Returns `null` when
+* no meaningful rotation is needed (caller keeps the original tile) or on any
+* decode/degenerate failure (never worse than the un-rectified input).
+*
+* The returned `angleDeg` is the applied correction (0 is never returned with a
+* jpeg — a null means "unchanged").
+*/
+async function rectifyPlateJpeg(jpeg, opts = {}) {
+	const raw = await (0, sharp.default)(jpeg).removeAlpha().raw().toBuffer({ resolveWithObject: true }).catch(() => null);
+	if (!raw) return null;
+	const { data, info } = raw;
+	if (info.width < 4 || info.height < 4) return null;
+	const rgb = {
+		data: new Uint8Array(data.buffer, data.byteOffset, data.byteLength),
+		width: info.width,
+		height: info.height,
+		channels: info.channels
+	};
+	const gray = toGrayscale(rgb);
+	const { angleDeg } = estimateSkewAngle(gray, opts);
+	if (Math.abs(angleDeg) < 2) return null;
+	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, {
+		expand: true,
+		fill
+	});
+	try {
+		return {
+			jpeg: await (0, sharp.default)(Buffer.from(rotated.data), { raw: {
+				width: rotated.width,
+				height: rotated.height,
+				channels: rotated.channels
+			} }).jpeg({ quality: opts.quality ?? 90 }).toBuffer(),
+			width: rotated.width,
+			height: rotated.height,
+			angleDeg
+		};
+	} catch {
+		return null;
+	}
+}
+//#endregion
 //#region src/detection-pipeline/pipeline/result-assembler.ts
 /**
 * Small deterministic id generator scoped to a single frame. Each call
@@ -2665,7 +3074,7 @@ function applyChildOutput(parent, childStep, output, stepLatencyMs, ctx) {
 			});
 			break;
 		case "text":
-			parent.ownLabels.push({
+			if (output.text.trim().length > 0) parent.ownLabels.push({
 				label: output.text,
 				score: output.confidence
 			});
@@ -2748,7 +3157,8 @@ function buildFrameResult(input) {
 				embedding,
 				...embeddingModelId !== void 0 ? { embeddingModelId } : {}
 			} : {},
-			...m.faceAlignedCrop !== void 0 ? { faceAlignedCrop: m.faceAlignedCrop } : {}
+			...m.faceAlignedCrop !== void 0 ? { faceAlignedCrop: m.faceAlignedCrop } : {},
+			...m.nativeFaceShortSidePx !== void 0 ? { nativeFaceShortSidePx: m.nativeFaceShortSidePx } : {}
 		};
 		if (input.debug) {
 			const cleanDebug = pruneUndefined({
@@ -3051,7 +3461,7 @@ var PipelineExecutor = class {
 	*
 	* @returns FrameResult + optional trace
 	*/
-	async run(tree, rootInput, fullFrameJpegProvider, imageWidth, imageHeight, deviceId, runOpts, nativeFaceCropProvider, cropZoneBbox) {
+	async run(tree, rootInput, fullFrameJpegProvider, imageWidth, imageHeight, deviceId, runOpts, nativeCropProvider, cropZoneBbox) {
 		const startMs = Date.now();
 		const verbosity = runOpts?.traceVerbosity ?? "off";
 		const traceBuilder = new ExecutionTraceBuilder(verbosity, deviceId, imageWidth, imageHeight, this.opts.engineRuntime);
@@ -3081,7 +3491,7 @@ var PipelineExecutor = class {
 					const mutable = this.synthesizeRootDetection(rootOutput, rootStep, idGen, rootMs, imageWidth, imageHeight);
 					applyChildOutput(mutable, rootStep, rootOutput, rootMs, ctx);
 					try {
-						await this.executeChildren(rootStep.children, mutable, fullFrameJpegProvider, imageWidth, imageHeight, traceBuilder, stepTimings, ctx, poolAgg, runOpts?.plane, deviceId, nativeFaceCropProvider);
+						await this.executeChildren(rootStep.children, mutable, fullFrameJpegProvider, imageWidth, imageHeight, traceBuilder, stepTimings, ctx, poolAgg, runOpts?.plane, deviceId, nativeCropProvider);
 					} catch (err) {
 						this.opts.logger?.warn("Pipeline child execution failed — keeping parent detection", {
 							tags: { deviceId },
@@ -3111,7 +3521,7 @@ var PipelineExecutor = class {
 					continue;
 				}
 				try {
-					await this.executeChildren(rootStep.children, mutable, fullFrameJpegProvider, imageWidth, imageHeight, traceBuilder, stepTimings, ctx, poolAgg, runOpts?.plane, deviceId, nativeFaceCropProvider);
+					await this.executeChildren(rootStep.children, mutable, fullFrameJpegProvider, imageWidth, imageHeight, traceBuilder, stepTimings, ctx, poolAgg, runOpts?.plane, deviceId, nativeCropProvider);
 				} catch (err) {
 					this.opts.logger?.warn("Pipeline child execution failed — keeping parent detection", {
 						tags: { deviceId },
@@ -3269,7 +3679,7 @@ var PipelineExecutor = class {
 		});
 		return output;
 	}
-	async executeChildren(children, parentDetection, fullFrameJpegProvider, imageWidth, imageHeight, traceBuilder, stepTimings, ctx, poolAgg, plane, deviceId, nativeFaceCropProvider) {
+	async executeChildren(children, parentDetection, fullFrameJpegProvider, imageWidth, imageHeight, traceBuilder, stepTimings, ctx, poolAgg, plane, deviceId, nativeCropProvider) {
 		for (const child of children) {
 			if (plane === "frame" && child.definition.inputClasses !== null) continue;
 			if (!this.matchesInputClasses(parentDetection.macroClass, child.inputClasses)) continue;
@@ -3292,7 +3702,7 @@ var PipelineExecutor = class {
 					}
 					const lms = parentDetection.landmarks;
 					if (lms && lms.length >= 5) {
-						if (!nativeFaceCropProvider && detShortSide < minFaceSize) {
+						if (!nativeCropProvider && detShortSide < minFaceSize) {
 							this.warnFaceTooSmall(child, detShortSide, minFaceSize, void 0, deviceId);
 							continue;
 						}
@@ -3303,8 +3713,8 @@ var PipelineExecutor = class {
 							imageWidth,
 							imageHeight,
 							outSize: modelEntry.inputSize.width,
-							...nativeFaceCropProvider ? {
-								nativeCropProvider: nativeFaceCropProvider,
+							...nativeCropProvider ? {
+								nativeCropProvider,
 								nativeMaxWidth: NATIVE_FACE_CROP_MAX_WIDTH
 							} : {}
 						});
@@ -3317,6 +3727,7 @@ var PipelineExecutor = class {
 						cropW = aligned.width;
 						cropH = aligned.height;
 						parentDetection.faceAlignedCrop = cropJpegBuf.toString("base64");
+						if (aligned.nativeFaceShortSidePx !== void 0) parentDetection.nativeFaceShortSidePx = aligned.nativeFaceShortSidePx;
 					} else {
 						if (detShortSide < minFaceSize) {
 							this.warnFaceTooSmall(child, detShortSide, minFaceSize, void 0, deviceId);
@@ -3328,10 +3739,31 @@ var PipelineExecutor = class {
 						cropH = crop.height;
 					}
 				} else {
-					const crop = await cropJpeg(fullFrameJpeg, parentDetection.bbox, imageWidth, imageHeight);
-					cropJpegBuf = crop.jpeg;
-					cropW = crop.width;
-					cropH = crop.height;
+					const nativeChild = nativeCropProvider && child.children.length === 0 ? await nativeChildCrop(nativeCropProvider, parentDetection.bbox, imageWidth, imageHeight, NATIVE_CHILD_CROP_MAX_WIDTH) : null;
+					if (nativeChild) {
+						cropJpegBuf = nativeChild.jpeg;
+						cropW = nativeChild.width;
+						cropH = nativeChild.height;
+					} else {
+						const crop = await cropJpeg(fullFrameJpeg, parentDetection.bbox, imageWidth, imageHeight);
+						cropJpegBuf = crop.jpeg;
+						cropW = crop.width;
+						cropH = crop.height;
+					}
+					if (child.definition.postprocessor === "ctc" && child.settings?.["rectify"] !== false) try {
+						const rectified = await rectifyPlateJpeg(cropJpegBuf);
+						if (rectified) {
+							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
+							} });
+						}
+					} catch {}
 				}
 				const childOutput = await this.executeStep(child, {
 					kind: "jpeg",
@@ -3351,7 +3783,7 @@ var PipelineExecutor = class {
 								y: l.y + py1
 							}));
 						}
-						await this.executeChildren(child.children, detail, fullFrameJpegProvider, imageWidth, imageHeight, traceBuilder, stepTimings, ctx, poolAgg, plane, deviceId, nativeFaceCropProvider);
+						await this.executeChildren(child.children, detail, fullFrameJpegProvider, imageWidth, imageHeight, traceBuilder, stepTimings, ctx, poolAgg, plane, deviceId, nativeCropProvider);
 					}
 				}
 			} catch (err) {
@@ -4459,13 +4891,13 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	}
 	async getSchema(engine) {
 		if (!engine || !engine.runtime) engine = await this.getSelectedEngine();
-		const format = engine.format;
 		const customByStep = await this.getCustomModels();
-		const slots = buildSchemaSlots(format, this.modelsDir, customByStep);
 		const { hardware } = await this.fetchProbeGatingData();
 		const env = runtimeEnvFromProcess(toProbedHardware(hardware));
+		const enginesWithDevices = this.getAvailableEnginesWithDevices(env);
+		const slots = buildSchemaSlots(new Set([engine.format, ...enginesWithDevices.map((e) => e.engine.format)]), this.modelsDir, customByStep);
 		return {
-			availableEngines: this.getAvailableEnginesWithDevices(env).map((e) => this.toAvailableEngine(e)),
+			availableEngines: enginesWithDevices.map((e) => this.toAvailableEngine(e)),
 			selectedEngine: { ...engine },
 			slots
 		};
@@ -4904,6 +5336,42 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 			}
 		};
 	}
+	/**
+	* Build the native-crop provider for the DETAIL plane (`nativeCropRef` set by
+	* `runDetailSubtree` when the parent crop came from the frame's native surface).
+	* Same best-effort round-trip as {@link buildNativeFaceCropProvider}, but the
+	* executor's ROI arrives normalized in the PARENT CROP's space, so it is first
+	* re-composed into FRAME-normalized coordinates (via `cropFrameSpace`) before
+	* hitting the native surface. This is what lets a leaf child (plate-ocr,
+	* face-embedding) read native pixels even though the executor is running on a
+	* cut of the frame, not the whole frame. A compose/native miss → `null` (the
+	* executor falls back to the downscaled tile crop).
+	*/
+	buildNativeCropProviderFromRef(ref) {
+		if (!ref) return void 0;
+		const api = this.addonCtx?.api;
+		if (!api) return void 0;
+		const { handle, cropFrameSpace } = ref;
+		return async (roi, maxWidth) => {
+			try {
+				const frameRoi = composeCropRoiToFrameNorm(roi, cropFrameSpace, handle.width, handle.height);
+				if (!frameRoi) return null;
+				const native = await api.pipelineRunner.getNativeCrop.query({
+					handle,
+					bbox: frameRoi,
+					...maxWidth !== void 0 ? { maxWidth } : {}
+				}, require_dist.nodePin(handle.nodeId));
+				if (!native || !native.bytes || native.width <= 0 || native.height <= 0) return null;
+				return {
+					bytes: native.bytes,
+					width: native.width,
+					height: native.height
+				};
+			} catch {
+				return null;
+			}
+		};
+	}
 	async runPipeline(input, onProgress) {
 		const nodeId = this.addonCtx?.kernel?.localNodeId ?? "hub";
 		const sessionId = input.sessionId ?? `run-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
@@ -4962,8 +5430,8 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 				jpegProvider = async () => data;
 			} else if (frame.format === "rgb" || frame.format === "bgr" || frame.format === "gray") {
 				const channels = frame.format === "gray" ? 1 : 3;
-				const sharp$3 = (await import("sharp")).default;
-				const jpeg = await sharp$3(data, { raw: {
+				const sharp$5 = (await import("sharp")).default;
+				const jpeg = await sharp$5(data, { raw: {
 					width: frame.width,
 					height: frame.height,
 					channels
@@ -4977,8 +5445,8 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 				};
 				jpegProvider = async () => jpeg;
 			} else {
-				const sharp$4 = (await import("sharp")).default;
-				const encoded = await sharp$4(data, { raw: {
+				const sharp$6 = (await import("sharp")).default;
+				const encoded = await sharp$6(data, { raw: {
 					width: frame.width,
 					height: frame.height,
 					channels: 3
@@ -5162,7 +5630,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 			const effectiveDeviceId = input.deviceId ?? 0;
 			const deviceOverrides = effectiveDeviceId > 0 ? await this.readDeviceStore(effectiveDeviceId) : {};
 			const effectiveTree = Object.keys(deviceOverrides).length > 0 ? applyDeviceOverridesToTree(tree, "object-detection", deviceOverrides) : tree;
-			const nativeFaceCropProvider = this.buildNativeFaceCropProvider(input.frameHandle);
+			const nativeCropProvider = this.buildNativeCropProviderFromRef(input.nativeCropRef) ?? this.buildNativeFaceCropProvider(input.frameHandle);
 			let cropZoneBbox;
 			if (isRuntime && effectiveDeviceId > 0 && effectiveTree.roots.some((r) => r.definition.extractMode === "crop-zone")) {
 				await this.ensureDeviceProxy(effectiveDeviceId);
@@ -5172,7 +5640,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 			const { result, trace } = await executor.run(effectiveTree, rootInput, jpegProvider, imageWidth, imageHeight, effectiveDeviceId, {
 				traceVerbosity: isRuntime ? this.eventBus ? "summary" : "off" : "full",
 				plane: input.plane
-			}, nativeFaceCropProvider, cropZoneBbox);
+			}, nativeCropProvider, cropZoneBbox);
 			if (isRuntime) {
 				if (trace && this.eventBus) this.eventBus.emit(require_dist.createEvent(require_dist.EventCategory.PipelineTrace, {
 					type: "device",
@@ -5462,8 +5930,8 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	/** Parse JPEG/PNG dimensions without decoding the full image */
 	async getJpegDimensions(buf) {
 		try {
-			const sharp$5 = (await import("sharp")).default;
-			const { width, height } = await sharp$5(buf).metadata();
+			const sharp$7 = (await import("sharp")).default;
+			const { width, height } = await sharp$7(buf).metadata();
 			return {
 				width: width ?? 640,
 				height: height ?? 640
@@ -6233,11 +6701,12 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 		}
 	}
 };
-function buildSchemaSlots(format, modelsDir, customByStep) {
+function buildSchemaSlots(formats, modelsDir, customByStep) {
 	const slotMap = /* @__PURE__ */ new Map();
+	const formatList = [...formats];
 	for (const pipelineStep of require_step_definitions.ALL_PIPELINE_STEPS) {
 		const step = pipelineStep.definition;
-		const availableModels = mergeCustomModels(step.models, customByStep?.get(step.id) ?? []).filter((m) => m.formats[format] && m.legacy !== true);
+		const availableModels = mergeCustomModels(step.models, customByStep?.get(step.id) ?? []).filter((m) => m.legacy !== true && formatList.some((f) => m.formats[f]));
 		if (availableModels.length === 0) continue;
 		const slot = step.slot;
 		if (!slotMap.has(slot)) slotMap.set(slot, []);