@camstack/addon-pipeline 1.0.7 → 1.1.0

package/dist/detection-pipeline/index.mjs

@@ -1,11 +1,255 @@
 import { t as __require } from "../chunk-BdkLduGY.mjs";
-import { B as EventCategory, C as evaluateZoneRules, F as errMsg, I as BaseAddon, S as detectionPipelineCapability, U as createEvent, W as hydrateSchema, X as sleep, a as COCO_TO_MACRO, i as COCO_80_LABELS, k as pipelineExecutorCapability, p as YAMNET_TO_MACRO, q as parseJsonUnknown, r as AUDIO_MACRO_LABELS, t as APPLE_SA_TO_MACRO, w as hfModelUrl } from "../dist-CjrjeaDd.mjs";
-import { a as isModelDownloaded, i as ensureModel, n as deleteModelFromDisk } from "../model-download-service-C7AjBsX9-B0ekM6dF.mjs";
+import { A as nodePin, B as BaseAddon, C as detectionPipelineCapability, J as hydrateSchema, L as supportedRuntimes$1, P as runtimeDevices$1, T as hfModelUrl, W as EventCategory, Z as parseJsonUnknown, a as COCO_TO_MACRO, et as sleep, i as COCO_80_LABELS, j as pipelineExecutorCapability, p as YAMNET_TO_MACRO, q as createEvent, r as AUDIO_MACRO_LABELS, t as APPLE_SA_TO_MACRO, w as evaluateZoneRules, x as defaultDeviceFor$1, z as errMsg } from "../dist-BA6DR_jV.mjs";
+import { a as isModelDownloaded, i as ensureModel, n as deleteModelFromDisk } from "../model-download-service-RxAOiYvX-CMAvhgO7.mjs";
 import * as fs from "node:fs";
 import * as path$1 from "node:path";
 import * as os from "node:os";
 import { spawn } from "node:child_process";
 import sharp from "sharp";
+//#region src/detection-pipeline/engine-store-keys.ts
+/**
+* Per-node scoping for the detection-pipeline engine cascade.
+*
+* The detection addon's settings store is a single CLUSTER-SHARED blob (the
+* settings-store cap is hub-resident; every node's detection instance reads and
+* writes the same keys). That is correct for node-agnostic settings (pipeline
+* steps, tuning) but WRONG for the engine cascade — `engineBackend` /
+* `engineDevice` / `probedBestEngine` are hardware-specific, so the hub (NPU)
+* and a remote agent (iGPU, or no accelerator at all) must hold INDEPENDENT
+* selections. Sharing them lets one node's pick (e.g. `openvino/npu`) override
+* another node that has no NPU.
+*
+* These three keys are therefore persisted node-scoped as `<key>@<nodeId>`.
+* Everything else in the store stays shared. A legacy un-scoped value (written
+* before this change, or by an older build) is read as a migration fallback and
+* re-persisted under the node-scoped key on the next write.
+*/
+var ENGINE_CASCADE_KEYS = [
+	"engineBackend",
+	"engineDevice",
+	"probedBestEngine"
+];
+function isEngineCascadeKey(key) {
+	return ENGINE_CASCADE_KEYS.includes(key);
+}
+/**
+* Normalise a raw kernel node id to the bare node id used for scoping.
+* `localNodeId` can carry a `<node>/<addon>` suffix; the engine selection is
+* per-NODE, so strip the addon segment. Falls back to `hub`.
+*/
+function normalizeEngineNodeId(rawNodeId) {
+	const raw = rawNodeId ?? "hub";
+	return raw.includes("/") ? raw.split("/")[0] ?? "hub" : raw;
+}
+/** The node-scoped store key for an engine cascade field. */
+function nodeEngineKey(base, nodeId) {
+	return `${base}@${normalizeEngineNodeId(nodeId)}`;
+}
+/**
+* Read an engine cascade value for a node: the node-scoped key if present,
+* otherwise the legacy un-scoped value (migration), otherwise undefined.
+*/
+function readNodeEngineValue(store, base, nodeId) {
+	const scoped = store[nodeEngineKey(base, nodeId)];
+	return scoped !== void 0 ? scoped : store[base];
+}
+/**
+* Project a raw store onto the plain engine cascade keys for THIS node, so the
+* UI schema (whose field keys are the bare `engineBackend` etc.) hydrates from
+* the node's own selection. Non-engine keys are left untouched. Node-scoped
+* keys for OTHER nodes are dropped from the projection (not relevant to this
+* node's form).
+*/
+function projectNodeEngine(store, nodeId) {
+	const out = {};
+	const scopedForAnyNode = /* @__PURE__ */ new Set();
+	for (const key of Object.keys(store)) {
+		const atIdx = key.indexOf("@");
+		if (isEngineCascadeKey(atIdx >= 0 ? key.slice(0, atIdx) : key)) {
+			scopedForAnyNode.add(key);
+			continue;
+		}
+		out[key] = store[key];
+	}
+	for (const base of ENGINE_CASCADE_KEYS) {
+		const value = readNodeEngineValue(store, base, nodeId);
+		if (value !== void 0) out[base] = value;
+	}
+	return out;
+}
+//#endregion
+//#region src/detection-pipeline/runtimes.ts
+var KNOWN_PLATFORMS = [
+	"darwin",
+	"linux",
+	"win32"
+];
+var KNOWN_ARCHES = ["arm64", "x64"];
+var KNOWN_GPU_TYPES = [
+	"nvidia",
+	"amd",
+	"intel",
+	"apple"
+];
+var KNOWN_NPU_TYPES = ["apple-ane", "intel-npu"];
+function toKnownPlatform(p) {
+	return KNOWN_PLATFORMS.find((v) => v === p) ?? "linux";
+}
+function toKnownArch(a) {
+	return KNOWN_ARCHES.find((v) => v === a) ?? "x64";
+}
+function gpuInfoFrom(hw) {
+	if (!hw.gpu) return null;
+	const type = KNOWN_GPU_TYPES.find((v) => v === hw.gpu?.type);
+	if (!type) return null;
+	return {
+		type,
+		name: ""
+	};
+}
+function npuInfoFrom(hw) {
+	if (!hw.npu) return null;
+	const type = KNOWN_NPU_TYPES.find((v) => v === hw.npu?.type);
+	if (!type) return null;
+	return { type };
+}
+function envToHardwareInfo(env) {
+	if (!env.hardware) return null;
+	return {
+		platform: toKnownPlatform(env.platform),
+		arch: toKnownArch(env.arch),
+		cpuModel: "",
+		cpuCores: 0,
+		totalRAM_MB: 0,
+		availableRAM_MB: 0,
+		gpu: gpuInfoFrom(env.hardware),
+		npu: npuInfoFrom(env.hardware)
+	};
+}
+function probedToHardwareInfo(hw) {
+	if (!hw) return null;
+	return {
+		platform: toKnownPlatform(process.platform),
+		arch: toKnownArch(process.arch),
+		cpuModel: "",
+		cpuCores: 0,
+		totalRAM_MB: 0,
+		availableRAM_MB: 0,
+		gpu: gpuInfoFrom(hw),
+		npu: npuInfoFrom(hw)
+	};
+}
+var RUNTIME_DETAIL = {
+	onnx: {
+		label: "ONNX Runtime",
+		pythonRequirements: ["requirements.txt", "requirements-onnxruntime.txt"],
+		tuning: {
+			concurrency: 4,
+			batchMode: "list",
+			maxBatchSize: 8,
+			intraOpThreads: 0
+		}
+	},
+	openvino: {
+		label: "OpenVINO",
+		pythonRequirements: ["requirements.txt", "requirements-openvino.txt"],
+		tuning: {
+			concurrency: 1,
+			batchMode: "none",
+			numStreams: 0
+		}
+	},
+	coreml: {
+		label: "CoreML",
+		pythonRequirements: ["requirements.txt", "requirements-coreml.txt"],
+		tuning: {
+			concurrency: 1,
+			batchMode: "none",
+			windowMs: 8,
+			maxBatchSize: 8,
+			numWorkers: 1
+		}
+	}
+};
+/**
+* Returns the list of supported runtime IDs for the given hardware env.
+* Delegates to `@camstack/types` `supportedRuntimes`.
+*/
+function supportedRuntimes(env) {
+	return supportedRuntimes$1(envToHardwareInfo(env));
+}
+/**
+* Returns the device options for a given runtime and probed hardware.
+* Delegates to `@camstack/types` `runtimeDevices`.
+*/
+function runtimeDevices(id, hardware) {
+	return runtimeDevices$1(id, probedToHardwareInfo(hardware));
+}
+/**
+* Returns the default device string for a given runtime.
+* Delegates to `@camstack/types` `defaultDeviceFor`.
+*/
+function defaultDeviceFor(id) {
+	return defaultDeviceFor$1(id);
+}
+/** Model format for each inference runtime supported by the detection pipeline. */
+var RUNTIME_FORMAT = {
+	onnx: "onnx",
+	openvino: "openvino",
+	coreml: "coreml"
+};
+/**
+* Returns the model format required for a given runtime.
+* Returns the locally-typed format string ('onnx' | 'openvino' | 'coreml')
+* matching the engine-provisioner's own ModelFormat type.
+*/
+function modelFormatFor(id) {
+	return RUNTIME_FORMAT[id];
+}
+function pythonRequirementsFor(id) {
+	return RUNTIME_DETAIL[id].pythonRequirements;
+}
+function tuningFor(id) {
+	return RUNTIME_DETAIL[id].tuning;
+}
+function runtimeLabel(id) {
+	return RUNTIME_DETAIL[id].label;
+}
+/**
+* Proactive-install hint kept for back-compat (re-exported from index.ts).
+* Intel on Linux warrants installing openvino; coremltools covers macOS;
+* openvino has no AMD/NVIDIA backend.
+*/
+function shouldInstallOpenvino(env) {
+	if (env.platform === "darwin") return false;
+	return env.gpu?.type === "intel" || env.npu?.type === "intel-npu";
+}
+//#endregion
+//#region src/detection-pipeline/auto-pick.ts
+var PREFERENCE = [
+	"coreml",
+	"openvino",
+	"onnx"
+];
+/**
+* Pure function — picks the best supported runtime for the given hardware env.
+*
+* Logic:
+* 1. If `bestBackendHint` is in the supported set, use it.
+* 2. Otherwise, walk PREFERENCE order and pick the first supported runtime.
+* 3. Floor to `'onnx'` (always supported).
+*
+* Device is always `defaultDeviceFor(chosen)`.
+*/
+function pickBestRuntime(env, bestBackendHint) {
+	const supported = supportedRuntimes(env);
+	const chosen = supported.find((id) => id === bestBackendHint) ?? PREFERENCE.find((id) => supported.includes(id)) ?? "onnx";
+	return {
+		runtimeId: chosen,
+		device: defaultDeviceFor(chosen)
+	};
+}
+//#endregion
 //#region src/detection-pipeline/engine/shared-inference-pool.ts
 var MSG_COMMAND = 0;
 var MSG_INFER_JPEG = 1;
