@camstack/addon-pipeline 1.2.29 → 1.2.36

package/dist/detection-pipeline/index.mjs

@@ -1,13 +1,13 @@
 import { n as __require } from "../chunk-DnnnRqeS.mjs";
-import { B as errMsg, E as evaluateZoneRules, F as runtimeDevices$1, G as createEvent, K as hydrateSchema, R as supportedRuntimes$1, T as enumerateInferenceDevices, V as BaseAddon, X as nodePin, Z as parseJsonUnknown, ct as object, dt as union, et as sleep, ft as EventCategory, h as YAMNET_TO_MACRO, j as pipelineExecutorCapability, nt as array, s as DEVICE_BACKEND_TO_FORMAT, t as APPLE_SA_TO_MACRO, ut as string, w as detectionPipelineCapability, x as defaultDeviceFor$1 } from "../dist-CsKaXmP8.mjs";
-import { a as getStepDefinition, i as getStep, n as ALL_STEPS, o as resolveModelForFormat, r as getDefaultModelForFormat, t as ALL_PIPELINE_STEPS } from "../step-definitions-1GIwU6R8.mjs";
+import { B as errMsg, E as evaluateZoneRules, F as runtimeDevices$1, G as createEvent, K as hydrateSchema, R as supportedRuntimes$1, T as enumerateInferenceDevices, V as BaseAddon, X as nodePin, Z as parseJsonUnknown, ct as object, dt as union, et as sleep, ft as EventCategory, h as YAMNET_TO_MACRO, j as pipelineExecutorCapability, nt as array, s as DEVICE_BACKEND_TO_FORMAT, t as APPLE_SA_TO_MACRO, ut as string, w as detectionPipelineCapability, x as defaultDeviceFor$1 } from "../dist-Du7_SNiR.mjs";
+import { a as getStep, i as getDefaultModelForFormatFromDef, n as ALL_STEPS, o as getStepDefinition, r as getDefaultModelForFormat, s as resolveModelForFormat, t as ALL_PIPELINE_STEPS } from "../step-definitions-C8tk9fPJ.mjs";
 import { t as pickNodePlatformArch } from "../node-topology-platform-BkR_k6WT.mjs";
 import { a as ensureModel, o as isModelDownloaded, r as deleteModelFromDisk } from "../model-download-service-Cp9f4dk6-CwUb5v3Y.mjs";
+import * as os from "node:os";
 import { spawn } from "node:child_process";
 import sharp from "sharp";
 import * as fs from "node:fs";
 import * as path$1 from "node:path";
-import * as os from "node:os";
 //#region src/detection-pipeline/runtimes.ts
 var KNOWN_PLATFORMS = [
 	"darwin",
@@ -73,14 +73,28 @@ function probedToHardwareInfo(hw) {
 		coral: coralInfoFrom(hw)
 	};
 }
