@camstack/addon-pipeline 1.1.44 → 1.1.46

package/dist/detection-pipeline/index.js

@@ -3,7 +3,7 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 const require_chunk = require("../chunk-D6vf50IK.js");
-const require_dist = require("../dist-CySHUkXY.js");
+const require_dist = require("../dist-C3CWl8fV.js");
 const require_node_topology_platform = require("../node-topology-platform-CFZ7F4xW.js");
 const require_model_download_service_C_IHWnXx = require("../model-download-service-C-IHWnXx-BLXzxpRB.js");
 let _camstack_shm_ring = require("@camstack/shm-ring");
@@ -298,1059 +298,813 @@ function projectNodeEngine(store, nodeId) {
 	return out;
 }
 //#endregion
-//#region src/detection-pipeline/engine/shared-inference-pool.ts
+//#region src/detection-pipeline/registry/model-catalogs.ts
+var HF_REPO = "camstack/camstack-models";
+var HF_SCRYPTED = "scrypted/plugin-models";
+var hf = (path) => require_dist.hfModelUrl(HF_REPO, path);
+var hfScrypted = (path) => require_dist.hfModelUrl(HF_SCRYPTED, path);
 /**
-* SharedInferencePool — TypeScript wrapper for inference_pool.py.
-*
-* Multi-process orchestrator. Owns N `PoolWorker` instances, each
-* holding its own Python subprocess + MLModel copy, and round-robins
-* inference dispatches across them. Model management (load/unload/
-* replace) propagates to all workers so every subprocess holds the
-* same model set at the same indices.
+* Build an OpenVINO format entry (always python runtime).
 *
-* Wire format (per worker):
-*   Request:  [4B total_len][4B req_id][1B msg_type][payload]
-*   Response: [4B total_len][4B req_id][JSON payload]
-*/
-var MSG_COMMAND = 0;
-var MSG_INFER_JPEG = 1;
-var MSG_INFER_RAW = 2;
-var MSG_CACHE_FRAME = 4;
-var MSG_INFER_CACHED = 5;
-/**
-* Cross-camera batching opcode — N items packed into a single IPC
-* frame. Wire shape:
-*   [1B model_idx][1B count][N × (4B w | 4B h | 1B fmt | 4B size | raw bytes)]
-* Python pool dispatches each item via `dispatcher.run` (asyncio.gather)
-* and returns a JSON array of detections in the same order.
-*/
-var MSG_INFER_BATCH = 3;
-var PREFIX_LEN = 9;
-/**
-* Wire-level enum for the raw-frame fast path. Values are append-only:
-* the Python pool reads the byte directly off the IPC frame; reordering
-* existing entries breaks all in-flight workers.
+* OpenVINO IR is a two-file bundle: a `.xml` topology + a sibling `.bin`
+* weights file with the same basename. We declare the `.bin` in `files` so
+* the (format-agnostic) downloader fetches it alongside the `.xml` — without
+* the weights, OpenVINO compile fails with "Empty weights data in bin file".
+* A plain `.onnx` run through the OpenVINO runtime (e.g. yamnet) has no
+* sibling, so none is added.
 */
-var RAW_FMT_CODE = {
-	rgb: 0,
-	bgr: 1,
-	gray: 2
-};
-var PoolHandle = class {
-	pool;
-	modelIndex;
-	runtime = "onnx";
-	device = "cpu";
-	constructor(pool, modelIndex) {
-		this.pool = pool;
-		this.modelIndex = modelIndex;
-	}
-	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
-		};
-	}
-	/**
-	* Inference on a frame previously cached in the Python pool via
-	* `pool.cacheFrame()`. Sends only 5 bytes through the pipe instead
-	* of 1.2MB raw data — eliminates the pipe transfer bottleneck.
-	*/
-	async inferFromCache(frameId) {
-		const start = performance.now();
-		return {
-			structured: await this.pool.inferCached(this.modelIndex, frameId),
-			inferenceMs: performance.now() - start
-		};
-	}
-	async dispose() {}
+var ovFormat = (url, sizeMB) => {
+	const base = url.split("/").pop() ?? "";
+	const files = base.endsWith(".xml") ? [base.replace(/\.xml$/, ".bin")] : void 0;
+	return {
+		url,
+		sizeMB,
+		runtimes: ["python"],
+		...files ? { files } : {}
+	};
 };
 /**
-* 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.
+* Build a precision-variant catalog entry (OpenVINO-only) derived from a base
+* detection model. fp16 halves the weights (Intel iGPU/NPU sweet spot); int8 is
+* NNCF post-training-quantized (~4× smaller, fastest on CPU/iGPU at a small
+* accuracy cost). The IRs live next to the base `.xml` on HF as
+* `camstack-<id>-<precision>.xml`. Lets an operator scale the model to the node
+* (e.g. yolo26x-int8 on a 265K, yolo26n-int8 on an N100).
 */
-var POOL_WORKER_TERM_GRACE_MS = 2e3;
+var ovPrecisionVariant = (baseId, ovDir, baseName, precision, sizeMB, legacy = false) => ({
+	id: `${baseId}-${precision}`,
+	name: `${baseName} (${precision.toUpperCase()})`,
+	description: `${baseName} — OpenVINO ${precision.toUpperCase()} variant for Intel iGPU/NPU; scale by hardware`,
+	inputSize: {
+		width: 640,
+		height: 640
+	},
+	labels: [],
+	preprocessMode: "letterbox",
+	formats: { openvino: ovFormat(hf(`${ovDir}/camstack-${baseId}-${precision}.xml`), sizeMB) },
+	...legacy ? { legacy: true } : {},
+	...precision === "int8" ? { group: {
+		family: baseId.slice(0, -1),
+		tier: baseId.slice(-1),
+		precision: "int8"
+	} } : {}
+});
+var MLPACKAGE_FILES = [
+	"Manifest.json",
+	"Data/com.apple.CoreML/model.mlmodel",
+	"Data/com.apple.CoreML/weights/weight.bin"
+];
+var YOLO26_TIER_NAME = {
+	n: "Nano",
+	s: "Small",
+	m: "Medium",
+	l: "Large"
+};
 /**
-* 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).
-*
-* The old teardown sent SIGTERM and dropped the reference immediately — a
-* worker busy in a native inference loop ignores SIGTERM and ORPHANS at full
-* CPU (observed after an engine re-spin). SIGKILL cannot be ignored, so the
-* escalation guarantees the process dies. Exported for tests.
+* Reduced-input YOLO26 variants (2026-07-11). A lower square input (320 / 256)
+* is the biggest, cheapest latency lever measured across every runtime — Mac
+* ANE, Intel Ultra NPU, and especially the N100 — at a small-object accuracy
+* cost. Each resolution ships a base (fp32) entry (onnx + coreml + openvino)
+* grouped under `{family, tier, resolution}`, plus an OpenVINO INT8 entry (best
+* on Intel/N100) grouped with `precision:'int8'`. The grouped selector surfaces
+* `resolution` as a variant axis alongside precision.
 */