@@ -772,6 +1016,26 @@ var HF_REPO = "camstack/camstack-models";
 var HF_SCRYPTED = "scrypted/plugin-models";
 var hf = (path) => hfModelUrl(HF_REPO, path);
 var hfScrypted = (path) => 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 } : {}
+	};
+};
 var MLPACKAGE_FILES = [
 	"Manifest.json",
 	"Data/com.apple.CoreML/model.mlmodel",
@@ -800,11 +1064,7 @@ var OBJECT_DETECTION_MODELS = [
 				files: [...MLPACKAGE_FILES],
 				runtimes: ["python"]
 			},
-			openvino: {
-				url: hf("objectDetection/yolov9/openvino/camstack-yolov9t.xml"),
-				sizeMB: 6,
-				runtimes: ["python"]
-			}
+			openvino: ovFormat(hf("objectDetection/yolov9/openvino/camstack-yolov9t.xml"), 6)
 		}
 	},
 	{
@@ -829,11 +1089,7 @@ var OBJECT_DETECTION_MODELS = [
 				files: [...MLPACKAGE_FILES],
 				runtimes: ["python"]
 			},
-			openvino: {
-				url: hf("objectDetection/yolov9/openvino/camstack-yolov9s.xml"),
-				sizeMB: 16,
-				runtimes: ["python"]
-			}
+			openvino: ovFormat(hf("objectDetection/yolov9/openvino/camstack-yolov9s.xml"), 16)
 		}
 	},
 	{
@@ -858,11 +1114,7 @@ var OBJECT_DETECTION_MODELS = [
 				files: [...MLPACKAGE_FILES],
 				runtimes: ["python"]
 			},
-			openvino: {
-				url: hf("objectDetection/yolov9/openvino/camstack-yolov9c.xml"),
-				sizeMB: 49,
-				runtimes: ["python"]
-			}
+			openvino: ovFormat(hf("objectDetection/yolov9/openvino/camstack-yolov9c.xml"), 49)
 		}
 	},
 	{
@@ -887,11 +1139,7 @@ var OBJECT_DETECTION_MODELS = [
 				files: [...MLPACKAGE_FILES],
 				runtimes: ["python"]
 			},
-			openvino: {
-				url: hf("objectDetection/yolo26/openvino/camstack-yolo26n.xml"),
-				sizeMB: 9,
-				runtimes: ["python"]
-			}
+			openvino: ovFormat(hf("objectDetection/yolo26/openvino/camstack-yolo26n.xml"), 9)
 		}
 	},
 	{
@@ -916,11 +1164,7 @@ var OBJECT_DETECTION_MODELS = [
 				files: [...MLPACKAGE_FILES],
 				runtimes: ["python"]
 			},
-			openvino: {
-				url: hf("objectDetection/yolo26/openvino/camstack-yolo26s.xml"),
-				sizeMB: 36,
-				runtimes: ["python"]
-			}
+			openvino: ovFormat(hf("objectDetection/yolo26/openvino/camstack-yolo26s.xml"), 36)
 		}
 	},
 	{
@@ -945,11 +1189,7 @@ var OBJECT_DETECTION_MODELS = [
 				files: [...MLPACKAGE_FILES],
 				runtimes: ["python"]
 			},
-			openvino: {
-				url: hf("objectDetection/yolo26/openvino/camstack-yolo26m.xml"),
-				sizeMB: 78,
-				runtimes: ["python"]
-			}
+			openvino: ovFormat(hf("objectDetection/yolo26/openvino/camstack-yolo26m.xml"), 78)
 		}
 	},
 	{
@@ -974,11 +1214,7 @@ var OBJECT_DETECTION_MODELS = [
 				files: [...MLPACKAGE_FILES],
 				runtimes: ["python"]
 			},
-			openvino: {
-				url: hf("objectDetection/yolo26/openvino/camstack-yolo26l.xml"),
-				sizeMB: 95,
-				runtimes: ["python"]
-			}
+			openvino: ovFormat(hf("objectDetection/yolo26/openvino/camstack-yolo26l.xml"), 95)
 		}
 	},
 	{
@@ -1003,11 +1239,7 @@ var OBJECT_DETECTION_MODELS = [
 				files: [...MLPACKAGE_FILES],
 				runtimes: ["python"]
 			},
-			openvino: {
-				url: hf("objectDetection/yolo26/openvino/camstack-yolo26x.xml"),
-				sizeMB: 213,
-				runtimes: ["python"]
-			}
+			openvino: ovFormat(hf("objectDetection/yolo26/openvino/camstack-yolo26x.xml"), 213)
 		}
 	},
 	{
@@ -1032,11 +1264,7 @@ var OBJECT_DETECTION_MODELS = [
 				files: [...MLPACKAGE_FILES],
 				runtimes: ["python"]
 			},
-			openvino: {
-				url: hfScrypted("openvino/scrypted_yolov9t_relu/best.xml"),
-				sizeMB: 6,
-				runtimes: ["python"]
-			}
+			openvino: ovFormat(hf("objectDetection/scrypted-yolov9-relu/openvino/scrypted_yolov9t_relu.xml"), 6)
 		}
 	},
 	{
@@ -1061,11 +1289,7 @@ var OBJECT_DETECTION_MODELS = [
 				files: [...MLPACKAGE_FILES],
 				runtimes: ["python"]
 			},
-			openvino: {
-				url: hfScrypted("openvino/scrypted_yolov9s_relu/best.xml"),
-				sizeMB: 16,
-				runtimes: ["python"]
-			}
+			openvino: ovFormat(hf("objectDetection/scrypted-yolov9-relu/openvino/scrypted_yolov9s_relu.xml"), 16)
 		}
 	},
 	{
@@ -1090,11 +1314,7 @@ var OBJECT_DETECTION_MODELS = [
 				files: [...MLPACKAGE_FILES],
 				runtimes: ["python"]
 			},
-			openvino: {
-				url: hfScrypted("openvino/scrypted_yolov9c_relu/best.xml"),
-				sizeMB: 49,
-				runtimes: ["python"]
-			}
+			openvino: ovFormat(hf("objectDetection/scrypted-yolov9-relu/openvino/scrypted_yolov9c_relu.xml"), 49)
 		}
 	},
 	{
@@ -1119,11 +1339,7 @@ var OBJECT_DETECTION_MODELS = [
 				files: [...MLPACKAGE_FILES],
 				runtimes: ["python"]
 			},
-			openvino: {
-				url: hfScrypted("openvino/scrypted_yolov9m_relu/best.xml"),
-				sizeMB: 38,
-				runtimes: ["python"]
-			}
+			openvino: ovFormat(hf("objectDetection/scrypted-yolov9-relu/openvino/scrypted_yolov9m_relu.xml"), 38)
 		}
 	}
 ];