+/**
+* THE per-runtime pool provisioning registry — the single source for every
+* pool's concurrency / worker count / batch tuning, keyed by the runtime THAT
+* POOL runs. `engine-factory` used to carry a second, parallel copy of these
+* defaults; it no longer does.
+*
+* `windowMs` / `maxBatchSize` are inert unless `batchMode !== 'none'`, and
+* `numStreams` / `intraOpThreads` are inert at 0 (the runtime picks) — they are
+* still spelled out per row so a reader never has to guess which default a
+* missing key would have hit.
+*/
 var RUNTIME_DETAIL = {
 	onnx: {
 		label: "ONNX Runtime",
 		pythonRequirements: ["requirements.txt", "requirements-onnxruntime.txt"],
 		tuning: {
 			concurrency: 4,
+			numWorkers: 1,
 			batchMode: "list",
+			windowMs: 2,
 			maxBatchSize: 8,
+			numStreams: 0,
 			intraOpThreads: 0
 		}
 	},
@@ -89,8 +103,12 @@ var RUNTIME_DETAIL = {
 		pythonRequirements: ["requirements.txt", "requirements-openvino.txt"],
 		tuning: {
 			concurrency: 1,
+			numWorkers: 1,
 			batchMode: "none",
-			numStreams: 0
+			windowMs: 2,
+			maxBatchSize: 8,
+			numStreams: 0,
+			intraOpThreads: 0
 		}
 	},
 	coreml: {
@@ -98,10 +116,12 @@ var RUNTIME_DETAIL = {
 		pythonRequirements: ["requirements.txt", "requirements-coreml.txt"],
 		tuning: {
 			concurrency: 1,
+			numWorkers: 1,
 			batchMode: "none",
 			windowMs: 8,
 			maxBatchSize: 8,
-			numWorkers: 1
+			numStreams: 0,
+			intraOpThreads: 0
 		}
 	},
 	edgetpu: {
@@ -109,8 +129,12 @@ var RUNTIME_DETAIL = {
 		pythonRequirements: ["requirements.txt", "requirements-edgetpu.txt"],
 		tuning: {
 			concurrency: 1,
+			numWorkers: 1,
 			batchMode: "none",
-			numWorkers: 1
+			windowMs: 2,
+			maxBatchSize: 8,
+			numStreams: 0,
+			intraOpThreads: 0
 		}
 	}
 };
@@ -153,6 +177,12 @@ function modelFormatFor(id) {
 function pythonRequirementsFor(id) {
 	return RUNTIME_DETAIL[id].pythonRequirements;
 }
+/**
+* The pool provisioning for ONE runtime. Callers must pass the runtime of the
+* pool they are provisioning — never the node's default runtime. See
+* `engine/pool-provisioning.ts` for the resolver that layers an operator
+* override on top of this.
+*/
 function tuningFor(id) {
 	return RUNTIME_DETAIL[id].tuning;
 }
@@ -213,43 +243,6 @@ 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";
@@ -300,10 +293,12 @@ function classifyAccelerator(backend, device) {
 *
 * Guarantees:
 *   - never throws (hot default-tree path);
-*   - never returns a model id that is not in the object-detection catalog
-*     with a build for `format` — an unmapped backend, a `'cpu'` class, a
-*     mapped id missing from the catalog, or a mapped id without a `format`
-*     build all fall back to the step's own `defaultModelId` (`yolo26n`).
+*   - never returns a model id without a build for `format` (unless the step
+*     has ZERO builds for `format`, which is unloadable regardless of pick and
+*     flagged by `collectZeroBuildIssues`) — an unmapped backend, a `'cpu'`
+*     class, a mapped id missing from the catalog, or a mapped id without a
+*     `format` build all fall back to the step's PER-FORMAT default
+*     (`getDefaultModelForFormatFromDef`), NOT the bare `defaultModelId`.
 *
 * `getStepDef` is injectable (defaults to the real catalog lookup) so the
 * missing-build fallback branch is unit-testable without a live catalog —
@@ -316,12 +311,12 @@ function resolveDefaultDetectionModel(backend, device, format, getStepDef = getS
 	} catch {
 		return "yolo26n";
 	}
-	const fallback = def.defaultModelId;
 	const candidate = MODEL_BY_CLASS[classifyAccelerator(backend, device)];
-	if (candidate === null) return fallback;
-	const entry = def.models.find((m) => m.id === candidate);
-	if (!entry || entry.formats[format] === void 0) return fallback;
-	return candidate;
+	if (candidate !== null) {
+		const entry = def.models.find((m) => m.id === candidate);
+		if (entry && entry.formats[format] !== void 0) return candidate;
+	}
+	return getDefaultModelForFormatFromDef(def, format);
 }
 //#endregion
 //#region src/detection-pipeline/engine/shared-inference-pool.ts
@@ -371,6 +366,62 @@ var RAW_FMT_CODE = {
 * large frame) never trips; override via env for constrained hardware.
 */
 var POOL_INFER_TIMEOUT_MS = Math.max(1e3, Number(process.env["CAMSTACK_POOL_INFER_TIMEOUT_MS"]) || 6e4);
+/**
+* Max inference requests outstanding to ONE worker before new ones are SHED.
+*
+* Without this the camera dies permanently the first time the worker gets
+* slow, and it did: device 615 produced nothing for 52 minutes on 2026-07-31.
+* The worker was neither dead nor deadlocked — it was replying at full rate,
+* about a minute behind, and every reply landed after {@link
+* POOL_INFER_TIMEOUT_MS} had already abandoned its request. The proof is in the
+* logs: a steady drip of `Response for unknown request id`, request ids
+* climbing ~13/s, for as long as the outage lasted.
+*
+* That state is self-sustaining and cannot drain, because frames keep arriving
+* while every one of them is written straight to the pipe. `dispatch` had NO
+* bound: a transient slowdown (inference went 40ms → 2500ms across several
+* cameras at 16:19 that day) buys a backlog that is never paid off, and once
+* the backlog exceeds the deadline the loss is total.
+*
+* The queue is therefore capped in TIME, not just in count: at the normal ~40ms
+* per inference this is ~0.3s of work, and even at a 20× slowdown it stays well
+* inside the 60s deadline — so a worker that falls behind sheds, catches up,
+* and recovers on its own. Python already sheds under its own per-model bound
+* and answers `{dropped: true}`; this is the same contract applied one layer
+* earlier, where the unbounded queue actually is.
+*/
+var POOL_MAX_IN_FLIGHT = Math.max(1, Number(process.env["CAMSTACK_POOL_MAX_IN_FLIGHT"]) || 8);
+/**
+* Reply deadline for a LIVE inference request (ms), as opposed to the generous
+* {@link POOL_INFER_TIMEOUT_MS} that model loads and commands keep.
+*
+* 60 seconds was never a deadline for live detection — it is three orders of
+* magnitude past the point where the answer is worth having. Frames arrive at
+* ~13/s; a detection that lands 60s late describes a scene that no longer
+* exists, and the only thing the wait accomplished was holding a queue slot
+* while the backlog grew. Operator directive 2026-07-31: "a few seconds are
+* already too many for this scenario".
+*
+* Three seconds is deliberately still loose — normal inference on this fleet is
+* 35-47ms, so this trips only at a ~70× slowdown — but it bounds the damage at
+* seconds instead of a minute, and combined with {@link POOL_MAX_IN_FLIGHT} it
+* makes the backlog mathematically unable to outrun the deadline: the queue can
+* never hold more than `cap × deadline` of work.
+*
+* Commands and model loads keep the long timeout on purpose: a cold model load
+* legitimately takes tens of seconds, and shedding or timing one out
+* desynchronizes the worker's model slots.
+*/
+var POOL_LIVE_INFER_TIMEOUT_MS = Math.max(250, Number(process.env["CAMSTACK_POOL_LIVE_INFER_TIMEOUT_MS"]) || 3e3);
+/** Opcodes the in-flight cap may shed. Commands and frame-cache writes are
+*  NEVER shed: a dropped command silently desynchronizes model state, and a
+*  dropped `cacheFrame` strands the `inferCached` that follows it. */
+var SHEDDABLE_MSG_TYPES = new Set([
+	MSG_INFER_JPEG,
+	MSG_INFER_RAW,
+	MSG_INFER_BATCH,
+	MSG_INFER_CACHED
+]);
 var PoolHandle = class {
 	pool;
 	modelIndex;
@@ -382,10 +433,7 @@ var PoolHandle = class {
 	}
 	async infer(input) {
 		const start = performance.now();
-		return {
-			structured: input.kind === "raw" ? await this.pool.inferRaw(this.modelIndex, input.data, input.width, input.height, input.format) : await this.pool.infer(this.modelIndex, input.data),
-			inferenceMs: performance.now() - start
-		};
+		return poolResultToEngineOutput(input.kind === "raw" ? await this.pool.inferRaw(this.modelIndex, input.data, input.width, input.height, input.format) : await this.pool.infer(this.modelIndex, input.data), performance.now() - start);
 	}
 	/**
 	* Inference on a frame previously cached in the Python pool via
@@ -394,20 +442,50 @@ var PoolHandle = class {
 	*/
 	async inferFromCache(frameId) {
 		const start = performance.now();
-		return {
-			structured: await this.pool.inferCached(this.modelIndex, frameId),
-			inferenceMs: performance.now() - start
-		};
+		return poolResultToEngineOutput(await this.pool.inferCached(this.modelIndex, frameId), performance.now() - start);
 	}
 	async dispose() {}
 };
 /**
+* Map a raw pool response record to an {@link EngineOutput}.
+*
+* An overload shed (`{dropped: true}` — from the Python pool's per-model bound
+* OR the TS worker in-flight cap, which deliberately mirrors it) becomes a
+* first-class `EngineOutput.dropped` with NO `structured` payload. Before this
+* mapping the shed record rode through as `structured`, failed the StepOutput
+* kind guard in the postprocess funnel, and every deliberate shed was logged
+* as `runInference failed … unexpected kind: undefined` at error level on
+* every node (~4/s cluster-wide, 2026-08-01). A shed is flow control, not a
+* fault — it must never reach a postprocessor. Exported for tests.
+*/
+function poolResultToEngineOutput(result, inferenceMs) {
+	if (result["dropped"] === true) {
+		const shedReason = result["shedReason"];
+		return {
+			dropped: true,
+			...typeof shedReason === "string" ? { shedReason } : {},
+			inferenceMs
+		};
+	}
+	return {
+		structured: result,
+		inferenceMs
+	};
+}
+/**
 * How long to wait for a worker to exit on SIGTERM before escalating to
 * SIGKILL. A worker idle between frames exits well under this; only a worker
 * stuck in a native inference call (openvino/onnx C++) needs the escalation.
 */
 var POOL_WORKER_TERM_GRACE_MS = 2e3;
 /**
+* Sampling stride for the "Python pool shed frame under overload" debug
+* line — see `trackDroppedResponse`. At the observed chronic-overload rate
+* (~13 shed/s, 2026-08-01) a stride of 500 yields roughly one line every
+* 40 s while `droppedTotal` in the line keeps the exact count.
+*/
+var SHED_LOG_SAMPLE_EVERY = 500;
+/**
 * Terminate a spawned child GRACEFULLY THEN FORCEFULLY: end stdin, send
 * SIGTERM, and if the process hasn't exited within `graceMs`, send SIGKILL.
 * Resolves once the process has exited (or was already dead).
@@ -450,6 +528,13 @@ var PoolWorker = class {
 	process = null;
 	receiveBuffer = Buffer.alloc(0);
 	pending = /* @__PURE__ */ new Map();
+	/** True while the in-flight cap is shedding — so the warning fires on the
+	*  EDGE rather than once per dropped frame. */
+	shedding = false;
+	/** Inference requests shed by the in-flight cap, for this worker's lifetime.
+	*  Surfaced so "the camera is quiet" and "the camera is saturated" can be
+	*  told apart without reading the logs. */
+	shedCount = 0;
 	nextRequestId = 1;
 	ready = false;
 	log;
@@ -461,6 +546,15 @@ var PoolWorker = class {
 	getPid() {
 		return this.process?.pid ?? null;
 	}
+	/** Requests written and not yet answered. This is the BACKLOG — the number
+	*  nothing measured while a camera sat at zero frames for 52 minutes. */
+	getInFlight() {
+		return this.pending.size;
+	}
+	/** Inference shed by the in-flight cap over this worker's lifetime. */
+	getShedCount() {
+		return this.shedCount;
+	}
 	isReady() {
 		return this.ready;
 	}
@@ -609,10 +703,51 @@ var PoolWorker = class {
 		this.ready = false;
 		await terminateChild(proc, POOL_WORKER_TERM_GRACE_MS);
 	}
+	/**
+	* Shed an inference request when the worker already has {@link
+	* POOL_MAX_IN_FLIGHT} outstanding — the backlog is what turns a slow worker
+	* into a dead camera. Returns the shed response, or `null` to proceed.
+	*
+	* A shed is LOUD the first time and then rate-limited: at frame rate this
+	* fires ~13×/s, so logging every one would bury the signal it is meant to
+	* raise — but logging none is how a camera went dark for 52 minutes looking
+	* like a quiet afternoon.
+	*/
+	shedIfSaturated(msgType) {
+		if (!SHEDDABLE_MSG_TYPES.has(msgType)) return null;
+		if (this.pending.size < POOL_MAX_IN_FLIGHT) {
+			this.shedding = false;
+			return null;
+		}
+		if (!this.shedding) {
+			this.shedding = true;
+			this.log.warn("worker saturated — shedding inference until it catches up", { meta: {
+				worker: this.opts.workerLabel,
+				pid: this.getPid(),
+				runtime: this.opts.poolRuntime,
+				device: this.opts.device ?? "default",
+				inFlight: this.pending.size,
+				cap: POOL_MAX_IN_FLIGHT,
+				deadlineMs: POOL_LIVE_INFER_TIMEOUT_MS
+			} });
+		}
+		this.shedCount++;
+		return {
+			dropped: true,
+			shedReason: "worker-in-flight-cap"
+		};
+	}
+	/** Live inference gets seconds; commands and model loads keep the long
+	*  timeout — see {@link POOL_LIVE_INFER_TIMEOUT_MS}. */
+	deadlineFor(msgType) {
+		return SHEDDABLE_MSG_TYPES.has(msgType) ? POOL_LIVE_INFER_TIMEOUT_MS : POOL_INFER_TIMEOUT_MS;
+	}
 	dispatch(msgType, payload) {
+		const shed = this.shedIfSaturated(msgType);
+		if (shed) return Promise.resolve(shed);
 		const reqId = this.allocRequestId();
 		return new Promise((resolve, reject) => {
-			const timer = this.armRequestTimeout(reqId, reject);
+			const timer = this.armRequestTimeout(reqId, reject, this.deadlineFor(msgType));
 			this.pending.set(reqId, {
 				resolve,
 				reject,
@@ -632,24 +767,30 @@ var PoolWorker = class {
 	* `POOL_INFER_TIMEOUT_MS`. `unref` so it never keeps the event loop alive.
 	* The normal response + `rejectAll` paths clear it via `PendingRequest.timer`.
 	*/
-	armRequestTimeout(reqId, reject) {
+	armRequestTimeout(reqId, reject, timeoutMs) {
 		const timer = setTimeout(() => {
 			if (this.pending.delete(reqId)) {
 				this.log.error("inference request timed out", { meta: {
 					worker: this.opts.workerLabel,
+					pid: this.getPid(),
+					runtime: this.opts.poolRuntime,
+					device: this.opts.device ?? "default",
+					inFlight: this.pending.size,
 					reqId,
 					timeoutMs: POOL_INFER_TIMEOUT_MS
 				} });
-				reject(/* @__PURE__ */ new Error(`PoolWorker[${this.opts.workerLabel}]: inference request ${reqId} timed out after ${POOL_INFER_TIMEOUT_MS}ms (worker alive, no reply)`));
+				reject(/* @__PURE__ */ new Error(`PoolWorker[${this.opts.workerLabel}]: inference request ${reqId} timed out after ${timeoutMs}ms (worker alive, no reply)`));
 			}
-		}, POOL_INFER_TIMEOUT_MS);
+		}, timeoutMs);
 		timer.unref?.();
 		return timer;
 	}
 	dispatchMulti(msgType, payloadLen, parts) {
+		const shed = this.shedIfSaturated(msgType);
+		if (shed) return Promise.resolve(shed);
 		const reqId = this.allocRequestId();
 		return new Promise((resolve, reject) => {
-			const timer = this.armRequestTimeout(reqId, reject);
+			const timer = this.armRequestTimeout(reqId, reject, this.deadlineFor(msgType));
 			this.pending.set(reqId, {
 				resolve,
 				reject,
@@ -755,6 +896,22 @@ var SharedInferencePool = class {
 	}
 	device;
 	/** Pid of the first worker (for legacy callers). Use `getPids()` for all. */
+	/** Summed backlog and shed count across the pool's workers. A rising
+	*  `inFlight` with a rising `shed` is a worker falling behind; a rising
+	*  `inFlight` with zero `shed` and no results is the state that used to be
+	*  invisible. */
+	getBacklog() {
+		let inFlight = 0;
+		let shed = 0;
+		for (const w of this.workers) {
+			inFlight += w.getInFlight();
+			shed += w.getShedCount();
+		}
+		return {
+			inFlight,
+			shed
+		};
+	}
 	getPid() {
 		return this.workers[0]?.getPid() ?? null;
 	}
@@ -788,6 +945,7 @@ var SharedInferencePool = class {
 			loadedCount,
 			startupMs,
 			runtime: this.poolRuntime,
+			device: this.device ?? "default",
 			workers: this.numWorkers,
 			pythonWorkers: innerWorkers,
 			pids: this.getPids()
@@ -879,20 +1037,35 @@ var SharedInferencePool = class {
 	async dispose() {
 		await Promise.all(this.workers.map((w) => w.dispose()));
 		this.workers.length = 0;
-		this.log.info("Pool process(es) terminated");
+		this.log.info("Pool process(es) terminated", { meta: {
+			runtime: this.poolRuntime,
+			device: this.device ?? "default"
+		} });
 	}
 	/**
 	* Recognise a Python overload-shed response (`"dropped": true`) on the
 	* single-frame inference paths. Previously indistinguishable from a
 	* genuine empty detection result — now counted + debug-logged so
 	* overload is measurable. The response passes through unchanged.
+	*
+	* SAMPLED log: one line per shed frame turned into 45 741 rows/hour on
+	* the hub during the 2026-08-01 chronic overload (~13 shed/s) — 2/3 of
+	* the hub's entire log volume, burying every other signal. The counter
+	* keeps exact totals (`droppedTotal` is authoritative, surfaced in
+	* `getStatus` consumers via `getDroppedResponseCount`); the log line
+	* now fires on the FIRST shed and every `SHED_LOG_SAMPLE_EVERY`th,
+	* carrying the running total so nothing is lost — only repeated.
 	*/
 	trackDroppedResponse(result, modelIndex) {
 		if (result["dropped"] === true) {
 			this.droppedResponseCount++;
-			this.log.debug("Python pool shed frame under overload", { meta: {
+			const total = this.droppedResponseCount;
+			if (total === 1 || total % SHED_LOG_SAMPLE_EVERY === 0) this.log.debug("Python pool shed frame under overload", { meta: {
 				modelIndex,
-				droppedTotal: this.droppedResponseCount
+				droppedTotal: total,
+				sampledEvery: SHED_LOG_SAMPLE_EVERY,
+				runtime: this.poolRuntime,
+				device: this.device ?? "default"
 			} });
 		}
 		return result;
@@ -967,6 +1140,66 @@ function flattenEnabledVideoSteps(steps) {
 	walk(steps);
 	return result;
 }
+/**
+* The steps that EXECUTE in a `plane: 'frame'` dispatch (two-plane design),
+* mirroring the executor's frame-plane skip in `executeChildren`: every
+* enabled top-level step runs at the root; a CHILD runs only when its catalog
+* definition is itself root-plane (`isDetailStep(addonId)` false). The walk
+* continues only through steps that execute — a skipped detail child's
+* descendants ride ITS per-track detail-subtree call, never this one.
+* Disabled and audio-classifier steps execute on neither plane.
+*/
+function collectFramePlaneSteps(steps, isDetailStep) {
+	const result = [];
+	const walk = (nodes, topLevel) => {
+		for (const step of nodes) {
+			if (!step.enabled) continue;
+			if (step.slot === "audio-classifier") continue;
+			if (!topLevel && isDetailStep(step.addonId)) continue;
+			result.push(step);
+			if (step.children?.length) walk(step.children, false);
+		}
+	};
+	walk(steps, true);
+	return result;
+}
+/**
+* Immutably remove from a frame-plane dispatch tree every enabled DETAIL
+* subtree (at any depth below the top level) whose top step `isUnrunnable`.
+* Those steps can never load into the dispatch device's pool — leaving them
+* in the tree makes `ensureModelsForSteps` fail the whole call on a format
+* build that does not exist. They are NOT dropped work: each runs later as
+* its own detail-subtree dispatch, where the device-jump resolver
+* (`resolveStepDevice`) places it on a same-node device that can run it, or
+* warns no-candidate loudly. Runnable detail children are kept so their
+* models pre-warm the device pool as before. Disabled subtrees are kept
+* verbatim (never walked — `ensureModelsForSteps` skips them anyway).
+*/
+function pruneUnrunnableDetailSteps(steps, isDetailStep, isUnrunnable) {
+	const prunedAddonIds = [];
+	const walk = (nodes, topLevel) => {
+		const kept = [];
+		for (const step of nodes) {
+			if (!step.enabled) {
+				kept.push(step);
+				continue;
+			}
+			if (!topLevel && isDetailStep(step.addonId) && isUnrunnable(step.addonId)) {
+				prunedAddonIds.push(step.addonId);
+				continue;
+			}
+			kept.push(step.children?.length ? {
+				...step,
+				children: walk(step.children, false)
+			} : step);
+		}
+		return kept;
+	};
+	return {
+		steps: walk(steps, true),
+		prunedAddonIds
+	};
+}
 //#endregion
 //#region src/detection-pipeline/engine/pipeline-model-manager.ts
 var PipelineModelManager = class {
@@ -1228,6 +1461,126 @@ var PipelineModelManager = class {
 	}
 };
 //#endregion
+//#region src/detection-pipeline/engine/resolve-device-engine.ts
+/**
+* Resolve a Phase-1 device key (`<backend>:<device>`, or bare `cpu`) into the
+* {@link PipelineEngineChoice} used to build that device's inference pool.
+* Throws on an unknown backend token so a bad `deviceKey` fails loud rather
+* than silently building a wrong pool. Format comes from the shared
+* {@link DEVICE_BACKEND_TO_FORMAT} SSOT (`@camstack/types`) — no local copy.
+*/
+function resolveDeviceEngine(deviceKey) {
+	const colon = deviceKey.indexOf(":");
+	const backend = colon >= 0 ? deviceKey.slice(0, colon) : deviceKey;
+	const device = colon >= 0 ? deviceKey.slice(colon + 1) : deviceKey;
+	const format = DEVICE_BACKEND_TO_FORMAT[backend];
+	if (format === void 0) throw new Error(`resolveDeviceEngine: unknown backend "${backend}" in deviceKey "${deviceKey}"`);
+	return {
+		runtime: "python",
+		backend,
+		format,
+		device
+	};
+}
+/**
+* The inverse of {@link resolveDeviceEngine}: the `<backend>:<device>` key that
+* names the pool an engine belongs to. Every pool-level log line carries this —
+* without it a default pool logs anonymously and six hours of logs cannot tell
+* "the NPU is unused" from "the NPU IS the anonymous default pool".
+* Falls back to the bare backend when the engine carries no device.
+*/
+function deviceKeyOf(engine) {
+	return engine.device ? `${engine.backend}:${engine.device}` : engine.backend;
+}
+//#endregion
+//#region src/detection-pipeline/engine/pool-provisioning.ts
+/** The fields a {@link PoolProvisioningOverride} may carry, in table order. */
+var OVERRIDABLE_KEYS = [
+	"concurrency",
+	"numWorkers",
+	"batchMode",
+	"windowMs",
+	"maxBatchSize",
+	"numStreams",
+	"intraOpThreads"
+];
+/** Backends that are not a runtime of their own and run on onnxruntime. */
+var BACKEND_TO_RUNTIME = {
+	onnx: "onnx",
+	cpu: "onnx",
+	cuda: "onnx",
+	openvino: "openvino",
+	coreml: "coreml",
+	edgetpu: "edgetpu"
+};
+/**
+* The registry runtime a device-pool backend provisions from. Unknown backends
+* floor to `onnx` — the same floor `resolveDeviceEngine` applies to the model
+* format, so a pool never comes up unprovisioned.
+*/
+function runtimeIdForBackend(backend) {
+	return BACKEND_TO_RUNTIME[backend] ?? "onnx";
+}
+/**
+* Resolve the provisioning for a pool running `engine`, applying the precedence
+* documented at the top of this module. `engine.device` is not consulted today
+* (see the module doc) but is part of the signature so a bench-backed
+* per-device row lands here and nowhere else.
+*/
+function resolvePoolProvisioning(engine, override = {}) {
+	const runtime = runtimeIdForBackend(engine.backend);
+	const profile = tuningFor(runtime);
+	return {
+		runtime,
+		overriddenFields: OVERRIDABLE_KEYS.filter((k) => override[k] !== void 0),
+		concurrency: Math.max(1, override.concurrency ?? profile.concurrency),
+		numWorkers: Math.max(1, override.numWorkers ?? profile.numWorkers),
+		batchMode: override.batchMode ?? profile.batchMode,
+		windowMs: override.windowMs ?? profile.windowMs,
+		maxBatchSize: override.maxBatchSize ?? profile.maxBatchSize,
+		numStreams: override.numStreams ?? profile.numStreams,
+		intraOpThreads: override.intraOpThreads ?? profile.intraOpThreads
+	};
+}
+function positiveNumber(value) {
+	return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : void 0;
+}
+function batchMode(value) {
+	return value === "none" || value === "list" || value === "window" ? value : void 0;
+}
+/**
+* Read the operator override out of the detection addon's settings. Only a
+* NON-AUTO value counts: the sliders persist `0` and the select persists `''`
+* for "Auto (backend default)", and those must resolve to the runtime's
+* registry value, not to a literal 0 worker threads.
+*
+* The result is deliberately sparse — an empty object means "nothing
+* overridden", which is what lets a per-device pool provision from its own
+* runtime instead of inheriting the node's.
+*/
+function readOperatorOverride(settings) {
+	const override = {};
+	const concurrency = positiveNumber(settings.concurrency);
+	if (concurrency !== void 0) override.concurrency = concurrency;
+	const numWorkers = positiveNumber(settings.numWorkers);
+	if (numWorkers !== void 0) override.numWorkers = numWorkers;
+	const mode = batchMode(settings.batchMode);
+	if (mode !== void 0) override.batchMode = mode;
+	const windowMs = positiveNumber(settings.windowMs);
+	if (windowMs !== void 0) override.windowMs = windowMs;
+	const maxBatchSize = positiveNumber(settings.maxBatchSize);
+	if (maxBatchSize !== void 0) override.maxBatchSize = maxBatchSize;
+	const numStreams = positiveNumber(settings.numStreams);
+	if (numStreams !== void 0) override.numStreams = numStreams;
+	const intraOpThreads = positiveNumber(settings.intraOpThreads);
+	if (intraOpThreads !== void 0) override.intraOpThreads = intraOpThreads;
+	return override;
+}
+/** Two overrides carry the same fields with the same values. */
+function overridesEqual(a, b) {
+	return OVERRIDABLE_KEYS.every((k) => a[k] === b[k]);
+}
+//#endregion
 //#region src/detection-pipeline/engine/engine-factory.ts
 var BACKEND_TO_POOL_RUNTIME = {
 	coreml: "coreml",
@@ -1244,7 +1597,7 @@ var RUNTIME_TO_FORMAT = {
 	edgetpu: "tflite"
 };
 /** The step whose detections are re-filtered downstream by the executor's
-*  per-macro `minConfidence*` sliders (`matchesMacroFilter`). Its pool-side
+*  per-macro `minConfidence*` sliders (`macroFilterVerdict`). Its pool-side
 *  floor must stay BELOW those sliders or it silently pre-empts them. */
 var OBJECT_DETECTION_STEP_ID = "object-detection";
 /**
@@ -1297,9 +1650,31 @@ var EngineFactory = class {
 	poolManager = null;
 	log;
 	opts;
+	/**
+	* `<backend>:<device>` — on EVERY log line this factory writes. A pool that
+	* logs anonymously cannot be told apart from another pool of the same runtime
+	* on a different accelerator.
+	*/
+	deviceKey;
+	/**
+	* Resolved at CONSTRUCTION, not at pool spawn, so it is inspectable without
+	* starting Python and so a pool that fails to spawn still logs what it was
+	* trying to be.
+	*/
+	resolvedProvisioning;
 	constructor(opts) {
 		this.opts = opts;
 		this.log = opts.logger;
+		this.deviceKey = deviceKeyOf(opts.engine);
+		this.resolvedProvisioning = resolvePoolProvisioning(opts.engine, opts.provisioning);
+	}
+	/**
+	* The provisioning this factory's pool runs with — resolved from the pool's
+	* OWN runtime plus any operator override. Read by the effective-tuning
+	* readout and by the tests that pin the per-runtime behaviour.
+	*/
+	get provisioning() {
+		return this.resolvedProvisioning;
 	}
 	/** Detection always uses the Python pool. */
 	get usesPythonPool() {
@@ -1401,40 +1776,51 @@ var EngineFactory = class {
 			this.poolManager = null;
 		}
 	}
+	/**
+	* The one pool-init log line. `deviceKey` / `device` are the reason it
+	* exists: the default pool used to log neither, so an operator reading a
+	* day of logs could not tell whether the NPU was idle or was simply the
+	* anonymous default pool.
+	*
+	* `overriddenFields` replaces the old `source` field. `source` claimed
+	* `'auto-default' | 'user-override'` about the CONCURRENCY TUNING but read as
+	* the provenance of the device/engine choice, and was `'user-override'` on
+	* every pool because the addon always passed explicit tuning. This lists the
+	* fields the operator actually overrode — empty means pure registry.
+	*/
+	logProvisioning() {
+		const p = this.resolvedProvisioning;
+		this.log.info("Python inference pool", { meta: {
+			deviceKey: this.deviceKey,
+			backend: this.opts.engine.backend,
+			device: this.opts.engine.device ?? null,
+			runtime: p.runtime,
+			concurrency: p.concurrency,
+			numWorkers: p.numWorkers,
+			overriddenFields: p.overriddenFields,
+			tuning: {
+				batchMode: p.batchMode,
+				windowMs: p.windowMs,
+				maxBatchSize: p.maxBatchSize,
+				numStreams: p.numStreams,
+				intraOpThreads: p.intraOpThreads
+			}
+		} });
+	}
 	async initPythonPool(steps) {
+		this.logProvisioning();
 		const pythonPath = this.opts.pythonPath;
 		if (!pythonPath) throw new Error("EngineFactory: pythonPath is required — the addon must call ctx.deps.ensurePython() and pass the result. The embedded portable Python download likely failed; check the addon logs for the download error.");
 		const poolRuntime = BACKEND_TO_POOL_RUNTIME[this.opts.engine.backend];
 		if (!poolRuntime) throw new Error(`No pool runtime mapping for backend "${this.opts.engine.backend}"`);
-		const concurrency = this.opts.concurrency ?? {
-			coreml: 1,
-			openvino: 1,
-			onnxruntime: 4,
-			edgetpu: 1
-		}[poolRuntime];
-		const isAutoDefault = this.opts.concurrency === void 0;
-		const defaultBatchMode = {
-			coreml: "window",
-			openvino: "none",
-			onnxruntime: "list",
-			edgetpu: "none"
-		};
-		const tuning = this.opts.tuning ?? {};
+		const { concurrency, numWorkers } = this.resolvedProvisioning;
 		const resolvedTuning = {
-			batchMode: tuning.batchMode ?? defaultBatchMode[poolRuntime],
-			windowMs: tuning.windowMs ?? 8,
-			maxBatchSize: tuning.maxBatchSize ?? 8,
-			numStreams: tuning.numStreams ?? 0,
-			intraOpThreads: tuning.intraOpThreads ?? 0
+			batchMode: this.resolvedProvisioning.batchMode,
+			windowMs: this.resolvedProvisioning.windowMs,
+			maxBatchSize: this.resolvedProvisioning.maxBatchSize,
+			numStreams: this.resolvedProvisioning.numStreams,
+			intraOpThreads: this.resolvedProvisioning.intraOpThreads
 		};
-		const numWorkers = Math.max(1, this.opts.numWorkers ?? 1);
-		this.log.info("Python inference pool", { meta: {
-			runtime: poolRuntime,
-			concurrency,
-			numWorkers,
-			source: isAutoDefault ? "auto-default" : "user-override",
-			tuning: resolvedTuning
-		} });
 		this.pool = new SharedInferencePool(pythonPath, poolRuntime, this.log.child("pool"), {
 			concurrency,
 			tuning: resolvedTuning,
@@ -1490,28 +1876,6 @@ var EngineFactory = class {
 	}
 };
 //#endregion
-//#region src/detection-pipeline/engine/resolve-device-engine.ts
-/**
-* Resolve a Phase-1 device key (`<backend>:<device>`, or bare `cpu`) into the
-* {@link PipelineEngineChoice} used to build that device's inference pool.
-* Throws on an unknown backend token so a bad `deviceKey` fails loud rather
-* than silently building a wrong pool. Format comes from the shared
-* {@link DEVICE_BACKEND_TO_FORMAT} SSOT (`@camstack/types`) — no local copy.
-*/
-function resolveDeviceEngine(deviceKey) {
-	const colon = deviceKey.indexOf(":");
-	const backend = colon >= 0 ? deviceKey.slice(0, colon) : deviceKey;
-	const device = colon >= 0 ? deviceKey.slice(colon + 1) : deviceKey;
-	const format = DEVICE_BACKEND_TO_FORMAT[backend];
-	if (format === void 0) throw new Error(`resolveDeviceEngine: unknown backend "${backend}" in deviceKey "${deviceKey}"`);
-	return {
-		runtime: "python",
-		backend,
-		format,
-		device
-	};
-}
-//#endregion
 //#region src/detection-pipeline/engine/idle-pool-reaper.ts
 var IdlePoolReaper = class {
 	lastUsed = /* @__PURE__ */ new Map();
@@ -1678,563 +2042,153 @@ var EngineProvisioner = class {
 	}
 };
 //#endregion
-//#region src/detection-pipeline/postprocess/dispatch.ts
-/** Detector NMS IoU fallback — the historical hardcoded literal, used when the
-*  step carries no `nmsIouThreshold` setting (unset == today). */
-var DEFAULT_NMS_IOU = .45;
+//#region src/detection-pipeline/pipeline/crop-utils.ts
 /**
-* 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.
+* Crop utilities — ROI extraction and bbox coordinate transforms.
 */
-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",
-	"embedding",
-	"text",
-	"mask"
-]);
 /**
-* Type guard: validates that a structured payload from the Python pool is a
-* well-formed StepOutput discriminated union.
-*
-* The Python inference_pool.py always sets `output.structured` with a `kind`
-* field. This guard narrows `Record<string, unknown>` to `StepOutput` without
-* resorting to double-cast.
+* Extract a JPEG crop from a full-frame JPEG buffer.
+* Clamps to image boundaries and returns the cropped JPEG + dimensions.
 */
-function isStepOutput(value) {
-	return typeof value === "object" && value !== null && typeof value["kind"] === "string" && VALID_KINDS.has(value["kind"]);
+async function cropJpeg(jpeg, bbox, imageWidth, imageHeight) {
+	const x1 = Math.max(0, Math.round(bbox[0]));
+	const y1 = Math.max(0, Math.round(bbox[1]));
+	const x2 = Math.min(imageWidth, Math.round(bbox[2]));
+	const y2 = Math.min(imageHeight, Math.round(bbox[3]));
+	const w = x2 - x1;
+	const h = y2 - y1;
+	if (w < 1 || h < 1) throw new Error(`Degenerate crop: [${x1},${y1},${x2},${y2}] on ${imageWidth}x${imageHeight}`);
+	return {
+		jpeg: await sharp(jpeg).extract({
+			left: x1,
+			top: y1,
+			width: w,
+			height: h
+		}).jpeg({ quality: 90 }).toBuffer(),
+		width: w,
+		height: h
+	};
 }
 /**
-* Return the structured payload as `StepOutput`, or null if it fails validation.
-* Callers must handle null by proceeding to raw-tensor postprocessing.
-*/
-function tryStructured(output) {
-	if (!output.structured) return null;
-	if (!isStepOutput(output.structured)) throw new Error(`Python pool returned structured output with unexpected kind: ${JSON.stringify(output.structured["kind"])}`);
-	return output.structured;
-}
-function postprocessYolo(output, stepDef, nmsIouThreshold) {
-	const structured = tryStructured(output);
-	if (structured) return structured;
-	const tensor = output.tensor;
-	if (!tensor) throw new Error("YOLO postprocessor: no tensor in engine output");
-	const labels = stepDef.labels ?? [];
-	const numClasses = labels.length || 80;
-	const numBoxes = tensor.length / (4 + numClasses);
-	const letterbox = output.letterbox;
-	const dets = [];
-	for (let i = 0; i < numBoxes; i++) {
-		const cx = tensor[i];
-		const cy = tensor[1 * numBoxes + i];
-		const w = tensor[2 * numBoxes + i];
-		const h = tensor[3 * numBoxes + i];
-		let bestScore = -Infinity;
-		let bestClass = 0;
-		for (let j = 0; j < numClasses; j++) {
-			const score = tensor[(4 + j) * numBoxes + i];
-			if (score > bestScore) {
-				bestScore = score;
-				bestClass = j;
-			}
-		}
-		if (bestScore <= 0) continue;
-		let x1 = cx - w / 2;
-		let y1 = cy - h / 2;
-		let x2 = cx + w / 2;
-		let y2 = cy + h / 2;
-		if (letterbox) {
-			x1 = (x1 - letterbox.padX) / letterbox.scale;
-			y1 = (y1 - letterbox.padY) / letterbox.scale;
-			x2 = (x2 - letterbox.padX) / letterbox.scale;
-			y2 = (y2 - letterbox.padY) / letterbox.scale;
-		}
-		const label = labels[bestClass] ?? String(bestClass);
-		dets.push({
-			class: label,
-			score: bestScore,
-			bbox: [
-				x1,
-				y1,
-				x2,
-				y2
-			]
-		});
-	}
-	return {
-		kind: "detections",
-		detections: simpleNms(dets, nmsIouThreshold)
-	};
-}
-function postprocessSsd(output, _stepDef) {
-	const structured = tryStructured(output);
-	if (structured) return structured;
-	throw new Error("SSD postprocessing runs in the Python inference pool (ssd.py); no TypeScript raw-tensor path.");
-}
-function postprocessScrfd(output, stepDef, nmsIouThreshold) {
-	const structured = tryStructured(output);
-	if (structured) return structured;
-	if (!output.tensors) throw new Error("SCRFD postprocessor: no tensors in engine output");
-	const strides = [
-		8,
-		16,
-		32
+* Transform a child detection's bbox from ROI-relative to image-absolute coordinates.
+*
+* When a child step (e.g., face-detection) runs on a crop of the parent (e.g., person),
+* its bbox is relative to the crop. This function maps it back to the full image space.
+*/
+function transformBboxToImageSpace(childBbox, parentBbox) {
+	const [px1, py1] = parentBbox;
+	return [
+		px1 + childBbox[0],
+		py1 + childBbox[1],
+		px1 + childBbox[2],
+		py1 + childBbox[3]
 	];
-	const anchorsPerStride = 2;
-	const inputSize = Math.max(stepDef.models[0]?.inputSize.width ?? 640, stepDef.models[0]?.inputSize.height ?? 640);
-	const strideData = matchTensorsToStrides(output.tensors, strides, inputSize, anchorsPerStride);
-	const letterbox = output.letterbox;
-	const scale = letterbox?.scale ?? 1;
-	const padX = letterbox?.padX ?? 0;
-	const padY = letterbox?.padY ?? 0;
-	const origW = letterbox?.originalWidth ?? inputSize;
-	const origH = letterbox?.originalHeight ?? inputSize;
-	const candidates = [];
-	for (const stride of strides) {
-		const data = strideData.get(stride);
-		if (!data) continue;
-		const { scores, bboxes, landmarks } = data;
-		const featSize = Math.ceil(inputSize / stride);
-		const numAnchors = featSize * featSize * anchorsPerStride;
-		for (let i = 0; i < numAnchors; i++) {
-			if (i >= scores.length) break;
-			const score = scores[i];
-			if (score <= 0) continue;
-			const gridIdx = Math.floor(i / anchorsPerStride);
-			const cx = (gridIdx % featSize + .5) * stride;
-			const cy = (Math.floor(gridIdx / featSize) + .5) * stride;
-			const x1 = cx - bboxes[i * 4] * stride;
-			const y1 = cy - bboxes[i * 4 + 1] * stride;
-			const x2 = cx + bboxes[i * 4 + 2] * stride;
-			const y2 = cy + bboxes[i * 4 + 3] * stride;
-			const ox1 = Math.max(0, Math.min(origW, (x1 - padX) / scale));
-			const oy1 = Math.max(0, Math.min(origH, (y1 - padY) / scale));
-			const ox2 = Math.max(0, Math.min(origW, (x2 - padX) / scale));
-			const oy2 = Math.max(0, Math.min(origH, (y2 - padY) / scale));
-			if (ox2 - ox1 < 1 || oy2 - oy1 < 1) continue;
-			const det = {
-				class: "face",
-				score: Math.round(score * 1e4) / 1e4,
-				bbox: [
-					Math.round(ox1 * 10) / 10,
-					Math.round(oy1 * 10) / 10,
-					Math.round(ox2 * 10) / 10,
-					Math.round(oy2 * 10) / 10
-				],
-				_xyxy: [
-					ox1,
-					oy1,
-					ox2,
-					oy2
-				]
-			};
-			if (landmarks && i * 10 + 9 < landmarks.length) {
-				det.landmarks = [];
-				for (let p = 0; p < 5; p++) {
-					const lx = (cx + landmarks[i * 10 + p * 2] * stride - padX) / scale;
-					const ly = (cy + landmarks[i * 10 + p * 2 + 1] * stride - padY) / scale;
-					det.landmarks.push({
-						x: Math.round(lx * 10) / 10,
-						y: Math.round(ly * 10) / 10
-					});
-				}
-			}
-			candidates.push(det);
-		}
-	}
-	return {
-		kind: "detections",
-		detections: simpleNms(candidates.map((c) => ({
-			class: c.class,
-			score: c.score,
-			bbox: c.bbox,
-			...c.landmarks ? { landmarks: c.landmarks } : {}
-		})), nmsIouThreshold)
-	};
-}
-/** Match ONNX output tensors to SCRFD strides by expected anchor count. */
-function matchTensorsToStrides(tensors, strides, inputSize, anchorsPerStride) {
-	const scoresByN = /* @__PURE__ */ new Map();
-	const bboxesByN = /* @__PURE__ */ new Map();
-	const landmarksByN = /* @__PURE__ */ new Map();
-	for (const [, tensor] of Object.entries(tensors)) for (const stride of strides) {
-		const featSize = Math.ceil(inputSize / stride);
-		const expectedN = featSize * featSize * anchorsPerStride;
-		if (tensor.length === expectedN) scoresByN.set(expectedN, tensor);
-		else if (tensor.length === expectedN * 4) bboxesByN.set(expectedN, tensor);
-		else if (tensor.length === expectedN * 10) landmarksByN.set(expectedN, tensor);
-	}
-	const result = /* @__PURE__ */ new Map();
-	for (const stride of strides) {
-		const featSize = Math.ceil(inputSize / stride);
-		const n = featSize * featSize * anchorsPerStride;
-		const scores = scoresByN.get(n);
-		const bboxes = bboxesByN.get(n);
-		if (scores && bboxes) result.set(stride, {
-			scores,
-			bboxes,
-			landmarks: landmarksByN.get(n)
-		});
-	}
-	return result;
-}
-function postprocessArcface(output, _stepDef) {
-	const structured = tryStructured(output);
-	if (structured) return structured;
-	const tensor = output.tensor;
-	if (!tensor) throw new Error("ArcFace postprocessor: no tensor in engine output");
-	let sumSq = 0;
-	for (let i = 0; i < tensor.length; i++) sumSq += tensor[i] * tensor[i];
-	const norm = Math.sqrt(sumSq);
-	const normalized = Array.from({ length: tensor.length });
-	for (let i = 0; i < tensor.length; i++) normalized[i] = norm === 0 ? 0 : tensor[i] / norm;
-	return {
-		kind: "embedding",
-		embedding: Array.from(tensor),
-		embeddingNorm: normalized
-	};
-}
-function postprocessClip(output, _stepDef) {
-	const structured = tryStructured(output);
-	if (structured) return structured;
-	const tensor = output.tensor;
-	if (!tensor) throw new Error("CLIP postprocessor: no tensor in engine output");
-	let sumSq = 0;
-	for (let i = 0; i < tensor.length; i++) sumSq += tensor[i] * tensor[i];
-	const norm = Math.sqrt(sumSq);
-	const normalized = Array.from({ length: tensor.length });
-	for (let i = 0; i < tensor.length; i++) normalized[i] = norm === 0 ? 0 : tensor[i] / norm;
-	return {
-		kind: "embedding",
-		embedding: Array.from(tensor),
-		embeddingNorm: normalized
-	};
 }
-function postprocessSoftmax(output, stepDef) {
-	const structured = tryStructured(output);
-	if (structured) return structured;
-	const tensor = output.tensor;
-	if (!tensor) throw new Error("Softmax postprocessor: no tensor in engine output");
-	const labels = stepDef.labels ?? [];
-	let max = -Infinity;
-	for (let i = 0; i < tensor.length; i++) if (tensor[i] > max) max = tensor[i];
-	const exps = new Float32Array(tensor.length);
-	let sum = 0;
-	for (let i = 0; i < tensor.length; i++) {
-		exps[i] = Math.exp(tensor[i] - max);
-		sum += exps[i];
-	}
-	const classifications = [];
-	for (let i = 0; i < exps.length; i++) {
-		const score = exps[i] / sum;
-		if (score >= .01) classifications.push({
-			class: labels[i] ?? String(i),
-			score
-		});
-	}
-	classifications.sort((a, b) => b.score - a.score);
-	return {
-		kind: "classifications",
-		classifications: classifications.slice(0, 5)
-	};
-}
-function postprocessCtc(output, stepDef) {
-	const structured = tryStructured(output);
-	if (structured) return structured;
-	const tensor = output.tensor;
-	if (!tensor) throw new Error("CTC postprocessor: no tensor in engine output");
-	const charset = stepDef.charset ?? [];
-	const numChars = charset.length || 97;
-	const seqLen = Math.floor(tensor.length / numChars);
-	const chars = [];
-	let totalScore = 0;
-	let prev = -1;
-	for (let t = 0; t < seqLen; t++) {
-		let bestIdx = 0;
-		let bestVal = tensor[t * numChars];
-		for (let c = 1; c < numChars; c++) {
-			const val = tensor[t * numChars + c];
-			if (val > bestVal) {
-				bestVal = val;
-				bestIdx = c;
-			}
-		}
-		totalScore += bestVal;
-		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,
-		confidence: seqLen > 0 ? totalScore / seqLen : 0
-	};
+/**
+* Check if a bbox is degenerate (zero or negative area).
+*/
+function isBboxDegenerate(bbox) {
+	return bbox[2] - bbox[0] < 1 || bbox[3] - bbox[1] < 1;
 }
+//#endregion
+//#region src/detection-pipeline/pipeline/crop-zone.ts
 /**
-* Bounding box [x, y, w, h] (mask-pixel space) of the largest 4-connected
-* foreground component. Port of `_largest_component_bbox` from
-* `python/postprocessors/saliency.py`.
+* Resolve the absolute-pixel crop bbox for a `crop-zone` root detector: the
+* bounding box of the UNION of every polygon referenced by the device's
+* ENABLED `package`-stage zone rules. Zone polygons are normalized (0..1); the
+* union is clamped to [0,1] then scaled to the frame's pixel dimensions.
 *
-* Returns null when there are no foreground pixels.
+* Returns `null` when there is nothing usable to crop to — no enabled rules, no
+* referenced geometry, or a degenerate result — in which case the caller falls
+* back to full-frame inference (behaviour identical to before the crop-zone
+* plumbing).
 */
-function largestComponentBbox(binary, w, h) {
-	const seeds = [];
-	for (let row = 0; row < h; row++) for (let col = 0; col < w; col++) if ((binary[row * w + col] ?? 0) > 0) seeds.push([row, col]);
-	if (seeds.length === 0) return null;
-	const visited = new Uint8Array(w * h);
-	let best = null;
-	for (const [sy, sx] of seeds) {
-		const seedIdx = sy * w + sx;
-		if (visited[seedIdx] === 1) continue;
-		const stack = [[sy, sx]];
-		visited[seedIdx] = 1;
-		let minX = sx;
-		let maxX = sx;
-		let minY = sy;
-		let maxY = sy;
-		let area = 0;
-		while (stack.length > 0) {
-			const [cy, cx] = stack.pop();
-			area += 1;
-			if (cx < minX) minX = cx;
-			if (cx > maxX) maxX = cx;
-			if (cy < minY) minY = cy;
-			if (cy > maxY) maxY = cy;
-			const neighbours = [
-				[cy - 1, cx],
-				[cy + 1, cx],
-				[cy, cx - 1],
-				[cy, cx + 1]
-			];
-			for (const [ny, nx] of neighbours) {
-				if (ny < 0 || ny >= h || nx < 0 || nx >= w) continue;
-				const nIdx = ny * w + nx;
-				if ((binary[nIdx] ?? 0) > 0 && visited[nIdx] !== 1) {
-					visited[nIdx] = 1;
-					stack.push([ny, nx]);
-				}
-			}
+function resolvePackageCropBbox(zones, packageRules, frameWidth, frameHeight) {
+	if (frameWidth <= 0 || frameHeight <= 0) return null;
+	const enabledRules = packageRules.filter((r) => r.enabled !== false);
+	if (enabledRules.length === 0) return null;
+	const zoneIds = /* @__PURE__ */ new Set();
+	for (const rule of enabledRules) for (const id of rule.zoneIds) zoneIds.add(id);
+	if (zoneIds.size === 0) return null;
+	const zoneById = new Map(zones.map((z) => [z.id, z]));
+	let minX = Number.POSITIVE_INFINITY;
+	let minY = Number.POSITIVE_INFINITY;
+	let maxX = Number.NEGATIVE_INFINITY;
+	let maxY = Number.NEGATIVE_INFINITY;
+	let sawPoint = false;
+	for (const id of zoneIds) {
+		const zone = zoneById.get(id);
+		if (!zone || zone.polygon.length === 0) continue;
+		for (const point of zone.polygon) {
+			sawPoint = true;
+			if (point.x < minX) minX = point.x;
+			if (point.y < minY) minY = point.y;
+			if (point.x > maxX) maxX = point.x;
+			if (point.y > maxY) maxY = point.y;
 		}
-		if (best === null || area > best.area) best = {
-			area,
-			minX,
-			minY,
-			maxX,
-			maxY
-		};
 	}
-	if (best === null) return null;
-	return [
-		best.minX,
-		best.minY,
-		best.maxX - best.minX + 1,
-		best.maxY - best.minY + 1
+	if (!sawPoint) return null;
+	const clamp01 = (v) => Math.max(0, Math.min(1, v));
+	const bbox = [
+		clamp01(minX) * frameWidth,
+		clamp01(minY) * frameHeight,
+		clamp01(maxX) * frameWidth,
+		clamp01(maxY) * frameHeight
 	];
+	if (isBboxDegenerate(bbox)) return null;
+	return bbox;
 }
-function postprocessSaliency(output, _stepDef) {
-	const structured = tryStructured(output);
-	if (structured) return structured;
-	const tensor = output.tensor;
-	if (!tensor) throw new Error("Saliency postprocessor: no tensor in engine output");
-	const binary = new Uint8Array(tensor.length);
-	for (let i = 0; i < tensor.length; i++) binary[i] = 1 / (1 + Math.exp(-tensor[i])) > .5 ? 255 : 0;
-	const side = Math.round(Math.sqrt(tensor.length));
-	const mask = Buffer.from(binary).toString("base64");
-	const maskBbox = largestComponentBbox(binary, side, side);
-	if (maskBbox !== null) return {
-		kind: "mask",
-		mask,
-		maskWidth: side,
-		maskHeight: side,
-		maskBbox
-	};
-	return {
-		kind: "mask",
-		mask,
-		maskWidth: side,
-		maskHeight: side
-	};
-}
-function postprocessYoloSeg(output, stepDef, nmsIouThreshold) {
-	const structured = tryStructured(output);
-	if (structured) return structured;
-	const tensors = output.tensors;
-	if (!tensors) throw new Error("YOLO-seg postprocessor: no tensors in engine output");
-	const labels = stepDef.labels ?? [];
-	const numClasses = labels.length || 80;
-	const numMaskCoeffs = 32;
-	const protoSize = 160;
-	const letterbox = output.letterbox;
-	let detTensor;
-	let protoTensor;
-	let detRows = 300;
-	let detCols = 0;
-	for (const [, tensor] of Object.entries(tensors)) {
-		if (tensor.length === numMaskCoeffs * protoSize * protoSize) {
-			protoTensor = tensor;
-			continue;
-		}
-		const cols = 38;
-		if (tensor.length % cols === 0) {
-			detTensor = tensor;
-			detRows = tensor.length / cols;
-			detCols = cols;
-			continue;
-		}
-		const rawCols = 4 + numClasses + numMaskCoeffs;
-		if (tensor.length % rawCols === 0 && !detTensor) {
-			detTensor = tensor;
-			detRows = tensor.length / rawCols;
-			detCols = rawCols;
-		}
-	}
-	if (!detTensor) throw new Error("YOLO-seg postprocessor: could not find detection tensor");
-	if (!protoTensor) throw new Error("YOLO-seg postprocessor: could not find prototype tensor");
-	const isNmsFormat = detCols === 38;
-	const dets = [];
-	for (let i = 0; i < detRows; i++) {
-		const offset = i * detCols;
-		let x1, y1, x2, y2;
-		let bestScore;
-		let bestClass;
-		let coeffStart;
-		if (isNmsFormat) {
-			x1 = detTensor[offset];
-			y1 = detTensor[offset + 1];
-			x2 = detTensor[offset + 2];
-			y2 = detTensor[offset + 3];
-			bestScore = detTensor[offset + 4];
-			bestClass = detTensor[offset + 5];
-			coeffStart = offset + 6;
-			if (bestScore <= 0) continue;
-			if (bestClass < 0) continue;
-		} else {
-			const cx = detTensor[offset];
-			const cy = detTensor[offset + 1];
-			const w = detTensor[offset + 2];
-			const h = detTensor[offset + 3];
-			bestScore = -Infinity;
-			bestClass = 0;
-			for (let j = 0; j < numClasses; j++) {
-				const score = detTensor[offset + 4 + j];
-				if (score > bestScore) {
-					bestScore = score;
-					bestClass = j;
-				}
-			}
-			if (bestScore <= 0) continue;
-			x1 = cx - w / 2;
-			y1 = cy - h / 2;
-			x2 = cx + w / 2;
-			y2 = cy + h / 2;
-			coeffStart = offset + 4 + numClasses;
-		}
-		const coeffs = new Float32Array(numMaskCoeffs);
-		for (let j = 0; j < numMaskCoeffs; j++) coeffs[j] = detTensor[coeffStart + j];
-		const maskPixels = protoSize * protoSize;
-		const maskRaw = new Float32Array(maskPixels);
-		for (let p = 0; p < maskPixels; p++) {
-			let sum = 0;
-			for (let c = 0; c < numMaskCoeffs; c++) sum += coeffs[c] * protoTensor[c * maskPixels + p];
-			maskRaw[p] = 1 / (1 + Math.exp(-sum));
-		}
-		const protoScale = protoSize / (stepDef.models[0]?.inputSize.width ?? 640);
-		const px1 = Math.max(0, Math.floor(x1 * protoScale));
-		const py1 = Math.max(0, Math.floor(y1 * protoScale));
-		const px2 = Math.min(protoSize, Math.ceil(x2 * protoScale));
-		const py2 = Math.min(protoSize, Math.ceil(y2 * protoScale));
-		const cropW = Math.max(1, px2 - px1);
-		const cropH = Math.max(1, py2 - py1);
-		const cropped = new Uint8Array(cropW * cropH);
-		for (let row = 0; row < cropH; row++) for (let col = 0; col < cropW; col++) {
-			const srcIdx = (py1 + row) * protoSize + (px1 + col);
-			cropped[row * cropW + col] = maskRaw[srcIdx] > .5 ? 255 : 0;
-		}
-		let ox1 = x1;
-		let oy1 = y1;
-		let ox2 = x2;
-		let oy2 = y2;
-		if (letterbox) {
-			ox1 = (x1 - letterbox.padX) / letterbox.scale;
-			oy1 = (y1 - letterbox.padY) / letterbox.scale;
-			ox2 = (x2 - letterbox.padX) / letterbox.scale;
-			oy2 = (y2 - letterbox.padY) / letterbox.scale;
-		}
-		const label = labels[bestClass] ?? String(bestClass);
-		const maskB64 = Buffer.from(cropped).toString("base64");
-		dets.push({
-			class: label,
-			score: Math.round(bestScore * 1e4) / 1e4,
-			bbox: [
-				Math.round(ox1 * 10) / 10,
-				Math.round(oy1 * 10) / 10,
-				Math.round(ox2 * 10) / 10,
-				Math.round(oy2 * 10) / 10
-			],
-			mask: maskB64,
-			maskWidth: cropW,
-			maskHeight: cropH
-		});
-	}
-	const keptBoxes = simpleNms(dets.map((d) => ({
-		class: d.class,
-		score: d.score,
-		bbox: d.bbox
-	})), nmsIouThreshold);
-	const keptSet = new Set(keptBoxes.map((d) => `${d.bbox[0]}_${d.bbox[1]}_${d.bbox[2]}_${d.bbox[3]}_${d.score}`));
-	return {
-		kind: "detections",
-		detections: dets.filter((d) => keptSet.has(`${d.bbox[0]}_${d.bbox[1]}_${d.bbox[2]}_${d.bbox[3]}_${d.score}`))
-	};
-}
-function postprocessYamnet(output, _stepDef) {
-	const structured = tryStructured(output);
-	if (structured) return structured;
-	throw new Error("YAMNet TypeScript postprocessing not implemented. Use Python backend or Apple SoundAnalysis.");
-}
-var DISPATCH = {
-	yolo: postprocessYolo,
-	ssd: postprocessSsd,
-	"yolo-seg": postprocessYoloSeg,
-	scrfd: postprocessScrfd,
-	arcface: postprocessArcface,
-	clip: postprocessClip,
-	softmax: postprocessSoftmax,
-	ctc: postprocessCtc,
-	saliency: postprocessSaliency,
-	yamnet: postprocessYamnet
-};
+//#endregion
+//#region src/detection-pipeline/postprocess/dispatch.ts
+var VALID_KINDS = new Set([
+	"detections",
+	"classifications",
+	"embedding",
+	"text",
+	"mask"
+]);
+/** Every postprocessor the Python pool implements — the dispatch table's keys
+*  survived the raw-tensor removal as a config-drift guard: an unknown
+*  postprocessor in a step definition still fails fast here. */
+var KNOWN_POSTPROCESSORS = new Set([
+	"yolo",
+	"ssd",
+	"yolo-seg",
+	"scrfd",
+	"arcface",
+	"clip",
+	"softmax",
+	"ctc",
+	"saliency",
+	"yamnet"
+]);
 /**
-* Dispatch postprocessing based on step definition's postprocessor type.
-*
-* For Python backends: output.structured is already populated → passthrough.
-* For Node.js ONNX: raw tensors → postprocess in TypeScript.
+* Type guard: validates that a structured payload from the Python pool is a
+* well-formed StepOutput discriminated union.
 *
-* Both paths pass through normalizeOutput() to ensure consistent format
-* (e.g., classification top-K, alternates).
+* The Python inference_pool.py always sets `output.structured` with a `kind`
+* field. This guard narrows `Record<string, unknown>` to `StepOutput` without
+* resorting to double-cast.
 */
-function dispatchPostprocess(output, stepDef, settings) {
-	const fn = DISPATCH[stepDef.postprocessor];
-	if (!fn) throw new Error(`Unknown postprocessor type: "${stepDef.postprocessor}"`);
-	const raw = settings?.["nmsIouThreshold"];
-	return normalizeOutput(fn(output, stepDef, typeof raw === "number" && raw > 0 ? raw : DEFAULT_NMS_IOU));
+function isStepOutput(value) {
+	return typeof value === "object" && value !== null && typeof value["kind"] === "string" && VALID_KINDS.has(value["kind"]);
 }
 /**
-* Normalize any StepOutput to a consistent format.
-* Single funnel for both Python and TypeScript postprocessor paths.
+* Validate + normalize a Python-pool engine output into a StepOutput.
+*/
+function dispatchPostprocess(output, stepDef) {
+	if (output.dropped === true) return {
+		kind: "detections",
+		detections: []
+	};
+	if (!KNOWN_POSTPROCESSORS.has(stepDef.postprocessor)) throw new Error(`Unknown postprocessor type: "${stepDef.postprocessor}"`);
+	if (!output.structured) throw new Error(`Postprocessing for step "${stepDef.id}" (${stepDef.postprocessor}) runs in the Python inference pool — the engine output carried no structured payload. The Node.js raw-tensor path was removed; there is nothing to fall back to.`);
+	if (!isStepOutput(output.structured)) throw new Error(`Python pool returned structured output with unexpected kind: ${JSON.stringify(output.structured["kind"])}`);
+	return normalizeOutput(output.structured);
+}
+/**
+* Normalize any StepOutput to a consistent format — the single funnel every
+* pool payload passes through.
 *
 * Classifications: keep only top-1 in classifications, move full list to alternates.
 */
@@ -2248,78 +2202,103 @@ function normalizeOutput(output) {
 		alternates: all
 	};
 }
-function simpleNms(dets, iouThreshold) {
-	if (dets.length === 0) return [];
-	const sorted = [...dets].toSorted((a, b) => b.score - a.score);
-	const kept = [];
-	const suppressed = /* @__PURE__ */ new Set();
-	for (let i = 0; i < sorted.length; i++) {
-		if (suppressed.has(i)) continue;
-		kept.push(sorted[i]);
-		for (let j = i + 1; j < sorted.length; j++) {
-			if (suppressed.has(j)) continue;
-			if (iou(sorted[i].bbox, sorted[j].bbox) > iouThreshold) suppressed.add(j);
-		}
-	}
-	return kept;
-}
-function iou(a, b) {
-	const ix1 = Math.max(a[0], b[0]);
-	const iy1 = Math.max(a[1], b[1]);
-	const ix2 = Math.min(a[2], b[2]);
-	const iy2 = Math.min(a[3], b[3]);
-	const inter = Math.max(0, ix2 - ix1) * Math.max(0, iy2 - iy1);
-	if (inter === 0) return 0;
-	return inter / ((a[2] - a[0]) * (a[3] - a[1]) + (b[2] - b[0]) * (b[3] - b[1]) - inter);
-}
 //#endregion
-//#region src/detection-pipeline/pipeline/crop-utils.ts
-/**
-* Crop utilities — ROI extraction and bbox coordinate transforms.
-*/
-/**
-* Extract a JPEG crop from a full-frame JPEG buffer.
-* Clamps to image boundaries and returns the cropped JPEG + dimensions.
-*/
-async function cropJpeg(jpeg, bbox, imageWidth, imageHeight) {
-	const x1 = Math.max(0, Math.round(bbox[0]));
-	const y1 = Math.max(0, Math.round(bbox[1]));
-	const x2 = Math.min(imageWidth, Math.round(bbox[2]));
-	const y2 = Math.min(imageHeight, Math.round(bbox[3]));
-	const w = x2 - x1;
-	const h = y2 - y1;
-	if (w < 1 || h < 1) throw new Error(`Degenerate crop: [${x1},${y1},${x2},${y2}] on ${imageWidth}x${imageHeight}`);
-	return {
-		jpeg: await sharp(jpeg).extract({
-			left: x1,
-			top: y1,
-			width: w,
-			height: h
-		}).jpeg({ quality: 90 }).toBuffer(),
-		width: w,
-		height: h
-	};
-}
-/**
-* Transform a child detection's bbox from ROI-relative to image-absolute coordinates.
-*
-* When a child step (e.g., face-detection) runs on a crop of the parent (e.g., person),
-* its bbox is relative to the crop. This function maps it back to the full image space.
-*/
-function transformBboxToImageSpace(childBbox, parentBbox) {
-	const [px1, py1] = parentBbox;
-	return [
-		px1 + childBbox[0],
-		py1 + childBbox[1],
-		px1 + childBbox[2],
-		py1 + childBbox[3]
-	];
+//#region src/detection-pipeline/pipeline/execution-trace.ts
+var traceCounter = 0;
+var ExecutionTraceBuilder = class {
+	verbosity;
+	deviceId;
+	frameWidth;
+	frameHeight;
+	engineRuntime;
+	steps = [];
+	startTime;
+	constructor(verbosity, deviceId, frameWidth, frameHeight, engineRuntime) {
+		this.verbosity = verbosity;
+		this.deviceId = deviceId;
+		this.frameWidth = frameWidth;
+		this.frameHeight = frameHeight;
+		this.engineRuntime = engineRuntime;
+		this.startTime = Date.now();
+	}
+	/** Whether trace collection is active. */
+	get isActive() {
+		return this.verbosity !== "off";
+	}
+	/**
+	* Record a completed step execution.
+	* No-op if verbosity is 'off'.
+	*/
+	addStep(params) {
+		if (this.verbosity === "off") return;
+		const totalMs = params.preprocessMs + params.inferenceMs + params.postprocessMs;
+		const trace = {
+			stepId: params.stepId,
+			modelId: params.modelId,
+			slot: params.slot,
+			postprocessor: params.postprocessor,
+			preprocessMs: Math.round(params.preprocessMs * 100) / 100,
+			inferenceMs: Math.round(params.inferenceMs * 100) / 100,
+			postprocessMs: Math.round(params.postprocessMs * 100) / 100,
+			totalMs: Math.round(totalMs * 100) / 100,
+			inputType: params.inputType,
+			inputSize: {
+				width: params.inputWidth,
+				height: params.inputHeight
+			},
+			parentDetection: this.verbosity === "full" ? params.parentDetection : void 0,
+			outputKind: params.output.kind,
+			outputCount: countOutput(params.output),
+			topResult: this.verbosity === "full" ? formatTopResult(params.output) : void 0,
+			error: params.error
+		};
+		this.steps.push(trace);
+	}
+	/**
+	* Finalize and return the complete execution trace.
+	* Returns null if verbosity is 'off'.
+	*/
+	build(detectionCount) {
+		if (this.verbosity === "off") return null;
+		const totalMs = Date.now() - this.startTime;
+		return {
+			traceId: `trace-${Date.now()}-${++traceCounter}`,
+			deviceId: this.deviceId,
+			timestamp: this.startTime,
+			frameSize: {
+				width: this.frameWidth,
+				height: this.frameHeight
+			},
+			engineRuntime: this.engineRuntime,
+			steps: this.steps,
+			totalMs,
+			detectionCount
+		};
+	}
+};
+function countOutput(output) {
+	switch (output.kind) {
+		case "detections": return output.detections.length;
+		case "classifications": return output.classifications.length;
+		case "embedding": return 1;
+		case "text": return output.text.length > 0 ? 1 : 0;
+		case "mask": return 1;
+	}
 }
-/**
-* Check if a bbox is degenerate (zero or negative area).
-*/
-function isBboxDegenerate(bbox) {
-	return bbox[2] - bbox[0] < 1 || bbox[3] - bbox[1] < 1;
+function formatTopResult(output) {
+	switch (output.kind) {
+		case "detections": {
+			const top = output.detections[0];
+			return top ? `${top.class} ${top.score.toFixed(2)}` : void 0;
+		}
+		case "classifications": {
+			const top = output.classifications[0];
+			return top ? `${top.class} ${top.score.toFixed(2)}` : void 0;
+		}
+		case "embedding": return `embedding[${output.embedding.length}]`;
+		case "text": return output.text || void 0;
+		case "mask": return `mask ${output.maskWidth}×${output.maskHeight}`;
+	}
 }
 //#endregion
 //#region src/detection-pipeline/pipeline/face-align.ts
@@ -2627,63 +2606,6 @@ async function alignFaceCrop(fullFrameJpeg, faceBbox, landmarksImageSpace, image
 		height: aligned.height
 	};
 }
-//#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 sharp(Buffer.from(native.bytes), { raw: {
-			width: native.width,
-			height: native.height,
-			channels: 3
-		} }).jpeg({ quality: 90 }).toBuffer(),
-		width: native.width,
-		height: native.height
-	};
-}
 /**
 * Detection score at/above which a near-full-frame box is trusted as a REAL
 * close subject rather than a phantom. Below this bar a full-frame box is
@@ -2765,6 +2687,63 @@ function isFullFramePhantomDetection(bbox, frameWidth, frameHeight, score, maxCo
 	return false;
 }
 //#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 sharp(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.
@@ -3279,6 +3258,7 @@ function buildFrameResult(input) {
 		width: input.width,
 		height: input.height,
 		detections,
+		...input.discarded !== void 0 && input.discarded.length > 0 ? { discarded: input.discarded } : {},
 		debug: frameDebug
 	};
 }
@@ -3288,136 +3268,38 @@ function bboxTupleToRect(bbox) {
 		x: x1,
 		y: y1,
 		width: x2 - x1,
-		height: y2 - y1
-	};
-}
-function pruneUndefined(obj) {
-	const out = {};
-	for (const [k, v] of Object.entries(obj)) if (v !== void 0) out[k] = v;
-	return out;
-}
-function generateFrameId() {
-	return `frame-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-}
-/** Seed a MutableObjectDetection from a root-level detector output. */
-function toMutableRootDetection(det, rootStep, idGen, rootStepLatencyMs) {
-	return {
-		id: idGen.next(),
-		kind: "first-level",
-		macroClass: det.class,
-		originalClass: det.class,
-		score: det.score,
-		bbox: [...det.bbox],
-		ownLabels: [],
-		alternateLabels: {},
-		stepLatencyMs: { [rootStep.stepId]: rootStepLatencyMs },
-		modelIds: { [rootStep.stepId]: rootStep.modelId },
-		extractMode: "full-frame",
-		...det.mask !== void 0 ? {
-			mask: det.mask,
-			maskWidth: det.maskWidth,
-			maskHeight: det.maskHeight
-		} : {},
-		...det.landmarks !== void 0 ? { landmarks: det.landmarks } : {}
-	};
-}
-//#endregion
-//#region src/detection-pipeline/pipeline/execution-trace.ts
-var traceCounter = 0;
-var ExecutionTraceBuilder = class {
-	verbosity;
-	deviceId;
-	frameWidth;
-	frameHeight;
-	engineRuntime;
-	steps = [];
-	startTime;
-	constructor(verbosity, deviceId, frameWidth, frameHeight, engineRuntime) {
-		this.verbosity = verbosity;
-		this.deviceId = deviceId;
-		this.frameWidth = frameWidth;
-		this.frameHeight = frameHeight;
-		this.engineRuntime = engineRuntime;
-		this.startTime = Date.now();
-	}
-	/** Whether trace collection is active. */
-	get isActive() {
-		return this.verbosity !== "off";
-	}
-	/**
-	* Record a completed step execution.
-	* No-op if verbosity is 'off'.
-	*/
-	addStep(params) {
-		if (this.verbosity === "off") return;
-		const totalMs = params.preprocessMs + params.inferenceMs + params.postprocessMs;
-		const trace = {
-			stepId: params.stepId,
-			modelId: params.modelId,
-			slot: params.slot,
-			postprocessor: params.postprocessor,
-			preprocessMs: Math.round(params.preprocessMs * 100) / 100,
-			inferenceMs: Math.round(params.inferenceMs * 100) / 100,
-			postprocessMs: Math.round(params.postprocessMs * 100) / 100,
-			totalMs: Math.round(totalMs * 100) / 100,
-			inputType: params.inputType,
-			inputSize: {
-				width: params.inputWidth,
-				height: params.inputHeight
-			},
-			parentDetection: this.verbosity === "full" ? params.parentDetection : void 0,
-			outputKind: params.output.kind,
-			outputCount: countOutput(params.output),
-			topResult: this.verbosity === "full" ? formatTopResult(params.output) : void 0,
-			error: params.error
-		};
-		this.steps.push(trace);
-	}
-	/**
-	* Finalize and return the complete execution trace.
-	* Returns null if verbosity is 'off'.
-	*/
-	build(detectionCount) {
-		if (this.verbosity === "off") return null;
-		const totalMs = Date.now() - this.startTime;
-		return {
-			traceId: `trace-${Date.now()}-${++traceCounter}`,
-			deviceId: this.deviceId,
-			timestamp: this.startTime,
-			frameSize: {
-				width: this.frameWidth,
-				height: this.frameHeight
-			},
-			engineRuntime: this.engineRuntime,
-			steps: this.steps,
-			totalMs,
-			detectionCount
-		};
-	}
-};
-function countOutput(output) {
-	switch (output.kind) {
-		case "detections": return output.detections.length;
-		case "classifications": return output.classifications.length;
-		case "embedding": return 1;
-		case "text": return output.text.length > 0 ? 1 : 0;
-		case "mask": return 1;
-	}
+		height: y2 - y1
+	};
 }
-function formatTopResult(output) {
-	switch (output.kind) {
-		case "detections": {
-			const top = output.detections[0];
-			return top ? `${top.class} ${top.score.toFixed(2)}` : void 0;
-		}
-		case "classifications": {
-			const top = output.classifications[0];
-			return top ? `${top.class} ${top.score.toFixed(2)}` : void 0;
-		}
-		case "embedding": return `embedding[${output.embedding.length}]`;
-		case "text": return output.text || void 0;
-		case "mask": return `mask ${output.maskWidth}×${output.maskHeight}`;
-	}
+function pruneUndefined(obj) {
+	const out = {};
+	for (const [k, v] of Object.entries(obj)) if (v !== void 0) out[k] = v;
+	return out;
+}
+function generateFrameId() {
+	return `frame-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+}
+/** Seed a MutableObjectDetection from a root-level detector output. */
+function toMutableRootDetection(det, rootStep, idGen, rootStepLatencyMs) {
+	return {
+		id: idGen.next(),
+		kind: "first-level",
+		macroClass: det.class,
+		originalClass: det.class,
+		score: det.score,
+		bbox: [...det.bbox],
+		ownLabels: [],
+		alternateLabels: {},
+		stepLatencyMs: { [rootStep.stepId]: rootStepLatencyMs },
+		modelIds: { [rootStep.stepId]: rootStep.modelId },
+		extractMode: "full-frame",
+		...det.mask !== void 0 ? {
+			mask: det.mask,
+			maskWidth: det.maskWidth,
+			maskHeight: det.maskHeight
+		} : {},
+		...det.landmarks !== void 0 ? { landmarks: det.landmarks } : {}
+	};
 }
 //#endregion
 //#region src/detection-pipeline/pipeline/executor.ts
@@ -3569,12 +3451,14 @@ var PipelineExecutor = class {
 			idGen,
 			details
 		};
+		let discarded;
 		for (const rootStep of tree.roots) {
 			if (debug) console.log(`[executor] rootStep=${rootStep.stepId} settings=${JSON.stringify(rootStep.settings ?? {})}`);
 			const cropPrep = rootStep.definition.extractMode === "crop-zone" && cropZoneBbox !== void 0 ? await this.prepareCropZoneInput(cropZoneBbox, fullFrameJpegProvider, imageWidth, imageHeight, deviceId) : null;
 			const rootStart = Date.now();
 			const rawRootOutput = await this.executeStep(rootStep, cropPrep?.input ?? rootInput, cropPrep?.width ?? imageWidth, cropPrep?.height ?? imageHeight, "full-frame", void 0, void 0, traceBuilder, stepTimings, poolAgg);
 			const rootMs = Date.now() - rootStart;
+			if (rawRootOutput === null) continue;
 			const rootOutput = cropPrep && rawRootOutput.kind === "detections" ? reprojectCropZoneDetections(rawRootOutput, cropPrep.origin) : rawRootOutput;
 			if (rootOutput.kind !== "detections") {
 				if (isEnrichmentOutput(rootOutput)) {
@@ -3604,10 +3488,35 @@ var PipelineExecutor = class {
 					if (mapped) {
 						mutable.originalClass = det.class;
 						mutable.macroClass = mapped;
-					} else if (!rootStep.definition.classMap.preserveOriginal) continue;
+					} else if (!rootStep.definition.classMap.preserveOriginal) {
+						(discarded ??= []).push({
+							bbox: [
+								mutable.bbox[0],
+								mutable.bbox[1],
+								mutable.bbox[2],
+								mutable.bbox[3]
+							],
+							macroClass: mutable.macroClass,
+							score: mutable.score,
+							reason: "class-filter"
+						});
+						continue;
+					}
 				}
-				if (!this.matchesMacroFilter(mutable.macroClass, mutable.score, rootStep.settings)) {
-					if (debug) console.log(`[executor] drop det macro=${mutable.macroClass} score=${mutable.score} (class or confidence filter)`);
+				const filterVerdict = this.macroFilterVerdict(mutable.macroClass, mutable.score, rootStep.settings);
+				if (filterVerdict !== "pass") {
+					(discarded ??= []).push({
+						bbox: [
+							mutable.bbox[0],
+							mutable.bbox[1],
+							mutable.bbox[2],
+							mutable.bbox[3]
+						],
+						macroClass: mutable.macroClass,
+						score: mutable.score,
+						reason: filterVerdict
+					});
+					if (debug) console.log(`[executor] drop det macro=${mutable.macroClass} score=${mutable.score} (${filterVerdict})`);
 					continue;
 				}
 				const fullFrameBar = rootStep.settings?.["fullFrameGuardMaxConfidence"];
@@ -3626,9 +3535,20 @@ var PipelineExecutor = class {
 							hardAreaRatio: typeof fullFrameHardArea === "number" ? fullFrameHardArea : void 0
 						}
 					});
+					(discarded ??= []).push({
+						bbox: [
+							mutable.bbox[0],
+							mutable.bbox[1],
+							mutable.bbox[2],
+							mutable.bbox[3]
+						],
+						macroClass: mutable.macroClass,
+						score: mutable.score,
+						reason: "full-frame-guard"
+					});
 					continue;
 				}
-				if (isFullFrameSurvivor(mutable.bbox, imageWidth, imageHeight, mutable.score, typeof fullFrameBar === "number" ? fullFrameBar : void 0)) this.opts.logger?.warn("full-frame box SURVIVED the guard on score", {
+				if (isFullFrameSurvivor(mutable.bbox, imageWidth, imageHeight, mutable.score, typeof fullFrameBar === "number" ? fullFrameBar : void 0)) this.opts.logger?.info("full-frame box SURVIVED the guard on score", {
 					tags: { deviceId },
 					meta: {
 						macroClass: mutable.macroClass,
@@ -3655,6 +3575,7 @@ var PipelineExecutor = class {
 				firstLevel.push(mutable);
 			}
 		}
+		const totalMs = Date.now() - startMs;
 		return {
 			result: buildFrameResult({
 				deviceId,
@@ -3662,8 +3583,9 @@ var PipelineExecutor = class {
 				height: imageHeight,
 				firstLevel,
 				details,
+				discarded,
 				stepTimings,
-				totalMs: Date.now() - startMs,
+				totalMs,
 				engine: this.opts.engineRuntime,
 				debug,
 				timestamp: Date.now(),
@@ -3768,13 +3690,40 @@ var PipelineExecutor = class {
 			});
 			throw new Error(`Inference failed for step "${step.stepId}": ${errorMsg}`, { cause: err });
 		}
+		if (engineOutput.dropped === true) {
+			stepTimings.push({
+				source: step.stepId,
+				modelId: step.modelId,
+				ms: Date.now() - preprocessStart,
+				detectionCount: 0
+			});
+			if (traceBuilder.isActive) traceBuilder.addStep({
+				stepId: step.stepId,
+				modelId: step.modelId,
+				slot: step.definition.slot,
+				postprocessor: step.definition.postprocessor,
+				preprocessMs,
+				inferenceMs: Date.now() - inferenceStart,
+				postprocessMs: 0,
+				inputType,
+				inputWidth,
+				inputHeight,
+				parentDetection: parentClass,
+				output: {
+					kind: "detections",
+					detections: []
+				},
+				error: `shed:${engineOutput.shedReason ?? "pool-overload"}`
+			});
+			return null;
+		}
 		const structured = engineOutput.structured ?? {};
 		const inferenceMs = typeof structured.inferenceMs === "number" ? structured.inferenceMs : Date.now() - inferenceStart;
 		if (typeof structured.preprocessMs === "number") poolAgg.preprocessMs += structured.preprocessMs;
 		if (typeof structured.predictMs === "number") poolAgg.predictMs += structured.predictMs;
 		if (typeof structured.batchSize === "number" && structured.batchSize > poolAgg.batchSize) poolAgg.batchSize = structured.batchSize;
 		const postprocessStart = Date.now();
-		const output = dispatchPostprocess(engineOutput, step.definition, step.settings);
+		const output = dispatchPostprocess(engineOutput, step.definition);
 		const postprocessMs = Date.now() - postprocessStart;
 		stepTimings.push({
 			source: step.stepId,
@@ -3917,6 +3866,7 @@ var PipelineExecutor = class {
 					data: cropJpegBuf
 				}, cropW, cropH, "crop-roi", parentDetection.bbox, parentDetection.macroClass, traceBuilder, stepTimings, poolAgg);
 				const childMs = Date.now() - childStart;
+				if (childOutput === null) continue;
 				const detailsBefore = ctx.details.length;
 				applyChildOutput(parentDetection, child, childOutput, childMs, ctx);
 				if (childOutput.kind === "detections" && child.children.length > 0) {
@@ -3950,20 +3900,25 @@ var PipelineExecutor = class {
 	* Apply the object-detection step's macro filter + per-macro
 	* minConfidence sliders introduced in the Phase 6 step rework.
 	*
+	* Returns WHICH gate failed rather than a bare boolean so the
+	* discard trail can label the dropped box with the honest reason
+	* (`class-filter` vs `below-threshold`) — the two are remediated
+	* differently (enable the class vs lower a slider).
+	*
 	* Expected `settings` shape:
 	*   - `enabledMacroClasses`: readonly string[] (e.g. ['person','vehicle','animal']).
 	*     Empty array = all allowed (legacy behaviour).
 	*   - `minConfidence<Macro>`: number (e.g. `minConfidencePerson: 0.5`)
 	*/
-	matchesMacroFilter(macroClass, score, settings) {
-		if (!settings) return true;
+	macroFilterVerdict(macroClass, score, settings) {
+		if (!settings) return "pass";
 		const enabled = settings["enabledMacroClasses"];
 		if (Array.isArray(enabled) && enabled.length > 0) {
-			if (!enabled.includes(macroClass)) return false;
+			if (!enabled.includes(macroClass)) return "class-filter";
 		}
 		const perMacroThreshold = settings[`minConfidence${capitalize(macroClass)}`];
-		if (typeof perMacroThreshold === "number" && score < perMacroThreshold) return false;
-		return true;
+		if (typeof perMacroThreshold === "number" && score < perMacroThreshold) return "below-threshold";
+		return "pass";
 	}
 };
 function capitalize(s) {
@@ -3971,52 +3926,41 @@ function capitalize(s) {
 	return s.charAt(0).toUpperCase() + s.slice(1);
 }
 //#endregion
-//#region src/detection-pipeline/pipeline/crop-zone.ts
+//#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;
+}
 /**
-* Resolve the absolute-pixel crop bbox for a `crop-zone` root detector: the
-* bounding box of the UNION of every polygon referenced by the device's
-* ENABLED `package`-stage zone rules. Zone polygons are normalized (0..1); the
-* union is clamped to [0,1] then scaled to the frame's pixel dimensions.
+* 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.
 *
-* Returns `null` when there is nothing usable to crop to — no enabled rules, no
-* referenced geometry, or a degenerate result — in which case the caller falls
-* back to full-frame inference (behaviour identical to before the crop-zone
-* plumbing).
+* Pure — never mutates its arguments.
 */
-function resolvePackageCropBbox(zones, packageRules, frameWidth, frameHeight) {
-	if (frameWidth <= 0 || frameHeight <= 0) return null;
-	const enabledRules = packageRules.filter((r) => r.enabled !== false);
-	if (enabledRules.length === 0) return null;
-	const zoneIds = /* @__PURE__ */ new Set();
-	for (const rule of enabledRules) for (const id of rule.zoneIds) zoneIds.add(id);
-	if (zoneIds.size === 0) return null;
-	const zoneById = new Map(zones.map((z) => [z.id, z]));
-	let minX = Number.POSITIVE_INFINITY;
-	let minY = Number.POSITIVE_INFINITY;
-	let maxX = Number.NEGATIVE_INFINITY;
-	let maxY = Number.NEGATIVE_INFINITY;
-	let sawPoint = false;
-	for (const id of zoneIds) {
-		const zone = zoneById.get(id);
-		if (!zone || zone.polygon.length === 0) continue;
-		for (const point of zone.polygon) {
-			sawPoint = true;
-			if (point.x < minX) minX = point.x;
-			if (point.y < minY) minY = point.y;
-			if (point.x > maxX) maxX = point.x;
-			if (point.y > maxY) maxY = point.y;
-		}
-	}
-	if (!sawPoint) return null;
-	const clamp01 = (v) => Math.max(0, Math.min(1, v));
-	const bbox = [
-		clamp01(minX) * frameWidth,
-		clamp01(minY) * frameHeight,
-		clamp01(maxX) * frameWidth,
-		clamp01(maxY) * frameHeight
-	];
-	if (isBboxDegenerate(bbox)) return null;
-	return bbox;
+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/pipeline/tree-builder.ts
@@ -4252,6 +4196,44 @@ function resolveInputSteps(steps, format, engine) {
 	};
 }
 //#endregion
+//#region src/detection-pipeline/zone-gate.ts
+function applyZoneRuleGate(result, zones, rules) {
+	if (result.detections.length === 0) return result;
+	if (zones.length === 0 || rules.length === 0) return result;
+	const frameW = result.width;
+	const frameH = result.height;
+	if (frameW === 0 || frameH === 0) return result;
+	const firstLevel = result.detections.filter((d) => d.kind === "first-level");
+	const details = result.detections.filter((d) => d.kind === "detail");
+	const { passed, excluded } = evaluateZoneRules(firstLevel, zones, rules, (det) => ({
+		x: (det.bbox.x + det.bbox.width / 2) / frameW,
+		y: (det.bbox.y + det.bbox.height / 2) / frameH
+	}), (det) => det.macroClass);
+	if (passed.length === firstLevel.length) return result;
+	const passedIds = new Set(passed.map((d) => d.id));
+	const filteredDetails = details.filter((d) => {
+		const parentId = d.parentId;
+		return parentId === void 0 || passedIds.has(parentId);
+	});
+	const zoneDiscards = excluded.map((d) => ({
+		bbox: [
+			d.bbox.x,
+			d.bbox.y,
+			d.bbox.x + d.bbox.width,
+			d.bbox.y + d.bbox.height
+		],
+		macroClass: d.macroClass,
+		score: d.score,
+		reason: "zone-gate"
+	}));
+	const mergedDiscarded = [...result.discarded ?? [], ...zoneDiscards];
+	return {
+		...result,
+		detections: [...passed, ...filteredDetails],
+		...mergedDiscarded.length > 0 ? { discarded: mergedDiscarded } : {}
+	};
+}
+//#endregion
 //#region src/detection-pipeline/provider.ts
 /**
 * DetectionPipelineProvider — implements IPipelineExecutorProvider.
@@ -4953,8 +4935,10 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 			modelsDir: this.modelsDir,
 			logger: this.log.child("engine-verify"),
 			pythonPath: this.executorOptions.pythonPath,
-			concurrency: 1,
-			numWorkers: 1
+			provisioning: {
+				concurrency: 1,
+				numWorkers: 1
+			}
 		});
 		try {
 			await probe.initialize([]);
@@ -5648,19 +5632,15 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 			emit(`Image: ${imageWidth}×${imageHeight}`);
 		}
 		decodeMs = performance.now() - decodeT0;
-		const deviceEngine = input.deviceKey ? resolveDeviceEngine(input.deviceKey) : void 0;
-		const resolveFormat = deviceEngine?.format ?? input.engine?.format ?? this.currentEngine.format;
-		const resolveEngine = deviceEngine ? {
-			backend: deviceEngine.backend,
-			device: deviceEngine.device ?? null
-		} : input.engine ? {
-			backend: input.engine.backend,
-			device: input.engine.device ?? null
-		} : {
-			backend: this.currentEngine.backend,
-			device: this.currentEngine.device ?? null
-		};
-		const benchmarkSteps = this.inputStepsToPipelineSteps(input.steps, resolveFormat, resolveEngine);
+		const dispatchResolution = this.resolveStepsForDispatch({
+			steps: input.steps,
+			deviceKey: input.deviceKey,
+			engineOverride: input.engine,
+			deviceId: input.deviceId,
+			plane: input.plane
+		});
+		const dispatchDeviceKey = dispatchResolution.deviceKey;
+		const benchmarkSteps = dispatchResolution.steps;
 		const stepsSignature = JSON.stringify(benchmarkSteps.map((s) => ({
 			id: s.addonId,
 			settings: s.settings ?? {}
@@ -5710,9 +5690,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 				modelsDir: this.modelsDir,
 				logger: this.log.child("engine-override"),
 				pythonPath: this.executorOptions.pythonPath ?? "",
-				concurrency: this.executorOptions.concurrency,
-				tuning: this.executorOptions.tuning,
-				numWorkers: this.executorOptions.numWorkers
+				provisioning: this.executorOptions.provisioning
 			});
 			const initPromise = newFactory.initialize([]);
 			this.overrideCache = {
@@ -5754,8 +5732,8 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 				logger: this.log
 			});
 			this.executor = executor;
-			const dispatchEngine = input.deviceKey ? resolveDeviceEngine(input.deviceKey) : runEngine;
-			const dispatchFactory = input.deviceKey ? await this.resolveDeviceFactory(input.deviceKey) : this.engineFactory;
+			const dispatchEngine = dispatchDeviceKey ? resolveDeviceEngine(dispatchDeviceKey) : runEngine;
+			const dispatchFactory = dispatchDeviceKey ? await this.resolveDeviceFactory(dispatchDeviceKey) : this.engineFactory;
 			const needed = enabledSteps.filter((s) => !dispatchFactory.isLoadedWithModel(s.addonId, s.modelId));
 			if (needed.length > 0) {
 				this.log.info("Benchmark: models to load", { meta: {
@@ -5892,9 +5870,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 				modelsDir: this.modelsDir,
 				logger: this.log.child("engine-override"),
 				pythonPath: this.executorOptions.pythonPath ?? "",
-				concurrency: this.executorOptions.concurrency,
-				tuning: this.executorOptions.tuning,
-				numWorkers: this.executorOptions.numWorkers
+				provisioning: this.executorOptions.provisioning
 			});
 			const initPromise = newFactory.initialize([]);
 			this.overrideCache = {
@@ -6006,6 +5982,142 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 		fn();
 	}
 	/**
+	* Resolve a dispatch's step tree against its target engine, with the
+	* CAPABILITY GATE + node-local engine fallback (cam-615, 2026-08-01;
+	* per-step split 2026-08-01 evening).
+	*
+	* A per-call `deviceKey` (orchestrator device routing / detail-plane step
+	* jump) selects an engine whose format every step EXECUTING IN THIS CALL
+	* must actually ship a model build for. When such a step's catalog has
+	* ZERO builds for that format (so not even `resolveModelForFormat`'s
+	* substitution can rescue it), dispatching anyway means every frame
+	* fails — before this gate it failed as a doomed 3-retry model download,
+	* ~5.5s per frame, forever.
+	*
+	* The gated set is per-plane — the ROOT decides the dispatch device, a
+	* child never bounces it (operator requirement: devices compensate for
+	* each other's missing steps; the original whole-tree gate let ONE
+	* tflite-less child knock the root off an otherwise-capable Coral):
+	*
+	*  - `'frame'` (the live per-frame path) executes only root-plane steps,
+	*    so only those gate the device. Detail children that can NEVER run on
+	*    this device are pruned from THIS dispatch (so `ensureModelsForSteps`
+	*    doesn't fail the call on a format build that does not exist) and
+	*    logged once — NOT dropped work: each runs later as its own per-track
+	*    detail dispatch, where the runner's device-jump resolver
+	*    (`resolveStepDevice`) places it on a same-node device that can run
+	*    it, or warns no-candidate loudly.
+	*  - any other plane (detail subtrees, benchmark, batch) executes the
+	*    whole passed tree inline on ONE pool — a single call cannot split
+	*    devices — so the whole-tree gate stays.
+	*
+	* Fallback is strictly NODE-LOCAL and ordered: the node's own selected
+	* engine (or the benchmark's explicit `engineOverride`) is the one and only
+	* fallback — frames never migrate to another node from here (that is the
+	* orchestrator's tier). The fallback is logged ONCE per distinct
+	* (deviceKey, steps, format) signature, with `tags: { deviceId }` when the
+	* dispatch is camera-scoped.
+	*
+	* When the node's own engine ALSO cannot run a step, this throws — fast,
+	* before any download attempt — and logs the full picture once (model,
+	* its available formats, both engines tried). A genuinely impossible
+	* configuration must stay loud, not vanish into a silent fallback chain.
+	*/
+	resolveStepsForDispatch(args) {
+		const { deviceKey, engineOverride, deviceId } = args;
+		const nodeFormat = engineOverride?.format ?? this.currentEngine.format;
+		const nodeEngine = engineOverride ? {
+			backend: engineOverride.backend,
+			device: engineOverride.device ?? null
+		} : {
+			backend: this.currentEngine.backend,
+			device: this.currentEngine.device ?? null
+		};
+		const nodeEngineLabel = `${nodeEngine.backend}/${nodeEngine.device ?? "default"} (${nodeFormat})`;
+		const deviceEngine = deviceKey ? resolveDeviceEngine(deviceKey) : void 0;
+		if (deviceKey === void 0 || deviceEngine === void 0) {
+			const steps = this.inputStepsToPipelineSteps(args.steps, nodeFormat, nodeEngine);
+			this.assertStepsRunnable(steps, nodeFormat, deviceId, [nodeEngineLabel]);
+			return {
+				deviceKey: void 0,
+				steps
+			};
+		}
+		const deviceFormat = deviceEngine.format;
+		const deviceStepEngine = {
+			backend: deviceEngine.backend,
+			device: deviceEngine.device ?? null
+		};
+		const steps = this.inputStepsToPipelineSteps(args.steps, deviceFormat, deviceStepEngine);
+		const framePlane = args.plane === "frame";
+		const zeroBuild = collectZeroBuildIssues(framePlane ? collectFramePlaneSteps(steps, isDetailPlaneStep) : flattenSteps(steps), deviceFormat);
+		if (zeroBuild.length === 0) {
+			if (!framePlane) return {
+				deviceKey,
+				steps
+			};
+			const pruneResult = pruneUnrunnableDetailSteps(steps, isDetailPlaneStep, (addonId) => stepHasZeroBuildsFor(addonId, deviceFormat));
+			if (pruneResult.prunedAddonIds.length > 0) {
+				const prunedList = pruneResult.prunedAddonIds.join(",");
+				this.logLiveDispatchIssueOnce(`detail-defer:${deviceKey}:${deviceFormat}:${prunedList}`, () => this.log.info("Detail steps have no model build for the dispatch device format — deferred to the detail-plane device jump", {
+					...deviceId !== void 0 ? { tags: { deviceId } } : {},
+					meta: {
+						deviceKey,
+						deviceFormat,
+						steps: [...pruneResult.prunedAddonIds]
+					}
+				}));
+			}
+			return {
+				deviceKey,
+				steps: pruneResult.steps
+			};
+		}
+		const blockedSteps = zeroBuild.map((issue) => issue.addonId);
+		this.logLiveDispatchIssueOnce(`capability-fallback:${deviceKey}:${deviceFormat}:${blockedSteps.join(",")}`, () => this.log.warn("Device pool cannot run step (no model build for its format) — falling back to the node-local default engine", {
+			...deviceId !== void 0 ? { tags: { deviceId } } : {},
+			meta: {
+				deviceKey,
+				deviceFormat,
+				steps: blockedSteps,
+				fallbackEngine: nodeEngineLabel
+			}
+		}));
+		const fallbackSteps = this.inputStepsToPipelineSteps(args.steps, nodeFormat, nodeEngine);
+		this.assertStepsRunnable(fallbackSteps, nodeFormat, deviceId, [`${deviceKey} (${deviceFormat})`, nodeEngineLabel]);
+		return {
+			deviceKey: void 0,
+			steps: fallbackSteps
+		};
+	}
+	/**
+	* The loud, fast half of the capability gate: throw when any ENABLED step
+	* has ZERO model builds for `format` — BEFORE any model download runs. The
+	* error names the step, its chosen model, the formats the catalog actually
+	* ships, and every engine that was tried, and is logged ONCE per distinct
+	* signature (the throw itself still surfaces per dispatch, but costs
+	* microseconds instead of a 3-retry download backoff).
+	*/
+	assertStepsRunnable(steps, format, deviceId, enginesTried) {
+		const zeroBuild = collectZeroBuildIssues(flattenSteps(steps), format);
+		if (zeroBuild.length === 0) return;
+		const detail = zeroBuild.map((issue) => {
+			const step = flattenSteps(steps).find((s) => s.addonId === issue.addonId);
+			const formats = availableFormatsForStep(issue.addonId);
+			return `step "${issue.addonId}" (model "${step?.modelId ?? "unknown"}") has no ${format} build (available: ${formats.join(", ") || "none"})`;
+		}).join("; ");
+		const message = `Pipeline dispatch impossible on this node: ${detail}. Engines tried: ${enginesTried.join(" → ")}.`;
+		this.logLiveDispatchIssueOnce(`unrunnable:${format}:${zeroBuild.map((i) => i.addonId).join(",")}`, () => this.log.error("Pipeline step cannot run on any node-local engine", {
+			...deviceId !== void 0 ? { tags: { deviceId } } : {},
+			meta: {
+				format,
+				enginesTried: [...enginesTried],
+				detail
+			}
+		}));
+		throw new Error(message);
+	}
+	/**
 	* Single-flight gate around `ensureModelsForSteps`. Concurrent
 	* callers (every camera that fires motion in the same window calls
 	* `runPipeline` → `ensureModelsForSteps`) share the same in-flight
@@ -6032,6 +6144,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 			for (const step of needed) {
 				const modelEntry = await this.resolveModelEntry(step.addonId, step.modelId);
 				if (modelEntry && !isModelDownloaded(this.modelsDir, modelEntry, format)) {
+					if (modelEntry.formats[format] === void 0) throw new Error(`Model "${modelEntry.id}" has no ${format} format build (available: ${Object.keys(modelEntry.formats).join(", ") || "none"}) — not retrying a permanent format mismatch`);
 					this.log.info("Downloading model for step", { meta: {
 						modelId: step.modelId,
 						format,
@@ -6149,19 +6262,16 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	}
 	async runPipelineBatchImpl(input) {
 		if (input.frames.length === 0) return { results: [] };
-		const deviceEngine = input.deviceKey ? resolveDeviceEngine(input.deviceKey) : void 0;
-		const resolveFormat = deviceEngine?.format ?? input.engine?.format ?? this.currentEngine.format;
-		const resolveEngine = deviceEngine ? {
-			backend: deviceEngine.backend,
-			device: deviceEngine.device ?? null
-		} : input.engine ? {
-			backend: input.engine.backend,
-			device: input.engine.device ?? null
-		} : {
-			backend: this.currentEngine.backend,
-			device: this.currentEngine.device ?? null
-		};
-		const benchmarkSteps = this.inputStepsToPipelineSteps(input.steps, resolveFormat, resolveEngine);
+		const dispatchResolution = this.resolveStepsForDispatch({
+			steps: input.steps,
+			deviceKey: input.deviceKey,
+			engineOverride: input.engine,
+			deviceId: input.deviceId,
+			plane: void 0
+		});
+		const dispatchDeviceKey = dispatchResolution.deviceKey;
+		const resolveFormat = dispatchDeviceKey ? resolveDeviceEngine(dispatchDeviceKey).format : input.engine?.format ?? this.currentEngine.format;
+		const benchmarkSteps = dispatchResolution.steps;
 		const enabledSteps = flattenEnabledVideoSteps(benchmarkSteps);
 		if (enabledSteps.length === 0) throw new Error("runPipelineBatch: no enabled steps");
 		const rootStep = enabledSteps[0];
@@ -6183,7 +6293,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 		await this.ensureEngineFactory();
 		const restoreEngine = await this.applyEngineOverride(input.engine);
 		try {
-			const factory = input.deviceKey ? await this.resolveDeviceFactory(input.deviceKey) : this.engineFactory;
+			const factory = dispatchDeviceKey ? await this.resolveDeviceFactory(dispatchDeviceKey) : this.engineFactory;
 			if (!factory) throw new Error("runPipelineBatch: factory not initialised");
 			if (enabledSteps.filter((s) => !factory.isLoadedWithModel(s.addonId, s.modelId)).length > 0) await this.ensureModelsForSteps(benchmarkSteps, factory, resolveFormat);
 			const canFastPath = singleRoot && allRaw && uniformDims && factory.supportsBatch();
@@ -6200,7 +6310,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 				frame,
 				deviceId: input.deviceId,
 				sessionId: input.sessionId,
-				deviceKey: input.deviceKey
+				deviceKey: dispatchDeviceKey
 			}))) };
 			const items = input.frames.map((frame) => ({
 				raw: Buffer.from(frame.data),
@@ -6385,31 +6495,10 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	* detections).
 	*/
 	gateDetectionsByZoneRules(deviceId, result) {
-		if (deviceId <= 0 || result.detections.length === 0) return result;
+		if (deviceId <= 0) return result;
 		const proxy = this.deviceProxies.get(deviceId);
 		if (!proxy) return result;
-		const zones = proxy.state.zones.value?.zones ?? [];
-		const rules = proxy.state.zoneRules.value?.detection ?? [];
-		if (zones.length === 0 || rules.length === 0) return result;
-		const frameW = result.width;
-		const frameH = result.height;
-		if (frameW === 0 || frameH === 0) return result;
-		const firstLevel = result.detections.filter((d) => d.kind === "first-level");
-		const details = result.detections.filter((d) => d.kind === "detail");
-		const { passed } = evaluateZoneRules(firstLevel, zones, rules, (det) => ({
-			x: (det.bbox.x + det.bbox.width / 2) / frameW,
-			y: (det.bbox.y + det.bbox.height / 2) / frameH
-		}), (det) => det.macroClass);
-		if (passed.length === firstLevel.length) return result;
-		const passedIds = new Set(passed.map((d) => d.id));
-		const filteredDetails = details.filter((d) => {
-			const parentId = d.parentId;
-			return parentId === void 0 || passedIds.has(parentId);
-		});
-		return {
-			...result,
-			detections: [...passed, ...filteredDetails]
-		};
+		return applyZoneRuleGate(result, proxy.state.zones.value?.zones ?? [], proxy.state.zoneRules.value?.detection ?? []);
 	}
 	async cacheFrameInPool(input) {
 		await this.ensureEngineFactory();
@@ -6426,13 +6515,18 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 		if (!this.engineFactory) return;
 		await this.engineFactory.uncacheFrame(input.frameId);
 	}
+	/**
+	* The tuning of the node's DEFAULT pool. Per-device pools each resolve their
+	* own runtime's row, so this is not "the node's tuning" — the per-pool truth
+	* is on each pool's `Python inference pool` log line and in `listLoadedEngines`.
+	*/
 	async getEffectiveTuning() {
-		const t = this.executorOptions.tuning;
+		const p = resolvePoolProvisioning(this.currentEngine, this.executorOptions.provisioning);
 		return {
-			batchMode: t?.batchMode ?? "none",
-			windowMs: t?.windowMs ?? 0,
-			maxBatchSize: t?.maxBatchSize ?? 1,
-			concurrency: this.executorOptions.concurrency ?? 1
+			batchMode: p.batchMode,
+			windowMs: p.windowMs,
+			maxBatchSize: p.maxBatchSize,
+			concurrency: p.concurrency
 		};
 	}
 	/**
@@ -6450,9 +6544,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 			modelsDir: this.modelsDir,
 			logger: this.log.child("engine"),
 			pythonPath: this.executorOptions.pythonPath ?? "",
-			concurrency: this.executorOptions.concurrency,
-			tuning: this.executorOptions.tuning,
-			numWorkers: this.executorOptions.numWorkers
+			provisioning: this.executorOptions.provisioning
 		});
 		await this.engineFactory.initialize([]);
 	}
@@ -6491,13 +6583,18 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 				modelsDir: this.modelsDir,
 				logger: this.log.child(`engine:${deviceKey}`),
 				pythonPath: this.executorOptions.pythonPath ?? "",
-				concurrency: this.executorOptions.concurrency,
-				tuning: this.executorOptions.tuning,
-				numWorkers: this.executorOptions.numWorkers
+				provisioning: this.executorOptions.provisioning
 			});
 			try {
 				await factory.initialize([]);
 			} catch (err) {
+				this.log.error("Device pool failed to initialize", { meta: {
+					deviceKey,
+					backend: engine.backend,
+					device: engine.device ?? null,
+					provisioning: factory.provisioning,
+					error: err instanceof Error ? err.message : String(err)
+				} });
 				await factory.dispose().catch(() => void 0);
 				throw err;
 			}
@@ -6991,12 +7088,49 @@ function stepsToPipelineConfig(steps, engine) {
 		} : {}
 	};
 }
-/** Flatten a step tree into a flat list (DFS). */
 /** Flatten a step tree into a flat list (DFS) — delegates to shared utility. */
 function flattenSteps(steps) {
 	return flattenEnabledVideoSteps(steps);
 }
 /**
+* Catalog root-vs-detail plane of a step: a non-null `inputClasses` on the
+* DEFINITION marks a crop child served per-track on the detail plane —
+* mirrors the executor's frame-plane skip (`executeChildren`) and the
+* runner's `deriveDetailSteps`. Unknown addonIds (already dropped from
+* resolved trees) default to root-plane.
+*/
+function isDetailPlaneStep(addonId) {
+	try {
+		return getStepDefinition(addonId).inputClasses !== null;
+	} catch {
+		return false;
+	}
+}
+/**
+* True when the step's FULL catalog ships no model with a build for
+* `format` — the single-step form of `collectZeroBuildIssues`. Unknown/custom
+* addonIds (no catalog to check) are never zero-build, mirroring the
+* collector's skip.
+*/
+function stepHasZeroBuildsFor(addonId, format) {
+	return collectZeroBuildIssues([{ addonId }], format).length > 0;
+}
+/**
+* The union of model formats a step's catalog ships ANY build for — the
+* "Available: …" half of the capability-gate error. Unknown/custom addonIds
+* yield an empty list (no catalog to enumerate), never a throw.
+*/
+function availableFormatsForStep(addonId) {
+	try {
+		const def = getStepDefinition(addonId);
+		const formats = /* @__PURE__ */ new Set();
+		for (const model of def.models) for (const format of Object.keys(model.formats)) formats.add(format);
+		return Array.from(formats).toSorted();
+	} catch {
+		return [];
+	}
+}
+/**
 * Return a shallow-cloned executable tree with `rootStepId`'s `settings`
 * merged with `overrides` (per-device values win). Non-matching root steps
 * pass through unchanged. Used by `runFrame` to apply per-device detection
@@ -7108,21 +7242,22 @@ function toNodePlatform(value) {
 	return value === "darwin" || value === "linux" || value === "win32" ? value : void 0;
 }
 /**
-* Tuning fields that bind into the Python pool at construction. Any
-* change requires a pool respawn to take effect (the executor caches
-* `tuning` at engine-factory build time). `onConfigChanged` watches
-* these and rebuilds the provider when they flip.
+* Slider keys on the "Inference executor" section that map 1:1 onto a
+* {@link RuntimePoolProfile} field. Used to inject the node-default runtime's
+* registry value as the field's suggested default in `getGlobalSettings`.
 */
-var POOL_BOUND_KEYS = [
+var PROFILE_SLIDER_KEYS = [
 	"concurrency",
-	"batchMode",
+	"numWorkers",
 	"windowMs",
 	"maxBatchSize",
 	"numStreams",
-	"intraOpThreads",
-	"numWorkers"
+	"intraOpThreads"
 ];
-var DetectionPipelineAddon = class DetectionPipelineAddon extends BaseAddon {
+function isProfileSliderKey(key) {
+	return PROFILE_SLIDER_KEYS.some((k) => k === key);
+}
+var DetectionPipelineAddon = class extends BaseAddon {
 	provider = null;
 	/** Last non-null probed hardware PER NODE — reused when the probe transiently
 	*  returns null so offered backends / device lists don't collapse. Keyed by
@@ -7137,14 +7272,17 @@ var DetectionPipelineAddon = class DetectionPipelineAddon extends BaseAddon {
 	*  ENGINE_METRICS_HEARTBEAT_MS for liveness. */
 	lastEmittedEngineSnapshot = null;
 	/**
-	* Last-applied tuning snapshot, taken at the end of `onInitialize`
-	* and refreshed at the end of `onConfigChanged`. Lets the change
-	* handler diff the current config against the snapshot and decide
-	* whether a pool respawn is necessary — most config edits (engine
-	* cascade, audio settings) don't touch the tuning fields and don't
-	* deserve a multi-second model reload.
+	* Last-applied OPERATOR OVERRIDE, taken at the end of `onInitialize` and
+	* refreshed at the end of `onConfigChanged`. Lets the change handler diff the
+	* current config against the snapshot and decide whether a pool respawn is
+	* necessary — most config edits (engine cascade, audio settings) don't touch
+	* the tuning fields and don't deserve a multi-second model reload.
+	*
+	* The per-runtime registry values are compile-time constants resolved inside
+	* each pool, so they can never be the reason for a respawn; only an operator
+	* edit can.
 	*/
-	lastAppliedPoolConfig = {};
+	lastAppliedOverride = {};
 	/**
 	* Embedded Python path resolved once at boot via
 	* `ctx.deps.ensurePython()`. Empty string means the download failed
@@ -7312,17 +7450,16 @@ var DetectionPipelineAddon = class DetectionPipelineAddon extends BaseAddon {
 				...section,
 				fields: section.fields.map((field) => {
 					if (field.type === "select") {
-						if (field.key === "batchMode" && tuning["batchMode"] !== void 0) return {
+						if (field.key === "batchMode") return {
 							...field,
-							default: tuning["batchMode"]
+							default: tuning.batchMode
 						};
 					}
 					if (field.type === "slider" && "key" in field) {
-						const tuned = tuning[field.key];
 						const sliderField = field;
-						let patchedField = typeof tuned === "number" ? {
+						let patchedField = isProfileSliderKey(sliderField.key) ? {
 							...sliderField,
-							default: tuned
+							default: tuning[sliderField.key]
 						} : sliderField;
 						if (sliderField.key === "concurrency" && backend === "coreml") patchedField = {
 							...patchedField,
@@ -7431,60 +7568,39 @@ var DetectionPipelineAddon = class DetectionPipelineAddon extends BaseAddon {
 		return normalizeEngineNodeId(this.ctxIfReady?.kernel?.localNodeId ?? "hub");
 	}
 	/**
-	* Resolve the effective pool tuning for the configured backend.
+	* The operator's explicit deviations from the per-runtime registry — and
+	* NOTHING else.
 	*
-	* Reads the registry's `tuningFor(backend)` and ignores any persisted
-	* override for `concurrency / batchMode / windowMs / maxBatchSize /
-	* numStreams / intraOpThreads`. Stored values are quietly discarded so an old
-	* suboptimal user-override (saved when the UI exposed these knobs)
-	* cannot resurrect itself after a restart.
+	* This used to be `resolveBackendTuning()`: it read `tuningFor(<the node's
+	* default backend>)` and handed the whole resolved row to the provider, which
+	* passed it verbatim to every pool it built. That is how an `openvino:npu`
+	* pool on an onnx-default node came up with onnx's `concurrency: 4`. The
+	* per-runtime values now resolve inside each pool
+	* (`engine/pool-provisioning.ts`), keyed by that pool's own runtime, so
+	* nothing backend-shaped may be computed here.
 	*
-	* The matrix sweep (`bench-pool-matrix.py` + `bench-coreml-patterns.py`)
-	* already chose the best per-backend combo; the operator no longer has
-	* a reason to disagree.
+	* Precedence, in full: an operator override below wins over the pool's
+	* runtime registry row; an "Auto" field (slider `0`, select `''`) is not an
+	* override. An override is node-wide by design — the operator set it against
+	* a node, not against a runtime.
 	*/
-	resolveBackendTuning() {
-		const t = tuningFor(this.provider?.resolvedEngineBackend() ?? "onnx");
-		const num = (v, dflt) => typeof v === "number" && v > 0 ? v : dflt;
-		const batch = (v, dflt) => v === "none" || v === "list" || v === "window" ? v : dflt;
-		return {
-			concurrency: num(t["concurrency"], 1),
-			batchMode: batch(t["batchMode"], "window"),
-			windowMs: num(t["windowMs"], 2),
-			maxBatchSize: num(t["maxBatchSize"], 8),
-			numStreams: num(t["numStreams"], 0),
-			intraOpThreads: num(t["intraOpThreads"], 0),
-			numWorkers: num(t["numWorkers"], 1)
-		};
+	resolveOperatorOverride() {
+		return readOperatorOverride(this.config);
 	}
 	/**
-	* Construct a fresh provider with the given effective tuning. Single source of
-	* truth for the provider wiring — shared by `onInitialize`, the post-resolve
-	* tuning reconciliation, and the `onConfigChanged` pool respawn.
+	* Construct a fresh provider carrying the operator override. Single source of
+	* truth for the provider wiring — shared by `onInitialize` and the
+	* `onConfigChanged` pool respawn. NOTHING backend-derived is passed: each
+	* pool resolves its own runtime's registry row.
 	*/
-	buildProvider(modelsDir, tuning) {
+	buildProvider(modelsDir, override) {
 		if (!this.ctx.settings) throw new Error("DetectionPipelineAddon: ctx.settings not available");
 		return new DetectionPipelineProvider(this.ctx.settings, modelsDir, this.ctx.logger, this.ctx.eventBus ?? null, () => ({ sections: [] }), {
-			concurrency: tuning.concurrency,
-			tuning: {
-				batchMode: tuning.batchMode,
-				windowMs: tuning.windowMs,
-				maxBatchSize: tuning.maxBatchSize,
-				numStreams: tuning.numStreams,
-				intraOpThreads: tuning.intraOpThreads
-			},
-			numWorkers: tuning.numWorkers,
+			provisioning: override,
 			pythonPath: this.pythonPath,
 			pythonAddonDir: this.pythonAddonDir
 		});
 	}
-	/**
-	* Pool-bound tuning keys of `a` and `b` are equal (used to decide whether a
-	* post-resolve / config-change respawn is actually needed).
-	*/
-	static poolTuningEqual(a, b) {
-		return a.concurrency === b.concurrency && a.batchMode === b.batchMode && a.windowMs === b.windowMs && a.maxBatchSize === b.maxBatchSize && a.numStreams === b.numStreams && a.intraOpThreads === b.intraOpThreads && a.numWorkers === b.numWorkers;
-	}
 	async onInitialize() {
 		const modelsDir = await this.resolveModelsDir();
 		if (!this.ctx.settings) throw new Error("DetectionPipelineAddon: ctx.settings not available");
@@ -7493,23 +7609,12 @@ var DetectionPipelineAddon = class DetectionPipelineAddon extends BaseAddon {
 		if (py.ok && py.pythonPath) this.pythonPath = py.pythonPath;
 		else this.ctx.logger.warn("Detection engine boot continues without Python — selection will provision on demand", {});
 		await this.proactivelyInstallOpenvino();
-		const initialTuning = this.resolveBackendTuning();
-		this.provider = this.buildProvider(modelsDir, initialTuning);
+		this.provider = this.buildProvider(modelsDir, this.resolveOperatorOverride());
 		await this.provider.init();
 		await this.provider.setApi(this.ctx);
-		const resolvedTuning = this.resolveBackendTuning();
-		if (!DetectionPipelineAddon.poolTuningEqual(initialTuning, resolvedTuning)) {
-			this.ctx.logger.info("detection-pipeline tuning reconciled to resolved engine", { meta: {
-				from: initialTuning,
-				to: resolvedTuning
-			} });
-			this.provider = this.buildProvider(modelsDir, resolvedTuning);
-			await this.provider.init();
-			await this.provider.setApi(this.ctx);
-		}
 		await this.provider.warmPool();
 		this.engineMetricsTimer = setInterval(() => this.emitEngineMetricsSnapshot(), ENGINE_METRICS_SNAPSHOT_INTERVAL_MS);
-		this.lastAppliedPoolConfig = this.snapshotPoolConfig();
+		this.lastAppliedOverride = this.resolveOperatorOverride();
 		return [{
 			capability: pipelineExecutorCapability,
 			provider: this.provider
@@ -7595,36 +7700,12 @@ var DetectionPipelineAddon = class DetectionPipelineAddon extends BaseAddon {
 		}
 	}
 	/**
-	* Snapshot the pool-bound subset of the EFFECTIVE tuning (post-
-	* `resolveBackendTuning`). Stored config values for these fields are
-	* ignored, so this snapshot only changes when `engineBackend` flips
-	* onto a different `tuningFor` row.
-	*/
-	snapshotPoolConfig() {
-		const t = this.resolveBackendTuning();
-		return {
-			concurrency: t.concurrency ?? 0,
-			batchMode: t.batchMode,
-			windowMs: t.windowMs,
-			maxBatchSize: t.maxBatchSize,
-			numStreams: t.numStreams,
-			intraOpThreads: t.intraOpThreads,
-			numWorkers: t.numWorkers
-		};
-	}
-	poolConfigChanged() {
-		const next = this.snapshotPoolConfig();
-		const prev = this.lastAppliedPoolConfig;
-		for (const k of POOL_BOUND_KEYS) if (next[k] !== prev[k]) return true;
-		return false;
-	}
-	/**
 	* BaseAddon calls `onConfigChanged` after every settings write. This is the
 	* SOLE apply path for tuning changes — none of those fields declare
 	* `requiresRestart` anymore (an addon restart re-probes hardware + reloads
-	* every model on every set, which is exactly what we want to avoid): pool-bound
-	* tuning (`concurrency`/`batchMode`/`windowMs`/…) drives an in-place pool
-	* respawn when the snapshot flips (`poolConfigChanged` below). The engine
+	* every model on every set, which is exactly what we want to avoid): a changed
+	* OPERATOR OVERRIDE drives an in-place pool respawn. The per-runtime registry
+	* values cannot change at runtime, so they can never trigger one. The engine
 	* SELECTION is no longer operator-facing — the node-default backend is derived
 	* once at boot (`setApi` → `resolveAutoEngine`) from static hardware, so there
 	* is no per-write engine re-select. The respawn applies optimistically — the
@@ -7632,14 +7713,15 @@ var DetectionPipelineAddon = class DetectionPipelineAddon extends BaseAddon {
 	* crashed), no addon bounce.
 	*/
 	async onConfigChanged() {
-		if (!this.poolConfigChanged()) return;
+		const next = this.resolveOperatorOverride();
+		if (overridesEqual(next, this.lastAppliedOverride)) return;
 		if (!this.provider) {
-			this.lastAppliedPoolConfig = this.snapshotPoolConfig();
+			this.lastAppliedOverride = next;
 			return;
 		}
-		this.ctx.logger.info("detection-pipeline tuning changed — respawning pool", { meta: {
-			prev: this.lastAppliedPoolConfig,
-			next: this.snapshotPoolConfig()
+		this.ctx.logger.info("detection-pipeline tuning override changed — respawning pool", { meta: {
+			prev: this.lastAppliedOverride,
+			next
 		} });
 		try {
 			await this.provider.shutdown();
@@ -7647,11 +7729,11 @@ var DetectionPipelineAddon = class DetectionPipelineAddon extends BaseAddon {
 			this.ctx.logger.warn("provider shutdown failed during tuning respawn", { meta: { error: err instanceof Error ? err.message : String(err) } });
 		}
 		const modelsDir = await this.resolveModelsDir();
-		this.provider = this.buildProvider(modelsDir, this.resolveBackendTuning());
+		this.provider = this.buildProvider(modelsDir, next);
 		await this.provider.init();
 		await this.provider.setApi(this.ctx);
 		await this.provider.warmPool();
-		this.lastAppliedPoolConfig = this.snapshotPoolConfig();
+		this.lastAppliedOverride = next;
 		this.ctx.logger.info("detection-pipeline pool respawn complete");
 	}
 };