-async function terminateChild(proc, graceMs) {
-	if (proc.exitCode !== null || proc.signalCode !== null) return;
-	try {
-		proc.stdin?.end();
-	} catch {}
-	await new Promise((resolve) => {
-		let settled = false;
-		let timer = null;
-		const done = () => {
-			if (settled) return;
-			settled = true;
-			if (timer) clearTimeout(timer);
-			resolve();
-		};
-		proc.once("exit", done);
-		try {
-			proc.kill("SIGTERM");
-		} catch {
-			done();
-			return;
-		}
-		timer = setTimeout(() => {
-			try {
-				proc.kill("SIGKILL");
-			} catch {}
-			done();
-		}, graceMs);
-	});
-}
-var PoolWorker = class {
-	process = null;
-	receiveBuffer = Buffer.alloc(0);
-	pending = /* @__PURE__ */ new Map();
-	nextRequestId = 1;
-	ready = false;
-	log;
-	opts;
-	constructor(opts) {
-		this.opts = opts;
-		this.log = opts.logger;
-	}
-	getPid() {
-		return this.process?.pid ?? null;
-	}
-	isReady() {
-		return this.ready;
-	}
-	async initialize(initialModels) {
-		this.process = (0, node_child_process.spawn)(this.opts.pythonPath, [this.opts.scriptPath], { stdio: [
-			"pipe",
-			"pipe",
-			"pipe"
-		] });
-		if (!this.process.stdout || !this.process.stdin) throw new Error("PoolWorker: failed to create process pipes");
-		this.process.stderr?.on("data", (chunk) => {
-			for (const line of chunk.toString().split("\n")) {
-				const trimmed = line.trim();
-				if (trimmed) this.log.warn(`[${this.opts.workerLabel}] ${trimmed}`);
-			}
-		});
-		this.process.on("error", (err) => {
-			this.log.error("Worker process error", { meta: {
-				worker: this.opts.workerLabel,
-				error: err.message
-			} });
-			this.rejectAll(err);
-		});
-		this.process.on("exit", (code) => {
-			if (code !== 0 && code !== null) {
-				this.log.error("Worker process exited", { meta: {
-					worker: this.opts.workerLabel,
-					code
-				} });
-				this.rejectAll(/* @__PURE__ */ new Error(`Worker process exited with code ${code}`));
-			}
-			this.ready = false;
-		});
-		this.process.stdout.on("data", (chunk) => {
-			this.receiveBuffer = Buffer.concat([this.receiveBuffer, chunk]);
-			this.drainResponses();
-		});
-		const config = {
-			runtime: this.opts.poolRuntime,
-			concurrency: this.opts.concurrency,
-			models: initialModels.map((m) => serializeModelConfig(m))
-		};
-		if (this.opts.tuning) {
-			config["batch_mode"] = this.opts.tuning.batchMode;
-			config["window_ms"] = this.opts.tuning.windowMs;
-			config["max_batch_size"] = this.opts.tuning.maxBatchSize;
-			config["num_streams"] = this.opts.tuning.numStreams;
-			config["intra_op_threads"] = this.opts.tuning.intraOpThreads;
+var yolo26Reduced = (tier, res, sizes) => {
+	const name = YOLO26_TIER_NAME[tier] ?? tier.toUpperCase();
+	return [{
+		id: `yolo26${tier}-${res}`,
+		group: {
+			family: "yolo26",
+			tier,
+			resolution: res
+		},
+		name: `YOLO26 ${name} @${res}`,
+		description: `YOLO26 ${name}, reduced ${res}×${res} input — faster on ANE / hub NPU / N100 at a small-object accuracy cost`,
+		inputSize: {
+			width: res,
+			height: res
+		},
+		labels: [],
+		preprocessMode: "letterbox",
+		formats: {
+			onnx: {
+				url: hf(`objectDetection/yolo26/onnx/camstack-yolo26${tier}-${res}.onnx`),
+				sizeMB: sizes.onnx
+			},
+			coreml: {
+				url: hf(`objectDetection/yolo26/coreml/camstack-yolo26${tier}-${res}.mlpackage`),
+				sizeMB: sizes.coreml,
+				isDirectory: true,
+				files: [...MLPACKAGE_FILES],
+				runtimes: ["python"]
+			},
+			openvino: ovFormat(hf(`objectDetection/yolo26/openvino/camstack-yolo26${tier}-${res}.xml`), sizes.ovFp32)
 		}
-		const configBuf = Buffer.from(JSON.stringify(config), "utf8");
-		this.writeFrame(0, MSG_COMMAND, configBuf);
-		return new Promise((resolve, reject) => {
-			const timeout = setTimeout(() => {
-				this.pending.delete(0);
-				reject(/* @__PURE__ */ new Error(`PoolWorker[${this.opts.workerLabel}]: timeout waiting for ready (120s)`));
-			}, 12e4);
-			this.pending.set(0, {
-				resolve: (result) => {
-					clearTimeout(timeout);
-					if (result["status"] === "ready") {
-						this.ready = true;
-						const loadedCount = result["models"];
-						const startupMs = result["startupMs"];
-						resolve({
-							startupMs,
-							loadedCount,
-							workers: result["workers"] ?? 1
-						});
-					} else reject(/* @__PURE__ */ new Error(`Unexpected pool status: ${JSON.stringify(result)}`));
-				},
-				reject: (err) => {
-					clearTimeout(timeout);
-					reject(err);
-				}
-			});
-		});
-	}
-	async infer(modelByte, jpeg) {
-		this.ensureReady();
-		const payload = Buffer.concat([Buffer.from([modelByte]), jpeg]);
-		return this.dispatch(MSG_INFER_JPEG, payload);
-	}
-	async inferRaw(modelByte, raw, width, height, format) {
-		this.ensureReady();
-		const fmtCode = RAW_FMT_CODE[format];
-		const rawHeader = Buffer.allocUnsafe(10);
-		rawHeader[0] = modelByte;
-		rawHeader.writeUInt32LE(width, 1);
-		rawHeader.writeUInt32LE(height, 5);
-		rawHeader[9] = fmtCode;
-		return this.dispatchMulti(MSG_INFER_RAW, rawHeader.length + raw.length, [rawHeader, raw]);
-	}
-	async inferBatch(modelByte, items) {
-		this.ensureReady();
-		if (items.length === 0) return [];
-		const headerSize = 2 + items.length * 13;
-		const totalRawSize = items.reduce((sum, it) => sum + it.raw.length, 0);
-		const payload = Buffer.allocUnsafe(headerSize + totalRawSize);
-		payload[0] = modelByte;
-		payload[1] = items.length;
-		let offset = 2;
-		for (const item of items) {
-			payload.writeUInt32LE(item.width, offset);
-			payload.writeUInt32LE(item.height, offset + 4);
-			payload[offset + 8] = RAW_FMT_CODE[item.format];
-			payload.writeUInt32LE(item.raw.length, offset + 9);
-			offset += 13;
-			item.raw.copy(payload, offset);
-			offset += item.raw.length;
+	}, {
+		id: `yolo26${tier}-${res}-int8`,
+		group: {
+			family: "yolo26",
+			tier,
+			precision: "int8",
+			resolution: res
+		},
+		name: `YOLO26 ${name} @${res} (INT8)`,
+		description: `YOLO26 ${name} @${res} — OpenVINO INT8 for Intel iGPU/CPU; the N100's fastest config`,
+		inputSize: {
+			width: res,
+			height: res
+		},
+		labels: [],
+		preprocessMode: "letterbox",
+		formats: { openvino: ovFormat(hf(`objectDetection/yolo26/openvino/camstack-yolo26${tier}-${res}-int8.xml`), sizes.ovInt8) }
+	}];
+};
+var OBJECT_DETECTION_MODELS = [
+	{
+		id: "yolov9t",
+		legacy: true,
+		name: "YOLOv9 Tiny",
+		description: "YOLOv9 Tiny — ultra-lightweight next-gen detector",
+		inputSize: {
+			width: 640,
+			height: 640
+		},
+		labels: [],
+		preprocessMode: "letterbox",
+		formats: {
+			onnx: {
+				url: hf("objectDetection/yolov9/onnx/camstack-yolov9t.onnx"),
+				sizeMB: 8
+			},
+			coreml: {
+				url: hf("objectDetection/yolov9/coreml/camstack-yolov9t.mlpackage"),
+				sizeMB: 4,
+				isDirectory: true,
+				files: [...MLPACKAGE_FILES],
+				runtimes: ["python"]
+			},
+			openvino: ovFormat(hf("objectDetection/yolov9/openvino/camstack-yolov9t.xml"), 6)
 		}
-		const response = await this.dispatch(MSG_INFER_BATCH, payload);
-		const results = response["results"];
-		if (!Array.isArray(results)) throw new Error(`PoolWorker.inferBatch: malformed response: ${JSON.stringify(response)}`);
-		return results;
-	}
-	async cacheFrame(frameId, raw, width, height, format) {
-		this.ensureReady();
-		const fmtCode = RAW_FMT_CODE[format];
-		const header = Buffer.allocUnsafe(13);
-		header.writeUInt32LE(frameId, 0);
-		header.writeUInt32LE(width, 4);
-		header.writeUInt32LE(height, 8);
-		header[12] = fmtCode;
-		const payloadLen = header.length + raw.length;
-		const result = await this.dispatchMulti(MSG_CACHE_FRAME, payloadLen, [header, raw]);
-		if (result["error"]) throw new Error(String(result["error"]));
-	}
-	async inferCached(modelByte, frameId) {
-		this.ensureReady();
-		const payload = Buffer.allocUnsafe(5);
-		payload[0] = modelByte;
-		payload.writeUInt32LE(frameId, 1);
-		return this.dispatch(MSG_INFER_CACHED, payload);
-	}
-	async sendCommand(cmd) {
-		this.ensureReady();
-		const payload = Buffer.from(JSON.stringify(cmd), "utf8");
-		return await this.dispatch(MSG_COMMAND, payload);
-	}
-	async dispose() {
-		const proc = this.process;
-		if (!proc) return;
-		this.process = null;
-		this.ready = false;
-		await terminateChild(proc, POOL_WORKER_TERM_GRACE_MS);
-	}
-	dispatch(msgType, payload) {
-		const reqId = this.allocRequestId();
-		return new Promise((resolve, reject) => {
-			this.pending.set(reqId, {
-				resolve,
-				reject
-			});
-			try {
-				this.writeFrame(reqId, msgType, payload);
-			} catch (err) {
-				this.pending.delete(reqId);
-				reject(err instanceof Error ? err : new Error(String(err)));
-			}
-		});
-	}
-	dispatchMulti(msgType, payloadLen, parts) {
-		const reqId = this.allocRequestId();
-		return new Promise((resolve, reject) => {
-			this.pending.set(reqId, {
-				resolve,
-				reject
-			});
-			try {
-				if (!this.process?.stdin) throw new Error("PoolWorker: not initialized");
-				const prefix = Buffer.allocUnsafe(PREFIX_LEN);
-				prefix.writeUInt32LE(5 + payloadLen, 0);
-				prefix.writeUInt32LE(reqId, 4);
-				prefix[8] = msgType;
-				this.process.stdin.write(prefix);
-				for (const part of parts) this.process.stdin.write(part);
-			} catch (err) {
-				this.pending.delete(reqId);
-				reject(err instanceof Error ? err : new Error(String(err)));
-			}
-		});
-	}
-	allocRequestId() {
-		let id = this.nextRequestId;
-		this.nextRequestId = id >= 4294967295 ? 1 : id + 1;
-		while (this.pending.has(id)) {
-			id = this.nextRequestId;
-			this.nextRequestId = id >= 4294967295 ? 1 : id + 1;
+	},
+	{
+		id: "yolov9s",
+		legacy: true,
+		name: "YOLOv9 Small",
+		description: "YOLOv9 Small — improved efficiency over YOLOv8s",
+		inputSize: {
+			width: 640,
+			height: 640
+		},
+		labels: [],
+		preprocessMode: "letterbox",
+		formats: {
+			onnx: {
+				url: hf("objectDetection/yolov9/onnx/camstack-yolov9s.onnx"),
+				sizeMB: 28
+			},
+			coreml: {
+				url: hf("objectDetection/yolov9/coreml/camstack-yolov9s.mlpackage"),
+				sizeMB: 14,
+				isDirectory: true,
+				files: [...MLPACKAGE_FILES],
+				runtimes: ["python"]
+			},
+			openvino: ovFormat(hf("objectDetection/yolov9/openvino/camstack-yolov9s.xml"), 16)
 		}
-		return id;
-	}
-	writeFrame(reqId, msgType, payload) {
-		if (!this.process?.stdin) throw new Error("PoolWorker: not initialized");
-		const totalLen = 5 + payload.length;
-		const header = Buffer.allocUnsafe(PREFIX_LEN);
-		header.writeUInt32LE(totalLen, 0);
-		header.writeUInt32LE(reqId, 4);
-		header[8] = msgType;
-		this.process.stdin.write(header);
-		this.process.stdin.write(payload);
-	}
-	ensureReady() {
-		if (!this.ready || !this.process?.stdin) throw new Error(`PoolWorker[${this.opts.workerLabel}]: not initialized`);
-	}
-	drainResponses() {
-		while (this.receiveBuffer.length >= 8) {
-			const totalLen = this.receiveBuffer.readUInt32LE(0);
-			if (this.receiveBuffer.length < 4 + totalLen) break;
-			const reqId = this.receiveBuffer.readUInt32LE(4);
-			const jsonBytes = this.receiveBuffer.subarray(8, 4 + totalLen);
-			this.receiveBuffer = this.receiveBuffer.subarray(4 + totalLen);
-			const entry = this.pending.get(reqId);
-			if (!entry) {
-				this.log.warn("Response for unknown request id", { meta: {
-					worker: this.opts.workerLabel,
-					reqId
-				} });
-				continue;
-			}
-			this.pending.delete(reqId);
-			try {
-				const parsed = JSON.parse(jsonBytes.toString("utf8"));
-				entry.resolve(parsed);
-			} catch (err) {
-				entry.reject(err instanceof Error ? err : new Error(String(err)));
-			}
+	},
+	{
+		id: "yolov9c",
+		legacy: true,
+		name: "YOLOv9 C",
+		description: "YOLOv9 C — high-accuracy compact model",
+		inputSize: {
+			width: 640,
+			height: 640
+		},
+		labels: [],
+		preprocessMode: "letterbox",
+		formats: {
+			onnx: {
+				url: hf("objectDetection/yolov9/onnx/camstack-yolov9c.onnx"),
+				sizeMB: 97
+			},
+			coreml: {
+				url: hf("objectDetection/yolov9/coreml/camstack-yolov9c.mlpackage"),
+				sizeMB: 48,
+				isDirectory: true,
+				files: [...MLPACKAGE_FILES],
+				runtimes: ["python"]
+			},
+			openvino: ovFormat(hf("objectDetection/yolov9/openvino/camstack-yolov9c.xml"), 49)
 		}
-	}
-	rejectAll(err) {
-		const entries = [...this.pending.values()];
-		this.pending.clear();
-		for (const entry of entries) entry.reject(err);
-	}
-};
-var SharedInferencePool = class {
-	pythonPath;
-	poolRuntime;
-	workers = [];
-	nextDispatchIdx = 0;
-	nextFreeIndex = 0;
-	nextFrameId = 1;
-	/**
-	* Cumulative count of frames the Python pool SHED under overload
-	* (`"dropped": true` responses from the per-model in-flight bound in
-	* inference_pool.py). Without this the shed response is
-	* indistinguishable from a genuine "no detections" result.
-	*/
-	droppedResponseCount = 0;
-	log;
-	concurrency;
-	tuning;
-	numWorkers;
-	constructor(pythonPath, poolRuntime, logger, options = {}) {
-		this.pythonPath = pythonPath;
-		this.poolRuntime = poolRuntime;
-		this.log = logger;
-		this.concurrency = Math.max(1, options.concurrency ?? 1);
-		this.tuning = options.tuning ?? null;
-		this.numWorkers = Math.max(1, options.numWorkers ?? 1);
-	}
-	/** Pid of the first worker (for legacy callers). Use `getPids()` for all. */
-	getPid() {
-		return this.workers[0]?.getPid() ?? null;
-	}
-	getPids() {
-		return this.workers.map((w) => w.getPid());
-	}
-	/**
-	* Start N pool workers in parallel. Each worker loads the same
-	* initial model set so subsequent inference calls land on a worker
-	* with the requested model already in its slot map.
-	*/
-	async initialize(initialModels = []) {
-		const scriptPath = this.resolveScriptPath();
-		for (let i = 0; i < this.numWorkers; i++) this.workers.push(new PoolWorker({
-			pythonPath: this.pythonPath,
-			scriptPath,
-			poolRuntime: this.poolRuntime,
-			concurrency: this.concurrency,
-			tuning: this.tuning,
-			logger: this.log,
-			workerLabel: `w${i}`
-		}));
-		const t0 = performance.now();
-		const results = await Promise.all(this.workers.map((w) => w.initialize(initialModels)));
-		const startupMs = Math.round(performance.now() - t0);
-		this.nextFreeIndex = initialModels.length;
-		const loadedCount = results[0]?.loadedCount ?? 0;
-		const innerWorkers = results.reduce((s, r) => s + r.workers, 0);
-		this.log.info("Pool ready", { meta: {
-			loadedCount,
-			startupMs,
-			runtime: this.poolRuntime,
-			workers: this.numWorkers,
-			pythonWorkers: innerWorkers,
-			pids: this.getPids()
-		} });
-		return {
-			startupMs,
-			loadedCount,
-			workers: this.numWorkers
-		};
-	}
-	async infer(modelIndex, jpeg) {
-		const w = this.pickWorker();
-		return this.trackDroppedResponse(await w.infer(this.encodeModelByte(modelIndex), jpeg), modelIndex);
-	}
-	async inferRaw(modelIndex, raw, width, height, format) {
-		const w = this.pickWorker();
-		return this.trackDroppedResponse(await w.inferRaw(this.encodeModelByte(modelIndex), raw, width, height, format), modelIndex);
-	}
-	async inferBatch(modelIndex, items) {
-		if (items.length > 255) throw new Error(`SharedInferencePool.inferBatch: max 255 items per call, got ${items.length}`);
-		return this.pickWorker().inferBatch(this.encodeModelByte(modelIndex), items);
-	}
-	async inferCached(modelIndex, frameId) {
-		const w = this.pickWorker();
-		return this.trackDroppedResponse(await w.inferCached(this.encodeModelByte(modelIndex), frameId), modelIndex);
-	}
-	/**
-	* Total `"dropped": true` responses seen from the Python pool — frames
-	* shed by the per-model in-flight bound under overload. Diagnostic
-	* counter (monotonic for the pool's lifetime).
-	*/
-	getDroppedResponseCount() {
-		return this.droppedResponseCount;
-	}
-	getHandle(modelIndex) {
-		return new PoolHandle(this, modelIndex);
-	}
-	async cacheFrame(raw, width, height, format) {
-		const frameId = this.nextFrameId++;
-		await Promise.all(this.workers.map((w) => w.cacheFrame(frameId, raw, width, height, format)));
-		return {
-			frameId,
-			width,
-			height
-		};
-	}
-	async uncacheFrame(frameId) {
-		await Promise.all(this.workers.map((w) => w.sendCommand({
-			cmd: "uncache_frame",
-			frameId
-		})));
-	}
-	async loadModel(index, config) {
-		const responses = await Promise.all(this.workers.map((w) => w.sendCommand({
-			cmd: "load",
-			index,
-			config: serializeModelConfig(config)
-		})));
-		for (const resp of responses) if (resp.status !== "ok") throw new Error(`Failed to load model at index ${index}: ${resp.error ?? "unknown"}`);
-		if (index >= this.nextFreeIndex) this.nextFreeIndex = index + 1;
-		return { loadMs: Math.max(...responses.map((r) => r.loadMs ?? 0)) };
-	}
-	async unloadModel(index) {
-		const responses = await Promise.all(this.workers.map((w) => w.sendCommand({
-			cmd: "unload",
-			index
-		})));
-		for (const resp of responses) if (resp.status !== "ok") throw new Error(`Failed to unload model at index ${index}: ${resp.error ?? "unknown"}`);
-	}
-	async replaceModel(index, config) {
-		const responses = await Promise.all(this.workers.map((w) => w.sendCommand({
-			cmd: "replace",
-			index,
-			config: serializeModelConfig(config)
-		})));
-		for (const resp of responses) if (resp.status !== "ok") throw new Error(`Failed to replace model at index ${index}: ${resp.error ?? "unknown"}`);
-		return { loadMs: Math.max(...responses.map((r) => r.loadMs ?? 0)) };
-	}
-	async getStatus() {
-		if (this.workers.length === 0) return [];
-		return (await this.workers[0].sendCommand({ cmd: "status" })).models ?? [];
-	}
-	allocateIndex() {
-		return this.nextFreeIndex++;
-	}
-	isReady() {
-		return this.workers.length > 0 && this.workers.every((w) => w.isReady());
-	}
-	async dispose() {
-		await Promise.all(this.workers.map((w) => w.dispose()));
-		this.workers.length = 0;
-		this.log.info("Pool process(es) terminated");
-	}
-	/**
-	* 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.
-	*/
-	trackDroppedResponse(result, modelIndex) {
-		if (result["dropped"] === true) {
-			this.droppedResponseCount++;
-			this.log.debug("Python pool shed frame under overload", { meta: {
-				modelIndex,
-				droppedTotal: this.droppedResponseCount
-			} });
-		}
-		return result;
-	}
-	pickWorker() {
-		if (this.workers.length === 0) throw new Error("SharedInferencePool: not initialized");
-		const idx = this.nextDispatchIdx;
-		this.nextDispatchIdx = (this.nextDispatchIdx + 1) % this.workers.length;
-		return this.workers[idx];
-	}
-	encodeModelByte(modelIndex) {
-		if (modelIndex < 0 || modelIndex > 254) throw new Error(`Model index ${modelIndex} out of range (0-254)`);
-		return modelIndex;
-	}
-	resolveScriptPath() {
-		const candidates = [
-			node_path.join(__dirname, "../../python/inference_pool.py"),
-			node_path.join(__dirname, "../python/inference_pool.py"),
-			node_path.join(__dirname, "../../../python/inference_pool.py")
-		];
-		try {
-			const pkgPath = require.resolve("@camstack/addon-detection-pipeline/package.json");
-			candidates.unshift(node_path.join(node_path.dirname(pkgPath), "python", "inference_pool.py"));
-		} catch {}
-		const found = candidates.find((p) => node_fs.existsSync(p));
-		if (!found) throw new Error(`inference_pool.py not found. Searched:\n${candidates.join("\n")}`);
-		return found;
-	}
-};
-function serializeModelConfig(config) {
-	const result = {
-		path: config.path,
-		inputSize: config.inputSize,
-		preprocessMode: config.preprocessMode,
-		postprocessor: config.postprocessor,
-		confidence: config.confidence
-	};
-	if (config.labels) result["labels"] = config.labels;
-	if (config.charset) result["charset"] = config.charset;
-	if (config.numClasses) result["numClasses"] = config.numClasses;
-	if (config.strides) result["strides"] = config.strides;
-	if (config.maskThreshold !== void 0) result["maskThreshold"] = config.maskThreshold;
-	if (config.device) result["device"] = config.device;
-	return result;
-}
-//#endregion
-//#region src/detection-pipeline/engine/step-utils.ts
-/**
-* Flatten a step tree into a list of enabled video steps (DFS).
-* Audio-classifier steps are excluded — they run independently
-* via the audio pipeline, not the video inference pool.
-*/
-function flattenEnabledVideoSteps(steps) {
-	const result = [];
-	const walk = (nodes) => {
-		for (const step of nodes) {
-			if (!step.enabled) continue;
-			if (step.slot === "audio-classifier") continue;
-			result.push(step);
-			if (step.children?.length) walk(step.children);
-		}
-	};
-	walk(steps);
-	return result;
-}
-//#endregion
-//#region src/detection-pipeline/engine/pipeline-model-manager.ts
-var PipelineModelManager = class {
-	pool;
-	buildPoolConfig;
-	/** stepId → modelId → loaded entry. */
-	loaded = /* @__PURE__ */ new Map();
-	/** stepId → currently-active modelId (the runtime choice). */
-	activeByStep = /* @__PURE__ */ new Map();
-	/** Monotonic counter feeding the LRU tick on every touch. */
-	lruClock = 0;
-	log;
-	maxModelsPerStep;
-	constructor(pool, buildPoolConfig, logger, options) {
-		this.pool = pool;
-		this.buildPoolConfig = buildPoolConfig;
-		this.log = logger;
-		this.maxModelsPerStep = options?.maxModelsPerStep ?? 4;
-	}
-	/**
-	* Apply a new pipeline configuration — driven by the runtime config
-	* (camera-serving pipeline). Rewrites the *active* model per step,
-	* keeping prior actives warm in extra slots up to `maxModelsPerStep`.
-	*
-	* Steps that disappear from `newSteps` get fully unloaded (every
-	* model variant for that stepId).
-	*/
-	async applyConfig(newSteps) {
-		const enabledSteps = flattenEnabledVideoSteps(newSteps);
-		const diff = this.computeDiff(enabledSteps);
-		for (const removed of diff.removed) {
-			await this.unloadEntry(removed);
-			this.log.info("Unloading step", { meta: {
-				step: removed.stepId,
-				modelId: removed.modelId,
-				poolIndex: removed.poolIndex
-			} });
-		}
-		for (const added of diff.added) {
-			await this.ensureLoaded(added.addonId, added.modelId);
-			this.activeByStep.set(added.addonId, added.modelId);
-			this.log.info("Step loaded", { meta: {
-				step: added.addonId,
-				modelId: added.modelId,
-				active: true
-			} });
-		}
-		for (const { step, oldModelId } of diff.modelChanged) {
-			await this.ensureLoaded(step.addonId, step.modelId);
-			this.activeByStep.set(step.addonId, step.modelId);
-			this.log.info("Active model switched", { meta: {
-				step: step.addonId,
-				fromModelId: oldModelId,
-				toModelId: step.modelId
-			} });
-			await this.enforceLruCap(step.addonId);
-		}
-	}
-	/**
-	* Get an `IInferenceEngine` handle. Without `modelId`, returns the
-	* active model for the step (camera-runtime hot path). Pass
-	* `modelId` to grab a specific warm variant (benchmark path).
-	* Touches the LRU clock so the looked-up model survives eviction
-	* pressure from concurrent loads.
-	*/
-	getHandle(stepId, modelId) {
-		const entry = this.resolveOrThrow(stepId, modelId);
-		this.touch(entry);
-		return this.pool.getHandle(entry.poolIndex);
-	}
-	/** True iff the step has any model loaded. */
-	isLoaded(stepId) {
-		return this.loaded.has(stepId) && (this.loaded.get(stepId)?.size ?? 0) > 0;
-	}
-	/** True iff the specific (stepId, modelId) pair is resident. */
-	isLoadedWithModel(stepId, modelId) {
-		return this.loaded.get(stepId)?.has(modelId) ?? false;
-	}
-	/** ModelId currently designated as active for the step. */
-	getLoadedModelId(stepId) {
-		return this.activeByStep.get(stepId);
-	}
-	/**
-	* Pool index for a given (stepId, modelId). Without `modelId`,
-	* returns the active model's index. Used by the inference fast
-	* paths that bypass `getHandle` and call `pool.inferBatch` directly.
-	*/
-	getPoolIndex(stepId, modelId) {
-		const entry = this.resolve(stepId, modelId);
-		if (!entry) return null;
-		this.touch(entry);
-		return entry.poolIndex;
-	}
-	/**
-	* Direct access to the underlying pool — exposed so the provider can
-	* call `inferBatch` without re-fetching individual handles. Pool
-	* lifetime is owned by `EngineFactory`, so callers must not dispose.
-	*/
-	getPool() {
-		return this.pool;
-	}
-	/**
-	* Snapshot of every (stepId, modelId, poolIndex) currently resident.
-	* Used by the `Warm instances` UI tab + cap-level `listLoadedEngines`
-	* to surface both the runtime model and the warm extras.
-	*/
-	getLoadedSteps() {
-		const out = [];
-		for (const [stepId, models] of this.loaded) {
-			const activeModelId = this.activeByStep.get(stepId);
-			for (const entry of models.values()) out.push({
-				stepId: entry.stepId,
-				modelId: entry.modelId,
-				poolIndex: entry.poolIndex,
-				active: entry.modelId === activeModelId
-			});
+	},
+	{
+		id: "yolo26n",
+		group: {
+			family: "yolo26",
+			tier: "n"
+		},
+		name: "YOLO26 Nano",
+		description: "YOLO26 Nano — latest generation ultra-lightweight detector with attention mechanism",
+		inputSize: {
+			width: 640,
+			height: 640
+		},
+		labels: [],
+		preprocessMode: "letterbox",
+		formats: {
+			onnx: {
+				url: hf("objectDetection/yolo26/onnx/camstack-yolo26n.onnx"),
+				sizeMB: 10
+			},
+			coreml: {
+				url: hf("objectDetection/yolo26/coreml/camstack-yolo26n.mlpackage"),
+				sizeMB: 5,
+				isDirectory: true,
+				files: [...MLPACKAGE_FILES],
+				runtimes: ["python"]
+			},
+			openvino: ovFormat(hf("objectDetection/yolo26/openvino/camstack-yolo26n.xml"), 9)
 		}
-		return out;
-	}
-	/**
-	* Load extra models without touching the active runtime model.
-	* Idempotent — already-loaded (stepId, modelId) pairs are no-op'd.
-	* If `maxModelsPerStep` is exceeded, the LRU non-active variant is
-	* evicted (NOT the active one — that would knock the runtime cameras
-	* offline). The "active" designation is unchanged: callers without
-	* a `modelId` argument keep hitting the runtime model.
-	*/
-	async loadAdditional(steps) {
-		for (const step of steps) {
-			if (this.isLoadedWithModel(step.addonId, step.modelId)) continue;
-			await this.ensureLoaded(step.addonId, step.modelId);
-			if (!this.activeByStep.has(step.addonId)) this.activeByStep.set(step.addonId, step.modelId);
+	},
+	{
+		id: "yolo26s",
+		group: {
+			family: "yolo26",
+			tier: "s"
+		},
+		name: "YOLO26 Small",
+		description: "YOLO26 Small — balanced speed/accuracy with attention-based architecture",
+		inputSize: {
+			width: 640,
+			height: 640
+		},
+		labels: [],
+		preprocessMode: "letterbox",
+		formats: {
+			onnx: {
+				url: hf("objectDetection/yolo26/onnx/camstack-yolo26s.onnx"),
+				sizeMB: 37
+			},
+			coreml: {
+				url: hf("objectDetection/yolo26/coreml/camstack-yolo26s.mlpackage"),
+				sizeMB: 18,
+				isDirectory: true,
+				files: [...MLPACKAGE_FILES],
+				runtimes: ["python"]
+			},
+			openvino: ovFormat(hf("objectDetection/yolo26/openvino/camstack-yolo26s.xml"), 36)
 		}
-	}
-	/**
-	* Load `(stepId, modelId)` into the pool if not already resident.
-	* Honors `maxModelsPerStep` — evicts a non-active LRU variant first
-	* when the cap would otherwise be exceeded.
-	*/
-	async ensureLoaded(stepId, modelId) {
-		let perStep = this.loaded.get(stepId);
-		if (!perStep) {
-			perStep = /* @__PURE__ */ new Map();
-			this.loaded.set(stepId, perStep);
+	},
+	{
+		id: "yolo26m",
+		group: {
+			family: "yolo26",
+			tier: "m"
+		},
+		name: "YOLO26 Medium",
+		description: "YOLO26 Medium — high accuracy general-purpose detector",
+		inputSize: {
+			width: 640,
+			height: 640
+		},
+		labels: [],
+		preprocessMode: "letterbox",
+		formats: {
+			onnx: {
+				url: hf("objectDetection/yolo26/onnx/camstack-yolo26m.onnx"),
+				sizeMB: 78
+			},
+			coreml: {
+				url: hf("objectDetection/yolo26/coreml/camstack-yolo26m.mlpackage"),
+				sizeMB: 39,
+				isDirectory: true,
+				files: [...MLPACKAGE_FILES],
+				runtimes: ["python"]
+			},
+			openvino: ovFormat(hf("objectDetection/yolo26/openvino/camstack-yolo26m.xml"), 78)
 		}
-		const existing = perStep.get(modelId);
-		if (existing) {
-			this.touch(existing);
-			return existing;
+	},
+	{
+		id: "yolo26l",
+		group: {
+			family: "yolo26",
+			tier: "l"
+		},
+		name: "YOLO26 Large",
+		description: "YOLO26 Large — maximum accuracy for demanding deployments",
+		inputSize: {
+			width: 640,
+			height: 640
+		},
+		labels: [],
+		preprocessMode: "letterbox",
+		formats: {
+			onnx: {
+				url: hf("objectDetection/yolo26/onnx/camstack-yolo26l.onnx"),
+				sizeMB: 95
+			},
+			coreml: {
+				url: hf("objectDetection/yolo26/coreml/camstack-yolo26l.mlpackage"),
+				sizeMB: 48,
+				isDirectory: true,
+				files: [...MLPACKAGE_FILES],
+				runtimes: ["python"]
+			},
+			openvino: ovFormat(hf("objectDetection/yolo26/openvino/camstack-yolo26l.xml"), 95)
 		}
-		while (perStep.size >= this.maxModelsPerStep) {
-			const evicted = this.pickEvictionTarget(stepId);
-			if (!evicted) break;
-			await this.unloadEntry(evicted);
-			this.log.info("LRU evicted warm model", { meta: {
-				step: stepId,
-				modelId: evicted.modelId,
-				poolIndex: evicted.poolIndex,
-				cap: this.maxModelsPerStep
-			} });
+	},
+	{
+		id: "yolo26x",
+		legacy: true,
+		name: "YOLO26 XLarge",
+		description: "YOLO26 XLarge — highest accuracy, attention-based architecture",
+		inputSize: {
+			width: 640,
+			height: 640
+		},
+		labels: [],
+		preprocessMode: "letterbox",
+		formats: {
+			onnx: {
+				url: hf("objectDetection/yolo26/onnx/camstack-yolo26x.onnx"),
+				sizeMB: 213
+			},
+			coreml: {
+				url: hf("objectDetection/yolo26/coreml/camstack-yolo26x.mlpackage"),
+				sizeMB: 107,
+				isDirectory: true,
+				files: [...MLPACKAGE_FILES],
+				runtimes: ["python"]
+			},
+			openvino: ovFormat(hf("objectDetection/yolo26/openvino/camstack-yolo26x.xml"), 213)
 		}
-		const index = this.pool.allocateIndex();
-		const config = this.buildPoolConfig(stepId, modelId);
-		this.log.info("Loading step variant", { meta: {
-			step: stepId,
-			modelId,
-			poolIndex: index
-		} });
-		const { loadMs } = await this.pool.loadModel(index, config);
-		this.log.info("Step variant loaded", { meta: {
-			step: stepId,
-			modelId,
-			poolIndex: index,
-			loadMs
-		} });
-		const entry = {
-			stepId,
-			modelId,
-			poolIndex: index,
-			lruTick: ++this.lruClock
-		};
-		perStep.set(modelId, entry);
-		return entry;
-	}
-	async unloadEntry(entry) {
-		await this.pool.unloadModel(entry.poolIndex);
-		const perStep = this.loaded.get(entry.stepId);
-		perStep?.delete(entry.modelId);
-		if (perStep && perStep.size === 0) {
-			this.loaded.delete(entry.stepId);
-			this.activeByStep.delete(entry.stepId);
+	},
+	{
+		id: "scrypted-yolov9t-relu",
+		legacy: true,
+		name: "YOLOv9 Tiny ReLU",
+		description: "YOLOv9t ReLU — optimized for int8 quantization",
+		inputSize: {
+			width: 320,
+			height: 320
+		},
+		labels: [],
+		preprocessMode: "letterbox",
+		formats: {
+			onnx: {
+				url: hfScrypted("onnx/scrypted_yolov9t_relu/scrypted_yolov9t_relu.onnx"),
+				sizeMB: 8.1
+			},
+			coreml: {
+				url: hfScrypted("coreml/scrypted_yolov9t_relu/scrypted_yolov9t_relu.mlpackage"),
+				sizeMB: 4,
+				isDirectory: true,
+				files: [...MLPACKAGE_FILES],
+				runtimes: ["python"]
+			},
+			openvino: ovFormat(hf("objectDetection/scrypted-yolov9-relu/openvino/scrypted_yolov9t_relu.xml"), 6)
 		}
-	}
-	/** Select the LRU non-active entry for a step. Returns null when only the active one is present. */
-	pickEvictionTarget(stepId) {
-		const perStep = this.loaded.get(stepId);
-		if (!perStep) return null;
-		const activeModelId = this.activeByStep.get(stepId);
-		let oldest = null;
-		for (const entry of perStep.values()) {
-			if (entry.modelId === activeModelId) continue;
-			if (!oldest || entry.lruTick < oldest.lruTick) oldest = entry;
+	},
+	{
+		id: "scrypted-yolov9s-relu",
+		legacy: true,
+		name: "YOLOv9 Small ReLU",
+		description: "YOLOv9s ReLU — improved efficiency, int8 ready",
+		inputSize: {
+			width: 320,
+			height: 320
+		},
+		labels: [],
+		preprocessMode: "letterbox",
+		formats: {
+			onnx: {
+				url: hfScrypted("onnx/scrypted_yolov9s_relu/scrypted_yolov9s_relu.onnx"),
+				sizeMB: 27.9
+			},
+			coreml: {
+				url: hfScrypted("coreml/scrypted_yolov9s_relu/scrypted_yolov9s_relu.mlpackage"),
+				sizeMB: 14,
+				isDirectory: true,
+				files: [...MLPACKAGE_FILES],
+				runtimes: ["python"]
+			},
+			openvino: ovFormat(hf("objectDetection/scrypted-yolov9-relu/openvino/scrypted_yolov9s_relu.xml"), 16)
 		}
-		return oldest;
-	}
-	/** Trim the step down to `maxModelsPerStep` entries, evicting LRU non-actives. */
-	async enforceLruCap(stepId) {
-		const perStep = this.loaded.get(stepId);
-		if (!perStep) return;
-		while (perStep.size > this.maxModelsPerStep) {
-			const evicted = this.pickEvictionTarget(stepId);
-			if (!evicted) break;
-			await this.unloadEntry(evicted);
+	},
+	{
+		id: "scrypted-yolov9c-relu",
+		legacy: true,
+		name: "YOLOv9 C ReLU",
+		description: "YOLOv9c ReLU — high-accuracy, int8 ready",
+		inputSize: {
+			width: 320,
+			height: 320
+		},
+		labels: [],
+		preprocessMode: "letterbox",
+		formats: {
+			onnx: {
+				url: hfScrypted("onnx/scrypted_yolov9c_relu/scrypted_yolov9c_relu.onnx"),
+				sizeMB: 96.9
+			},
+			coreml: {
+				url: hfScrypted("coreml/scrypted_yolov9c_relu/scrypted_yolov9c_relu.mlpackage"),
+				sizeMB: 48,
+				isDirectory: true,
+				files: [...MLPACKAGE_FILES],
+				runtimes: ["python"]
+			},
+			openvino: ovFormat(hf("objectDetection/scrypted-yolov9-relu/openvino/scrypted_yolov9c_relu.xml"), 49)
 		}
+	},
+	{
+		id: "scrypted-yolov9m-relu",
+		legacy: true,
+		name: "YOLOv9 M ReLU",
+		description: "YOLOv9m ReLU — medium, int8 ready",
+		inputSize: {
+			width: 320,
+			height: 320
+		},
+		labels: [],
+		preprocessMode: "letterbox",
+		formats: {
+			onnx: {
+				url: hfScrypted("onnx/scrypted_yolov9m_relu/scrypted_yolov9m_relu.onnx"),
+				sizeMB: 76.6
+			},
+			coreml: {
+				url: hfScrypted("coreml/scrypted_yolov9m_relu/scrypted_yolov9m_relu.mlpackage"),
+				sizeMB: 38,
+				isDirectory: true,
+				files: [...MLPACKAGE_FILES],
+				runtimes: ["python"]
+			},
+			openvino: ovFormat(hf("objectDetection/scrypted-yolov9-relu/openvino/scrypted_yolov9m_relu.xml"), 38)
+		}
+	},
+	ovPrecisionVariant("yolov9t", "objectDetection/yolov9/openvino", "YOLOv9 Tiny", "fp16", 5, true),
+	ovPrecisionVariant("yolov9t", "objectDetection/yolov9/openvino", "YOLOv9 Tiny", "int8", 3, true),
+	ovPrecisionVariant("yolov9s", "objectDetection/yolov9/openvino", "YOLOv9 Small", "fp16", 15, true),
+	ovPrecisionVariant("yolov9s", "objectDetection/yolov9/openvino", "YOLOv9 Small", "int8", 8, true),
+	ovPrecisionVariant("yolo26n", "objectDetection/yolo26/openvino", "YOLO26 Nano", "fp16", 5, true),
+	ovPrecisionVariant("yolo26n", "objectDetection/yolo26/openvino", "YOLO26 Nano", "int8", 3),
+	ovPrecisionVariant("yolo26s", "objectDetection/yolo26/openvino", "YOLO26 Small", "fp16", 19, true),
+	ovPrecisionVariant("yolo26s", "objectDetection/yolo26/openvino", "YOLO26 Small", "int8", 10),
+	ovPrecisionVariant("yolo26m", "objectDetection/yolo26/openvino", "YOLO26 Medium", "fp16", 41, true),
+	ovPrecisionVariant("yolo26m", "objectDetection/yolo26/openvino", "YOLO26 Medium", "int8", 21),
+	ovPrecisionVariant("yolo26l", "objectDetection/yolo26/openvino", "YOLO26 Large", "fp16", 50, true),
+	ovPrecisionVariant("yolo26l", "objectDetection/yolo26/openvino", "YOLO26 Large", "int8", 25),
+	...yolo26Reduced("n", 320, {
+		onnx: 10.47,
+		coreml: 5.05,
+		ovFp32: 10.05,
+		ovInt8: 3.29
+	}),
+	...yolo26Reduced("n", 256, {
+		onnx: 10.47,
+		coreml: 5.05,
+		ovFp32: 10.05,
+		ovInt8: 3.29
+	}),
+	...yolo26Reduced("s", 320, {
+		onnx: 38.82,
+		coreml: 19.23,
+		ovFp32: 38.4,
+		ovInt8: 10.43
+	}),
+	...yolo26Reduced("s", 256, {
+		onnx: 38.82,
+		coreml: 19.23,
+		ovFp32: 38.4,
+		ovInt8: 10.43
+	}),
+	...yolo26Reduced("m", 320, {
+		onnx: 83.31,
+		coreml: 41.07,
+		ovFp32: 82.09,
+		ovInt8: 21.47
+	}),
+	...yolo26Reduced("m", 256, {
+		onnx: 83.31,
+		coreml: 41.07,
+		ovFp32: 82.09,
+		ovInt8: 21.47
+	}),
+	...yolo26Reduced("l", 320, {
+		onnx: 101.74,
+		coreml: 49.97,
+		ovFp32: 99.85,
+		ovInt8: 26.31
+	}),
+	...yolo26Reduced("l", 256, {
+		onnx: 101.74,
+		coreml: 49.97,
+		ovFp32: 99.85,
+		ovInt8: 26.31
+	}),
+	ovPrecisionVariant("yolo26x", "objectDetection/yolo26/openvino", "YOLO26 XLarge", "fp16", 112, true),
+	ovPrecisionVariant("yolo26x", "objectDetection/yolo26/openvino", "YOLO26 XLarge", "int8", 56, true)
+];
+var FACE_DETECTION_MODELS = [{
+	id: "scrfd-2.5g",
+	name: "SCRFD 2.5G",
+	description: "SCRFD 2.5G — balanced face detection model",
+	inputSize: {
+		width: 640,
+		height: 640
+	},
+	labels: [{
+		id: "face",
+		name: "Face"
+	}],
+	preprocessMode: "letterbox",
+	formats: {
+		onnx: {
+			url: hf("faceDetection/scrfd/onnx/camstack-scrfd-2.5g.onnx"),
+			sizeMB: 3.1
+		},
+		coreml: {
+			url: hf("faceDetection/scrfd/coreml/camstack-scrfd-2.5g.mlpackage"),
+			sizeMB: 1.7,
+			isDirectory: true,
+			files: [...MLPACKAGE_FILES],
+			runtimes: ["python"]
+		},
+		openvino: ovFormat(hf("faceDetection/scrfd/openvino/camstack-scrfd-2.5g.xml"), 1.8)
 	}
-	resolve(stepId, modelId) {
-		const perStep = this.loaded.get(stepId);
-		if (!perStep) return null;
-		const targetModelId = modelId ?? this.activeByStep.get(stepId);
-		if (!targetModelId) return null;
-		return perStep.get(targetModelId) ?? null;
-	}
-	resolveOrThrow(stepId, modelId) {
-		const entry = this.resolve(stepId, modelId);
-		if (!entry) throw new Error(`Step "${stepId}"${modelId ? ` (model "${modelId}")` : ""} is not loaded in the inference pool`);
-		return entry;
+}, {
+	id: "scrypted-yolov9t-face",
+	name: "YOLOv9t Face ReLU",
+	description: "YOLOv9t face detection — YOLO-based, fast, 320x320 ReLU",
+	inputSize: {
+		width: 320,
+		height: 320
+	},
+	labels: [{
+		id: "face",
+		name: "Face"
+	}],
+	preprocessMode: "letterbox",
+	formats: {
+		onnx: {
+			url: hfScrypted("onnx/scrypted_yolov9t_relu_face/scrypted_yolov9t_relu_face.onnx"),
+			sizeMB: 8.1
+		},
+		coreml: {
+			url: hfScrypted("coreml/scrypted_yolov9t_relu_face/scrypted_yolov9t_relu_face.mlpackage"),
+			sizeMB: 4,
+			isDirectory: true,
+			files: [...MLPACKAGE_FILES],
+			runtimes: ["python"]
+		},
+		openvino: ovFormat(hf("faceDetection/scrypted-yolov9-face/openvino/scrypted_yolov9t_relu_face.xml"), 6)
 	}
-	touch(entry) {
-		entry.lruTick = ++this.lruClock;
+}];
+var FACE_EMBEDDING_MODELS = [{
+	id: "arcface-r100",
+	name: "ArcFace R100",
+	description: "ArcFace ResNet-100 — high-accuracy face recognition embeddings (512-d)",
+	inputSize: {
+		width: 112,
+		height: 112
+	},
+	inputLayout: "nhwc",
+	labels: [{
+		id: "embedding",
+		name: "Face Embedding"
+	}],
+	preprocessMode: "resize",
+	faceAlignment: true,
+	formats: {
+		onnx: {
+			url: hf("faceRecognition/arcface/onnx/camstack-arcface-arcface.onnx"),
+			sizeMB: 130
+		},
+		coreml: {
+			url: hf("faceRecognition/arcface/coreml/camstack-arcface-r100.mlpackage"),
+			sizeMB: 65,
+			isDirectory: true,
+			files: [...MLPACKAGE_FILES],
+			runtimes: ["python"]
+		},
+		openvino: ovFormat(hf("faceRecognition/arcface/openvino/camstack-arcface-r100.xml"), 65)
 	}
-	/** Compute diff between currently-active steps and desired steps. */
-	computeDiff(desiredSteps) {
-		const desiredMap = /* @__PURE__ */ new Map();
-		for (const step of desiredSteps) desiredMap.set(step.addonId, step);
-		const added = [];
-		const removed = [];
-		const modelChanged = [];
-		const unchanged = [];
-		for (const [stepId, activeModelId] of this.activeByStep) {
-			const activeEntry = this.loaded.get(stepId)?.get(activeModelId);
-			if (!activeEntry) continue;
-			const desired = desiredMap.get(stepId);
-			if (!desired) {
-				const perStep = this.loaded.get(stepId);
-				if (perStep) for (const entry of perStep.values()) removed.push(entry);
-			} else if (desired.modelId !== activeModelId) modelChanged.push({
-				step: desired,
-				oldModelId: activeModelId
-			});
-			else unchanged.push(activeEntry);
-		}
-		for (const [stepId, step] of desiredMap) if (!this.activeByStep.has(stepId)) added.push(step);
-		return {
-			added,
-			removed,
-			modelChanged,
-			unchanged
-		};
+}, {
+	id: "inception-resnet-v1",
+	name: "Inception ResNet V1",
+	description: "FaceNet-style face recognition embeddings (512-d) — hosted on plugin-models HF repo",
+	inputSize: {
+		width: 160,
+		height: 160
+	},
+	labels: [{
+		id: "embedding",
+		name: "Face Embedding"
+	}],
+	preprocessMode: "resize",
+	formats: {
+		onnx: {
+			url: hfScrypted("onnx/inception_resnet_v1/inception_resnet_v1.onnx"),
+			sizeMB: 89.6
+		},
+		coreml: {
+			url: hfScrypted("coreml/inception_resnet_v1/inception_resnet_v1.mlpackage"),
+			sizeMB: 45,
+			isDirectory: true,
+			files: [...MLPACKAGE_FILES],
+			runtimes: ["python"]
+		},
+		openvino: ovFormat(hf("faceRecognition/inception-resnet-v1/openvino/camstack-inception-resnet-v1.xml"), 45)
 	}
-};
-//#endregion
-//#region src/detection-pipeline/registry/model-catalogs.ts
-var HF_REPO = "camstack/camstack-models";
-var HF_SCRYPTED = "scrypted/plugin-models";
-var hf = (path) => require_dist.hfModelUrl(HF_REPO, path);
-var hfScrypted = (path) => require_dist.hfModelUrl(HF_SCRYPTED, path);
-/**
-* Build an OpenVINO format entry (always python runtime).
-*
-* OpenVINO IR is a two-file bundle: a `.xml` topology + a sibling `.bin`
-* weights file with the same basename. We declare the `.bin` in `files` so
-* the (format-agnostic) downloader fetches it alongside the `.xml` — without
-* the weights, OpenVINO compile fails with "Empty weights data in bin file".
-* A plain `.onnx` run through the OpenVINO runtime (e.g. yamnet) has no
-* sibling, so none is added.
-*/
-var ovFormat = (url, sizeMB) => {
-	const base = url.split("/").pop() ?? "";
-	const files = base.endsWith(".xml") ? [base.replace(/\.xml$/, ".bin")] : void 0;
-	return {
-		url,
-		sizeMB,
-		runtimes: ["python"],
-		...files ? { files } : {}
-	};
-};
-/**
-* Build a precision-variant catalog entry (OpenVINO-only) derived from a base
-* detection model. fp16 halves the weights (Intel iGPU/NPU sweet spot); int8 is
-* NNCF post-training-quantized (~4× smaller, fastest on CPU/iGPU at a small
-* accuracy cost). The IRs live next to the base `.xml` on HF as
-* `camstack-<id>-<precision>.xml`. Lets an operator scale the model to the node
-* (e.g. yolo26x-int8 on a 265K, yolo26n-int8 on an N100).
-*/
-var ovPrecisionVariant = (baseId, ovDir, baseName, precision, sizeMB, legacy = false) => ({
-	id: `${baseId}-${precision}`,
-	name: `${baseName} (${precision.toUpperCase()})`,
-	description: `${baseName} — OpenVINO ${precision.toUpperCase()} variant for Intel iGPU/NPU; scale by hardware`,
+}];
+var PLATE_DETECTION_MODELS = [{
+	id: "yolov8n-plate",
+	name: "YOLOv8 Nano — License Plate",
+	description: "YOLOv8 Nano fine-tuned for license plate detection",
 	inputSize: {
 		width: 640,
 		height: 640
 	},
-	labels: [],
+	labels: [{
+		id: "plate",
+		name: "License Plate"
+	}],
 	preprocessMode: "letterbox",
-	formats: { openvino: ovFormat(hf(`${ovDir}/camstack-${baseId}-${precision}.xml`), sizeMB) },
-	...legacy ? { legacy: true } : {},
-	...precision === "int8" ? { group: {
-		family: baseId.slice(0, -1),
-		tier: baseId.slice(-1),
-		precision: "int8"
-	} } : {}
-});
-var MLPACKAGE_FILES = [
-	"Manifest.json",
-	"Data/com.apple.CoreML/model.mlmodel",
-	"Data/com.apple.CoreML/weights/weight.bin"
-];
-var OBJECT_DETECTION_MODELS = [
-	{
-		id: "yolov9t",
-		legacy: true,
-		name: "YOLOv9 Tiny",
-		description: "YOLOv9 Tiny — ultra-lightweight next-gen detector",
-		inputSize: {
-			width: 640,
-			height: 640
+	formats: {
+		onnx: {
+			url: hf("plateDetection/yolov8-plate/onnx/camstack-yolov8n-plate.onnx"),
+			sizeMB: 12
 		},
-		labels: [],
-		preprocessMode: "letterbox",
-		formats: {
-			onnx: {
-				url: hf("objectDetection/yolov9/onnx/camstack-yolov9t.onnx"),
-				sizeMB: 8
-			},
-			coreml: {
-				url: hf("objectDetection/yolov9/coreml/camstack-yolov9t.mlpackage"),
-				sizeMB: 4,
-				isDirectory: true,
-				files: [...MLPACKAGE_FILES],
-				runtimes: ["python"]
-			},
-			openvino: ovFormat(hf("objectDetection/yolov9/openvino/camstack-yolov9t.xml"), 6)
-		}
+		coreml: {
+			url: hf("plateDetection/yolov8-plate/coreml/camstack-yolov8n-plate.mlpackage"),
+			sizeMB: 5.9,
+			isDirectory: true,
+			files: [...MLPACKAGE_FILES],
+			runtimes: ["python"]
+		},
+		openvino: ovFormat(hf("plateDetection/yolov8-plate/openvino/camstack-yolov8n-plate.xml"), 6.1)
+	}
+}];
+var PLATE_OCR_MODELS = [{
+	id: "vgg-english-g2",
+	name: "VGG English G2",
+	description: "EasyOCR VGG English G2 — text recognition for license plates and scene text",
+	inputSize: {
+		width: 384,
+		height: 64
 	},
-	{
-		id: "yolov9s",
-		legacy: true,
-		name: "YOLOv9 Small",
-		description: "YOLOv9 Small — improved efficiency over YOLOv8s",
-		inputSize: {
-			width: 640,
-			height: 640
+	labels: [{
+		id: "text",
+		name: "Plate Text"
+	}],
+	preprocessMode: "resize",
+	formats: {
+		onnx: {
+			url: hfScrypted("onnx/vgg_english_g2/vgg_english_g2.onnx"),
+			sizeMB: 14.4
 		},
-		labels: [],
-		preprocessMode: "letterbox",
-		formats: {
-			onnx: {
-				url: hf("objectDetection/yolov9/onnx/camstack-yolov9s.onnx"),
-				sizeMB: 28
-			},
-			coreml: {
-				url: hf("objectDetection/yolov9/coreml/camstack-yolov9s.mlpackage"),
-				sizeMB: 14,
-				isDirectory: true,
-				files: [...MLPACKAGE_FILES],
-				runtimes: ["python"]
-			},
-			openvino: ovFormat(hf("objectDetection/yolov9/openvino/camstack-yolov9s.xml"), 16)
-		}
+		coreml: {
+			url: hfScrypted("coreml/vgg_english_g2/vgg_english_g2.mlpackage"),
+			sizeMB: 11.2,
+			isDirectory: true,
+			files: [...MLPACKAGE_FILES],
+			runtimes: ["python"]
+		},
+		openvino: ovFormat(hf("plateRecognition/vgg_english_g2/openvino/vgg_english_g2.xml"), 7.2)
+	}
+}];
+var ANIMAL_CLASSIFIER_MODELS = [{
+	id: "animals-10",
+	name: "Animal Classifier (10)",
+	description: "ViT-based animal type classifier — cat, cow, dog, dolphin, eagle, panda, horse, monkey, sheep, spider",
+	inputSize: {
+		width: 224,
+		height: 224
 	},
-	{
-		id: "yolov9c",
-		legacy: true,
-		name: "YOLOv9 C",
-		description: "YOLOv9 C — high-accuracy compact model",
-		inputSize: {
-			width: 640,
-			height: 640
+	inputNormalization: "imagenet",
+	labels: [{
+		id: "animal-type",
+		name: "Animal Type"
+	}],
+	preprocessMode: "resize",
+	formats: {
+		onnx: {
+			url: hf("animalClassification/animals-10/onnx/camstack-animals-10.onnx"),
+			sizeMB: 328
 		},
-		labels: [],
-		preprocessMode: "letterbox",
-		formats: {
-			onnx: {
-				url: hf("objectDetection/yolov9/onnx/camstack-yolov9c.onnx"),
-				sizeMB: 97
-			},
-			coreml: {
-				url: hf("objectDetection/yolov9/coreml/camstack-yolov9c.mlpackage"),
-				sizeMB: 48,
-				isDirectory: true,
-				files: [...MLPACKAGE_FILES],
-				runtimes: ["python"]
-			},
-			openvino: ovFormat(hf("objectDetection/yolov9/openvino/camstack-yolov9c.xml"), 49)
-		}
+		coreml: {
+			url: hf("animalClassification/animals-10/coreml/camstack-animals-10.mlpackage"),
+			sizeMB: 164,
+			isDirectory: true,
+			files: [...MLPACKAGE_FILES],
+			runtimes: ["python"]
+		},
+		openvino: ovFormat(hf("animalClassification/animals-10/openvino/camstack-animals-10.xml"), 164)
+	}
+}];
+var BIRD_CLASSIFIER_MODELS = [{
+	id: "bird-nabirds-404",
+	name: "NABirds (404 species)",
+	description: "ResNet50 trained on NABirds — 404 North American species",
+	inputSize: {
+		width: 224,
+		height: 224
 	},
-	{
-		id: "yolo26n",
-		group: {
-			family: "yolo26",
-			tier: "n"
+	inputNormalization: "imagenet",
+	labels: [{
+		id: "species",
+		name: "Bird Species"
+	}],
+	preprocessMode: "resize",
+	formats: {
+		onnx: {
+			url: hf("animalClassification/bird-nabirds/onnx/camstack-bird-nabirds-404.onnx"),
+			sizeMB: 93
+		},
+		coreml: {
+			url: hf("animalClassification/bird-nabirds/coreml/camstack-bird-nabirds-404.mlpackage"),
+			sizeMB: 47,
+			isDirectory: true,
+			files: [...MLPACKAGE_FILES],
+			runtimes: ["python"]
+		},
+		openvino: ovFormat(hf("animalClassification/bird-nabirds/openvino/camstack-bird-nabirds-404.xml"), 47)
+	},
+	extraFiles: [{
+		url: hf("animalClassification/bird-nabirds/onnx/camstack-bird-nabirds-404-labels.json"),
+		filename: "camstack-bird-nabirds-404-labels.json",
+		sizeMB: .02
+	}]
+}];
+var VEHICLE_CLASSIFIER_MODELS = [{
+	id: "vehicle-type-efficientnet",
+	name: "Vehicle Type (EfficientNet)",
+	description: "EfficientNet-B4 vehicle make/model/year classifier — 8,949 classes from VMMRdb",
+	inputSize: {
+		width: 380,
+		height: 380
+	},
+	inputNormalization: "imagenet",
+	labels: [{
+		id: "vehicle-type",
+		name: "Vehicle Type"
+	}],
+	preprocessMode: "resize",
+	formats: {
+		onnx: {
+			url: hf("vehicleClassification/efficientnet/onnx/camstack-vehicle-type-efficientnet.onnx"),
+			sizeMB: 135
 		},
-		name: "YOLO26 Nano",
-		description: "YOLO26 Nano — latest generation ultra-lightweight detector with attention mechanism",
-		inputSize: {
-			width: 640,
-			height: 640
+		coreml: {
+			url: hf("vehicleClassification/efficientnet/coreml/camstack-vehicle-type-efficientnet.mlpackage"),
+			sizeMB: 10,
+			isDirectory: true,
+			files: [...MLPACKAGE_FILES],
+			runtimes: ["python"]
 		},
-		labels: [],
-		preprocessMode: "letterbox",
-		formats: {
-			onnx: {
-				url: hf("objectDetection/yolo26/onnx/camstack-yolo26n.onnx"),
-				sizeMB: 10
-			},
-			coreml: {
-				url: hf("objectDetection/yolo26/coreml/camstack-yolo26n.mlpackage"),
-				sizeMB: 5,
-				isDirectory: true,
-				files: [...MLPACKAGE_FILES],
-				runtimes: ["python"]
-			},
-			openvino: ovFormat(hf("objectDetection/yolo26/openvino/camstack-yolo26n.xml"), 9)
-		}
+		openvino: ovFormat(hf("vehicleClassification/efficientnet/openvino/camstack-vehicle-type-efficientnet.xml"), 68)
 	},
-	{
-		id: "yolo26s",
-		group: {
-			family: "yolo26",
-			tier: "s"
+	extraFiles: [{
+		url: hf("vehicleClassification/efficientnet/camstack-vehicle-type-labels.json"),
+		filename: "camstack-vehicle-type-labels.json",
+		sizeMB: .2
+	}]
+}];
+var SEGMENTATION_REFINER_MODELS = [{
+	id: "u2netp",
+	name: "U2-Net Portable",
+	description: "U2-Net-P — ultra-lightweight salient object segmentation (4.7 MB)",
+	inputSize: {
+		width: 320,
+		height: 320
+	},
+	labels: [{
+		id: "mask",
+		name: "Segmentation Mask"
+	}],
+	preprocessMode: "resize",
+	formats: {
+		onnx: {
+			url: hf("segmentationRefiner/u2netp/onnx/camstack-u2netp.onnx"),
+			sizeMB: 5
 		},
-		name: "YOLO26 Small",
-		description: "YOLO26 Small — balanced speed/accuracy with attention-based architecture",
-		inputSize: {
-			width: 640,
-			height: 640
+		coreml: {
+			url: hf("segmentationRefiner/u2netp/coreml/camstack-u2netp.mlpackage"),
+			sizeMB: 3,
+			isDirectory: true,
+			files: [...MLPACKAGE_FILES],
+			runtimes: ["python"]
 		},
-		labels: [],
-		preprocessMode: "letterbox",
-		formats: {
-			onnx: {
-				url: hf("objectDetection/yolo26/onnx/camstack-yolo26s.onnx"),
-				sizeMB: 37
-			},
-			coreml: {
-				url: hf("objectDetection/yolo26/coreml/camstack-yolo26s.mlpackage"),
-				sizeMB: 18,
-				isDirectory: true,
-				files: [...MLPACKAGE_FILES],
-				runtimes: ["python"]
-			},
-			openvino: ovFormat(hf("objectDetection/yolo26/openvino/camstack-yolo26s.xml"), 36)
-		}
-	},
+		openvino: ovFormat(hf("segmentationRefiner/u2netp/openvino/camstack-u2netp.xml"), 2.5)
+	}
+}];
+var INSTANCE_SEGMENTATION_MODELS = [
 	{
-		id: "yolo26m",
-		group: {
-			family: "yolo26",
-			tier: "m"
-		},
-		name: "YOLO26 Medium",
-		description: "YOLO26 Medium — high accuracy general-purpose detector",
+		id: "yolo26n-seg",
+		name: "YOLO26 Nano Seg",
+		description: "YOLO26 Nano Segmentation — ultra-lightweight instance segmentation with masks",
 		inputSize: {
 			width: 640,
 			height: 640
@@ -1359,27 +1113,23 @@ var OBJECT_DETECTION_MODELS = [
 		preprocessMode: "letterbox",
 		formats: {
 			onnx: {
-				url: hf("objectDetection/yolo26/onnx/camstack-yolo26m.onnx"),
-				sizeMB: 78
+				url: hf("segmentation/yolo26-seg/onnx/camstack-yolo26n-seg.onnx"),
+				sizeMB: 11
 			},
 			coreml: {
-				url: hf("objectDetection/yolo26/coreml/camstack-yolo26m.mlpackage"),
-				sizeMB: 39,
+				url: hf("segmentation/yolo26-seg/coreml/camstack-yolo26n-seg.mlpackage"),
+				sizeMB: 6,
 				isDirectory: true,
 				files: [...MLPACKAGE_FILES],
 				runtimes: ["python"]
 			},
-			openvino: ovFormat(hf("objectDetection/yolo26/openvino/camstack-yolo26m.xml"), 78)
+			openvino: ovFormat(hf("segmentation/yolo26-seg/openvino/camstack-yolo26n-seg.xml"), 11)
 		}
 	},
 	{
-		id: "yolo26l",
-		group: {
-			family: "yolo26",
-			tier: "l"
-		},
-		name: "YOLO26 Large",
-		description: "YOLO26 Large — maximum accuracy for demanding deployments",
+		id: "yolo26s-seg",
+		name: "YOLO26 Small Seg",
+		description: "YOLO26 Small Segmentation — balanced instance segmentation",
 		inputSize: {
 			width: 640,
 			height: 640
@@ -1388,24 +1138,23 @@ var OBJECT_DETECTION_MODELS = [
 		preprocessMode: "letterbox",
 		formats: {
 			onnx: {
-				url: hf("objectDetection/yolo26/onnx/camstack-yolo26l.onnx"),
-				sizeMB: 95
+				url: hf("segmentation/yolo26-seg/onnx/camstack-yolo26s-seg.onnx"),
+				sizeMB: 40
 			},
 			coreml: {
-				url: hf("objectDetection/yolo26/coreml/camstack-yolo26l.mlpackage"),
-				sizeMB: 48,
+				url: hf("segmentation/yolo26-seg/coreml/camstack-yolo26s-seg.mlpackage"),
+				sizeMB: 20,
 				isDirectory: true,
 				files: [...MLPACKAGE_FILES],
 				runtimes: ["python"]
 			},
-			openvino: ovFormat(hf("objectDetection/yolo26/openvino/camstack-yolo26l.xml"), 95)
+			openvino: ovFormat(hf("segmentation/yolo26-seg/openvino/camstack-yolo26s-seg.xml"), 40)
 		}
 	},
 	{
-		id: "yolo26x",
-		legacy: true,
-		name: "YOLO26 XLarge",
-		description: "YOLO26 XLarge — highest accuracy, attention-based architecture",
+		id: "yolo26m-seg",
+		name: "YOLO26 Medium Seg",
+		description: "YOLO26 Medium Segmentation — high-accuracy instance segmentation",
 		inputSize: {
 			width: 640,
 			height: 640
@@ -1414,1054 +1163,1492 @@ var OBJECT_DETECTION_MODELS = [
 		preprocessMode: "letterbox",
 		formats: {
 			onnx: {
-				url: hf("objectDetection/yolo26/onnx/camstack-yolo26x.onnx"),
-				sizeMB: 213
-			},
-			coreml: {
-				url: hf("objectDetection/yolo26/coreml/camstack-yolo26x.mlpackage"),
-				sizeMB: 107,
-				isDirectory: true,
-				files: [...MLPACKAGE_FILES],
-				runtimes: ["python"]
-			},
-			openvino: ovFormat(hf("objectDetection/yolo26/openvino/camstack-yolo26x.xml"), 213)
-		}
-	},
-	{
-		id: "scrypted-yolov9t-relu",
-		legacy: true,
-		name: "YOLOv9 Tiny ReLU",
-		description: "YOLOv9t ReLU — optimized for int8 quantization",
-		inputSize: {
-			width: 320,
-			height: 320
-		},
-		labels: [],
-		preprocessMode: "letterbox",
-		formats: {
-			onnx: {
-				url: hfScrypted("onnx/scrypted_yolov9t_relu/scrypted_yolov9t_relu.onnx"),
-				sizeMB: 8.1
+				url: hf("segmentation/yolo26-seg/onnx/camstack-yolo26m-seg.onnx"),
+				sizeMB: 90
 			},
 			coreml: {
-				url: hfScrypted("coreml/scrypted_yolov9t_relu/scrypted_yolov9t_relu.mlpackage"),
-				sizeMB: 4,
+				url: hf("segmentation/yolo26-seg/coreml/camstack-yolo26m-seg.mlpackage"),
+				sizeMB: 45,
 				isDirectory: true,
 				files: [...MLPACKAGE_FILES],
 				runtimes: ["python"]
 			},
-			openvino: ovFormat(hf("objectDetection/scrypted-yolov9-relu/openvino/scrypted_yolov9t_relu.xml"), 6)
+			openvino: ovFormat(hf("segmentation/yolo26-seg/openvino/camstack-yolo26m-seg.xml"), 90)
 		}
-	},
+	}
+];
+var CLIP_EMBEDDING_MODELS = [
 	{
-		id: "scrypted-yolov9s-relu",
-		legacy: true,
-		name: "YOLOv9 Small ReLU",
-		description: "YOLOv9s ReLU — improved efficiency, int8 ready",
+		id: "mobileclip-s0",
+		name: "MobileCLIP S0",
+		description: "MobileCLIP S0 — Apple ultra-fast CLIP vision encoder, 512-dim, 256×256 (40 MB ONNX)",
 		inputSize: {
-			width: 320,
-			height: 320
+			width: 256,
+			height: 256
 		},
-		labels: [],
-		preprocessMode: "letterbox",
+		labels: [{
+			id: "embedding",
+			name: "CLIP Embedding"
+		}],
+		preprocessMode: "resize",
+		inputNormalization: "none",
 		formats: {
 			onnx: {
-				url: hfScrypted("onnx/scrypted_yolov9s_relu/scrypted_yolov9s_relu.onnx"),
-				sizeMB: 27.9
+				url: hf("clip/mobileclip-s0/onnx/camstack-mobileclip-s0-vision.onnx"),
+				sizeMB: 40
 			},
+			openvino: ovFormat(hf("clip/mobileclip-s0/openvino/camstack-mobileclip-s0-vision.xml"), 25),
 			coreml: {
-				url: hfScrypted("coreml/scrypted_yolov9s_relu/scrypted_yolov9s_relu.mlpackage"),
-				sizeMB: 14,
+				url: hf("clip/mobileclip-s0/coreml/camstack-mobileclip-s0-vision.mlpackage"),
+				sizeMB: 30,
 				isDirectory: true,
 				files: [...MLPACKAGE_FILES],
 				runtimes: ["python"]
-			},
-			openvino: ovFormat(hf("objectDetection/scrypted-yolov9-relu/openvino/scrypted_yolov9s_relu.xml"), 16)
+			}
 		}
 	},
 	{
-		id: "scrypted-yolov9c-relu",
-		legacy: true,
-		name: "YOLOv9 C ReLU",
-		description: "YOLOv9c ReLU — high-accuracy, int8 ready",
+		id: "mobileclip-s1",
+		name: "MobileCLIP S1",
+		description: "MobileCLIP S1 — Apple balanced CLIP vision encoder, 512-dim, 256×256 (90 MB ONNX)",
 		inputSize: {
-			width: 320,
-			height: 320
+			width: 256,
+			height: 256
 		},
-		labels: [],
-		preprocessMode: "letterbox",
+		labels: [{
+			id: "embedding",
+			name: "CLIP Embedding"
+		}],
+		preprocessMode: "resize",
+		inputNormalization: "none",
 		formats: {
 			onnx: {
-				url: hfScrypted("onnx/scrypted_yolov9c_relu/scrypted_yolov9c_relu.onnx"),
-				sizeMB: 96.9
+				url: hf("clip/mobileclip-s1/onnx/camstack-mobileclip-s1-vision.onnx"),
+				sizeMB: 90
 			},
+			openvino: ovFormat(hf("clip/mobileclip-s1/openvino/camstack-mobileclip-s1-vision.xml"), 55),
 			coreml: {
-				url: hfScrypted("coreml/scrypted_yolov9c_relu/scrypted_yolov9c_relu.mlpackage"),
-				sizeMB: 48,
+				url: hf("clip/mobileclip-s1/coreml/camstack-mobileclip-s1-vision.mlpackage"),
+				sizeMB: 65,
 				isDirectory: true,
 				files: [...MLPACKAGE_FILES],
 				runtimes: ["python"]
-			},
-			openvino: ovFormat(hf("objectDetection/scrypted-yolov9-relu/openvino/scrypted_yolov9c_relu.xml"), 49)
+			}
 		}
 	},
 	{
-		id: "scrypted-yolov9m-relu",
-		legacy: true,
-		name: "YOLOv9 M ReLU",
-		description: "YOLOv9m ReLU — medium, int8 ready",
+		id: "mobileclip-s2",
+		name: "MobileCLIP S2",
+		description: "MobileCLIP S2 — Apple high-accuracy CLIP vision encoder, 512-dim, 256×256 (150 MB ONNX)",
 		inputSize: {
-			width: 320,
-			height: 320
+			width: 256,
+			height: 256
 		},
-		labels: [],
-		preprocessMode: "letterbox",
+		labels: [{
+			id: "embedding",
+			name: "CLIP Embedding"
+		}],
+		preprocessMode: "resize",
+		inputNormalization: "none",
 		formats: {
 			onnx: {
-				url: hfScrypted("onnx/scrypted_yolov9m_relu/scrypted_yolov9m_relu.onnx"),
-				sizeMB: 76.6
+				url: hf("clip/mobileclip-s2/onnx/camstack-mobileclip-s2-vision.onnx"),
+				sizeMB: 150
 			},
+			openvino: ovFormat(hf("clip/mobileclip-s2/openvino/camstack-mobileclip-s2-vision.xml"), 90),
 			coreml: {
-				url: hfScrypted("coreml/scrypted_yolov9m_relu/scrypted_yolov9m_relu.mlpackage"),
-				sizeMB: 38,
+				url: hf("clip/mobileclip-s2/coreml/camstack-mobileclip-s2-vision.mlpackage"),
+				sizeMB: 110,
 				isDirectory: true,
 				files: [...MLPACKAGE_FILES],
 				runtimes: ["python"]
-			},
-			openvino: ovFormat(hf("objectDetection/scrypted-yolov9-relu/openvino/scrypted_yolov9m_relu.xml"), 38)
+			}
 		}
-	},
-	ovPrecisionVariant("yolov9t", "objectDetection/yolov9/openvino", "YOLOv9 Tiny", "fp16", 5, true),
-	ovPrecisionVariant("yolov9t", "objectDetection/yolov9/openvino", "YOLOv9 Tiny", "int8", 3, true),
-	ovPrecisionVariant("yolov9s", "objectDetection/yolov9/openvino", "YOLOv9 Small", "fp16", 15, true),
-	ovPrecisionVariant("yolov9s", "objectDetection/yolov9/openvino", "YOLOv9 Small", "int8", 8, true),
-	ovPrecisionVariant("yolo26n", "objectDetection/yolo26/openvino", "YOLO26 Nano", "fp16", 5, true),
-	ovPrecisionVariant("yolo26n", "objectDetection/yolo26/openvino", "YOLO26 Nano", "int8", 3),
-	ovPrecisionVariant("yolo26s", "objectDetection/yolo26/openvino", "YOLO26 Small", "fp16", 19, true),
-	ovPrecisionVariant("yolo26s", "objectDetection/yolo26/openvino", "YOLO26 Small", "int8", 10),
-	ovPrecisionVariant("yolo26m", "objectDetection/yolo26/openvino", "YOLO26 Medium", "fp16", 41, true),
-	ovPrecisionVariant("yolo26m", "objectDetection/yolo26/openvino", "YOLO26 Medium", "int8", 21),
-	ovPrecisionVariant("yolo26l", "objectDetection/yolo26/openvino", "YOLO26 Large", "fp16", 50, true),
-	ovPrecisionVariant("yolo26l", "objectDetection/yolo26/openvino", "YOLO26 Large", "int8", 25),
-	ovPrecisionVariant("yolo26x", "objectDetection/yolo26/openvino", "YOLO26 XLarge", "fp16", 112, true),
-	ovPrecisionVariant("yolo26x", "objectDetection/yolo26/openvino", "YOLO26 XLarge", "int8", 56, true)
-];
-var FACE_DETECTION_MODELS = [{
-	id: "scrfd-2.5g",
-	name: "SCRFD 2.5G",
-	description: "SCRFD 2.5G — balanced face detection model",
-	inputSize: {
-		width: 640,
-		height: 640
-	},
-	labels: [{
-		id: "face",
-		name: "Face"
-	}],
-	preprocessMode: "letterbox",
-	formats: {
-		onnx: {
-			url: hf("faceDetection/scrfd/onnx/camstack-scrfd-2.5g.onnx"),
-			sizeMB: 3.1
-		},
-		coreml: {
-			url: hf("faceDetection/scrfd/coreml/camstack-scrfd-2.5g.mlpackage"),
-			sizeMB: 1.7,
-			isDirectory: true,
-			files: [...MLPACKAGE_FILES],
-			runtimes: ["python"]
-		},
-		openvino: ovFormat(hf("faceDetection/scrfd/openvino/camstack-scrfd-2.5g.xml"), 1.8)
-	}
-}, {
-	id: "scrypted-yolov9t-face",
-	name: "YOLOv9t Face ReLU",
-	description: "YOLOv9t face detection — YOLO-based, fast, 320x320 ReLU",
-	inputSize: {
-		width: 320,
-		height: 320
-	},
-	labels: [{
-		id: "face",
-		name: "Face"
-	}],
-	preprocessMode: "letterbox",
-	formats: {
-		onnx: {
-			url: hfScrypted("onnx/scrypted_yolov9t_relu_face/scrypted_yolov9t_relu_face.onnx"),
-			sizeMB: 8.1
-		},
-		coreml: {
-			url: hfScrypted("coreml/scrypted_yolov9t_relu_face/scrypted_yolov9t_relu_face.mlpackage"),
-			sizeMB: 4,
-			isDirectory: true,
-			files: [...MLPACKAGE_FILES],
-			runtimes: ["python"]
-		},
-		openvino: ovFormat(hf("faceDetection/scrypted-yolov9-face/openvino/scrypted_yolov9t_relu_face.xml"), 6)
 	}
-}];
-var FACE_EMBEDDING_MODELS = [{
-	id: "arcface-r100",
-	name: "ArcFace R100",
-	description: "ArcFace ResNet-100 — high-accuracy face recognition embeddings (512-d)",
+];
+var AUDIO_CLASSIFIER_MODELS = [{
+	id: "yamnet-onnx",
+	name: "YAMNet",
+	description: "Google YAMNet — 521-class audio event classifier (3.2 MB ONNX, runs on any platform)",
 	inputSize: {
-		width: 112,
-		height: 112
+		width: 1,
+		height: 16e3
 	},
-	inputLayout: "nhwc",
-	labels: [{
-		id: "embedding",
-		name: "Face Embedding"
-	}],
+	labels: [],
 	preprocessMode: "resize",
-	faceAlignment: true,
 	formats: {
 		onnx: {
-			url: hf("faceRecognition/arcface/onnx/camstack-arcface-arcface.onnx"),
-			sizeMB: 130
+			url: hf("audioClassification/yamnet/onnx/camstack-yamnet.onnx"),
+			sizeMB: 3.2
 		},
+		openvino: ovFormat(hf("audioClassification/yamnet/openvino/camstack-yamnet.xml"), 3.2),
 		coreml: {
-			url: hf("faceRecognition/arcface/coreml/camstack-arcface-r100.mlpackage"),
-			sizeMB: 65,
-			isDirectory: true,
-			files: [...MLPACKAGE_FILES],
+			url: hf("audioClassification/yamnet/onnx/camstack-yamnet.onnx"),
+			sizeMB: 3.2,
 			runtimes: ["python"]
-		},
-		openvino: ovFormat(hf("faceRecognition/arcface/openvino/camstack-arcface-r100.xml"), 65)
+		}
 	}
 }, {
-	id: "inception-resnet-v1",
-	name: "Inception ResNet V1",
-	description: "FaceNet-style face recognition embeddings (512-d) — hosted on plugin-models HF repo",
+	id: "apple-soundanalysis",
+	name: "Apple SoundAnalysis",
+	description: "macOS built-in — 303 sound categories, Neural Engine accelerated, zero download",
 	inputSize: {
-		width: 160,
-		height: 160
+		width: 1,
+		height: 16e3
 	},
-	labels: [{
-		id: "embedding",
-		name: "Face Embedding"
-	}],
+	labels: [],
 	preprocessMode: "resize",
-	formats: {
-		onnx: {
-			url: hfScrypted("onnx/inception_resnet_v1/inception_resnet_v1.onnx"),
-			sizeMB: 89.6
-		},
-		coreml: {
-			url: hfScrypted("coreml/inception_resnet_v1/inception_resnet_v1.mlpackage"),
-			sizeMB: 45,
-			isDirectory: true,
-			files: [...MLPACKAGE_FILES],
-			runtimes: ["python"]
-		},
-		openvino: ovFormat(hf("faceRecognition/inception-resnet-v1/openvino/camstack-inception-resnet-v1.xml"), 45)
+	formats: { coreml: {
+		url: "",
+		sizeMB: 0
+	} }
+}];
+//#endregion
+//#region src/detection-pipeline/registry/step-definitions.ts
+var ANIMAL_10_LABELS = [
+	"cat",
+	"cow",
+	"dog",
+	"dolphin",
+	"eagle",
+	"giant panda",
+	"horse",
+	"monkey",
+	"sheep",
+	"spider"
+];
+var VGG_G2_CHARSET = ["", ..."0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz".split("")];
+var PipelineStepBase = class {
+	definition;
+	constructor(definition) {
+		this.definition = definition;
+	}
+	getConfigSchema() {
+		return [];
+	}
+};
+var ObjectDetectionStep = class {
+	definition = {
+		id: "object-detection",
+		name: "Object Detection",
+		slot: "detector",
+		postprocessor: "yolo",
+		extractMode: "full-frame",
+		inputClasses: null,
+		outputClasses: [
+			"person",
+			"vehicle",
+			"animal"
+		],
+		models: [...OBJECT_DETECTION_MODELS],
+		defaultModelId: "yolo26n",
+		defaultConfidence: .5,
+		labels: require_dist.COCO_80_LABELS.map((l) => l.id),
+		classMap: require_dist.COCO_TO_MACRO
+	};
+	getConfigSchema() {
+		return [
+			{
+				type: "multiselect",
+				key: "enabledMacroClasses",
+				label: "Enabled Classes",
+				description: "Which macro classes to detect (empty = all three).",
+				options: [
+					{
+						value: "person",
+						label: "Person"
+					},
+					{
+						value: "vehicle",
+						label: "Vehicle"
+					},
+					{
+						value: "animal",
+						label: "Animal"
+					}
+				],
+				default: [
+					"person",
+					"vehicle",
+					"animal"
+				]
+			},
+			{
+				type: "slider",
+				key: "minConfidencePerson",
+				label: "Min Confidence — Person",
+				description: "Drop person predictions below this score.",
+				min: 0,
+				max: 1,
+				step: .05,
+				default: .5,
+				showValue: true
+			},
+			{
+				type: "slider",
+				key: "minConfidenceVehicle",
+				label: "Min Confidence — Vehicle",
+				description: "Drop vehicle predictions below this score.",
+				min: 0,
+				max: 1,
+				step: .05,
+				default: .5,
+				showValue: true
+			},
+			{
+				type: "slider",
+				key: "minConfidenceAnimal",
+				label: "Min Confidence — Animal",
+				description: "Drop animal predictions below this score.",
+				min: 0,
+				max: 1,
+				step: .05,
+				default: .5,
+				showValue: true
+			}
+		];
 	}
-}];
-var PLATE_DETECTION_MODELS = [{
-	id: "yolov8n-plate",
-	name: "YOLOv8 Nano — License Plate",
-	description: "YOLOv8 Nano fine-tuned for license plate detection",
-	inputSize: {
-		width: 640,
-		height: 640
-	},
-	labels: [{
-		id: "plate",
-		name: "License Plate"
-	}],
-	preprocessMode: "letterbox",
-	formats: {
-		onnx: {
-			url: hf("plateDetection/yolov8-plate/onnx/camstack-yolov8n-plate.onnx"),
-			sizeMB: 12
-		},
-		coreml: {
-			url: hf("plateDetection/yolov8-plate/coreml/camstack-yolov8n-plate.mlpackage"),
-			sizeMB: 5.9,
-			isDirectory: true,
-			files: [...MLPACKAGE_FILES],
-			runtimes: ["python"]
-		},
-		openvino: ovFormat(hf("plateDetection/yolov8-plate/openvino/camstack-yolov8n-plate.xml"), 6.1)
+};
+var AudioClassifierStep = class {
+	definition = {
+		id: "audio-classifier",
+		name: "Audio Classifier",
+		slot: "audio-classifier",
+		postprocessor: "yamnet",
+		extractMode: "full-frame",
+		inputClasses: null,
+		outputClasses: ["audio"],
+		models: [...AUDIO_CLASSIFIER_MODELS],
+		defaultModelId: "yamnet-onnx",
+		defaultModelIdByFormat: { coreml: "apple-soundanalysis" },
+		enabledByDefault: true,
+		defaultConfidence: .3
+	};
+	getConfigSchema() {
+		return [{
+			type: "multiselect",
+			key: "enabledAudioClasses",
+			label: "Audio Classes",
+			description: "Which audio macro classes to surface (empty = all).",
+			options: require_dist.AUDIO_MACRO_LABELS.map((l) => ({
+				value: l.id,
+				label: `${l.icon ?? ""} ${l.name}`.trim()
+			})),
+			default: [
+				"scream",
+				"crying",
+				"dog",
+				"alarm",
+				"doorbell",
+				"glass_breaking",
+				"gunshot",
+				"siren",
+				"footsteps"
+			]
+		}, {
+			type: "slider",
+			key: "minConfidence",
+			label: "Min Confidence",
+			description: "Drop predictions whose score is below this threshold.",
+			default: .3,
+			min: 0,
+			max: 1,
+			step: .05,
+			showValue: true
+		}];
 	}
-}];
-var PLATE_OCR_MODELS = [{
-	id: "vgg-english-g2",
-	name: "VGG English G2",
-	description: "EasyOCR VGG English G2 — text recognition for license plates and scene text",
-	inputSize: {
-		width: 384,
-		height: 64
-	},
-	labels: [{
-		id: "text",
-		name: "Plate Text"
-	}],
-	preprocessMode: "resize",
-	formats: {
-		onnx: {
-			url: hfScrypted("onnx/vgg_english_g2/vgg_english_g2.onnx"),
-			sizeMB: 14.4
-		},
-		coreml: {
-			url: hfScrypted("coreml/vgg_english_g2/vgg_english_g2.mlpackage"),
-			sizeMB: 11.2,
-			isDirectory: true,
-			files: [...MLPACKAGE_FILES],
-			runtimes: ["python"]
-		},
-		openvino: ovFormat(hf("plateRecognition/vgg_english_g2/openvino/vgg_english_g2.xml"), 7.2)
+};
+var AnimalClassifierStep = class {
+	definition = {
+		id: "animal-classifier",
+		name: "Animal Classifier",
+		slot: "classifier",
+		postprocessor: "softmax",
+		extractMode: "crop-roi",
+		inputClasses: ["animal"],
+		outputClasses: ["animal-type"],
+		models: [...ANIMAL_CLASSIFIER_MODELS],
+		defaultModelId: "animals-10",
+		enabledByDefault: false,
+		defaultConfidence: .2,
+		labels: [...ANIMAL_10_LABELS]
+	};
+	getConfigSchema() {
+		return [{
+			type: "multiselect",
+			key: "enabledClasses",
+			label: "Species",
+			description: "Which animal species to keep (empty = all). The classifier still scores every label but only the selected classes are returned on the detection.",
+			options: ANIMAL_10_LABELS.map((l) => ({
+				value: l,
+				label: l
+			})),
+			default: []
+		}, {
+			type: "slider",
+			key: "minConfidence",
+			label: "Min Confidence",
+			description: "Drop classifications whose score is below this threshold.",
+			default: this.definition.defaultConfidence,
+			min: 0,
+			max: 1,
+			step: .05,
+			showValue: true
+		}];
 	}
-}];
-var ANIMAL_CLASSIFIER_MODELS = [{
-	id: "animals-10",
-	name: "Animal Classifier (10)",
-	description: "ViT-based animal type classifier — cat, cow, dog, dolphin, eagle, panda, horse, monkey, sheep, spider",
-	inputSize: {
-		width: 224,
-		height: 224
-	},
-	inputNormalization: "imagenet",
-	labels: [{
-		id: "animal-type",
-		name: "Animal Type"
-	}],
-	preprocessMode: "resize",
-	formats: {
-		onnx: {
-			url: hf("animalClassification/animals-10/onnx/camstack-animals-10.onnx"),
-			sizeMB: 328
-		},
-		coreml: {
-			url: hf("animalClassification/animals-10/coreml/camstack-animals-10.mlpackage"),
-			sizeMB: 164,
-			isDirectory: true,
-			files: [...MLPACKAGE_FILES],
-			runtimes: ["python"]
-		},
-		openvino: ovFormat(hf("animalClassification/animals-10/openvino/camstack-animals-10.xml"), 164)
+};
+var ClassifierWithMinConfidence = class extends PipelineStepBase {
+	getConfigSchema() {
+		return [{
+			type: "slider",
+			key: "minConfidence",
+			label: "Min Confidence",
+			description: "Drop classifications whose score is below this threshold.",
+			default: this.definition.defaultConfidence,
+			min: 0,
+			max: 1,
+			step: .05,
+			showValue: true
+		}];
+	}
+};
+var STEP_FACE_DETECTION = new PipelineStepBase({
+	id: "face-detection",
+	name: "Face Detection",
+	slot: "cropper",
+	postprocessor: "scrfd",
+	extractMode: "crop-roi",
+	inputClasses: ["person"],
+	outputClasses: ["face"],
+	models: [...FACE_DETECTION_MODELS],
+	defaultModelId: "scrfd-2.5g",
+	defaultConfidence: .5,
+	defaultMinParentScore: .7
+});
+var STEP_FACE_EMBEDDING = new PipelineStepBase({
+	id: "face-embedding",
+	name: "Face Embedding",
+	slot: "classifier",
+	postprocessor: "arcface",
+	extractMode: "crop-roi",
+	inputClasses: ["face"],
+	outputClasses: ["identity"],
+	models: [...FACE_EMBEDDING_MODELS],
+	defaultModelId: "arcface-r100",
+	defaultConfidence: 0
+});
+var STEP_CLIP_EMBEDDING = new PipelineStepBase({
+	id: "clip-embedding",
+	name: "CLIP Embedding",
+	slot: "classifier",
+	postprocessor: "clip",
+	extractMode: "crop-roi",
+	inputClasses: null,
+	outputClasses: ["embedding"],
+	models: [...CLIP_EMBEDDING_MODELS],
+	defaultModelId: "mobileclip-s1",
+	enabledByDefault: false,
+	defaultConfidence: 0,
+	defaultMinParentScore: .4,
+	group: "CLIP"
+});
+var STEP_PLATE_DETECTION = new PipelineStepBase({
+	id: "plate-detection",
+	name: "Plate Detection",
+	slot: "cropper",
+	postprocessor: "yolo",
+	extractMode: "crop-roi",
+	inputClasses: ["vehicle"],
+	outputClasses: ["plate"],
+	models: [...PLATE_DETECTION_MODELS],
+	defaultModelId: "yolov8n-plate",
+	defaultConfidence: .5,
+	defaultMinParentScore: .7,
+	labels: ["plate"]
+});
+var STEP_PLATE_OCR = new PipelineStepBase({
+	id: "plate-ocr",
+	name: "Plate OCR",
+	slot: "classifier",
+	postprocessor: "ctc",
+	extractMode: "crop-roi",
+	inputClasses: ["plate"],
+	outputClasses: ["plate-text"],
+	models: [...PLATE_OCR_MODELS],
+	defaultModelId: "vgg-english-g2",
+	defaultConfidence: 0,
+	charset: [...VGG_G2_CHARSET]
+});
+var STEP_BIRD_CLASSIFIER = new ClassifierWithMinConfidence({
+	id: "bird-classifier",
+	name: "Bird Classifier",
+	slot: "classifier",
+	postprocessor: "softmax",
+	extractMode: "crop-roi",
+	inputClasses: ["animal"],
+	outputClasses: ["species"],
+	models: [...BIRD_CLASSIFIER_MODELS],
+	defaultModelId: "bird-nabirds-404",
+	enabledByDefault: false,
+	defaultConfidence: .2
+});
+var STEP_VEHICLE_CLASSIFIER = new ClassifierWithMinConfidence({
+	id: "vehicle-classifier",
+	name: "Vehicle Classifier",
+	slot: "classifier",
+	postprocessor: "softmax",
+	extractMode: "crop-roi",
+	inputClasses: ["vehicle"],
+	outputClasses: ["vehicle-type"],
+	models: [...VEHICLE_CLASSIFIER_MODELS],
+	defaultModelId: "vehicle-type-efficientnet",
+	enabledByDefault: false,
+	defaultConfidence: .3
+});
+var STEP_SEGMENTATION = new PipelineStepBase({
+	id: "segmentation",
+	name: "Segmentation",
+	slot: "refiner",
+	postprocessor: "saliency",
+	extractMode: "crop-roi",
+	inputClasses: null,
+	outputClasses: ["mask"],
+	models: [...SEGMENTATION_REFINER_MODELS],
+	defaultModelId: "u2netp",
+	enabledByDefault: false,
+	defaultConfidence: 0,
+	group: "Segmentation"
+});
+new PipelineStepBase({
+	id: "instance-segmentation",
+	name: "Instance Segmentation",
+	slot: "refiner",
+	postprocessor: "yolo-seg",
+	extractMode: "full-frame",
+	inputClasses: null,
+	outputClasses: ["mask"],
+	models: [...INSTANCE_SEGMENTATION_MODELS],
+	defaultModelId: "yolo26n-seg",
+	enabledByDefault: false,
+	defaultConfidence: .25,
+	labels: require_dist.COCO_80_LABELS.map((l) => l.id),
+	classMap: require_dist.COCO_TO_MACRO,
+	group: "Segmentation"
+});
+var STEP_OBJECT_DETECTION_INSTANCE = new ObjectDetectionStep();
+var STEP_AUDIO_CLASSIFIER_INSTANCE = new AudioClassifierStep();
+var ALL_PIPELINE_STEPS = [
+	STEP_OBJECT_DETECTION_INSTANCE,
+	STEP_FACE_DETECTION,
+	STEP_FACE_EMBEDDING,
+	STEP_CLIP_EMBEDDING,
+	STEP_PLATE_DETECTION,
+	STEP_PLATE_OCR,
+	new AnimalClassifierStep(),
+	STEP_BIRD_CLASSIFIER,
+	STEP_VEHICLE_CLASSIFIER,
+	STEP_SEGMENTATION,
+	STEP_AUDIO_CLASSIFIER_INSTANCE
+];
+/** Compat: flat array of StepDefinition for existing consumers */
+var ALL_STEPS = ALL_PIPELINE_STEPS.map((s) => s.definition);
+var STEP_MAP = new Map(ALL_PIPELINE_STEPS.map((s) => [s.definition.id, s]));
+/**
+* Look up a pipeline step by ID (class instance with getConfigSchema).
+* @throws if the step ID is not registered.
+*/
+function getStep(stepId) {
+	const step = STEP_MAP.get(stepId);
+	if (!step) throw new Error(`Unknown pipeline step: "${stepId}". Available: ${ALL_PIPELINE_STEPS.map((s) => s.definition.id).join(", ")}`);
+	return step;
+}
+/**
+* Look up a step definition by ID (compat shortcut).
+* @throws if the step ID is not registered.
+*/
+function getStepDefinition(stepId) {
+	return getStep(stepId).definition;
+}
+/**
+* Get the default model ID for a step given the current model format.
+*
+* Resolution order:
+*   1. `def.defaultModelIdByFormat?.[format]` — the step's declared
+*      per-format preference — if that model exists in `def.models` AND
+*      has a build for `format`.
+*   2. `def.defaultModelId` — the step's plain declared default — if it
+*      exists in `def.models` AND has a build for `format`.
+*   3. The smallest-by-size model among those with a `format` build
+*      (legacy fallback, preserved for steps/formats with no declared
+*      preference reachable).
+*   4. `def.defaultModelId` unchanged, when ZERO models have a `format`
+*      build — an unloadable case flagged elsewhere, not resolved here.
+*/
+function getDefaultModelForFormat(stepId, format) {
+	const def = getStepDefinition(stepId);
+	const hasFormatBuild = (modelId) => def.models.find((m) => m.id === modelId)?.formats[format] !== void 0;
+	const declaredForFormat = def.defaultModelIdByFormat?.[format];
+	if (declaredForFormat !== void 0 && hasFormatBuild(declaredForFormat)) return declaredForFormat;
+	if (hasFormatBuild(def.defaultModelId)) return def.defaultModelId;
+	const available = def.models.filter((m) => m.formats[format] && m.legacy !== true);
+	if (available.length === 0) return def.defaultModelId;
+	return [...available].toSorted((a, b) => {
+		return (a.formats[format]?.sizeMB ?? Infinity) - (b.formats[format]?.sizeMB ?? Infinity);
+	})[0].id;
+}
+/**
+* The single node-local authority for turning a CHOSEN model (or none) into a
+* concrete model that has a build for this node's engine `format`. Fuses the
+* two previously-duplicated decisions (orchestrator `pickDefaultModelId` +
+* provider `substituteIncompatibleModels`):
+*
+*   - chosen === null            → the addon's default model for `format`.
+*   - chosen is a catalog model  → keep it if it has a `format` build; else
+*                                  the addon's default model for `format`
+*                                  (a substitution — the caller surfaces it).
+*   - chosen is NOT in the catalog (custom/unknown) → returned unchanged; the
+*                                  operator owns a custom model's format compat.
+*   - unknown stepId             → chosen returned unchanged (never throws).
+*/
+function resolveModelForFormat(stepId, chosenModelId, format) {
+	let def;
+	try {
+		def = getStepDefinition(stepId);
+	} catch {
+		return chosenModelId ?? "";
 	}
-}];
-var BIRD_CLASSIFIER_MODELS = [{
-	id: "bird-nabirds-404",
-	name: "NABirds (404 species)",
-	description: "ResNet50 trained on NABirds — 404 North American species",
-	inputSize: {
-		width: 224,
-		height: 224
-	},
-	inputNormalization: "imagenet",
-	labels: [{
-		id: "species",
-		name: "Bird Species"
-	}],
-	preprocessMode: "resize",
-	formats: {
-		onnx: {
-			url: hf("animalClassification/bird-nabirds/onnx/camstack-bird-nabirds-404.onnx"),
-			sizeMB: 93
-		},
-		coreml: {
-			url: hf("animalClassification/bird-nabirds/coreml/camstack-bird-nabirds-404.mlpackage"),
-			sizeMB: 47,
-			isDirectory: true,
-			files: [...MLPACKAGE_FILES],
-			runtimes: ["python"]
-		},
-		openvino: ovFormat(hf("animalClassification/bird-nabirds/openvino/camstack-bird-nabirds-404.xml"), 47)
-	},
-	extraFiles: [{
-		url: hf("animalClassification/bird-nabirds/onnx/camstack-bird-nabirds-404-labels.json"),
-		filename: "camstack-bird-nabirds-404-labels.json",
-		sizeMB: .02
-	}]
-}];
-var VEHICLE_CLASSIFIER_MODELS = [{
-	id: "vehicle-type-efficientnet",
-	name: "Vehicle Type (EfficientNet)",
-	description: "EfficientNet-B4 vehicle make/model/year classifier — 8,949 classes from VMMRdb",
-	inputSize: {
-		width: 380,
-		height: 380
-	},
-	inputNormalization: "imagenet",
-	labels: [{
-		id: "vehicle-type",
-		name: "Vehicle Type"
-	}],
-	preprocessMode: "resize",
-	formats: {
-		onnx: {
-			url: hf("vehicleClassification/efficientnet/onnx/camstack-vehicle-type-efficientnet.onnx"),
-			sizeMB: 135
-		},
-		coreml: {
-			url: hf("vehicleClassification/efficientnet/coreml/camstack-vehicle-type-efficientnet.mlpackage"),
-			sizeMB: 10,
-			isDirectory: true,
-			files: [...MLPACKAGE_FILES],
-			runtimes: ["python"]
-		},
-		openvino: ovFormat(hf("vehicleClassification/efficientnet/openvino/camstack-vehicle-type-efficientnet.xml"), 68)
-	},
-	extraFiles: [{
-		url: hf("vehicleClassification/efficientnet/camstack-vehicle-type-labels.json"),
-		filename: "camstack-vehicle-type-labels.json",
-		sizeMB: .2
-	}]
-}];
-var SEGMENTATION_REFINER_MODELS = [{
-	id: "u2netp",
-	name: "U2-Net Portable",
-	description: "U2-Net-P — ultra-lightweight salient object segmentation (4.7 MB)",
-	inputSize: {
-		width: 320,
-		height: 320
-	},
-	labels: [{
-		id: "mask",
-		name: "Segmentation Mask"
-	}],
-	preprocessMode: "resize",
-	formats: {
-		onnx: {
-			url: hf("segmentationRefiner/u2netp/onnx/camstack-u2netp.onnx"),
-			sizeMB: 5
-		},
-		coreml: {
-			url: hf("segmentationRefiner/u2netp/coreml/camstack-u2netp.mlpackage"),
-			sizeMB: 3,
-			isDirectory: true,
-			files: [...MLPACKAGE_FILES],
-			runtimes: ["python"]
-		},
-		openvino: ovFormat(hf("segmentationRefiner/u2netp/openvino/camstack-u2netp.xml"), 2.5)
+	if (chosenModelId === null) return getDefaultModelForFormat(stepId, format);
+	const entry = def.models.find((m) => m.id === chosenModelId);
+	if (!entry) return chosenModelId;
+	if (entry.formats[format]) return chosenModelId;
+	return getDefaultModelForFormat(stepId, format);
+}
+//#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 = "object-detection";
+/**
+* Balanced default object-detection model per accelerator class (measured on
+* COCO val2017). `'cpu'` maps to `null` → the caller substitutes the step's
+* own `defaultModelId` (`yolo26n`), the safe nano that does not collapse on
+* small objects. The three accelerated ids are reduced-input YOLO26 variants
+* shipped in the catalog (onnx + coreml + openvino builds each).
+*/
+var MODEL_BY_CLASS = {
+	"apple-ane": "yolo26l-256",
+	"intel-npu": "yolo26m-320",
+	"intel-gpu": "yolo26m-256",
+	cpu: null
+};
+/**
+* Classify a node's engine into an {@link AcceleratorClass} from its resolved
+* `backend` + `device`. Pure, total, never throws.
+*
+* OpenVINO's default device is `'auto'` (the python pool resolves NPU > GPU >
+* CPU at load). Because OpenVINO is only ever OFFERED when an Intel iGPU is
+* present, the GPU is the guaranteed accelerator while the NPU is an explicit
+* opt-in — so `'auto'` (and any non-cpu/non-npu device) is treated as
+* GPU-class conservatively. An operator who explicitly pins `device: 'npu'`
+* gets the NPU-tuned m-320.
+*
+* Also accepts the accelerator carried in the `backend` slot (e.g. `'ane'`,
+* `'mps'`, `'npu'`, `'intel-gpu'`) so a caller passing a device-style backend
+* still classifies correctly — real callers pass onnx/openvino/coreml.
+*/
+function classifyAccelerator(backend, device) {
+	const b = backend.toLowerCase();
+	const d = device?.toLowerCase() ?? null;
+	if (b === "coreml" || b === "ane" || b === "mps") return "apple-ane";
+	if (b === "openvino") {
+		if (d === "npu") return "intel-npu";
+		if (d === "cpu") return "cpu";
+		return "intel-gpu";
+	}
+	if (b === "npu" || b === "intel-npu") return "intel-npu";
+	if (b === "gpu" || b === "intel-gpu" || b === "gpu-openvino") return "intel-gpu";
+	return "cpu";
+}
+/**
+* Resolve the hardware-aware default object-detection model id for a node's
+* engine `(backend, device, format)`.
+*
+* 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`).
+*
+* `getStepDef` is injectable (defaults to the real catalog lookup) so the
+* missing-build fallback branch is unit-testable without a live catalog —
+* mirrors `collectZeroBuildIssues`' injection seam.
+*/
+function resolveDefaultDetectionModel(backend, device, format, getStepDef = getStepDefinition) {
+	let def;
+	try {
+		def = getStepDef(OBJECT_DETECTION_STEP_ID);
+	} 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;
+}
+//#endregion
+//#region src/detection-pipeline/engine/shared-inference-pool.ts
+/**
+* SharedInferencePool — TypeScript wrapper for inference_pool.py.
+*
+* Multi-process orchestrator. Owns N `PoolWorker` instances, each
+* holding its own Python subprocess + MLModel copy, and round-robins
+* inference dispatches across them. Model management (load/unload/
+* replace) propagates to all workers so every subprocess holds the
+* same model set at the same indices.
+*
+* Wire format (per worker):
+*   Request:  [4B total_len][4B req_id][1B msg_type][payload]
+*   Response: [4B total_len][4B req_id][JSON payload]
+*/
+var MSG_COMMAND = 0;
+var MSG_INFER_JPEG = 1;
+var MSG_INFER_RAW = 2;
+var MSG_CACHE_FRAME = 4;
+var MSG_INFER_CACHED = 5;
+/**
+* Cross-camera batching opcode — N items packed into a single IPC
+* frame. Wire shape:
+*   [1B model_idx][1B count][N × (4B w | 4B h | 1B fmt | 4B size | raw bytes)]
+* Python pool dispatches each item via `dispatcher.run` (asyncio.gather)
+* and returns a JSON array of detections in the same order.
+*/
+var MSG_INFER_BATCH = 3;
+var PREFIX_LEN = 9;
+/**
+* Wire-level enum for the raw-frame fast path. Values are append-only:
+* the Python pool reads the byte directly off the IPC frame; reordering
+* existing entries breaks all in-flight workers.
+*/
+var RAW_FMT_CODE = {
+	rgb: 0,
+	bgr: 1,
+	gray: 2
+};
+var PoolHandle = class {
+	pool;
+	modelIndex;
+	runtime = "onnx";
+	device = "cpu";
+	constructor(pool, modelIndex) {
+		this.pool = pool;
+		this.modelIndex = modelIndex;
 	}
-}];
-var INSTANCE_SEGMENTATION_MODELS = [
-	{
-		id: "yolo26n-seg",
-		name: "YOLO26 Nano Seg",
-		description: "YOLO26 Nano Segmentation — ultra-lightweight instance segmentation with masks",
-		inputSize: {
-			width: 640,
-			height: 640
-		},
-		labels: [],
-		preprocessMode: "letterbox",
-		formats: {
-			onnx: {
-				url: hf("segmentation/yolo26-seg/onnx/camstack-yolo26n-seg.onnx"),
-				sizeMB: 11
-			},
-			coreml: {
-				url: hf("segmentation/yolo26-seg/coreml/camstack-yolo26n-seg.mlpackage"),
-				sizeMB: 6,
-				isDirectory: true,
-				files: [...MLPACKAGE_FILES],
-				runtimes: ["python"]
-			},
-			openvino: ovFormat(hf("segmentation/yolo26-seg/openvino/camstack-yolo26n-seg.xml"), 11)
-		}
-	},
-	{
-		id: "yolo26s-seg",
-		name: "YOLO26 Small Seg",
-		description: "YOLO26 Small Segmentation — balanced instance segmentation",
-		inputSize: {
-			width: 640,
-			height: 640
-		},
-		labels: [],
-		preprocessMode: "letterbox",
-		formats: {
-			onnx: {
-				url: hf("segmentation/yolo26-seg/onnx/camstack-yolo26s-seg.onnx"),
-				sizeMB: 40
-			},
-			coreml: {
-				url: hf("segmentation/yolo26-seg/coreml/camstack-yolo26s-seg.mlpackage"),
-				sizeMB: 20,
-				isDirectory: true,
-				files: [...MLPACKAGE_FILES],
-				runtimes: ["python"]
-			},
-			openvino: ovFormat(hf("segmentation/yolo26-seg/openvino/camstack-yolo26s-seg.xml"), 40)
-		}
-	},
-	{
-		id: "yolo26m-seg",
-		name: "YOLO26 Medium Seg",
-		description: "YOLO26 Medium Segmentation — high-accuracy instance segmentation",
-		inputSize: {
-			width: 640,
-			height: 640
-		},
-		labels: [],
-		preprocessMode: "letterbox",
-		formats: {
-			onnx: {
-				url: hf("segmentation/yolo26-seg/onnx/camstack-yolo26m-seg.onnx"),
-				sizeMB: 90
-			},
-			coreml: {
-				url: hf("segmentation/yolo26-seg/coreml/camstack-yolo26m-seg.mlpackage"),
-				sizeMB: 45,
-				isDirectory: true,
-				files: [...MLPACKAGE_FILES],
-				runtimes: ["python"]
-			},
-			openvino: ovFormat(hf("segmentation/yolo26-seg/openvino/camstack-yolo26m-seg.xml"), 90)
-		}
+	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
+		};
 	}
-];
-var CLIP_EMBEDDING_MODELS = [
-	{
-		id: "mobileclip-s0",
-		name: "MobileCLIP S0",
-		description: "MobileCLIP S0 — Apple ultra-fast CLIP vision encoder, 512-dim, 256×256 (40 MB ONNX)",
-		inputSize: {
-			width: 256,
-			height: 256
-		},
-		labels: [{
-			id: "embedding",
-			name: "CLIP Embedding"
-		}],
-		preprocessMode: "resize",
-		inputNormalization: "none",
-		formats: {
-			onnx: {
-				url: hf("clip/mobileclip-s0/onnx/camstack-mobileclip-s0-vision.onnx"),
-				sizeMB: 40
-			},
-			openvino: ovFormat(hf("clip/mobileclip-s0/openvino/camstack-mobileclip-s0-vision.xml"), 25),
-			coreml: {
-				url: hf("clip/mobileclip-s0/coreml/camstack-mobileclip-s0-vision.mlpackage"),
-				sizeMB: 30,
-				isDirectory: true,
-				files: [...MLPACKAGE_FILES],
-				runtimes: ["python"]
-			}
+	/**
+	* Inference on a frame previously cached in the Python pool via
+	* `pool.cacheFrame()`. Sends only 5 bytes through the pipe instead
+	* of 1.2MB raw data — eliminates the pipe transfer bottleneck.
+	*/
+	async inferFromCache(frameId) {
+		const start = performance.now();
+		return {
+			structured: await this.pool.inferCached(this.modelIndex, frameId),
+			inferenceMs: performance.now() - start
+		};
+	}
+	async dispose() {}
+};
+/**
+* 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;
+/**
+* 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).
+*
+* The old teardown sent SIGTERM and dropped the reference immediately — a
+* worker busy in a native inference loop ignores SIGTERM and ORPHANS at full
+* CPU (observed after an engine re-spin). SIGKILL cannot be ignored, so the
+* escalation guarantees the process dies. Exported for tests.
+*/
+async function terminateChild(proc, graceMs) {
+	if (proc.exitCode !== null || proc.signalCode !== null) return;
+	try {
+		proc.stdin?.end();
+	} catch {}
+	await new Promise((resolve) => {
+		let settled = false;
+		let timer = null;
+		const done = () => {
+			if (settled) return;
+			settled = true;
+			if (timer) clearTimeout(timer);
+			resolve();
+		};
+		proc.once("exit", done);
+		try {
+			proc.kill("SIGTERM");
+		} catch {
+			done();
+			return;
 		}
-	},
-	{
-		id: "mobileclip-s1",
-		name: "MobileCLIP S1",
-		description: "MobileCLIP S1 — Apple balanced CLIP vision encoder, 512-dim, 256×256 (90 MB ONNX)",
-		inputSize: {
-			width: 256,
-			height: 256
-		},
-		labels: [{
-			id: "embedding",
-			name: "CLIP Embedding"
-		}],
-		preprocessMode: "resize",
-		inputNormalization: "none",
-		formats: {
-			onnx: {
-				url: hf("clip/mobileclip-s1/onnx/camstack-mobileclip-s1-vision.onnx"),
-				sizeMB: 90
-			},
-			openvino: ovFormat(hf("clip/mobileclip-s1/openvino/camstack-mobileclip-s1-vision.xml"), 55),
-			coreml: {
-				url: hf("clip/mobileclip-s1/coreml/camstack-mobileclip-s1-vision.mlpackage"),
-				sizeMB: 65,
-				isDirectory: true,
-				files: [...MLPACKAGE_FILES],
-				runtimes: ["python"]
+		timer = setTimeout(() => {
+			try {
+				proc.kill("SIGKILL");
+			} catch {}
+			done();
+		}, graceMs);
+	});
+}
+var PoolWorker = class {
+	process = null;
+	receiveBuffer = Buffer.alloc(0);
+	pending = /* @__PURE__ */ new Map();
+	nextRequestId = 1;
+	ready = false;
+	log;
+	opts;
+	constructor(opts) {
+		this.opts = opts;
+		this.log = opts.logger;
+	}
+	getPid() {
+		return this.process?.pid ?? null;
+	}
+	isReady() {
+		return this.ready;
+	}
+	async initialize(initialModels) {
+		this.process = (0, node_child_process.spawn)(this.opts.pythonPath, [this.opts.scriptPath], { stdio: [
+			"pipe",
+			"pipe",
+			"pipe"
+		] });
+		if (!this.process.stdout || !this.process.stdin) throw new Error("PoolWorker: failed to create process pipes");
+		this.process.stderr?.on("data", (chunk) => {
+			for (const line of chunk.toString().split("\n")) {
+				const trimmed = line.trim();
+				if (trimmed) this.log.warn(`[${this.opts.workerLabel}] ${trimmed}`);
 			}
-		}
-	},
-	{
-		id: "mobileclip-s2",
-		name: "MobileCLIP S2",
-		description: "MobileCLIP S2 — Apple high-accuracy CLIP vision encoder, 512-dim, 256×256 (150 MB ONNX)",
-		inputSize: {
-			width: 256,
-			height: 256
-		},
-		labels: [{
-			id: "embedding",
-			name: "CLIP Embedding"
-		}],
-		preprocessMode: "resize",
-		inputNormalization: "none",
-		formats: {
-			onnx: {
-				url: hf("clip/mobileclip-s2/onnx/camstack-mobileclip-s2-vision.onnx"),
-				sizeMB: 150
-			},
-			openvino: ovFormat(hf("clip/mobileclip-s2/openvino/camstack-mobileclip-s2-vision.xml"), 90),
-			coreml: {
-				url: hf("clip/mobileclip-s2/coreml/camstack-mobileclip-s2-vision.mlpackage"),
-				sizeMB: 110,
-				isDirectory: true,
-				files: [...MLPACKAGE_FILES],
-				runtimes: ["python"]
+		});
+		this.process.on("error", (err) => {
+			this.log.error("Worker process error", { meta: {
+				worker: this.opts.workerLabel,
+				error: err.message
+			} });
+			this.rejectAll(err);
+		});
+		this.process.on("exit", (code) => {
+			if (code !== 0 && code !== null) {
+				this.log.error("Worker process exited", { meta: {
+					worker: this.opts.workerLabel,
+					code
+				} });
+				this.rejectAll(/* @__PURE__ */ new Error(`Worker process exited with code ${code}`));
 			}
+			this.ready = false;
+		});
+		this.process.stdout.on("data", (chunk) => {
+			this.receiveBuffer = Buffer.concat([this.receiveBuffer, chunk]);
+			this.drainResponses();
+		});
+		const config = {
+			runtime: this.opts.poolRuntime,
+			concurrency: this.opts.concurrency,
+			models: initialModels.map((m) => serializeModelConfig(m))
+		};
+		if (this.opts.tuning) {
+			config["batch_mode"] = this.opts.tuning.batchMode;
+			config["window_ms"] = this.opts.tuning.windowMs;
+			config["max_batch_size"] = this.opts.tuning.maxBatchSize;
+			config["num_streams"] = this.opts.tuning.numStreams;
+			config["intra_op_threads"] = this.opts.tuning.intraOpThreads;
 		}
+		const configBuf = Buffer.from(JSON.stringify(config), "utf8");
+		this.writeFrame(0, MSG_COMMAND, configBuf);
+		return new Promise((resolve, reject) => {
+			const timeout = setTimeout(() => {
+				this.pending.delete(0);
+				reject(/* @__PURE__ */ new Error(`PoolWorker[${this.opts.workerLabel}]: timeout waiting for ready (120s)`));
+			}, 12e4);
+			this.pending.set(0, {
+				resolve: (result) => {
+					clearTimeout(timeout);
+					if (result["status"] === "ready") {
+						this.ready = true;
+						const loadedCount = result["models"];
+						const startupMs = result["startupMs"];
+						resolve({
+							startupMs,
+							loadedCount,
+							workers: result["workers"] ?? 1
+						});
+					} else reject(/* @__PURE__ */ new Error(`Unexpected pool status: ${JSON.stringify(result)}`));
+				},
+				reject: (err) => {
+					clearTimeout(timeout);
+					reject(err);
+				}
+			});
+		});
 	}
-];
-var AUDIO_CLASSIFIER_MODELS = [{
-	id: "yamnet-onnx",
-	name: "YAMNet",
-	description: "Google YAMNet — 521-class audio event classifier (3.2 MB ONNX, runs on any platform)",
-	inputSize: {
-		width: 1,
-		height: 16e3
-	},
-	labels: [],
-	preprocessMode: "resize",
-	formats: {
-		onnx: {
-			url: hf("audioClassification/yamnet/onnx/camstack-yamnet.onnx"),
-			sizeMB: 3.2
-		},
-		openvino: ovFormat(hf("audioClassification/yamnet/openvino/camstack-yamnet.xml"), 3.2),
-		coreml: {
-			url: hf("audioClassification/yamnet/onnx/camstack-yamnet.onnx"),
-			sizeMB: 3.2,
-			runtimes: ["python"]
+	async infer(modelByte, jpeg) {
+		this.ensureReady();
+		const payload = Buffer.concat([Buffer.from([modelByte]), jpeg]);
+		return this.dispatch(MSG_INFER_JPEG, payload);
+	}
+	async inferRaw(modelByte, raw, width, height, format) {
+		this.ensureReady();
+		const fmtCode = RAW_FMT_CODE[format];
+		const rawHeader = Buffer.allocUnsafe(10);
+		rawHeader[0] = modelByte;
+		rawHeader.writeUInt32LE(width, 1);
+		rawHeader.writeUInt32LE(height, 5);
+		rawHeader[9] = fmtCode;
+		return this.dispatchMulti(MSG_INFER_RAW, rawHeader.length + raw.length, [rawHeader, raw]);
+	}
+	async inferBatch(modelByte, items) {
+		this.ensureReady();
+		if (items.length === 0) return [];
+		const headerSize = 2 + items.length * 13;
+		const totalRawSize = items.reduce((sum, it) => sum + it.raw.length, 0);
+		const payload = Buffer.allocUnsafe(headerSize + totalRawSize);
+		payload[0] = modelByte;
+		payload[1] = items.length;
+		let offset = 2;
+		for (const item of items) {
+			payload.writeUInt32LE(item.width, offset);
+			payload.writeUInt32LE(item.height, offset + 4);
+			payload[offset + 8] = RAW_FMT_CODE[item.format];
+			payload.writeUInt32LE(item.raw.length, offset + 9);
+			offset += 13;
+			item.raw.copy(payload, offset);
+			offset += item.raw.length;
 		}
+		const response = await this.dispatch(MSG_INFER_BATCH, payload);
+		const results = response["results"];
+		if (!Array.isArray(results)) throw new Error(`PoolWorker.inferBatch: malformed response: ${JSON.stringify(response)}`);
+		return results;
 	}
-}, {
-	id: "apple-soundanalysis",
-	name: "Apple SoundAnalysis",
-	description: "macOS built-in — 303 sound categories, Neural Engine accelerated, zero download",
-	inputSize: {
-		width: 1,
-		height: 16e3
-	},
-	labels: [],
-	preprocessMode: "resize",
-	formats: { coreml: {
-		url: "",
-		sizeMB: 0
-	} }
-}];
-//#endregion
-//#region src/detection-pipeline/registry/step-definitions.ts
-var ANIMAL_10_LABELS = [
-	"cat",
-	"cow",
-	"dog",
-	"dolphin",
-	"eagle",
-	"giant panda",
-	"horse",
-	"monkey",
-	"sheep",
-	"spider"
-];
-var VGG_G2_CHARSET = ["", ..."0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz".split("")];
-var PipelineStepBase = class {
-	definition;
-	constructor(definition) {
-		this.definition = definition;
+	async cacheFrame(frameId, raw, width, height, format) {
+		this.ensureReady();
+		const fmtCode = RAW_FMT_CODE[format];
+		const header = Buffer.allocUnsafe(13);
+		header.writeUInt32LE(frameId, 0);
+		header.writeUInt32LE(width, 4);
+		header.writeUInt32LE(height, 8);
+		header[12] = fmtCode;
+		const payloadLen = header.length + raw.length;
+		const result = await this.dispatchMulti(MSG_CACHE_FRAME, payloadLen, [header, raw]);
+		if (result["error"]) throw new Error(String(result["error"]));
+	}
+	async inferCached(modelByte, frameId) {
+		this.ensureReady();
+		const payload = Buffer.allocUnsafe(5);
+		payload[0] = modelByte;
+		payload.writeUInt32LE(frameId, 1);
+		return this.dispatch(MSG_INFER_CACHED, payload);
+	}
+	async sendCommand(cmd) {
+		this.ensureReady();
+		const payload = Buffer.from(JSON.stringify(cmd), "utf8");
+		return await this.dispatch(MSG_COMMAND, payload);
+	}
+	async dispose() {
+		const proc = this.process;
+		if (!proc) return;
+		this.process = null;
+		this.ready = false;
+		await terminateChild(proc, POOL_WORKER_TERM_GRACE_MS);
+	}
+	dispatch(msgType, payload) {
+		const reqId = this.allocRequestId();
+		return new Promise((resolve, reject) => {
+			this.pending.set(reqId, {
+				resolve,
+				reject
+			});
+			try {
+				this.writeFrame(reqId, msgType, payload);
+			} catch (err) {
+				this.pending.delete(reqId);
+				reject(err instanceof Error ? err : new Error(String(err)));
+			}
+		});
+	}
+	dispatchMulti(msgType, payloadLen, parts) {
+		const reqId = this.allocRequestId();
+		return new Promise((resolve, reject) => {
+			this.pending.set(reqId, {
+				resolve,
+				reject
+			});
+			try {
+				if (!this.process?.stdin) throw new Error("PoolWorker: not initialized");
+				const prefix = Buffer.allocUnsafe(PREFIX_LEN);
+				prefix.writeUInt32LE(5 + payloadLen, 0);
+				prefix.writeUInt32LE(reqId, 4);
+				prefix[8] = msgType;
+				this.process.stdin.write(prefix);
+				for (const part of parts) this.process.stdin.write(part);
+			} catch (err) {
+				this.pending.delete(reqId);
+				reject(err instanceof Error ? err : new Error(String(err)));
+			}
+		});
 	}
-	getConfigSchema() {
-		return [];
+	allocRequestId() {
+		let id = this.nextRequestId;
+		this.nextRequestId = id >= 4294967295 ? 1 : id + 1;
+		while (this.pending.has(id)) {
+			id = this.nextRequestId;
+			this.nextRequestId = id >= 4294967295 ? 1 : id + 1;
+		}
+		return id;
 	}
-};
-var ObjectDetectionStep = class {
-	definition = {
-		id: "object-detection",
-		name: "Object Detection",
-		slot: "detector",
-		postprocessor: "yolo",
-		extractMode: "full-frame",
-		inputClasses: null,
-		outputClasses: [
-			"person",
-			"vehicle",
-			"animal"
-		],
-		models: [...OBJECT_DETECTION_MODELS],
-		defaultModelId: "yolo26n",
-		defaultConfidence: .5,
-		labels: require_dist.COCO_80_LABELS.map((l) => l.id),
-		classMap: require_dist.COCO_TO_MACRO
-	};
-	getConfigSchema() {
-		return [
-			{
-				type: "multiselect",
-				key: "enabledMacroClasses",
-				label: "Enabled Classes",
-				description: "Which macro classes to detect (empty = all three).",
-				options: [
-					{
-						value: "person",
-						label: "Person"
-					},
-					{
-						value: "vehicle",
-						label: "Vehicle"
-					},
-					{
-						value: "animal",
-						label: "Animal"
-					}
-				],
-				default: [
-					"person",
-					"vehicle",
-					"animal"
-				]
-			},
-			{
-				type: "slider",
-				key: "minConfidencePerson",
-				label: "Min Confidence — Person",
-				description: "Drop person predictions below this score.",
-				min: 0,
-				max: 1,
-				step: .05,
-				default: .5,
-				showValue: true
-			},
-			{
-				type: "slider",
-				key: "minConfidenceVehicle",
-				label: "Min Confidence — Vehicle",
-				description: "Drop vehicle predictions below this score.",
-				min: 0,
-				max: 1,
-				step: .05,
-				default: .5,
-				showValue: true
-			},
-			{
-				type: "slider",
-				key: "minConfidenceAnimal",
-				label: "Min Confidence — Animal",
-				description: "Drop animal predictions below this score.",
-				min: 0,
-				max: 1,
-				step: .05,
-				default: .5,
-				showValue: true
+	writeFrame(reqId, msgType, payload) {
+		if (!this.process?.stdin) throw new Error("PoolWorker: not initialized");
+		const totalLen = 5 + payload.length;
+		const header = Buffer.allocUnsafe(PREFIX_LEN);
+		header.writeUInt32LE(totalLen, 0);
+		header.writeUInt32LE(reqId, 4);
+		header[8] = msgType;
+		this.process.stdin.write(header);
+		this.process.stdin.write(payload);
+	}
+	ensureReady() {
+		if (!this.ready || !this.process?.stdin) throw new Error(`PoolWorker[${this.opts.workerLabel}]: not initialized`);
+	}
+	drainResponses() {
+		while (this.receiveBuffer.length >= 8) {
+			const totalLen = this.receiveBuffer.readUInt32LE(0);
+			if (this.receiveBuffer.length < 4 + totalLen) break;
+			const reqId = this.receiveBuffer.readUInt32LE(4);
+			const jsonBytes = this.receiveBuffer.subarray(8, 4 + totalLen);
+			this.receiveBuffer = this.receiveBuffer.subarray(4 + totalLen);
+			const entry = this.pending.get(reqId);
+			if (!entry) {
+				this.log.warn("Response for unknown request id", { meta: {
+					worker: this.opts.workerLabel,
+					reqId
+				} });
+				continue;
 			}
-		];
+			this.pending.delete(reqId);
+			try {
+				const parsed = JSON.parse(jsonBytes.toString("utf8"));
+				entry.resolve(parsed);
+			} catch (err) {
+				entry.reject(err instanceof Error ? err : new Error(String(err)));
+			}
+		}
+	}
+	rejectAll(err) {
+		const entries = [...this.pending.values()];
+		this.pending.clear();
+		for (const entry of entries) entry.reject(err);
 	}
 };
-var AudioClassifierStep = class {
-	definition = {
-		id: "audio-classifier",
-		name: "Audio Classifier",
-		slot: "audio-classifier",
-		postprocessor: "yamnet",
-		extractMode: "full-frame",
-		inputClasses: null,
-		outputClasses: ["audio"],
-		models: [...AUDIO_CLASSIFIER_MODELS],
-		defaultModelId: "yamnet-onnx",
-		defaultModelIdByFormat: { coreml: "apple-soundanalysis" },
-		enabledByDefault: true,
-		defaultConfidence: .3
-	};
-	getConfigSchema() {
-		return [{
-			type: "multiselect",
-			key: "enabledAudioClasses",
-			label: "Audio Classes",
-			description: "Which audio macro classes to surface (empty = all).",
-			options: require_dist.AUDIO_MACRO_LABELS.map((l) => ({
-				value: l.id,
-				label: `${l.icon ?? ""} ${l.name}`.trim()
-			})),
-			default: [
-				"scream",
-				"crying",
-				"dog",
-				"alarm",
-				"doorbell",
-				"glass_breaking",
-				"gunshot",
-				"siren",
-				"footsteps"
-			]
-		}, {
-			type: "slider",
-			key: "minConfidence",
-			label: "Min Confidence",
-			description: "Drop predictions whose score is below this threshold.",
-			default: .3,
-			min: 0,
-			max: 1,
-			step: .05,
-			showValue: true
-		}];
+var SharedInferencePool = class {
+	pythonPath;
+	poolRuntime;
+	workers = [];
+	nextDispatchIdx = 0;
+	nextFreeIndex = 0;
+	nextFrameId = 1;
+	/**
+	* Cumulative count of frames the Python pool SHED under overload
+	* (`"dropped": true` responses from the per-model in-flight bound in
+	* inference_pool.py). Without this the shed response is
+	* indistinguishable from a genuine "no detections" result.
+	*/
+	droppedResponseCount = 0;
+	log;
+	concurrency;
+	tuning;
+	numWorkers;
+	constructor(pythonPath, poolRuntime, logger, options = {}) {
+		this.pythonPath = pythonPath;
+		this.poolRuntime = poolRuntime;
+		this.log = logger;
+		this.concurrency = Math.max(1, options.concurrency ?? 1);
+		this.tuning = options.tuning ?? null;
+		this.numWorkers = Math.max(1, options.numWorkers ?? 1);
+	}
+	/** Pid of the first worker (for legacy callers). Use `getPids()` for all. */
+	getPid() {
+		return this.workers[0]?.getPid() ?? null;
+	}
+	getPids() {
+		return this.workers.map((w) => w.getPid());
+	}
+	/**
+	* Start N pool workers in parallel. Each worker loads the same
+	* initial model set so subsequent inference calls land on a worker
+	* with the requested model already in its slot map.
+	*/
+	async initialize(initialModels = []) {
+		const scriptPath = this.resolveScriptPath();
+		for (let i = 0; i < this.numWorkers; i++) this.workers.push(new PoolWorker({
+			pythonPath: this.pythonPath,
+			scriptPath,
+			poolRuntime: this.poolRuntime,
+			concurrency: this.concurrency,
+			tuning: this.tuning,
+			logger: this.log,
+			workerLabel: `w${i}`
+		}));
+		const t0 = performance.now();
+		const results = await Promise.all(this.workers.map((w) => w.initialize(initialModels)));
+		const startupMs = Math.round(performance.now() - t0);
+		this.nextFreeIndex = initialModels.length;
+		const loadedCount = results[0]?.loadedCount ?? 0;
+		const innerWorkers = results.reduce((s, r) => s + r.workers, 0);
+		this.log.info("Pool ready", { meta: {
+			loadedCount,
+			startupMs,
+			runtime: this.poolRuntime,
+			workers: this.numWorkers,
+			pythonWorkers: innerWorkers,
+			pids: this.getPids()
+		} });
+		return {
+			startupMs,
+			loadedCount,
+			workers: this.numWorkers
+		};
+	}
+	async infer(modelIndex, jpeg) {
+		const w = this.pickWorker();
+		return this.trackDroppedResponse(await w.infer(this.encodeModelByte(modelIndex), jpeg), modelIndex);
 	}
-};
-var AnimalClassifierStep = class {
-	definition = {
-		id: "animal-classifier",
-		name: "Animal Classifier",
-		slot: "classifier",
-		postprocessor: "softmax",
-		extractMode: "crop-roi",
-		inputClasses: ["animal"],
-		outputClasses: ["animal-type"],
-		models: [...ANIMAL_CLASSIFIER_MODELS],
-		defaultModelId: "animals-10",
-		enabledByDefault: false,
-		defaultConfidence: .2,
-		labels: [...ANIMAL_10_LABELS]
-	};
-	getConfigSchema() {
-		return [{
-			type: "multiselect",
-			key: "enabledClasses",
-			label: "Species",
-			description: "Which animal species to keep (empty = all). The classifier still scores every label but only the selected classes are returned on the detection.",
-			options: ANIMAL_10_LABELS.map((l) => ({
-				value: l,
-				label: l
-			})),
-			default: []
-		}, {
-			type: "slider",
-			key: "minConfidence",
-			label: "Min Confidence",
-			description: "Drop classifications whose score is below this threshold.",
-			default: this.definition.defaultConfidence,
-			min: 0,
-			max: 1,
-			step: .05,
-			showValue: true
-		}];
+	async inferRaw(modelIndex, raw, width, height, format) {
+		const w = this.pickWorker();
+		return this.trackDroppedResponse(await w.inferRaw(this.encodeModelByte(modelIndex), raw, width, height, format), modelIndex);
 	}
-};
-var ClassifierWithMinConfidence = class extends PipelineStepBase {
-	getConfigSchema() {
-		return [{
-			type: "slider",
-			key: "minConfidence",
-			label: "Min Confidence",
-			description: "Drop classifications whose score is below this threshold.",
-			default: this.definition.defaultConfidence,
-			min: 0,
-			max: 1,
-			step: .05,
-			showValue: true
-		}];
+	async inferBatch(modelIndex, items) {
+		if (items.length > 255) throw new Error(`SharedInferencePool.inferBatch: max 255 items per call, got ${items.length}`);
+		return this.pickWorker().inferBatch(this.encodeModelByte(modelIndex), items);
 	}
-};
-var STEP_FACE_DETECTION = new PipelineStepBase({
-	id: "face-detection",
-	name: "Face Detection",
-	slot: "cropper",
-	postprocessor: "scrfd",
-	extractMode: "crop-roi",
-	inputClasses: ["person"],
-	outputClasses: ["face"],
-	models: [...FACE_DETECTION_MODELS],
-	defaultModelId: "scrfd-2.5g",
-	defaultConfidence: .5,
-	defaultMinParentScore: .7
-});
-var STEP_FACE_EMBEDDING = new PipelineStepBase({
-	id: "face-embedding",
-	name: "Face Embedding",
-	slot: "classifier",
-	postprocessor: "arcface",
-	extractMode: "crop-roi",
-	inputClasses: ["face"],
-	outputClasses: ["identity"],
-	models: [...FACE_EMBEDDING_MODELS],
-	defaultModelId: "arcface-r100",
-	defaultConfidence: 0
-});
-var STEP_CLIP_EMBEDDING = new PipelineStepBase({
-	id: "clip-embedding",
-	name: "CLIP Embedding",
-	slot: "classifier",
-	postprocessor: "clip",
-	extractMode: "crop-roi",
-	inputClasses: null,
-	outputClasses: ["embedding"],
-	models: [...CLIP_EMBEDDING_MODELS],
-	defaultModelId: "mobileclip-s1",
-	enabledByDefault: false,
-	defaultConfidence: 0,
-	defaultMinParentScore: .4,
-	group: "CLIP"
-});
-var STEP_PLATE_DETECTION = new PipelineStepBase({
-	id: "plate-detection",
-	name: "Plate Detection",
-	slot: "cropper",
-	postprocessor: "yolo",
-	extractMode: "crop-roi",
-	inputClasses: ["vehicle"],
-	outputClasses: ["plate"],
-	models: [...PLATE_DETECTION_MODELS],
-	defaultModelId: "yolov8n-plate",
-	defaultConfidence: .5,
-	defaultMinParentScore: .7,
-	labels: ["plate"]
-});
-var STEP_PLATE_OCR = new PipelineStepBase({
-	id: "plate-ocr",
-	name: "Plate OCR",
-	slot: "classifier",
-	postprocessor: "ctc",
-	extractMode: "crop-roi",
-	inputClasses: ["plate"],
-	outputClasses: ["plate-text"],
-	models: [...PLATE_OCR_MODELS],
-	defaultModelId: "vgg-english-g2",
-	defaultConfidence: 0,
-	charset: [...VGG_G2_CHARSET]
-});
-var STEP_BIRD_CLASSIFIER = new ClassifierWithMinConfidence({
-	id: "bird-classifier",
-	name: "Bird Classifier",
-	slot: "classifier",
-	postprocessor: "softmax",
-	extractMode: "crop-roi",
-	inputClasses: ["animal"],
-	outputClasses: ["species"],
-	models: [...BIRD_CLASSIFIER_MODELS],
-	defaultModelId: "bird-nabirds-404",
-	enabledByDefault: false,
-	defaultConfidence: .2
-});
-var STEP_VEHICLE_CLASSIFIER = new ClassifierWithMinConfidence({
-	id: "vehicle-classifier",
-	name: "Vehicle Classifier",
-	slot: "classifier",
-	postprocessor: "softmax",
-	extractMode: "crop-roi",
-	inputClasses: ["vehicle"],
-	outputClasses: ["vehicle-type"],
-	models: [...VEHICLE_CLASSIFIER_MODELS],
-	defaultModelId: "vehicle-type-efficientnet",
-	enabledByDefault: false,
-	defaultConfidence: .3
-});
-var STEP_SEGMENTATION = new PipelineStepBase({
-	id: "segmentation",
-	name: "Segmentation",
-	slot: "refiner",
-	postprocessor: "saliency",
-	extractMode: "crop-roi",
-	inputClasses: null,
-	outputClasses: ["mask"],
-	models: [...SEGMENTATION_REFINER_MODELS],
-	defaultModelId: "u2netp",
-	enabledByDefault: false,
-	defaultConfidence: 0,
-	group: "Segmentation"
-});
-new PipelineStepBase({
-	id: "instance-segmentation",
-	name: "Instance Segmentation",
-	slot: "refiner",
-	postprocessor: "yolo-seg",
-	extractMode: "full-frame",
-	inputClasses: null,
-	outputClasses: ["mask"],
-	models: [...INSTANCE_SEGMENTATION_MODELS],
-	defaultModelId: "yolo26n-seg",
-	enabledByDefault: false,
-	defaultConfidence: .25,
-	labels: require_dist.COCO_80_LABELS.map((l) => l.id),
-	classMap: require_dist.COCO_TO_MACRO,
-	group: "Segmentation"
-});
-var STEP_OBJECT_DETECTION_INSTANCE = new ObjectDetectionStep();
-var STEP_AUDIO_CLASSIFIER_INSTANCE = new AudioClassifierStep();
-var ALL_PIPELINE_STEPS = [
-	STEP_OBJECT_DETECTION_INSTANCE,
-	STEP_FACE_DETECTION,
-	STEP_FACE_EMBEDDING,
-	STEP_CLIP_EMBEDDING,
-	STEP_PLATE_DETECTION,
-	STEP_PLATE_OCR,
-	new AnimalClassifierStep(),
-	STEP_BIRD_CLASSIFIER,
-	STEP_VEHICLE_CLASSIFIER,
-	STEP_SEGMENTATION,
-	STEP_AUDIO_CLASSIFIER_INSTANCE
-];
-/** Compat: flat array of StepDefinition for existing consumers */
-var ALL_STEPS = ALL_PIPELINE_STEPS.map((s) => s.definition);
-var STEP_MAP = new Map(ALL_PIPELINE_STEPS.map((s) => [s.definition.id, s]));
-/**
-* Look up a pipeline step by ID (class instance with getConfigSchema).
-* @throws if the step ID is not registered.
-*/
-function getStep(stepId) {
-	const step = STEP_MAP.get(stepId);
-	if (!step) throw new Error(`Unknown pipeline step: "${stepId}". Available: ${ALL_PIPELINE_STEPS.map((s) => s.definition.id).join(", ")}`);
-	return step;
-}
-/**
-* Look up a step definition by ID (compat shortcut).
-* @throws if the step ID is not registered.
-*/
-function getStepDefinition(stepId) {
-	return getStep(stepId).definition;
+	async inferCached(modelIndex, frameId) {
+		const w = this.pickWorker();
+		return this.trackDroppedResponse(await w.inferCached(this.encodeModelByte(modelIndex), frameId), modelIndex);
+	}
+	/**
+	* Total `"dropped": true` responses seen from the Python pool — frames
+	* shed by the per-model in-flight bound under overload. Diagnostic
+	* counter (monotonic for the pool's lifetime).
+	*/
+	getDroppedResponseCount() {
+		return this.droppedResponseCount;
+	}
+	getHandle(modelIndex) {
+		return new PoolHandle(this, modelIndex);
+	}
+	async cacheFrame(raw, width, height, format) {
+		const frameId = this.nextFrameId++;
+		await Promise.all(this.workers.map((w) => w.cacheFrame(frameId, raw, width, height, format)));
+		return {
+			frameId,
+			width,
+			height
+		};
+	}
+	async uncacheFrame(frameId) {
+		await Promise.all(this.workers.map((w) => w.sendCommand({
+			cmd: "uncache_frame",
+			frameId
+		})));
+	}
+	async loadModel(index, config) {
+		const responses = await Promise.all(this.workers.map((w) => w.sendCommand({
+			cmd: "load",
+			index,
+			config: serializeModelConfig(config)
+		})));
+		for (const resp of responses) if (resp.status !== "ok") throw new Error(`Failed to load model at index ${index}: ${resp.error ?? "unknown"}`);
+		if (index >= this.nextFreeIndex) this.nextFreeIndex = index + 1;
+		return { loadMs: Math.max(...responses.map((r) => r.loadMs ?? 0)) };
+	}
+	async unloadModel(index) {
+		const responses = await Promise.all(this.workers.map((w) => w.sendCommand({
+			cmd: "unload",
+			index
+		})));
+		for (const resp of responses) if (resp.status !== "ok") throw new Error(`Failed to unload model at index ${index}: ${resp.error ?? "unknown"}`);
+	}
+	async replaceModel(index, config) {
+		const responses = await Promise.all(this.workers.map((w) => w.sendCommand({
+			cmd: "replace",
+			index,
+			config: serializeModelConfig(config)
+		})));
+		for (const resp of responses) if (resp.status !== "ok") throw new Error(`Failed to replace model at index ${index}: ${resp.error ?? "unknown"}`);
+		return { loadMs: Math.max(...responses.map((r) => r.loadMs ?? 0)) };
+	}
+	async getStatus() {
+		if (this.workers.length === 0) return [];
+		return (await this.workers[0].sendCommand({ cmd: "status" })).models ?? [];
+	}
+	allocateIndex() {
+		return this.nextFreeIndex++;
+	}
+	isReady() {
+		return this.workers.length > 0 && this.workers.every((w) => w.isReady());
+	}
+	async dispose() {
+		await Promise.all(this.workers.map((w) => w.dispose()));
+		this.workers.length = 0;
+		this.log.info("Pool process(es) terminated");
+	}
+	/**
+	* 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.
+	*/
+	trackDroppedResponse(result, modelIndex) {
+		if (result["dropped"] === true) {
+			this.droppedResponseCount++;
+			this.log.debug("Python pool shed frame under overload", { meta: {
+				modelIndex,
+				droppedTotal: this.droppedResponseCount
+			} });
+		}
+		return result;
+	}
+	pickWorker() {
+		if (this.workers.length === 0) throw new Error("SharedInferencePool: not initialized");
+		const idx = this.nextDispatchIdx;
+		this.nextDispatchIdx = (this.nextDispatchIdx + 1) % this.workers.length;
+		return this.workers[idx];
+	}
+	encodeModelByte(modelIndex) {
+		if (modelIndex < 0 || modelIndex > 254) throw new Error(`Model index ${modelIndex} out of range (0-254)`);
+		return modelIndex;
+	}
+	resolveScriptPath() {
+		const candidates = [
+			node_path.join(__dirname, "../../python/inference_pool.py"),
+			node_path.join(__dirname, "../python/inference_pool.py"),
+			node_path.join(__dirname, "../../../python/inference_pool.py")
+		];
+		try {
+			const pkgPath = require.resolve("@camstack/addon-detection-pipeline/package.json");
+			candidates.unshift(node_path.join(node_path.dirname(pkgPath), "python", "inference_pool.py"));
+		} catch {}
+		const found = candidates.find((p) => node_fs.existsSync(p));
+		if (!found) throw new Error(`inference_pool.py not found. Searched:\n${candidates.join("\n")}`);
+		return found;
+	}
+};
+function serializeModelConfig(config) {
+	const result = {
+		path: config.path,
+		inputSize: config.inputSize,
+		preprocessMode: config.preprocessMode,
+		postprocessor: config.postprocessor,
+		confidence: config.confidence
+	};
+	if (config.labels) result["labels"] = config.labels;
+	if (config.charset) result["charset"] = config.charset;
+	if (config.numClasses) result["numClasses"] = config.numClasses;
+	if (config.strides) result["strides"] = config.strides;
+	if (config.maskThreshold !== void 0) result["maskThreshold"] = config.maskThreshold;
+	if (config.device) result["device"] = config.device;
+	return result;
 }
+//#endregion
+//#region src/detection-pipeline/engine/step-utils.ts
 /**
-* Get the default model ID for a step given the current model format.
-*
-* Resolution order:
-*   1. `def.defaultModelIdByFormat?.[format]` — the step's declared
-*      per-format preference — if that model exists in `def.models` AND
-*      has a build for `format`.
-*   2. `def.defaultModelId` — the step's plain declared default — if it
-*      exists in `def.models` AND has a build for `format`.
-*   3. The smallest-by-size model among those with a `format` build
-*      (legacy fallback, preserved for steps/formats with no declared
-*      preference reachable).
-*   4. `def.defaultModelId` unchanged, when ZERO models have a `format`
-*      build — an unloadable case flagged elsewhere, not resolved here.
+* Flatten a step tree into a list of enabled video steps (DFS).
+* Audio-classifier steps are excluded — they run independently
+* via the audio pipeline, not the video inference pool.
 */
-function getDefaultModelForFormat(stepId, format) {
-	const def = getStepDefinition(stepId);
-	const hasFormatBuild = (modelId) => def.models.find((m) => m.id === modelId)?.formats[format] !== void 0;
-	const declaredForFormat = def.defaultModelIdByFormat?.[format];
-	if (declaredForFormat !== void 0 && hasFormatBuild(declaredForFormat)) return declaredForFormat;
-	if (hasFormatBuild(def.defaultModelId)) return def.defaultModelId;
-	const available = def.models.filter((m) => m.formats[format] && m.legacy !== true);
-	if (available.length === 0) return def.defaultModelId;
-	return [...available].toSorted((a, b) => {
-		return (a.formats[format]?.sizeMB ?? Infinity) - (b.formats[format]?.sizeMB ?? Infinity);
-	})[0].id;
+function flattenEnabledVideoSteps(steps) {
+	const result = [];
+	const walk = (nodes) => {
+		for (const step of nodes) {
+			if (!step.enabled) continue;
+			if (step.slot === "audio-classifier") continue;
+			result.push(step);
+			if (step.children?.length) walk(step.children);
+		}
+	};
+	walk(steps);
+	return result;
 }
-/**
-* The single node-local authority for turning a CHOSEN model (or none) into a
-* concrete model that has a build for this node's engine `format`. Fuses the
-* two previously-duplicated decisions (orchestrator `pickDefaultModelId` +
-* provider `substituteIncompatibleModels`):
-*
-*   - chosen === null            → the addon's default model for `format`.
-*   - chosen is a catalog model  → keep it if it has a `format` build; else
-*                                  the addon's default model for `format`
-*                                  (a substitution — the caller surfaces it).
-*   - chosen is NOT in the catalog (custom/unknown) → returned unchanged; the
-*                                  operator owns a custom model's format compat.
-*   - unknown stepId             → chosen returned unchanged (never throws).
-*/
-function resolveModelForFormat(stepId, chosenModelId, format) {
-	let def;
-	try {
-		def = getStepDefinition(stepId);
-	} catch {
-		return chosenModelId ?? "";
+//#endregion
+//#region src/detection-pipeline/engine/pipeline-model-manager.ts
+var PipelineModelManager = class {
+	pool;
+	buildPoolConfig;
+	/** stepId → modelId → loaded entry. */
+	loaded = /* @__PURE__ */ new Map();
+	/** stepId → currently-active modelId (the runtime choice). */
+	activeByStep = /* @__PURE__ */ new Map();
+	/** Monotonic counter feeding the LRU tick on every touch. */
+	lruClock = 0;
+	log;
+	maxModelsPerStep;
+	constructor(pool, buildPoolConfig, logger, options) {
+		this.pool = pool;
+		this.buildPoolConfig = buildPoolConfig;
+		this.log = logger;
+		this.maxModelsPerStep = options?.maxModelsPerStep ?? 4;
+	}
+	/**
+	* Apply a new pipeline configuration — driven by the runtime config
+	* (camera-serving pipeline). Rewrites the *active* model per step,
+	* keeping prior actives warm in extra slots up to `maxModelsPerStep`.
+	*
+	* Steps that disappear from `newSteps` get fully unloaded (every
+	* model variant for that stepId).
+	*/
+	async applyConfig(newSteps) {
+		const enabledSteps = flattenEnabledVideoSteps(newSteps);
+		const diff = this.computeDiff(enabledSteps);
+		for (const removed of diff.removed) {
+			await this.unloadEntry(removed);
+			this.log.info("Unloading step", { meta: {
+				step: removed.stepId,
+				modelId: removed.modelId,
+				poolIndex: removed.poolIndex
+			} });
+		}
+		for (const added of diff.added) {
+			await this.ensureLoaded(added.addonId, added.modelId);
+			this.activeByStep.set(added.addonId, added.modelId);
+			this.log.info("Step loaded", { meta: {
+				step: added.addonId,
+				modelId: added.modelId,
+				active: true
+			} });
+		}
+		for (const { step, oldModelId } of diff.modelChanged) {
+			await this.ensureLoaded(step.addonId, step.modelId);
+			this.activeByStep.set(step.addonId, step.modelId);
+			this.log.info("Active model switched", { meta: {
+				step: step.addonId,
+				fromModelId: oldModelId,
+				toModelId: step.modelId
+			} });
+			await this.enforceLruCap(step.addonId);
+		}
+	}
+	/**
+	* Get an `IInferenceEngine` handle. Without `modelId`, returns the
+	* active model for the step (camera-runtime hot path). Pass
+	* `modelId` to grab a specific warm variant (benchmark path).
+	* Touches the LRU clock so the looked-up model survives eviction
+	* pressure from concurrent loads.
+	*/
+	getHandle(stepId, modelId) {
+		const entry = this.resolveOrThrow(stepId, modelId);
+		this.touch(entry);
+		return this.pool.getHandle(entry.poolIndex);
+	}
+	/** True iff the step has any model loaded. */
+	isLoaded(stepId) {
+		return this.loaded.has(stepId) && (this.loaded.get(stepId)?.size ?? 0) > 0;
+	}
+	/** True iff the specific (stepId, modelId) pair is resident. */
+	isLoadedWithModel(stepId, modelId) {
+		return this.loaded.get(stepId)?.has(modelId) ?? false;
+	}
+	/** ModelId currently designated as active for the step. */
+	getLoadedModelId(stepId) {
+		return this.activeByStep.get(stepId);
+	}
+	/**
+	* Pool index for a given (stepId, modelId). Without `modelId`,
+	* returns the active model's index. Used by the inference fast
+	* paths that bypass `getHandle` and call `pool.inferBatch` directly.
+	*/
+	getPoolIndex(stepId, modelId) {
+		const entry = this.resolve(stepId, modelId);
+		if (!entry) return null;
+		this.touch(entry);
+		return entry.poolIndex;
+	}
+	/**
+	* Direct access to the underlying pool — exposed so the provider can
+	* call `inferBatch` without re-fetching individual handles. Pool
+	* lifetime is owned by `EngineFactory`, so callers must not dispose.
+	*/
+	getPool() {
+		return this.pool;
+	}
+	/**
+	* Snapshot of every (stepId, modelId, poolIndex) currently resident.
+	* Used by the `Warm instances` UI tab + cap-level `listLoadedEngines`
+	* to surface both the runtime model and the warm extras.
+	*/
+	getLoadedSteps() {
+		const out = [];
+		for (const [stepId, models] of this.loaded) {
+			const activeModelId = this.activeByStep.get(stepId);
+			for (const entry of models.values()) out.push({
+				stepId: entry.stepId,
+				modelId: entry.modelId,
+				poolIndex: entry.poolIndex,
+				active: entry.modelId === activeModelId
+			});
+		}
+		return out;
 	}
-	if (chosenModelId === null) return getDefaultModelForFormat(stepId, format);
-	const entry = def.models.find((m) => m.id === chosenModelId);
-	if (!entry) return chosenModelId;
-	if (entry.formats[format]) return chosenModelId;
-	return getDefaultModelForFormat(stepId, format);
-}
+	/**
+	* Load extra models without touching the active runtime model.
+	* Idempotent — already-loaded (stepId, modelId) pairs are no-op'd.
+	* If `maxModelsPerStep` is exceeded, the LRU non-active variant is
+	* evicted (NOT the active one — that would knock the runtime cameras
+	* offline). The "active" designation is unchanged: callers without
+	* a `modelId` argument keep hitting the runtime model.
+	*/
+	async loadAdditional(steps) {
+		for (const step of steps) {
+			if (this.isLoadedWithModel(step.addonId, step.modelId)) continue;
+			await this.ensureLoaded(step.addonId, step.modelId);
+			if (!this.activeByStep.has(step.addonId)) this.activeByStep.set(step.addonId, step.modelId);
+		}
+	}
+	/**
+	* Load `(stepId, modelId)` into the pool if not already resident.
+	* Honors `maxModelsPerStep` — evicts a non-active LRU variant first
+	* when the cap would otherwise be exceeded.
+	*/
+	async ensureLoaded(stepId, modelId) {
+		let perStep = this.loaded.get(stepId);
+		if (!perStep) {
+			perStep = /* @__PURE__ */ new Map();
+			this.loaded.set(stepId, perStep);
+		}
+		const existing = perStep.get(modelId);
+		if (existing) {
+			this.touch(existing);
+			return existing;
+		}
+		while (perStep.size >= this.maxModelsPerStep) {
+			const evicted = this.pickEvictionTarget(stepId);
+			if (!evicted) break;
+			await this.unloadEntry(evicted);
+			this.log.info("LRU evicted warm model", { meta: {
+				step: stepId,
+				modelId: evicted.modelId,
+				poolIndex: evicted.poolIndex,
+				cap: this.maxModelsPerStep
+			} });
+		}
+		const index = this.pool.allocateIndex();
+		const config = this.buildPoolConfig(stepId, modelId);
+		this.log.info("Loading step variant", { meta: {
+			step: stepId,
+			modelId,
+			poolIndex: index
+		} });
+		const { loadMs } = await this.pool.loadModel(index, config);
+		this.log.info("Step variant loaded", { meta: {
+			step: stepId,
+			modelId,
+			poolIndex: index,
+			loadMs
+		} });
+		const entry = {
+			stepId,
+			modelId,
+			poolIndex: index,
+			lruTick: ++this.lruClock
+		};
+		perStep.set(modelId, entry);
+		return entry;
+	}
+	async unloadEntry(entry) {
+		await this.pool.unloadModel(entry.poolIndex);
+		const perStep = this.loaded.get(entry.stepId);
+		perStep?.delete(entry.modelId);
+		if (perStep && perStep.size === 0) {
+			this.loaded.delete(entry.stepId);
+			this.activeByStep.delete(entry.stepId);
+		}
+	}
+	/** Select the LRU non-active entry for a step. Returns null when only the active one is present. */
+	pickEvictionTarget(stepId) {
+		const perStep = this.loaded.get(stepId);
+		if (!perStep) return null;
+		const activeModelId = this.activeByStep.get(stepId);
+		let oldest = null;
+		for (const entry of perStep.values()) {
+			if (entry.modelId === activeModelId) continue;
+			if (!oldest || entry.lruTick < oldest.lruTick) oldest = entry;
+		}
+		return oldest;
+	}
+	/** Trim the step down to `maxModelsPerStep` entries, evicting LRU non-actives. */
+	async enforceLruCap(stepId) {
+		const perStep = this.loaded.get(stepId);
+		if (!perStep) return;
+		while (perStep.size > this.maxModelsPerStep) {
+			const evicted = this.pickEvictionTarget(stepId);
+			if (!evicted) break;
+			await this.unloadEntry(evicted);
+		}
+	}
+	resolve(stepId, modelId) {
+		const perStep = this.loaded.get(stepId);
+		if (!perStep) return null;
+		const targetModelId = modelId ?? this.activeByStep.get(stepId);
+		if (!targetModelId) return null;
+		return perStep.get(targetModelId) ?? null;
+	}
+	resolveOrThrow(stepId, modelId) {
+		const entry = this.resolve(stepId, modelId);
+		if (!entry) throw new Error(`Step "${stepId}"${modelId ? ` (model "${modelId}")` : ""} is not loaded in the inference pool`);
+		return entry;
+	}
+	touch(entry) {
+		entry.lruTick = ++this.lruClock;
+	}
+	/** Compute diff between currently-active steps and desired steps. */
+	computeDiff(desiredSteps) {
+		const desiredMap = /* @__PURE__ */ new Map();
+		for (const step of desiredSteps) desiredMap.set(step.addonId, step);
+		const added = [];
+		const removed = [];
+		const modelChanged = [];
+		const unchanged = [];
+		for (const [stepId, activeModelId] of this.activeByStep) {
+			const activeEntry = this.loaded.get(stepId)?.get(activeModelId);
+			if (!activeEntry) continue;
+			const desired = desiredMap.get(stepId);
+			if (!desired) {
+				const perStep = this.loaded.get(stepId);
+				if (perStep) for (const entry of perStep.values()) removed.push(entry);
+			} else if (desired.modelId !== activeModelId) modelChanged.push({
+				step: desired,
+				oldModelId: activeModelId
+			});
+			else unchanged.push(activeEntry);
+		}
+		for (const [stepId, step] of desiredMap) if (!this.activeByStep.has(stepId)) added.push(step);
+		return {
+			added,
+			removed,
+			modelChanged,
+			unchanged
+		};
+	}
+};
 //#endregion
 //#region src/detection-pipeline/engine/engine-factory.ts
 var BACKEND_TO_POOL_RUNTIME = {
@@ -4365,6 +4552,12 @@ function collectUnknownAddonIssues(steps, getStepDef = getStepDefinition) {
 * `PipelineDefaultStep[]` (the catalog-enriched shape the executor consumes),
 * resolving each step's model for `format` via `resolveModelForFormat`.
 *
+* "Auto" model selection (ABSENT `modelId`) is hardware-aware for the
+* object-detection step when `engine` is provided: the default is resolved
+* via `resolveDefaultDetectionModel(engine.backend, engine.device, format)`.
+* A PINNED `modelId` is kept verbatim (subject to the usual format-build
+* substitution); every other step keeps its flat per-format default.
+*
 * Pure and side-effect-free — never throws. This is the seam behind the
 * LIVE per-camera dispatch path (`DetectionPipelineProvider.
 * inputStepsToPipelineSteps`), which runs once per decoded frame (up to
@@ -4375,7 +4568,7 @@ function collectUnknownAddonIssues(steps, getStepDef = getStepDefinition) {
 * `diagnostics.substitutions` instead of happening silently. The caller
 * (the provider) owns logging + dedup for both.
 */
-function resolveInputSteps(steps, format) {
+function resolveInputSteps(steps, format, engine) {
 	const resolvedSteps = [];
 	const unknownAddonIds = [];
 	const substitutions = [];
@@ -4388,14 +4581,14 @@ function resolveInputSteps(steps, format) {
 			continue;
 		}
 		const chosenModelId = s.modelId ?? null;
-		const runningModelId = resolveModelForFormat(s.addonId, chosenModelId, format);
+		const runningModelId = chosenModelId === null && engine !== void 0 && s.addonId === "object-detection" ? resolveDefaultDetectionModel(engine.backend, engine.device, format) : resolveModelForFormat(s.addonId, chosenModelId, format);
 		if (chosenModelId !== null && runningModelId !== chosenModelId) substitutions.push({
 			addonId: s.addonId,
 			chosen: chosenModelId,
 			running: runningModelId,
 			format
 		});
-		const childResult = s.children ? resolveInputSteps(s.children, format) : null;
+		const childResult = s.children ? resolveInputSteps(s.children, format, engine) : null;
 		if (childResult) {
 			unknownAddonIds.push(...childResult.diagnostics.unknownAddonIds);
 			substitutions.push(...childResult.diagnostics.substitutions);
@@ -4428,8 +4621,6 @@ function resolveInputSteps(steps, format) {
 * This is the main provider that consumers (DetectionWiring, Benchmark, tRPC)
 * interact with. It manages the engine factory, pipeline executor, and config persistence.
 */
-var KEY_STEPS = "pipelineSteps";
-var KEY_ENGINE = "pipelineEngine";
 var KEY_TEMPLATES = "pipelineTemplates";
 function pythonModuleForBackend(backend) {
 	switch (backend) {
@@ -4512,14 +4703,6 @@ function readStored(raw, guard) {
 		return null;
 	}
 }
-function isEngineChoice(v) {
-	if (v === null || typeof v !== "object" || Array.isArray(v)) return false;
-	const rec = { ...v };
-	return typeof rec["runtime"] === "string" && typeof rec["backend"] === "string" && typeof rec["format"] === "string";
-}
-function isPipelineStepArray(v) {
-	return Array.isArray(v);
-}
 /**
 * Phase 7 (settings redesign) template migration.
 *
@@ -4736,13 +4919,6 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	*/
 	frameHandleReaders = null;
 	/**
-	* True once the engine + models are fully ready for inference. No
-	* longer gates runtime dispatch (Phase 4 removed the legacy `runFrame`
-	* which read this flag); kept as a diagnostic the admin UI / tests
-	* surface via the future `isReady()` helper.
-	*/
-	ready = false;
-	/**
 	* Lazy detection-engine runtime provisioner (Phase 2). Owns the
 	* idle → installing → verifying → ready state machine for the
 	* currently-selected engine and is the SOLE authority the inference
@@ -4794,6 +4970,8 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	writeStore;
 	/** Read per-device settings. */
 	readDeviceStore;
+	/** Delete all per-device settings for a device (used by `clearDeviceOverrides`). */
+	clearDeviceStore;
 	constructor(settings, modelsDir, logger, eventBus = null, detectionConfigSchemaSource = null, executorOptions = {}) {
 		this.modelsDir = modelsDir;
 		this.eventBus = eventBus;
@@ -4803,6 +4981,8 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 		this.readStore = () => settings.readAddonStore();
 		this.writeStore = (patch) => settings.writeAddonStore(patch);
 		this.readDeviceStore = settings.readDeviceStore ?? (async () => ({}));
+		const clearDeviceStore = settings.clearDeviceStore;
+		this.clearDeviceStore = clearDeviceStore ? (deviceId) => clearDeviceStore.call(settings, deviceId) : async () => void 0;
 		this.currentEngine = ONNX_FLOOR;
 		this.log.info("Engine pick pending (placeholder until probe / persisted selection)", { meta: {
 			runtime: this.currentEngine.runtime,
@@ -4865,9 +5045,9 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 		}
 		await this.ensureEngineFactory();
 	}
-	/** True when the engine + model pool are fully warmed and inference-ready. */
+	/** True when the engine provisioning machine reports inference-ready. */
 	isReady() {
-		return this.ready;
+		return this.getEngineProvisioning().state === "ready";
 	}
 	/** Store the addon context. ctx.api is a lazy getter resolved at call time. */
 	async setApi(addonCtx) {
@@ -5269,7 +5449,8 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 		};
 	}
 	async getDefaultSteps(engine) {
-		return buildDefaultStepTree(engine.format);
+		const detectionModelId = resolveDefaultDetectionModel(engine.backend, engine.device ?? null, engine.format);
+		return buildDefaultStepTree(engine.format, detectionModelId);
 	}
 	/**
 	* Resolve every step's model for this node's engine format via the shared
@@ -5312,45 +5493,25 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	getActiveModelSubstitutions() {
 		return [...this.modelSubstitutions.values()];
 	}
+	/**
+	* PURE node-default step tree — computed on demand, never persisted.
+	*
+	* The object-detection default is hardware-aware (this node's resolved
+	* backend + device via `resolveDefaultDetectionModel`); every other step
+	* keeps its flat per-format default. The result is cached in
+	* `currentSteps` only as a memo — the cache is dropped whenever the
+	* engine (hence model format) changes, so a re-read always reflects the
+	* live engine. Nothing in the live per-camera dispatch path reads this:
+	* it exists as the benchmark fallback (empty input steps), the Gate-A
+	* config-issue probe, and the "effective post-reset model" probe.
+	*/
 	async getGlobalSteps() {
 		if (this.currentSteps) return this.currentSteps;
-		const raw = (await this.readStore())[KEY_STEPS];
-		if (!raw) {
-			const defaults = buildDefaultStepTree(this.currentEngine.format);
-			if (defaults.length === 0) return null;
-			this.currentSteps = this.resolveStepModels(defaults);
-			this.writeStore({ [KEY_STEPS]: JSON.stringify(defaults) });
-			this.log.info("Bootstrapped default pipeline — object-detection + face + plate recognition enabled by default", { meta: { rootSteps: defaults.length } });
-			return this.currentSteps;
-		}
-		try {
-			let steps = readStored(raw, isPipelineStepArray) ?? [];
-			if (steps.length === 0) return null;
-			if (!steps.some((s) => s.slot === "audio-classifier")) {
-				const format = this.currentEngine.format;
-				const audioDef = getStepDefinition("audio-classifier");
-				if (audioDef.models.some((m) => m.formats[format])) {
-					const modelId = getDefaultModelForFormat("audio-classifier", format);
-					const audioStep = {
-						addonId: audioDef.id,
-						addonName: audioDef.name,
-						slot: audioDef.slot,
-						inputClasses: audioDef.inputClasses ?? [],
-						outputClasses: audioDef.outputClasses,
-						enabled: true,
-						modelId,
-						children: []
-					};
-					steps = [...steps, audioStep];
-					this.writeStore({ [KEY_STEPS]: JSON.stringify(steps) });
-					this.log.info("Migration: added audio-classifier step to persisted pipeline config");
-				}
-			}
-			this.currentSteps = this.resolveStepModels(steps);
-			return this.currentSteps;
-		} catch {
-			throw new Error(`Failed to parse persisted pipeline steps: corrupt data in key "${KEY_STEPS}"`);
-		}
+		const detectionModelId = resolveDefaultDetectionModel(this.currentEngine.backend, this.currentEngine.device ?? null, this.currentEngine.format);
+		const defaults = buildDefaultStepTree(this.currentEngine.format, detectionModelId);
+		if (defaults.length === 0) return null;
+		this.currentSteps = this.resolveStepModels(defaults);
+		return this.currentSteps;
 	}
 	async getGlobalPipelineConfig() {
 		if (!this.currentSteps) return null;
@@ -5805,7 +5966,14 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 		}
 		decodeMs = performance.now() - decodeT0;
 		const resolveFormat = input.engine?.format ?? this.currentEngine.format;
-		const benchmarkSteps = this.inputStepsToPipelineSteps(input.steps, resolveFormat);
+		const resolveEngine = 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 stepsSignature = JSON.stringify(benchmarkSteps.map((s) => ({
 			id: s.addonId,
 			settings: s.settings ?? {}
@@ -6118,8 +6286,11 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	* would resolve models against the node's persisted format instead of the
 	* format actually being benchmarked.
 	*/
-	inputStepsToPipelineSteps(steps, format = this.currentEngine.format) {
-		const { steps: resolvedSteps, diagnostics } = resolveInputSteps(steps, format);
+	inputStepsToPipelineSteps(steps, format = this.currentEngine.format, engine = {
+		backend: this.currentEngine.backend,
+		device: this.currentEngine.device ?? null
+	}) {
+		const { steps: resolvedSteps, diagnostics } = resolveInputSteps(steps, format, engine);
 		for (const addonId of diagnostics.unknownAddonIds) this.logLiveDispatchIssueOnce(`unknown:${addonId}`, () => this.log.warn("Live pipeline step references an unknown addon — dropping step", { meta: { addonId } }));
 		for (const sub of diagnostics.substitutions) this.logLiveDispatchIssueOnce(`${sub.addonId}|${sub.chosen}|${sub.running}|${sub.format}`, () => this.log.info("Live pipeline step model substituted for engine format (node-local)", { meta: {
 			step: sub.addonId,
@@ -6237,67 +6408,6 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 			height: 640
 		};
 	}
-	async detect(input) {
-		const { addonId, frame } = input;
-		const { executor, tree } = await this.ensureExecutor();
-		const data = Buffer.from(frame.data);
-		let rootInput;
-		let jpegProvider;
-		if (frame.format === "jpeg") {
-			rootInput = {
-				kind: "jpeg",
-				data
-			};
-			jpegProvider = async () => data;
-		} else if (frame.format === "rgb" || frame.format === "bgr" || frame.format === "gray") {
-			const channels = frame.format === "gray" ? 1 : 3;
-			const sharp$6 = (await import("sharp")).default;
-			const jpeg = await sharp$6(data, { raw: {
-				width: frame.width,
-				height: frame.height,
-				channels
-			} }).jpeg({
-				quality: 85,
-				mozjpeg: false
-			}).toBuffer();
-			rootInput = {
-				kind: "jpeg",
-				data: jpeg
-			};
-			jpegProvider = async () => jpeg;
-		} else {
-			const sharp$7 = (await import("sharp")).default;
-			const encoded = await sharp$7(data, { raw: {
-				width: frame.width,
-				height: frame.height,
-				channels: 3
-			} }).jpeg({
-				quality: 80,
-				mozjpeg: false
-			}).toBuffer();
-			rootInput = {
-				kind: "jpeg",
-				data: encoded
-			};
-			jpegProvider = async () => encoded;
-		}
-		const { result } = await executor.run(tree, rootInput, jpegProvider, frame.width, frame.height, 0);
-		return {
-			detections: result.detections.filter((d) => d.kind === "first-level").map((d) => ({
-				class: d.macroClass,
-				originalClass: d.debug?.originalClass ?? d.macroClass,
-				score: d.score,
-				bbox: {
-					x: d.bbox.x,
-					y: d.bbox.y,
-					w: d.bbox.width,
-					h: d.bbox.height
-				}
-			})),
-			inferenceMs: result.debug?.totalInferenceMs ?? 0,
-			modelId: addonId
-		};
-	}
 	/**
 	* Batched run — dispatches N raw frames against the same loaded
 	* single-step model in one IPC round-trip via
@@ -6340,7 +6450,14 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	async runPipelineBatchImpl(input) {
 		if (input.frames.length === 0) return { results: [] };
 		const resolveFormat = input.engine?.format ?? this.currentEngine.format;
-		const benchmarkSteps = this.inputStepsToPipelineSteps(input.steps, resolveFormat);
+		const resolveEngine = 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 enabledSteps = flattenEnabledVideoSteps(benchmarkSteps);
 		if (enabledSteps.length === 0) throw new Error("runPipelineBatch: no enabled steps");
 		const rootStep = enabledSteps[0];
@@ -6632,71 +6749,11 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 		});
 		await this.engineFactory.initialize([]);
 	}
-	async ensureExecutor() {
-		if (this.initPromise) await this.initPromise;
-		if (!this.engineFactory) {
-			await this.assertEngineReady();
-			this.initPromise = this.doInitialize();
-			try {
-				await this.initPromise;
-			} finally {
-				this.initPromise = null;
-			}
-		}
-		if (!this.currentSteps) throw new Error("No pipeline steps configured");
-		const tree = buildExecutableTree(this.currentSteps, (stepId) => this.engineFactory.getEngine(stepId));
-		return {
-			executor: this.executor,
-			tree
-		};
-	}
-	/** Actual initialization — download models, create engine, load pool. Called once. */
-	async doInitialize() {
-		const steps = await this.getGlobalSteps();
-		if (!steps) throw new Error("No pipeline steps configured. Use setGlobalSteps() first.");
-		this.log.info("Pipeline initializing — frames will be dropped until ready");
-		const format = this.currentEngine.format;
-		const downloads = [];
-		for (const step of flattenSteps(steps)) {
-			const modelEntry = await this.resolveModelEntry(step.addonId, step.modelId);
-			if (!modelEntry) {
-				this.log.warn("Model not found in step catalog — skipping download", { meta: {
-					modelId: step.modelId,
-					step: step.addonId
-				} });
-				continue;
-			}
-			if (!require_model_download_service_C_IHWnXx.isModelDownloaded(this.modelsDir, modelEntry, format)) this.log.info("Downloading model", { meta: {
-				modelId: step.modelId,
-				format
-			} });
-			downloads.push(require_model_download_service_C_IHWnXx.ensureModel(this.modelsDir, modelEntry, format).then(() => {}));
-		}
-		await Promise.all(downloads);
-		await this.ensureBackendDeps(this.currentEngine);
-		this.engineFactory = new EngineFactory({
-			engine: this.currentEngine,
-			modelsDir: this.modelsDir,
-			logger: this.log.child("engine"),
-			pythonPath: this.executorOptions.pythonPath ?? "",
-			concurrency: this.executorOptions.concurrency,
-			tuning: this.executorOptions.tuning,
-			numWorkers: this.executorOptions.numWorkers
-		});
-		await this.engineFactory.initialize(steps);
-		this.currentSteps = steps;
-		const runtimeStr = `${this.currentEngine.runtime}+${this.currentEngine.backend}`;
-		this.executor = new PipelineExecutor({
-			engineRuntime: runtimeStr,
-			logger: this.log
-		});
-		this.ready = true;
-		this.log.info("Pipeline ready — accepting frames");
-	}
 	/**
 	* Phase 2b — resolve the engine from the addon's new schema-backed
-	* fields (`engineRuntime`, `engineBackend`, `engineDevice`). Fallback
-	* to the legacy `KEY_ENGINE` JSON blob for pre-migration stores.
+	* fields (`engineRuntime`, `engineBackend`, `engineDevice`). The legacy
+	* `pipelineEngine` JSON-blob fallback was removed with the executor seed
+	* (any store predating the per-node cascade simply re-runs auto-pick).
 	*
 	* The `'auto'` sentinel is treated as NO override (returns null) so the
 	* caller re-resolves LIVE via `resolveAutoEngine()` — `'auto'` is the
@@ -6739,8 +6796,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 				...device ? { device } : {}
 			};
 		}
-		const raw = store[KEY_ENGINE];
-		return readStored(raw, isEngineChoice);
+		return null;
 	}
 	/**
 	* Re-run the platform probe for the inference engine and persist the
@@ -6789,6 +6845,66 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 		this.log.info("videoPipelineSteps updated", { meta: { addons: Object.keys(sanitized).length } });
 		return { success: true };
 	}
+	/**
+	* Clear THIS node's executor-side PER-DEVICE settings stores — the
+	* per-camera step overrides the object-detection root reads via
+	* `applyDeviceOverridesToTree`.
+	*
+	* Node-routed (the cap's default `nodeIdMode: 'routing'`): the generated
+	* cap-router strips `nodeId` and dispatches to the target node, so this
+	* method runs ON the node being cleared and takes no argument.
+	*
+	* This is the slimmed executor leg of the orchestrator's
+	* `resetNodePipelineDefaults` flow. The legacy `resetToDefault` — which
+	* also reset a persisted GLOBAL step-tree seed nothing in the live
+	* per-camera path read — was removed together with that seed
+	* (`getGlobalSteps` is pure now, so there is nothing node-global left to
+	* reset here).
+	*
+	* Idempotent: clearing already-empty per-device stores is a no-op.
+	*/
+	async clearDeviceOverrides() {
+		const clearedDevices = await this.clearAllDeviceOverrides();
+		this.log.info("executor per-device overrides cleared", { meta: { clearedDevices } });
+		return {
+			success: true,
+			clearedDevices
+		};
+	}
+	/**
+	* Clear the per-device pipeline-step overrides for every known device.
+	* Returns the count of devices whose store was cleared. There is no
+	* bulk-list primitive over the per-device store, so devices are
+	* enumerated via the device-manager and cleared one by one
+	* (`clearDeviceStore` is idempotent — a device with no overrides is a
+	* no-op). Never throws: a device-manager outage degrades to "cleared
+	* nothing" so the reset flow still completes.
+	*/
+	async clearAllDeviceOverrides() {
+		const api = this.addonCtx?.api;
+		if (!api) return 0;
+		let devices = [];
+		try {
+			devices = await api.deviceManager.listAll.query({});
+		} catch (err) {
+			this.log.warn("clearDeviceOverrides: device enumeration failed — skipping per-device clear", { meta: { error: require_dist.errMsg(err) } });
+			return 0;
+		}
+		let cleared = 0;
+		for (const device of devices) try {
+			await this.clearDeviceStore(device.id);
+			cleared++;
+		} catch (err) {
+			this.log.warn("clearDeviceOverrides: failed to clear per-device overrides for device", {
+				tags: { deviceId: device.id },
+				meta: {
+					deviceId: device.id,
+					error: require_dist.errMsg(err)
+				}
+			});
+		}
+		return cleared;
+	}
 	async listLoadedEngines() {
 		const out = [];
 		const overrideFactory = this.overrideCache?.factory ?? null;
@@ -7114,7 +7230,7 @@ function resolveChildSlots(slot) {
 * - Covers 90% of NVR use cases (person/vehicle/animal detection + face detection)
 * - Users opt-in to heavy classifiers (vehicle type, plate OCR, bird species) when needed
 */
-function buildDefaultStepTree(format) {
+function buildDefaultStepTree(format, objectDetectionModelId) {
 	const makeStep = (stepId, children, opts) => {
 		const def = getStepDefinition(stepId);
 		if (!def.models.some((m) => m.formats[format])) return null;
@@ -7140,7 +7256,7 @@ function buildDefaultStepTree(format) {
 		makeStep("bird-classifier", [], { enabled: false }),
 		makeStep("vehicle-classifier", [], { enabled: false }),
 		makeStep("segmentation", [], { enabled: false })
-	].filter((s) => s !== null));
+	].filter((s) => s !== null), objectDetectionModelId !== void 0 ? { modelId: objectDetectionModelId } : void 0);
 	const audioStep = makeStep("audio-classifier", []);
 	const steps = [];
 	if (root) steps.push(root);