@camstack/addon-pipeline 1.0.7 → 1.0.8

package/dist/detection-pipeline/index.js

@@ -3,7 +3,7 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 const require_model_download_service_C7AjBsX9 = require("../model-download-service-C7AjBsX9-rXY-VFDk.js");
-const require_dist = require("../dist-G45MVm6i.js");
+const require_dist = require("../dist-BLcTVvol.js");
 let node_fs = require("node:fs");
 node_fs = require_model_download_service_C7AjBsX9.__toESM(node_fs);
 let node_path = require("node:path");
@@ -2165,6 +2165,78 @@ var EngineFactory = class {
 	}
 };
 //#endregion
+//#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/postprocess/dispatch.ts
 var VALID_KINDS = new Set([
 	"detections",
@@ -2204,7 +2276,7 @@ function postprocessYolo(output, stepDef) {
 	const letterbox = output.letterbox;
 	const dets = [];
 	for (let i = 0; i < numBoxes; i++) {
-		const cx = tensor[0 * numBoxes + i];
+		const cx = tensor[i];
 		const cy = tensor[1 * numBoxes + i];
 		const w = tensor[2 * numBoxes + i];
 		const h = tensor[3 * numBoxes + i];
@@ -2360,7 +2432,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",
@@ -3535,34 +3607,69 @@ function walkFieldsForDefaults(fields, out) {
 }
 //#endregion
 //#region src/detection-pipeline/runtimes.ts
-var AUTO = {
-	value: "auto",
-	label: "Auto"
-};
-var CPU = {
-	value: "cpu",
-	label: "CPU"
-};
-var RUNTIMES = [
-	{
-		id: "onnx",
+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",
-		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,
@@ -3571,25 +3678,8 @@ var RUNTIMES = [
 			intraOpThreads: 0
 		}
 	},
-	{
-		id: "openvino",
+	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,
@@ -3597,29 +3687,8 @@ var RUNTIMES = [
 			numStreams: 0
 		}
 	},
-	{
-		id: "coreml",
+	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,
@@ -3629,32 +3698,50 @@ var RUNTIMES = [
 			numWorkers: 1
 		}
 	}
-];
-function def(id) {
-	const d = RUNTIMES.find((r) => r.id === id);
-	if (!d) throw new Error(`Unknown runtime: ${id}`);
-	return d;
-}
+};
+/**
+* Returns the list of supported runtime IDs for the given hardware env.
+* Delegates to `@camstack/types` `supportedRuntimes`.
+*/
 function supportedRuntimes(env) {
-	return RUNTIMES.filter((r) => r.supports(env)).map((r) => r.id);
+	return require_dist.supportedRuntimes(envToHardwareInfo(env));
 }
+/**
+* Returns the device options for a given runtime and probed hardware.
+* Delegates to `@camstack/types` `runtimeDevices`.
+*/
 function runtimeDevices(id, hardware) {
-	return def(id).devices(hardware);
+	return require_dist.runtimeDevices(id, probedToHardwareInfo(hardware));
 }
+/**
+* Returns the default device string for a given runtime.
+* Delegates to `@camstack/types` `defaultDeviceFor`.
+*/
 function defaultDeviceFor(id) {
-	return def(id).defaultDevice;
-}
-function pythonRequirementsFor(id) {
-	return def(id).pythonRequirements;
+	return require_dist.defaultDeviceFor(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 def(id).modelFormat;
+	return RUNTIME_FORMAT[id];
+}
+function pythonRequirementsFor(id) {
+	return RUNTIME_DETAIL[id].pythonRequirements;
 }
 function tuningFor(id) {
-	return def(id).tuning;
+	return RUNTIME_DETAIL[id].tuning;
 }
 function runtimeLabel(id) {
-	return def(id).label;
+	return RUNTIME_DETAIL[id].label;
 }
 /**
 * Proactive-install hint kept for back-compat (re-exported from index.ts).
@@ -3995,6 +4082,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;
@@ -4084,7 +4192,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 		this.readStore = () => settings.readAddonStore();
 		this.writeStore = (patch) => settings.writeAddonStore(patch);
 		this.readDeviceStore = settings.readDeviceStore ?? (async () => ({}));
-		this.currentEngine = DetectionPipelineProvider.detectBestEngine();
+		this.currentEngine = ONNX_FLOOR;
 		this.log.info("Engine selected (default)", { meta: {
 			runtime: this.currentEngine.runtime,
 			backend: this.currentEngine.backend,
@@ -4150,62 +4258,27 @@ 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 {
+			this.startProvisioningForCurrentEngine();
+			const unsubscribe = this.addonCtx.onCapabilityStateChange("platform-probe", { type: "global" }, (state) => {
+				if (state !== "ready") return;
+				unsubscribe();
+				if (!this.needsAutoPick) return;
+				this.autoPickAndPersist().then(() => {
+					this.needsAutoPick = false;
+					this.startProvisioningForCurrentEngine();
+				});
+			});
+			this.addonCtx.addDisposer(unsubscribe);
 		}
-		this.startProvisioningForCurrentEngine();
+		else this.startProvisioningForCurrentEngine();
 	}
 	/**
 	* Auto-pick the best supported runtime at first boot (no stored engine).
@@ -4220,7 +4293,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;
@@ -4234,9 +4307,10 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 			device: pick.device
 		};
 		this.currentEngine = engine;
+		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,
@@ -4409,11 +4483,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 };
 		}
@@ -5478,7 +5563,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
@@ -5662,25 +5747,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,
@@ -5852,18 +5939,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";
 				})();
@@ -5873,16 +5956,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,
@@ -6305,7 +6389,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) {
@@ -6348,6 +6433,15 @@ var POOL_BOUND_KEYS = [
 ];
 var DetectionPipelineAddon = class extends require_dist.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
@@ -6402,6 +6496,14 @@ var DetectionPipelineAddon = class extends require_dist.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",
@@ -6538,14 +6640,18 @@ var DetectionPipelineAddon = class extends require_dist.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) => ({
@@ -6553,14 +6659,22 @@ var DetectionPipelineAddon = class extends require_dist.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: [] };
@@ -6591,15 +6705,15 @@ var DetectionPipelineAddon = class extends require_dist.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;
 				})
@@ -6616,23 +6730,41 @@ var DetectionPipelineAddon = class extends require_dist.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, require_dist.nodePin(node)))?.hardware;
 			if (!hw) return null;
 			return {
 				npu: hw.npu ? { type: hw.npu.type } : null,
@@ -6643,6 +6775,61 @@ var DetectionPipelineAddon = class extends require_dist.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
@@ -6656,7 +6843,7 @@ var DetectionPipelineAddon = class extends require_dist.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 {
@@ -6675,6 +6862,7 @@ var DetectionPipelineAddon = class extends require_dist.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;
@@ -6696,7 +6884,7 @@ var DetectionPipelineAddon = class extends require_dist.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.warmPool();
@@ -6748,8 +6936,8 @@ var DetectionPipelineAddon = class extends require_dist.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 —
@@ -6818,6 +7006,7 @@ var DetectionPipelineAddon = class extends require_dist.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) } });
 		});