@@ -1152,11 +1368,7 @@ var FACE_DETECTION_MODELS = [{
 			files: [...MLPACKAGE_FILES],
 			runtimes: ["python"]
 		},
-		openvino: {
-			url: hf("faceDetection/scrfd/openvino/camstack-scrfd-2.5g.xml"),
-			sizeMB: 1.8,
-			runtimes: ["python"]
-		}
+		openvino: ovFormat(hf("faceDetection/scrfd/openvino/camstack-scrfd-2.5g.xml"), 1.8)
 	}
 }, {
 	id: "scrypted-yolov9t-face",
@@ -1183,11 +1395,7 @@ var FACE_DETECTION_MODELS = [{
 			files: [...MLPACKAGE_FILES],
 			runtimes: ["python"]
 		},
-		openvino: {
-			url: hfScrypted("openvino/scrypted_yolov9t_relu_face/best.xml"),
-			sizeMB: 6,
-			runtimes: ["python"]
-		}
+		openvino: ovFormat(hf("faceDetection/scrypted-yolov9-face/openvino/scrypted_yolov9t_relu_face.xml"), 6)
 	}
 }];
 var FACE_EMBEDDING_MODELS = [{
@@ -1217,11 +1425,7 @@ var FACE_EMBEDDING_MODELS = [{
 			files: [...MLPACKAGE_FILES],
 			runtimes: ["python"]
 		},
-		openvino: {
-			url: hf("faceRecognition/arcface/openvino/camstack-arcface-r100.xml"),
-			sizeMB: 65,
-			runtimes: ["python"]
-		}
+		openvino: ovFormat(hf("faceRecognition/arcface/openvino/camstack-arcface-r100.xml"), 65)
 	}
 }, {
 	id: "inception-resnet-v1",
@@ -1248,11 +1452,7 @@ var FACE_EMBEDDING_MODELS = [{
 			files: [...MLPACKAGE_FILES],
 			runtimes: ["python"]
 		},
-		openvino: {
-			url: hfScrypted("openvino/inception_resnet_v1/best.xml"),
-			sizeMB: 45,
-			runtimes: ["python"]
-		}
+		openvino: ovFormat(hf("faceRecognition/inception-resnet-v1/openvino/camstack-inception-resnet-v1.xml"), 45)
 	}
 }];
 var PLATE_DETECTION_MODELS = [{
@@ -1280,11 +1480,7 @@ var PLATE_DETECTION_MODELS = [{
 			files: [...MLPACKAGE_FILES],
 			runtimes: ["python"]
 		},
-		openvino: {
-			url: hf("plateDetection/yolov8-plate/openvino/camstack-yolov8n-plate.xml"),
-			sizeMB: 6.1,
-			runtimes: ["python"]
-		}
+		openvino: ovFormat(hf("plateDetection/yolov8-plate/openvino/camstack-yolov8n-plate.xml"), 6.1)
 	}
 }];
 var PLATE_OCR_MODELS = [{
@@ -1312,11 +1508,7 @@ var PLATE_OCR_MODELS = [{
 			files: [...MLPACKAGE_FILES],
 			runtimes: ["python"]
 		},
-		openvino: {
-			url: hfScrypted("openvino/vgg_english_g2/best.xml"),
-			sizeMB: 7.2,
-			runtimes: ["python"]
-		}
+		openvino: ovFormat(hf("plateRecognition/vgg_english_g2/openvino/vgg_english_g2.xml"), 7.2)
 	}
 }];
 var ANIMAL_CLASSIFIER_MODELS = [{
@@ -1345,11 +1537,7 @@ var ANIMAL_CLASSIFIER_MODELS = [{
 			files: [...MLPACKAGE_FILES],
 			runtimes: ["python"]
 		},
-		openvino: {
-			url: hf("animalClassification/animals-10/openvino/camstack-animals-10.xml"),
-			sizeMB: 164,
-			runtimes: ["python"]
-		}
+		openvino: ovFormat(hf("animalClassification/animals-10/openvino/camstack-animals-10.xml"), 164)
 	}
 }];
 var BIRD_CLASSIFIER_MODELS = [{
@@ -1378,11 +1566,7 @@ var BIRD_CLASSIFIER_MODELS = [{
 			files: [...MLPACKAGE_FILES],
 			runtimes: ["python"]
 		},
-		openvino: {
-			url: hf("animalClassification/bird-nabirds/openvino/camstack-bird-nabirds-404.xml"),
-			sizeMB: 47,
-			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"),
@@ -1416,11 +1600,7 @@ var VEHICLE_CLASSIFIER_MODELS = [{
 			files: [...MLPACKAGE_FILES],
 			runtimes: ["python"]
 		},
-		openvino: {
-			url: hf("vehicleClassification/efficientnet/openvino/camstack-vehicle-type-efficientnet.xml"),
-			sizeMB: 68,
-			runtimes: ["python"]
-		}
+		openvino: ovFormat(hf("vehicleClassification/efficientnet/openvino/camstack-vehicle-type-efficientnet.xml"), 68)
 	},
 	extraFiles: [{
 		url: hf("vehicleClassification/efficientnet/camstack-vehicle-type-labels.json"),
@@ -1453,11 +1633,7 @@ var SEGMENTATION_REFINER_MODELS = [{
 			files: [...MLPACKAGE_FILES],
 			runtimes: ["python"]
 		},
-		openvino: {
-			url: hf("segmentationRefiner/u2netp/openvino/camstack-u2netp.xml"),
-			sizeMB: 2.5,
-			runtimes: ["python"]
-		}
+		openvino: ovFormat(hf("segmentationRefiner/u2netp/openvino/camstack-u2netp.xml"), 2.5)
 	}
 }];
 var INSTANCE_SEGMENTATION_MODELS = [
@@ -1483,11 +1659,7 @@ var INSTANCE_SEGMENTATION_MODELS = [
 				files: [...MLPACKAGE_FILES],
 				runtimes: ["python"]
 			},
-			openvino: {
-				url: hf("segmentation/yolo26-seg/openvino/camstack-yolo26n-seg.xml"),
-				sizeMB: 11,
-				runtimes: ["python"]
-			}
+			openvino: ovFormat(hf("segmentation/yolo26-seg/openvino/camstack-yolo26n-seg.xml"), 11)
 		}
 	},
 	{
@@ -1512,11 +1684,7 @@ var INSTANCE_SEGMENTATION_MODELS = [
 				files: [...MLPACKAGE_FILES],
 				runtimes: ["python"]
 			},
-			openvino: {
-				url: hf("segmentation/yolo26-seg/openvino/camstack-yolo26s-seg.xml"),
-				sizeMB: 40,
-				runtimes: ["python"]
-			}
+			openvino: ovFormat(hf("segmentation/yolo26-seg/openvino/camstack-yolo26s-seg.xml"), 40)
 		}
 	},
 	{
@@ -1541,11 +1709,7 @@ var INSTANCE_SEGMENTATION_MODELS = [
 				files: [...MLPACKAGE_FILES],
 				runtimes: ["python"]
 			},
-			openvino: {
-				url: hf("segmentation/yolo26-seg/openvino/camstack-yolo26m-seg.xml"),
-				sizeMB: 90,
-				runtimes: ["python"]
-			}
+			openvino: ovFormat(hf("segmentation/yolo26-seg/openvino/camstack-yolo26m-seg.xml"), 90)
 		}
 	}
 ];
@@ -1561,16 +1725,12 @@ var AUDIO_CLASSIFIER_MODELS = [{
 	preprocessMode: "resize",
 	formats: {
 		onnx: {
-			url: hf("audioClassifier/yamnet/onnx/camstack-yamnet.onnx"),
+			url: hf("audioClassification/yamnet/onnx/camstack-yamnet.onnx"),
 			sizeMB: 3.2
 		},
-		openvino: {
-			url: hf("audioClassifier/yamnet/onnx/camstack-yamnet.onnx"),
-			sizeMB: 3.2,
-			runtimes: ["python"]
-		},
+		openvino: ovFormat(hf("audioClassification/yamnet/openvino/camstack-yamnet.xml"), 3.2),
 		coreml: {
-			url: hf("audioClassifier/yamnet/onnx/camstack-yamnet.onnx"),
+			url: hf("audioClassification/yamnet/onnx/camstack-yamnet.onnx"),
 			sizeMB: 3.2,
 			runtimes: ["python"]
 		}
@@ -2158,71 +2318,174 @@ var EngineFactory = class {
 	}
 };
 //#endregion
-//#region src/detection-pipeline/postprocess/dispatch.ts
-var VALID_KINDS = new Set([
-	"detections",
-	"classifications",
-	"embedding",
-	"text",
-	"mask"
-]);
-/**
-* Type guard: validates that a structured payload from the Python pool is a
-* well-formed StepOutput discriminated union.
-*
-* The Python inference_pool.py always sets `output.structured` with a `kind`
-* field. This guard narrows `Record<string, unknown>` to `StepOutput` without
-* resorting to double-cast.
-*/
-function isStepOutput(value) {
-	return typeof value === "object" && value !== null && typeof value["kind"] === "string" && VALID_KINDS.has(value["kind"]);
-}
-/**
-* Return the structured payload as `StepOutput`, or null if it fails validation.
-* Callers must handle null by proceeding to raw-tensor postprocessing.
-*/
-function tryStructured(output) {
-	if (!output.structured) return null;
-	if (!isStepOutput(output.structured)) throw new Error(`Python pool returned structured output with unexpected kind: ${JSON.stringify(output.structured["kind"])}`);
-	return output.structured;
-}
-function postprocessYolo(output, stepDef) {
-	const structured = tryStructured(output);
-	if (structured) return structured;
-	const tensor = output.tensor;
-	if (!tensor) throw new Error("YOLO postprocessor: no tensor in engine output");
-	const labels = stepDef.labels ?? [];
-	const numClasses = labels.length || 80;
-	const numBoxes = tensor.length / (4 + numClasses);
-	const letterbox = output.letterbox;
-	const dets = [];
-	for (let i = 0; i < numBoxes; i++) {
-		const cx = tensor[0 * numBoxes + i];
-		const cy = tensor[1 * numBoxes + i];
-		const w = tensor[2 * numBoxes + i];
-		const h = tensor[3 * numBoxes + i];
-		let bestScore = -Infinity;
-		let bestClass = 0;
-		for (let j = 0; j < numClasses; j++) {
-			const score = tensor[(4 + j) * numBoxes + i];
-			if (score > bestScore) {
-				bestScore = score;
-				bestClass = j;
-			}
-		}
-		if (bestScore <= 0) continue;
-		let x1 = cx - w / 2;
-		let y1 = cy - h / 2;
-		let x2 = cx + w / 2;
-		let y2 = cy + h / 2;
-		if (letterbox) {
-			x1 = (x1 - letterbox.padX) / letterbox.scale;
-			y1 = (y1 - letterbox.padY) / letterbox.scale;
-			x2 = (x2 - letterbox.padX) / letterbox.scale;
-			y2 = (y2 - letterbox.padY) / letterbox.scale;
-		}
-		const label = labels[bestClass] ?? String(bestClass);
-		dets.push({
+//#region src/detection-pipeline/engine-provisioner.ts
+/** Incremental backoff growing to a ~5 min cap; retries indefinitely at cap. */
+var BACKOFF_SCHEDULE_MS = [
+	5e3,
+	15e3,
+	3e4,
+	6e4,
+	12e4,
+	3e5
+];
+var IDLE_STATE = {
+	runtimeId: null,
+	device: null,
+	state: "idle"
+};
+var EngineProvisioner = class {
+	fx;
+	current = IDLE_STATE;
+	/** Bumped on every select/dispose — stale async results (old generation) are ignored. */
+	generation = 0;
+	cancelTimer = null;
+	retryIndex = 0;
+	constructor(fx) {
+		this.fx = fx;
+	}
+	get state() {
+		return this.current;
+	}
+	isReady() {
+		return this.current.state === "ready";
+	}
+	select(runtimeId, device) {
+		this.generation++;
+		this.retryIndex = 0;
+		this.clearTimer();
+		this.transition({
+			runtimeId,
+			device,
+			state: "installing",
+			progress: 0
+		});
+		this.provision(this.generation, runtimeId, device);
+	}
+	dispose() {
+		this.generation++;
+		this.clearTimer();
+	}
+	clearTimer() {
+		if (this.cancelTimer !== null) {
+			this.cancelTimer();
+			this.cancelTimer = null;
+		}
+	}
+	transition(next) {
+		this.current = next;
+		this.fx.onChange(next);
+	}
+	async provision(gen, runtimeId, device) {
+		try {
+			await Promise.all([this.fx.installRequirements(this.fx.requirementsFor(runtimeId)), this.fx.ensureModelForFormat(this.fx.modelFormatFor(runtimeId))]);
+			if (gen !== this.generation) return;
+			this.transition({
+				runtimeId,
+				device,
+				state: "verifying",
+				progress: 100
+			});
+			await this.fx.verify(runtimeId, device);
+			if (gen !== this.generation) return;
+			this.retryIndex = 0;
+			this.transition({
+				runtimeId,
+				device,
+				state: "ready"
+			});
+		} catch (err) {
+			if (gen !== this.generation) return;
+			const message = err instanceof Error ? err.message : String(err);
+			const delay = BACKOFF_SCHEDULE_MS[Math.min(this.retryIndex, BACKOFF_SCHEDULE_MS.length - 1)];
+			this.retryIndex++;
+			const nextRetryAt = this.fx.now() + delay;
+			this.transition({
+				runtimeId,
+				device,
+				state: "failed",
+				error: message,
+				nextRetryAt
+			});
+			this.cancelTimer = this.fx.setTimer(delay, () => {
+				if (gen !== this.generation) return;
+				this.cancelTimer = null;
+				this.transition({
+					runtimeId,
+					device,
+					state: "installing",
+					progress: 0
+				});
+				this.provision(gen, runtimeId, device);
+			});
+		}
+	}
+};
+//#endregion
+//#region src/detection-pipeline/postprocess/dispatch.ts
+var VALID_KINDS = new Set([
+	"detections",
+	"classifications",
+	"embedding",
+	"text",
+	"mask"
+]);
+/**
+* Type guard: validates that a structured payload from the Python pool is a
+* well-formed StepOutput discriminated union.
+*
+* The Python inference_pool.py always sets `output.structured` with a `kind`
+* field. This guard narrows `Record<string, unknown>` to `StepOutput` without
+* resorting to double-cast.
+*/
+function isStepOutput(value) {
+	return typeof value === "object" && value !== null && typeof value["kind"] === "string" && VALID_KINDS.has(value["kind"]);
+}
+/**
+* Return the structured payload as `StepOutput`, or null if it fails validation.
+* Callers must handle null by proceeding to raw-tensor postprocessing.
+*/
+function tryStructured(output) {
+	if (!output.structured) return null;
+	if (!isStepOutput(output.structured)) throw new Error(`Python pool returned structured output with unexpected kind: ${JSON.stringify(output.structured["kind"])}`);
+	return output.structured;
+}
+function postprocessYolo(output, stepDef) {
+	const structured = tryStructured(output);
+	if (structured) return structured;
+	const tensor = output.tensor;
+	if (!tensor) throw new Error("YOLO postprocessor: no tensor in engine output");
+	const labels = stepDef.labels ?? [];
+	const numClasses = labels.length || 80;
+	const numBoxes = tensor.length / (4 + numClasses);
+	const letterbox = output.letterbox;
+	const dets = [];
+	for (let i = 0; i < numBoxes; i++) {
+		const cx = tensor[i];
+		const cy = tensor[1 * numBoxes + i];
+		const w = tensor[2 * numBoxes + i];
+		const h = tensor[3 * numBoxes + i];
+		let bestScore = -Infinity;
+		let bestClass = 0;
+		for (let j = 0; j < numClasses; j++) {
+			const score = tensor[(4 + j) * numBoxes + i];
+			if (score > bestScore) {
+				bestScore = score;
+				bestClass = j;
+			}
+		}
+		if (bestScore <= 0) continue;
+		let x1 = cx - w / 2;
+		let y1 = cy - h / 2;
+		let x2 = cx + w / 2;
+		let y2 = cy + h / 2;
+		if (letterbox) {
+			x1 = (x1 - letterbox.padX) / letterbox.scale;
+			y1 = (y1 - letterbox.padY) / letterbox.scale;
+			x2 = (x2 - letterbox.padX) / letterbox.scale;
+			y2 = (y2 - letterbox.padY) / letterbox.scale;
+		}
+		const label = labels[bestClass] ?? String(bestClass);
+		dets.push({
 			class: label,
 			score: bestScore,
 			bbox: [
@@ -2353,7 +2616,7 @@ function postprocessArcface(output, _stepDef) {
 	let sumSq = 0;
 	for (let i = 0; i < tensor.length; i++) sumSq += tensor[i] * tensor[i];
 	const norm = Math.sqrt(sumSq);
-	const normalized = new Array(tensor.length);
+	const normalized = Array.from({ length: tensor.length });
 	for (let i = 0; i < tensor.length; i++) normalized[i] = norm === 0 ? 0 : tensor[i] / norm;
 	return {
 		kind: "embedding",
@@ -3389,403 +3652,143 @@ var PipelineExecutor = class {
 		return output;
 	}
 	async executeChildren(children, parentDetection, fullFrameJpegProvider, imageWidth, imageHeight, traceBuilder, stepTimings, ctx, poolAgg) {
-		for (const child of children) {
-			if (!this.matchesInputClasses(parentDetection.macroClass, child.inputClasses)) continue;
-			const minParentScore = child.settings?.minParentScore ?? child.definition?.defaultMinParentScore;
-			if (typeof minParentScore === "number" && parentDetection.score < minParentScore) continue;
-			if (isBboxDegenerate(parentDetection.bbox)) continue;
-			try {
-				const childStart = Date.now();
-				const fullFrameJpeg = await fullFrameJpegProvider();
-				const modelEntry = child.definition.models.find((m) => m.id === child.modelId);
-				let cropJpegBuf;
-				let cropW;
-				let cropH;
-				if (modelEntry?.faceAlignment) {
-					const minFaceSize = typeof child.settings?.["minFaceSize"] === "number" ? child.settings["minFaceSize"] : DEFAULT_MIN_FACE_SIZE_PX;
-					if (bboxShortSide(parentDetection.bbox) < minFaceSize) continue;
-					const lms = parentDetection.landmarks;
-					if (lms && lms.length >= 5) {
-						const aligned = await alignFaceCrop(fullFrameJpeg, parentDetection.bbox, lms, imageWidth, imageHeight, { outSize: modelEntry.inputSize.width });
-						cropJpegBuf = aligned.jpeg;
-						cropW = aligned.width;
-						cropH = aligned.height;
-					} else {
-						const crop = await cropJpeg(fullFrameJpeg, parentDetection.bbox, imageWidth, imageHeight);
-						cropJpegBuf = crop.jpeg;
-						cropW = crop.width;
-						cropH = crop.height;
-					}
-				} else {
-					const crop = await cropJpeg(fullFrameJpeg, parentDetection.bbox, imageWidth, imageHeight);
-					cropJpegBuf = crop.jpeg;
-					cropW = crop.width;
-					cropH = crop.height;
-				}
-				const childOutput = await this.executeStep(child, {
-					kind: "jpeg",
-					data: cropJpegBuf
-				}, cropW, cropH, "crop-roi", parentDetection.bbox, parentDetection.macroClass, traceBuilder, stepTimings, poolAgg);
-				const childMs = Date.now() - childStart;
-				const detailsBefore = ctx.details.length;
-				applyChildOutput(parentDetection, child, childOutput, childMs, ctx);
-				if (childOutput.kind === "detections" && child.children.length > 0) {
-					const newDetails = ctx.details.slice(detailsBefore);
-					for (const detail of newDetails) {
-						detail.bbox = transformBboxToImageSpace(detail.bbox, parentDetection.bbox);
-						if (detail.landmarks) {
-							const [px1, py1] = parentDetection.bbox;
-							detail.landmarks = detail.landmarks.map((l) => ({
-								x: l.x + px1,
-								y: l.y + py1
-							}));
-						}
-						await this.executeChildren(child.children, detail, fullFrameJpegProvider, imageWidth, imageHeight, traceBuilder, stepTimings, ctx, poolAgg);
-					}
-				}
-			} catch {}
-		}
-	}
-	matchesInputClasses(className, inputClasses) {
-		if (inputClasses.length === 0) return true;
-		return inputClasses.includes(className);
-	}
-	/**
-	* Apply the object-detection step's macro filter + per-macro
-	* minConfidence sliders introduced in the Phase 6 step rework.
-	*
-	* Expected `settings` shape:
-	*   - `enabledMacroClasses`: readonly string[] (e.g. ['person','vehicle','animal']).
-	*     Empty array = all allowed (legacy behaviour).
-	*   - `minConfidence<Macro>`: number (e.g. `minConfidencePerson: 0.5`)
-	*/
-	matchesMacroFilter(macroClass, score, settings) {
-		if (!settings) return true;
-		const enabled = settings["enabledMacroClasses"];
-		if (Array.isArray(enabled) && enabled.length > 0) {
-			if (!enabled.includes(macroClass)) return false;
-		}
-		const perMacroThreshold = settings[`minConfidence${capitalize(macroClass)}`];
-		if (typeof perMacroThreshold === "number" && score < perMacroThreshold) return false;
-		return true;
-	}
-};
-function capitalize(s) {
-	if (s.length === 0) return s;
-	return s.charAt(0).toUpperCase() + s.slice(1);
-}
-//#endregion
-//#region src/detection-pipeline/pipeline/tree-builder.ts
-/**
-* Build an executable tree from user config.
-*
-* @param steps - User-configured pipeline steps (from PipelineDefaultStep[])
-* @param getEngine - Function that returns an IInferenceEngine for a step ID.
-*                    Throws if step not loaded.
-*/
-function buildExecutableTree(steps, getEngine) {
-	return { roots: steps.filter((s) => s.enabled).filter((s) => s.slot !== "audio-classifier").map((s) => buildNode(s, getEngine)) };
-}
-function buildNode(step, getEngine) {
-	const definition = getStepDefinition(step.addonId);
-	const engine = getEngine(step.addonId);
-	const children = (step.children ?? []).filter((c) => c.enabled).map((c) => buildNode(c, getEngine));
-	const mergedSettings = {
-		...collectSchemaDefaults(step.addonId),
-		...step.settings
-	};
-	return {
-		stepId: step.addonId,
-		definition,
-		engine,
-		modelId: step.modelId,
-		inputClasses: definition.inputClasses ?? [],
-		enabled: step.enabled,
-		children,
-		...Object.keys(mergedSettings).length > 0 ? { settings: mergedSettings } : {}
-	};
-}
-/**
-* Walk the step's declared `getConfigSchema()` and collect every field
-* with a primitive `default` value into a plain record. Group fields
-* are flattened — a nested `{ type: 'group', fields: [...] }` is
-* entered recursively. Fields without a declared default are skipped.
-*/
-function collectSchemaDefaults(stepId) {
-	const schema = getStep(stepId).getConfigSchema();
-	const out = {};
-	walkFieldsForDefaults(schema, out);
-	return out;
-}
-function walkFieldsForDefaults(fields, out) {
-	for (const field of fields) {
-		if ("type" in field && field.type === "group" && "fields" in field) {
-			walkFieldsForDefaults(field.fields, out);
-			continue;
-		}
-		if ("key" in field && "default" in field && field.default !== void 0) out[field.key] = field.default;
-	}
-}
-//#endregion
-//#region src/detection-pipeline/runtimes.ts
-var AUTO = {
-	value: "auto",
-	label: "Auto"
-};
-var CPU = {
-	value: "cpu",
-	label: "CPU"
-};
-var RUNTIMES = [
-	{
-		id: "onnx",
-		label: "ONNX Runtime",
-		supports: () => true,
-		devices: (hw) => {
-			if (!hw) return [CPU];
-			const out = [CPU];
-			if (hw.gpu?.type === "nvidia") out.push({
-				value: "cuda",
-				label: "CUDA"
-			});
-			if (hw.npu?.type === "apple-ane") out.push({
-				value: "coreml",
-				label: "CoreML EP"
-			});
-			return out;
-		},
-		defaultDevice: "cpu",
-		modelFormat: "onnx",
-		pythonRequirements: ["requirements.txt", "requirements-onnxruntime.txt"],
-		tuning: {
-			concurrency: 4,
-			batchMode: "list",
-			maxBatchSize: 8,
-			intraOpThreads: 0
-		}
-	},
-	{
-		id: "openvino",
-		label: "OpenVINO",
-		supports: (env) => env.arch === "x64" && env.platform !== "darwin" && env.hardware?.gpu?.type === "intel",
-		devices: (hw) => {
-			if (!hw) return [AUTO];
-			const out = [AUTO, CPU];
-			if (hw.gpu?.type === "intel") out.push({
-				value: "gpu",
-				label: "GPU"
-			});
-			if (hw.npu?.type === "intel-npu") out.push({
-				value: "npu",
-				label: "NPU"
-			});
-			return out;
-		},
-		defaultDevice: "auto",
-		modelFormat: "openvino",
-		pythonRequirements: ["requirements.txt", "requirements-openvino.txt"],
-		tuning: {
-			concurrency: 1,
-			batchMode: "none",
-			numStreams: 0
-		}
-	},
-	{
-		id: "coreml",
-		label: "CoreML",
-		supports: (env) => env.platform === "darwin",
-		devices: (hw) => {
-			const all = {
-				value: "all",
-				label: "All (ANE + GPU + CPU)"
-			};
-			if (!hw) return [all];
-			const out = [all];
-			if (hw.npu?.type === "apple-ane") out.push({
-				value: "ane",
-				label: "Apple Neural Engine"
-			});
-			out.push({
-				value: "gpu",
-				label: "GPU"
-			}, CPU);
-			return out;
-		},
-		defaultDevice: "all",
-		modelFormat: "coreml",
-		pythonRequirements: ["requirements.txt", "requirements-coreml.txt"],
-		tuning: {
-			concurrency: 1,
-			batchMode: "none",
-			windowMs: 8,
-			maxBatchSize: 8,
-			numWorkers: 1
-		}
-	}
-];
-function def(id) {
-	const d = RUNTIMES.find((r) => r.id === id);
-	if (!d) throw new Error(`Unknown runtime: ${id}`);
-	return d;
-}
-function supportedRuntimes(env) {
-	return RUNTIMES.filter((r) => r.supports(env)).map((r) => r.id);
-}
-function runtimeDevices(id, hardware) {
-	return def(id).devices(hardware);
-}
-function defaultDeviceFor(id) {
-	return def(id).defaultDevice;
-}
-function pythonRequirementsFor(id) {
-	return def(id).pythonRequirements;
-}
-function modelFormatFor(id) {
-	return def(id).modelFormat;
-}
-function tuningFor(id) {
-	return def(id).tuning;
-}
-function runtimeLabel(id) {
-	return def(id).label;
-}
-/**
-* Proactive-install hint kept for back-compat (re-exported from index.ts).
-* Intel on Linux warrants installing openvino; coremltools covers macOS;
-* openvino has no AMD/NVIDIA backend.
-*/
-function shouldInstallOpenvino(env) {
-	if (env.platform === "darwin") return false;
-	return env.gpu?.type === "intel" || env.npu?.type === "intel-npu";
-}
-//#endregion
-//#region src/detection-pipeline/engine-provisioner.ts
-/** Incremental backoff growing to a ~5 min cap; retries indefinitely at cap. */
-var BACKOFF_SCHEDULE_MS = [
-	5e3,
-	15e3,
-	3e4,
-	6e4,
-	12e4,
-	3e5
-];
-var IDLE_STATE = {
-	runtimeId: null,
-	device: null,
-	state: "idle"
-};
-var EngineProvisioner = class {
-	fx;
-	current = IDLE_STATE;
-	/** Bumped on every select/dispose — stale async results (old generation) are ignored. */
-	generation = 0;
-	cancelTimer = null;
-	retryIndex = 0;
-	constructor(fx) {
-		this.fx = fx;
-	}
-	get state() {
-		return this.current;
-	}
-	isReady() {
-		return this.current.state === "ready";
-	}
-	select(runtimeId, device) {
-		this.generation++;
-		this.retryIndex = 0;
-		this.clearTimer();
-		this.transition({
-			runtimeId,
-			device,
-			state: "installing",
-			progress: 0
-		});
-		this.provision(this.generation, runtimeId, device);
-	}
-	dispose() {
-		this.generation++;
-		this.clearTimer();
-	}
-	clearTimer() {
-		if (this.cancelTimer !== null) {
-			this.cancelTimer();
-			this.cancelTimer = null;
+		for (const child of children) {
+			if (!this.matchesInputClasses(parentDetection.macroClass, child.inputClasses)) continue;
+			const minParentScore = child.settings?.minParentScore ?? child.definition?.defaultMinParentScore;
+			if (typeof minParentScore === "number" && parentDetection.score < minParentScore) continue;
+			if (isBboxDegenerate(parentDetection.bbox)) continue;
+			try {
+				const childStart = Date.now();
+				const fullFrameJpeg = await fullFrameJpegProvider();
+				const modelEntry = child.definition.models.find((m) => m.id === child.modelId);
+				let cropJpegBuf;
+				let cropW;
+				let cropH;
+				if (modelEntry?.faceAlignment) {
+					const minFaceSize = typeof child.settings?.["minFaceSize"] === "number" ? child.settings["minFaceSize"] : DEFAULT_MIN_FACE_SIZE_PX;
+					if (bboxShortSide(parentDetection.bbox) < minFaceSize) continue;
+					const lms = parentDetection.landmarks;
+					if (lms && lms.length >= 5) {
+						const aligned = await alignFaceCrop(fullFrameJpeg, parentDetection.bbox, lms, imageWidth, imageHeight, { outSize: modelEntry.inputSize.width });
+						cropJpegBuf = aligned.jpeg;
+						cropW = aligned.width;
+						cropH = aligned.height;
+					} else {
+						const crop = await cropJpeg(fullFrameJpeg, parentDetection.bbox, imageWidth, imageHeight);
+						cropJpegBuf = crop.jpeg;
+						cropW = crop.width;
+						cropH = crop.height;
+					}
+				} else {
+					const crop = await cropJpeg(fullFrameJpeg, parentDetection.bbox, imageWidth, imageHeight);
+					cropJpegBuf = crop.jpeg;
+					cropW = crop.width;
+					cropH = crop.height;
+				}
+				const childOutput = await this.executeStep(child, {
+					kind: "jpeg",
+					data: cropJpegBuf
+				}, cropW, cropH, "crop-roi", parentDetection.bbox, parentDetection.macroClass, traceBuilder, stepTimings, poolAgg);
+				const childMs = Date.now() - childStart;
+				const detailsBefore = ctx.details.length;
+				applyChildOutput(parentDetection, child, childOutput, childMs, ctx);
+				if (childOutput.kind === "detections" && child.children.length > 0) {
+					const newDetails = ctx.details.slice(detailsBefore);
+					for (const detail of newDetails) {
+						detail.bbox = transformBboxToImageSpace(detail.bbox, parentDetection.bbox);
+						if (detail.landmarks) {
+							const [px1, py1] = parentDetection.bbox;
+							detail.landmarks = detail.landmarks.map((l) => ({
+								x: l.x + px1,
+								y: l.y + py1
+							}));
+						}
+						await this.executeChildren(child.children, detail, fullFrameJpegProvider, imageWidth, imageHeight, traceBuilder, stepTimings, ctx, poolAgg);
+					}
+				}
+			} catch {}
 		}
 	}
-	transition(next) {
-		this.current = next;
-		this.fx.onChange(next);
+	matchesInputClasses(className, inputClasses) {
+		if (inputClasses.length === 0) return true;
+		return inputClasses.includes(className);
 	}
-	async provision(gen, runtimeId, device) {
-		try {
-			await Promise.all([this.fx.installRequirements(this.fx.requirementsFor(runtimeId)), this.fx.ensureModelForFormat(this.fx.modelFormatFor(runtimeId))]);
-			if (gen !== this.generation) return;
-			this.transition({
-				runtimeId,
-				device,
-				state: "verifying",
-				progress: 100
-			});
-			await this.fx.verify(runtimeId, device);
-			if (gen !== this.generation) return;
-			this.retryIndex = 0;
-			this.transition({
-				runtimeId,
-				device,
-				state: "ready"
-			});
-		} catch (err) {
-			if (gen !== this.generation) return;
-			const message = err instanceof Error ? err.message : String(err);
-			const delay = BACKOFF_SCHEDULE_MS[Math.min(this.retryIndex, BACKOFF_SCHEDULE_MS.length - 1)];
-			this.retryIndex++;
-			const nextRetryAt = this.fx.now() + delay;
-			this.transition({
-				runtimeId,
-				device,
-				state: "failed",
-				error: message,
-				nextRetryAt
-			});
-			this.cancelTimer = this.fx.setTimer(delay, () => {
-				if (gen !== this.generation) return;
-				this.cancelTimer = null;
-				this.transition({
-					runtimeId,
-					device,
-					state: "installing",
-					progress: 0
-				});
-				this.provision(gen, runtimeId, device);
-			});
+	/**
+	* Apply the object-detection step's macro filter + per-macro
+	* minConfidence sliders introduced in the Phase 6 step rework.
+	*
+	* Expected `settings` shape:
+	*   - `enabledMacroClasses`: readonly string[] (e.g. ['person','vehicle','animal']).
+	*     Empty array = all allowed (legacy behaviour).
+	*   - `minConfidence<Macro>`: number (e.g. `minConfidencePerson: 0.5`)
+	*/
+	matchesMacroFilter(macroClass, score, settings) {
+		if (!settings) return true;
+		const enabled = settings["enabledMacroClasses"];
+		if (Array.isArray(enabled) && enabled.length > 0) {
+			if (!enabled.includes(macroClass)) return false;
 		}
+		const perMacroThreshold = settings[`minConfidence${capitalize(macroClass)}`];
+		if (typeof perMacroThreshold === "number" && score < perMacroThreshold) return false;
+		return true;
 	}
 };
+function capitalize(s) {
+	if (s.length === 0) return s;
+	return s.charAt(0).toUpperCase() + s.slice(1);
+}
 //#endregion
-//#region src/detection-pipeline/auto-pick.ts
-var PREFERENCE = [
-	"coreml",
-	"openvino",
-	"onnx"
-];
+//#region src/detection-pipeline/pipeline/tree-builder.ts
 /**
-* Pure function — picks the best supported runtime for the given hardware env.
-*
-* Logic:
-* 1. If `bestBackendHint` is in the supported set, use it.
-* 2. Otherwise, walk PREFERENCE order and pick the first supported runtime.
-* 3. Floor to `'onnx'` (always supported).
+* Build an executable tree from user config.
 *
-* Device is always `defaultDeviceFor(chosen)`.
+* @param steps - User-configured pipeline steps (from PipelineDefaultStep[])
+* @param getEngine - Function that returns an IInferenceEngine for a step ID.
+*                    Throws if step not loaded.
 */
-function pickBestRuntime(env, bestBackendHint) {
-	const supported = supportedRuntimes(env);
-	const chosen = supported.find((id) => id === bestBackendHint) ?? PREFERENCE.find((id) => supported.includes(id)) ?? "onnx";
+function buildExecutableTree(steps, getEngine) {
+	return { roots: steps.filter((s) => s.enabled).filter((s) => s.slot !== "audio-classifier").map((s) => buildNode(s, getEngine)) };
+}
+function buildNode(step, getEngine) {
+	const definition = getStepDefinition(step.addonId);
+	const engine = getEngine(step.addonId);
+	const children = (step.children ?? []).filter((c) => c.enabled).map((c) => buildNode(c, getEngine));
+	const mergedSettings = {
+		...collectSchemaDefaults(step.addonId),
+		...step.settings
+	};
 	return {
-		runtimeId: chosen,
-		device: defaultDeviceFor(chosen)
+		stepId: step.addonId,
+		definition,
+		engine,
+		modelId: step.modelId,
+		inputClasses: definition.inputClasses ?? [],
+		enabled: step.enabled,
+		children,
+		...Object.keys(mergedSettings).length > 0 ? { settings: mergedSettings } : {}
 	};
 }
+/**
+* Walk the step's declared `getConfigSchema()` and collect every field
+* with a primitive `default` value into a plain record. Group fields
+* are flattened — a nested `{ type: 'group', fields: [...] }` is
+* entered recursively. Fields without a declared default are skipped.
+*/
+function collectSchemaDefaults(stepId) {
+	const schema = getStep(stepId).getConfigSchema();
+	const out = {};
+	walkFieldsForDefaults(schema, out);
+	return out;
+}
+function walkFieldsForDefaults(fields, out) {
+	for (const field of fields) {
+		if ("type" in field && field.type === "group" && "fields" in field) {
+			walkFieldsForDefaults(field.fields, out);
+			continue;
+		}
+		if ("key" in field && "default" in field && field.default !== void 0) out[field.key] = field.default;
+	}
+}
 //#endregion
 //#region src/detection-pipeline/provider.ts
 /**
@@ -3988,6 +3991,27 @@ function toProbedHardware(hw) {
 		gpu: hw.gpu ? { type: hw.gpu.type } : null
 	};
 }
+var ONNX_FLOOR = {
+	runtime: "python",
+	backend: "onnx",
+	format: "onnx",
+	device: "cpu"
+};
+/**
+* Build the onnx-cpu floor pick using `pickBestRuntime` with a null hardware
+* env.  Used wherever the old `detectBestEngine()` sync probe fell back — the
+* result is identical (onnx / cpu) but is now derived through the shared rules
+* instead of duplicated inline.
+*/
+function onnxFloorPick() {
+	const pick = pickBestRuntime(runtimeEnvFromProcess(null), null);
+	return {
+		runtime: "python",
+		backend: pick.runtimeId,
+		format: modelFormatFor(pick.runtimeId),
+		device: pick.device
+	};
+}
 var DetectionPipelineProvider = class DetectionPipelineProvider {
 	modelsDir;
 	eventBus;
@@ -4046,6 +4070,13 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	*/
 	needsAutoPick = false;
 	/**
+	* Unsubscribe handle for the deferred-auto-pick `platform-probe` ready
+	* listener (armed in `setApi` when the probe isn't ready yet). Cleared once
+	* the engine is resolved — either by the listener firing or by the boot
+	* safety-net `ensureBootEngineProvisioned`.
+	*/
+	deferredAutoPickUnsub = null;
+	/**
 	* Warm cache for benchmark engine-override runs.
 	*
 	* Each override rebuild costs a full Python pool spin-up (~300-500ms)
@@ -4077,8 +4108,8 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 		this.readStore = () => settings.readAddonStore();
 		this.writeStore = (patch) => settings.writeAddonStore(patch);
 		this.readDeviceStore = settings.readDeviceStore ?? (async () => ({}));
-		this.currentEngine = DetectionPipelineProvider.detectBestEngine();
-		this.log.info("Engine selected (default)", { meta: {
+		this.currentEngine = ONNX_FLOOR;
+		this.log.info("Engine pick pending (placeholder until probe / persisted selection)", { meta: {
 			runtime: this.currentEngine.runtime,
 			backend: this.currentEngine.backend,
 			format: this.currentEngine.format
@@ -4143,69 +4174,78 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	isReady() {
 		return this.ready;
 	}
-	/** Detect the best inference engine for this platform. */
-	static detectBestEngine() {
-		const platform = process.platform;
-		const arch = process.arch;
-		if (platform === "darwin" && arch === "arm64") return {
-			runtime: "python",
-			backend: "coreml",
-			format: "coreml",
-			device: "all"
-		};
-		if (platform === "darwin") return {
-			runtime: "python",
-			backend: "coreml",
-			format: "coreml",
-			device: "gpu"
-		};
-		try {
-			const { execFileSync } = __require("node:child_process");
-			execFileSync("nvidia-smi", ["--query-gpu=name", "--format=csv,noheader"], {
-				timeout: 3e3,
-				stdio: "pipe"
-			});
-			return {
-				runtime: "python",
-				backend: "onnx",
-				format: "onnx",
-				device: "cuda"
-			};
-		} catch {}
-		try {
-			const fsmod = __require("node:fs");
-			const isIntel = __require("node:os").cpus()[0]?.model?.includes("Intel") ?? false;
-			const hasIgpu = fsmod.existsSync("/dev/dri/renderD128");
-			const hasNpu = fsmod.existsSync("/dev/accel/accel0") || fsmod.existsSync("/dev/accel");
-			if (isIntel && (hasIgpu || hasNpu)) return {
-				runtime: "python",
-				backend: "openvino",
-				format: "openvino",
-				device: "auto"
-			};
-		} catch {}
-		return {
-			runtime: "python",
-			backend: "onnx",
-			format: "onnx",
-			device: "cpu"
-		};
-	}
 	/** Store the addon context. ctx.api is a lazy getter resolved at call time. */
 	async setApi(addonCtx) {
 		this.addonCtx = addonCtx;
-		if (this.needsAutoPick) {
+		if (this.needsAutoPick) if (this.addonCtx.useCapability("platform-probe").isReady) {
 			await this.autoPickAndPersist();
 			this.needsAutoPick = false;
+			this.startProvisioningForCurrentEngine();
+		} else {
+			const unsubscribe = this.addonCtx.onCapabilityStateChange("platform-probe", { type: "global" }, (state) => {
+				if (state !== "ready") return;
+				this.cancelDeferredAutoPick();
+				if (!this.needsAutoPick) return;
+				this.autoPickAndPersist().then(() => {
+					this.needsAutoPick = false;
+					this.startProvisioningForCurrentEngine();
+				});
+			});
+			this.deferredAutoPickUnsub = unsubscribe;
+			this.addonCtx.addDisposer(() => this.cancelDeferredAutoPick());
 		}
+		else this.startProvisioningForCurrentEngine();
+	}
+	/** Tear down the deferred-auto-pick probe listener, if still armed. */
+	cancelDeferredAutoPick() {
+		if (this.deferredAutoPickUnsub) {
+			this.deferredAutoPickUnsub();
+			this.deferredAutoPickUnsub = null;
+		}
+	}
+	/**
+	* Boot safety-net: deterministically provision the hardware-probed engine.
+	*
+	* Called from the addon's `onInitialize` right after `reprobeEngine` has
+	* written this node's probe-driven selection (e.g. `engineBackend=openvino`)
+	* to the store. When first-boot auto-pick was DEFERRED (probe not ready at
+	* `setApi`), the engine would otherwise stay `idle` — selected but never
+	* provisioned — because the `onCapabilityStateChange('platform-probe')` ready
+	* edge can be missed when the cap is already 'ready' by the time we subscribe
+	* (the old eager-onnx-floor masked this; removing it surfaced a node that
+	* boots with no engine at all). This loads the now-persisted selection and
+	* starts provisioning it, so the node reliably comes up on its real best
+	* engine (openvino on Intel) with no onnx floor and no missed boot. No-op
+	* when provisioning already started (persisted-engine path / listener fired)
+	* or when nothing has been selected yet.
+	*/
+	async ensureBootEngineProvisioned() {
+		if (this.getEngineProvisioning().state !== "idle") return;
+		const stored = await this.loadEngine();
+		if (!stored) return;
+		this.currentEngine = stored;
+		this.needsAutoPick = false;
+		this.cancelDeferredAutoPick();
+		this.log.info("Boot engine provisioning from probed selection", { meta: {
+			runtime: stored.runtime,
+			backend: stored.backend,
+			device: stored.device ?? null
+		} });
 		this.startProvisioningForCurrentEngine();
 	}
 	/**
 	* Auto-pick the best supported runtime at first boot (no stored engine).
 	* Uses the platform-probe cap's hardware + bestScore hint when available;
 	* falls back to platform/arch when the probe cap is not yet reachable.
+	*
 	* Persists the selection as `engineBackend` + `engineDevice` so subsequent
-	* boots load it via `loadEngine()` and skip this path.
+	* boots load it via `loadEngine()` and skip this path — but ONLY when the
+	* probe actually answered (real `hardware` or a `bestScore` hint). If the
+	* probe query failed (cold-start race, cap momentarily unreachable), the
+	* pick floors to onnx purely for lack of information; persisting that would
+	* LOCK onnx and skip auto-pick on every future boot even after the
+	* accelerator surfaces. In that case we set the in-memory floor for liveness
+	* but leave the store untouched so the next boot re-attempts the pick.
 	*/
 	async autoPickAndPersist() {
 		let hardware = null;
@@ -4213,7 +4253,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 		try {
 			const api = this.addonCtx?.api;
 			if (api) {
-				const caps = await api.platformProbe.getCapabilities.query();
+				const caps = await api.platformProbe.getCapabilities.query({ nodeId: this.localProbeNodeId() });
 				hardware = caps?.hardware ?? null;
 				const bs = caps?.bestScore;
 				if (bs && bs.runtime === "python") bestBackendHint = bs.backend;
@@ -4227,9 +4267,17 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 			device: pick.device
 		};
 		this.currentEngine = engine;
+		if (!(hardware !== null || bestBackendHint !== null)) {
+			this.log.warn("Auto-pick: probe returned no hardware/hint — using onnx floor WITHOUT persisting", { meta: {
+				backend: pick.runtimeId,
+				device: pick.device
+			} });
+			return;
+		}
+		const apNode = this.localProbeNodeId();
 		await this.writeStore({
-			engineBackend: pick.runtimeId,
-			engineDevice: pick.device
+			[nodeEngineKey("engineBackend", apNode)]: pick.runtimeId,
+			[nodeEngineKey("engineDevice", apNode)]: pick.device
 		});
 		this.log.info("Auto-picked engine at first boot", { meta: {
 			backend: pick.runtimeId,
@@ -4402,11 +4450,22 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	* callers fall back to the registry's safe minimum. The engine OFFER derives
 	* from hardware ONLY — install state (probe `scores`) never gates it.
 	*/
+	/**
+	* The local Moleculer node id (child-suffix stripped). MUST be passed to every
+	* `platformProbe.getCapabilities` query: the cap is a singleton and a query
+	* with no nodeId resolves to the HUB's probe — so on a remote agent the engine
+	* decision would use the HUB's hardware (e.g. an Intel NPU the agent doesn't
+	* have) and pin a device the node can't run, breaking provisioning.
+	*/
+	localProbeNodeId() {
+		const raw = this.addonCtx?.kernel?.localNodeId ?? "hub";
+		return raw.includes("/") ? raw.split("/")[0] : raw;
+	}
 	async fetchProbeGatingData() {
 		try {
 			const api = this.addonCtx?.api;
 			if (!api) return { hardware: null };
-			return { hardware: (await api.platformProbe.getCapabilities.query())?.hardware ?? null };
+			return { hardware: (await api.platformProbe.getCapabilities.query({ nodeId: this.localProbeNodeId() }))?.hardware ?? null };
 		} catch {
 			return { hardware: null };
 		}
@@ -5471,7 +5530,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 			this.engineFactory = null;
 			this.executor = null;
 		}
-		for (const id of [...this.deviceProxies.keys()]) this.releaseDeviceProxy(id);
+		for (const id of Array.from(this.deviceProxies.keys())) this.releaseDeviceProxy(id);
 	}
 	/**
 	* Resolve and cache a {@link DeviceProxy} for the given camera. Pins
@@ -5655,25 +5714,27 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	* fields (`engineRuntime`, `engineBackend`, `engineDevice`). Fallback
 	* to the legacy `KEY_ENGINE` JSON blob for pre-migration stores.
 	* Returns null when neither source has anything; the caller keeps
-	* whatever `detectBestEngine()` picked at construction.
+	* the onnx floor set at construction until autoPickAndPersist() runs.
 	*/
 	async loadEngine() {
 		const store = await this.readStore();
 		const storedRuntime = store["engineRuntime"];
-		const storedBackend = store["engineBackend"];
+		const node = this.localProbeNodeId();
+		const storedBackend = readNodeEngineValue(store, "engineBackend", node);
 		if (typeof storedBackend === "string" && storedBackend.length > 0) {
 			const backend = storedBackend;
-			const storedDevice = typeof store["engineDevice"] === "string" ? String(store["engineDevice"]) : "";
-			const detected = DetectionPipelineProvider.detectBestEngine();
+			const storedDeviceRaw = readNodeEngineValue(store, "engineDevice", node);
+			const storedDevice = typeof storedDeviceRaw === "string" ? storedDeviceRaw : "";
+			const floor = onnxFloorPick();
 			const migratedBackend = typeof storedRuntime === "string" && storedRuntime === "node" && backend === "cpu" ? "onnx" : backend;
 			if (!DetectionPipelineProvider.isPythonBackendAvailable(migratedBackend, this.executorOptions.pythonPath ?? "")) {
-				this.log.warn("Stored engine backend unavailable on this node — falling back to detected best", { meta: {
+				this.log.warn("Stored engine backend unavailable on this node — falling back to onnx floor", { meta: {
 					stored: migratedBackend,
-					fallback: `${detected.backend}`
+					fallback: `${floor.backend}`
 				} });
-				return detected;
+				return floor;
 			}
-			const device = storedDevice || detected.device;
+			const device = storedDevice || floor.device;
 			return {
 				runtime: "python",
 				backend: migratedBackend,
@@ -5845,18 +5906,14 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 		const api = this.addonCtx?.api;
 		let best;
 		if (api) try {
-			const caps = await api.platformProbe.getCapabilities.query();
+			const caps = await api.platformProbe.getCapabilities.query({ nodeId: this.localProbeNodeId() });
 			const bs = caps?.bestScore;
 			if (bs && bs.runtime === "python") {
 				const probeBackend = bs.backend;
 				const probeDevice = (() => {
 					const hw = caps.hardware;
-					if (probeBackend === "coreml") return hw?.npu?.type === "apple-ane" ? "ane" : "all";
-					if (probeBackend === "openvino") {
-						if (hw?.npu?.type === "intel-npu") return "npu";
-						if (hw?.gpu?.type === "intel") return "gpu";
-						return "auto";
-					}
+					if (probeBackend === "openvino") return defaultDeviceFor("openvino");
+					if (probeBackend === "coreml") return defaultDeviceFor("coreml");
 					if (probeBackend === "onnx") return hw?.gpu?.type === "nvidia" ? "cuda" : "cpu";
 					return "cpu";
 				})();
@@ -5866,16 +5923,17 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 					format: backendToFormat(probeBackend),
 					device: probeDevice
 				};
-			} else best = DetectionPipelineProvider.detectBestEngine();
+			} else best = onnxFloorPick();
 		} catch {
-			best = DetectionPipelineProvider.detectBestEngine();
+			best = onnxFloorPick();
 		}
-		else best = DetectionPipelineProvider.detectBestEngine();
+		else best = onnxFloorPick();
 		const probedLabel = `${best.backend}/${best.device ?? "default"}`;
+		const rpNode = this.localProbeNodeId();
 		await this.writeStore({
-			probedBestEngine: probedLabel,
-			engineBackend: best.backend,
-			engineDevice: best.device ?? "cpu"
+			[nodeEngineKey("probedBestEngine", rpNode)]: probedLabel,
+			[nodeEngineKey("engineBackend", rpNode)]: best.backend,
+			[nodeEngineKey("engineDevice", rpNode)]: best.device ?? "cpu"
 		});
 		this.log.info("Re-probed engine — wrote back engineBackend + engineDevice", { meta: {
 			backend: best.backend,
@@ -6298,7 +6356,8 @@ var DEFAULT_CONFIG = {
 	engineRuntime: "python",
 	engineBackend: "onnx",
 	engineDevice: "cpu",
-	probedBestEngine: ""
+	probedBestEngine: "",
+	activeEngine: ""
 };
 /** Derive the model-format from a backend value. Called by the provider. */
 function backendToFormat(backend) {
@@ -6341,6 +6400,15 @@ var POOL_BOUND_KEYS = [
 ];
 var DetectionPipelineAddon = class extends BaseAddon {
 	provider = null;
+	/** Last non-null probed hardware PER NODE — reused when the probe transiently
+	*  returns null so offered backends / device lists don't collapse. Keyed by
+	*  node because the hub addon probes other nodes when serving their config. */
+	lastGoodHardwareByNode = /* @__PURE__ */ new Map();
+	/** This node's effective engine selection, cached from the node-scoped store
+	*  so the synchronous `resolveBackendTuning` and the reprobe gate don't read
+	*  the cluster-shared bare keys. Refreshed at init + on every config change. */
+	nodeEngineBackend = DEFAULT_CONFIG.engineBackend;
+	nodeProbedBestEngine = "";
 	engineMetricsTimer = null;
 	/** Snapshot-equality cache for engine-metrics emit. Most ticks
 	*  the engine inventory is unchanged (no model load/unload), so
@@ -6395,6 +6463,14 @@ var DetectionPipelineAddon = class extends BaseAddon {
 						tooltip: "Re-probe engine"
 					}]
 				}),
+				this.field({
+					type: "text",
+					key: "activeEngine",
+					label: "Active engine",
+					description: "The runtime/device the inference pool ACTUALLY loaded on this node, with its provisioning state (format: provider/device (state)). If this differs from the selected provider below — e.g. \"onnx/cpu (ready)\" while OpenVINO is selected — the chosen accelerator could not load on this host and the engine fell back to the ONNX-CPU baseline.",
+					readonlyField: true,
+					default: ""
+				}),
 				this.field({
 					type: "select",
 					key: "engineBackend",
@@ -6531,14 +6607,18 @@ var DetectionPipelineAddon = class extends BaseAddon {
 	* probe is unreachable). Stored backend / device snap back to the registry
 	* floor / default when they fall outside the offered set.
 	*/
-	async getGlobalSettings(overlay) {
-		const ctx = this.ctxIfReady;
-		const stored = ctx?.settings ? await ctx.settings.readAddonStore() ?? {} : {};
+	async getGlobalSettings(overlay, _cap, nodeId) {
+		const targetNode = nodeId ? normalizeEngineNodeId(nodeId) : this.localNodeId();
+		const rawStored = await this.resolveUiSettingsStore();
+		if (rawStored === null) return null;
+		const stored = projectNodeEngine(rawStored, targetNode);
+		const storedBackendRaw = stored["engineBackend"];
+		if (typeof storedBackendRaw !== "string" || storedBackendRaw === "") return null;
 		const merged = overlay ? {
 			...stored,
 			...overlay
 		} : stored;
-		const env = await this.probeHardwareEnv();
+		const env = await this.probeHardwareEnv(targetNode);
 		const hardware = env.hardware;
 		const offered = supportedRuntimes(env);
 		const runtimeBackends = offered.map((id) => ({
@@ -6546,14 +6626,22 @@ var DetectionPipelineAddon = class extends BaseAddon {
 			label: runtimeLabel(id)
 		}));
 		const storedBackend = typeof merged.engineBackend === "string" ? merged.engineBackend : "";
-		const backend = offered.find((id) => id === storedBackend) ?? offered[0] ?? "onnx";
+		const backend = (() => {
+			const rid = toRuntimeId(storedBackend);
+			if (rid === "onnx") return "onnx";
+			if (offered.includes(rid)) return rid;
+			return rid === "openvino" && env.platform !== "darwin" && env.arch === "x64" || rid === "coreml" && env.platform === "darwin" ? rid : offered[0] ?? "onnx";
+		})();
 		const deviceOptions = runtimeDevices(backend, hardware);
 		const storedDevice = typeof merged.engineDevice === "string" ? merged.engineDevice : "";
 		const device = deviceOptions.find((d) => d.value === storedDevice)?.value ?? defaultDeviceFor(backend);
+		const prov = targetNode === this.localNodeId() ? this.provider?.getEngineProvisioning() : void 0;
+		const activeEngine = prov && prov.runtimeId ? `${prov.runtimeId}/${prov.device ?? "default"} (${prov.state})` : "";
 		const raw = {
 			...merged,
 			engineBackend: backend,
-			engineDevice: device
+			engineDevice: device,
+			activeEngine
 		};
 		const schema = this.globalSettingsSchema();
 		if (!schema) return { sections: [] };
@@ -6584,15 +6672,15 @@ var DetectionPipelineAddon = class extends BaseAddon {
 					if (field.type === "slider" && "key" in field) {
 						const tuned = tuning[field.key];
 						const sliderField = field;
-						let patched = typeof tuned === "number" ? {
+						let patchedField = typeof tuned === "number" ? {
 							...sliderField,
 							default: tuned
 						} : sliderField;
-						if (sliderField.key === "concurrency" && backend === "coreml") patched = {
-							...patched,
+						if (sliderField.key === "concurrency" && backend === "coreml") patchedField = {
+							...patchedField,
 							max: 4
 						};
-						return patched;
+						return patchedField;
 					}
 					return field;
 				})
@@ -6609,23 +6697,41 @@ var DetectionPipelineAddon = class extends BaseAddon {
 	* Protected seam — overridable by tests (canned hardware) and reused by the
 	* Phase 2 auto-pick path. NEVER reads install state.
 	*/
-	async probeHardwareEnv() {
-		const hardware = await this.resolveProbeHardware();
+	/**
+	* Resolve the persisted UI settings store, or `null` when it can't be read
+	* right now (ctx/settings not wired — mid-restart). A readable-but-empty
+	* store (genuine first boot) returns `{}`, never null. `getGlobalSettings`
+	* uses the null signal to avoid serving fabricated empty-store defaults
+	* during the restart window. Seam kept protected so tests can drive the
+	* unreadable vs empty vs populated cases without faking a full AddonContext.
+	*/
+	async resolveUiSettingsStore() {
+		const settings = this.ctxIfReady?.settings;
+		if (!settings) return null;
+		return await settings.readAddonStore() ?? {};
+	}
+	async probeHardwareEnv(nodeId) {
+		const node = nodeId ?? this.localNodeId();
+		const hardware = await this.resolveProbeHardware(node);
+		if (hardware) this.lastGoodHardwareByNode.set(node, hardware);
+		const effective = hardware ?? this.lastGoodHardwareByNode.get(node) ?? null;
 		return {
 			platform: process.platform,
 			arch: process.arch,
-			hardware
+			hardware: effective
 		};
 	}
 	/**
-	* Fetch the probed hardware from the platform-probe cap. Returns null when
-	* the cap is not reachable (caller falls back to the registry's safe minimum).
+	* Fetch the probed hardware from the platform-probe cap for `nodeId` (default
+	* = self). Returns null when the cap is not reachable (caller falls back to
+	* the registry's safe minimum).
 	*/
-	async resolveProbeHardware() {
+	async resolveProbeHardware(nodeId) {
 		try {
 			const api = this.ctxIfReady?.api;
 			if (!api) return null;
-			const hw = (await api.platformProbe.getCapabilities.query())?.hardware;
+			const node = nodeId ?? this.localNodeId();
+			const hw = (node === this.localNodeId() ? await api.platformProbe.getCapabilities.query() : await api.platformProbe.getCapabilities.query(void 0, nodePin(node)))?.hardware;
 			if (!hw) return null;
 			return {
 				npu: hw.npu ? { type: hw.npu.type } : null,
@@ -6636,6 +6742,61 @@ var DetectionPipelineAddon = class extends BaseAddon {
 		}
 	}
 	/**
+	* Bare node id used to scope the engine cascade in the shared store. MUST
+	* match the provider's `localProbeNodeId()` (kernel.localNodeId, default
+	* 'hub') so the UI write path (this) and the provider read/write path
+	* (loadEngine / autoPick / reprobe) target the SAME `<key>@<nodeId>`. The old
+	* `?? this.ctx.id` fallback resolved to the ADDON id ('detection-pipeline')
+	* when kernel.localNodeId was absent, so UI saves landed on a key the
+	* provider never read — silently losing the per-node selection.
+	*/
+	localNodeId() {
+		return normalizeEngineNodeId(this.ctxIfReady?.kernel?.localNodeId ?? "hub");
+	}
+	/**
+	* Refresh this node's cached engine selection from the node-scoped store.
+	* `resolveBackendTuning` is synchronous and the reprobe gate runs before the
+	* provider exists, so both read these cached fields instead of the
+	* cluster-shared bare keys (which belong to no single node). Best-effort: a
+	* transiently-unreadable store leaves the last cached values in place.
+	*/
+	async refreshNodeEngineFromStore() {
+		const store = await this.resolveUiSettingsStore();
+		if (store === null) return;
+		const node = this.localNodeId();
+		const backend = readNodeEngineValue(store, "engineBackend", node);
+		if (typeof backend === "string" && backend !== "") this.nodeEngineBackend = backend;
+		const probed = readNodeEngineValue(store, "probedBestEngine", node);
+		this.nodeProbedBestEngine = typeof probed === "string" ? probed : "";
+	}
+	/**
+	* Persist a settings patch, mirroring the engine cascade fields to the TARGET
+	* node's scoped keys so each node keeps an INDEPENDENT engine selection in the
+	* cluster-central store. The hub addon serves writes for every node, so it
+	* scopes by the requested `nodeId` (default self).
+	*
+	* When the target IS this node, `super.updateGlobalSettings` drives the normal
+	* apply path (`resolveConfig` / `onConfigChanged` / `requiresRestart` restart),
+	* and the bare engine keys it writes are shadowed by the node-scoped keys on
+	* read. When the target is a SIBLING node, we persist the scoped engine keys +
+	* the non-engine bare keys but DON'T run this node's restart/reprovision — the
+	* owning node applies its own engine selection on its next (re)start.
+	*/
+	async updateGlobalSettings(patch, nodeId) {
+		const targetNode = nodeId ? normalizeEngineNodeId(nodeId) : this.localNodeId();
+		const patchRecord = patch;
+		const scopedEngine = {};
+		for (const key of ENGINE_CASCADE_KEYS) if (key in patchRecord) scopedEngine[nodeEngineKey(key, targetNode)] = patchRecord[key];
+		if (Object.keys(scopedEngine).length > 0) await this.ctxIfReady?.settings?.writeAddonStore(scopedEngine);
+		if (targetNode === this.localNodeId()) {
+			await super.updateGlobalSettings(patch, nodeId);
+			return;
+		}
+		const sharedPatch = {};
+		for (const [k, v] of Object.entries(patchRecord)) if (!ENGINE_CASCADE_KEYS.includes(k)) sharedPatch[k] = v;
+		if (Object.keys(sharedPatch).length > 0) await this.ctxIfReady?.settings?.writeAddonStore(sharedPatch);
+	}
+	/**
 	* Resolve the effective pool tuning for the configured backend.
 	*
 	* Reads the registry's `tuningFor(backend)` and ignores any persisted
@@ -6649,7 +6810,7 @@ var DetectionPipelineAddon = class extends BaseAddon {
 	* a reason to disagree.
 	*/
 	resolveBackendTuning() {
-		const t = tuningFor(toRuntimeId(this.config.engineBackend ?? DEFAULT_CONFIG.engineBackend));
+		const t = tuningFor(toRuntimeId(this.nodeEngineBackend ?? DEFAULT_CONFIG.engineBackend));
 		const num = (v, dflt) => typeof v === "number" && v > 0 ? v : dflt;
 		const batch = (v, dflt) => v === "none" || v === "list" || v === "window" ? v : dflt;
 		return {
@@ -6668,6 +6829,7 @@ var DetectionPipelineAddon = class extends BaseAddon {
 			relativePath: ""
 		}).catch(() => "camstack-data/models");
 		if (!this.ctx.settings) throw new Error("DetectionPipelineAddon: ctx.settings not available");
+		await this.refreshNodeEngineFromStore();
 		this.pythonAddonDir = resolveAddonPythonDir();
 		const py = await ensurePythonReady(this.ctx.deps, this.ctx.logger);
 		if (py.ok && py.pythonPath) this.pythonPath = py.pythonPath;
@@ -6689,9 +6851,12 @@ var DetectionPipelineAddon = class extends BaseAddon {
 		});
 		await this.provider.init();
 		await this.provider.setApi(this.ctx);
-		if (!this.config.probedBestEngine) await this.provider.reprobeEngine().catch((err) => {
+		if (!this.nodeProbedBestEngine) await this.provider.reprobeEngine().catch((err) => {
 			this.ctx.logger.warn("auto-reprobe engine failed", { meta: { error: err instanceof Error ? err.message : String(err) } });
 		});
+		await this.provider.ensureBootEngineProvisioned().catch((err) => {
+			this.ctx.logger.warn("ensureBootEngineProvisioned failed", { meta: { error: err instanceof Error ? err.message : String(err) } });
+		});
 		await this.provider.warmPool();
 		this.engineMetricsTimer = setInterval(() => this.emitEngineMetricsSnapshot(), ENGINE_METRICS_SNAPSHOT_INTERVAL_MS);
 		this.lastAppliedPoolConfig = this.snapshotPoolConfig();
@@ -6741,8 +6906,8 @@ var DetectionPipelineAddon = class extends BaseAddon {
 	/**
 	* Proactively install the OpenVINO Python package when Intel hardware
 	* (iGPU or NPU) is detected. Called once from `onInitialize`, before the
-	* provider is constructed, so the module is available when the platform
-	* probe runs its next `import openvino.runtime` check.
+	* provider is constructed, so the module is RUNNABLE when the engine is
+	* first loaded (gated by `loadEngine`'s `isPythonBackendAvailable` check).
 	*
 	* Failure is non-fatal: a warning is logged and the addon continues with
 	* the onnx-cpu baseline. The hardware query itself is also best-effort —
@@ -6811,6 +6976,7 @@ var DetectionPipelineAddon = class extends BaseAddon {
 	* lifecycle (engineFactory rebuild on next runPipeline).
 	*/
 	async onConfigChanged() {
+		await this.refreshNodeEngineFromStore();
 		if (this.provider) await this.provider.onEngineSelectionChanged().catch((err) => {
 			this.ctx.logger.warn("engine provisioning re-select failed on config change", { meta: { error: err instanceof Error ? err.message : String(err) } });
 		});