@camstack/addon-pipeline 1.1.70 → 1.2.0

package/dist/detection-pipeline/index.mjs

@@ -1,6 +1,6 @@
 import { t as __require } from "../chunk-BdkLduGY.mjs";
-import { $ as sleep, A as pipelineExecutorCapability, B as errMsg, C as evaluateZoneRules, F as runtimeDevices$1, G as createEvent, K as hydrateSchema, R as supportedRuntimes$1, S as detectionPipelineCapability, V as BaseAddon, X as parseJsonUnknown, b as defaultDeviceFor$1, dt as EventCategory, k as nodePin, lt as string, m as YAMNET_TO_MACRO, st as object, t as APPLE_SA_TO_MACRO, tt as array, ut as union } from "../dist-CurVt3xC.mjs";
-import { a as getStepDefinition, i as getStep, n as ALL_STEPS, o as resolveModelForFormat, r as getDefaultModelForFormat, t as ALL_PIPELINE_STEPS } from "../step-definitions-BKm17nce.mjs";
+import { B as supportedRuntimes$1, C as detectionPipelineCapability, H as errMsg, J as hydrateSchema, L as runtimeDevices$1, M as pipelineExecutorCapability, Q as parseJsonUnknown, T as evaluateZoneRules, U as BaseAddon, dt as string, ft as union, h as YAMNET_TO_MACRO, j as nodePin, lt as object, pt as EventCategory, q as createEvent, rt as array, s as DEVICE_BACKEND_TO_FORMAT, t as APPLE_SA_TO_MACRO, tt as sleep, w as enumerateInferenceDevices, x as defaultDeviceFor$1 } from "../dist-DLWXeXC1.mjs";
+import { a as getStepDefinition, i as getStep, n as ALL_STEPS, o as resolveModelForFormat, r as getDefaultModelForFormat, t as ALL_PIPELINE_STEPS } from "../step-definitions-CVk19Y0u.mjs";
 import { t as pickNodePlatformArch } from "../node-topology-platform-BkR_k6WT.mjs";
 import { a as ensureModel, o as isModelDownloaded, r as deleteModelFromDisk } from "../model-download-service-Cp9f4dk6-CwUb5v3Y.mjs";
 import { spawn } from "node:child_process";
@@ -156,9 +156,6 @@ function pythonRequirementsFor(id) {
 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;
@@ -194,117 +191,27 @@ function pickBestRuntime(env, bestBackendHint) {
 		device: defaultDeviceFor(chosen)
 	};
 }
-/**
-* The ordered device candidates a runtime will try for an `'auto'`/`'all'`
-* device pick — mirrors what the python inference pool actually resolves
-* (openvino `_resolve_ov_devices`: NPU>GPU>CPU; coreml compute-units `all`:
-* ANE>GPU>CPU). Surfaced in `probedBestEngine` so the UI shows the real
-* accelerator order (`openvino/auto [NPU, GPU, CPU]`) instead of a bare `auto`
-* tag. Returns `[]` for runtimes with a single fixed device (onnx → CPU) — the
-* caller then keeps the plain `backend/device` label.
-*/
-function engineDeviceSequence(runtimeId, env) {
-	const hw = env.hardware;
-	switch (runtimeId) {
-		case "openvino": {
-			const seq = [];
-			if (hw?.npu?.type === "intel-npu") seq.push("NPU");
-			if (hw?.gpu?.type === "intel") seq.push("GPU");
-			seq.push("CPU");
-			return seq;
-		}
-		case "coreml": {
-			const seq = [];
-			if (hw?.npu?.type === "apple-ane") seq.push("ANE");
-			if (hw?.gpu != null) seq.push("GPU");
-			seq.push("CPU");
-			return seq;
-		}
-		default: return [];
-	}
-}
 //#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.
+* Node-id normalisation for the detection pipeline.
 *
-* These three keys are therefore persisted node-scoped as `<key>@<nodeId>`.
-* Everything else in the store stays shared. There is NO fallback to a legacy
-* un-scoped value for ANY node (the hub included) and no in-code migration: a
-* bare key (written before scoping, or by an older build) is inert — invisible
-* to every node. A node with no scoped key reads `undefined`, which drives its
-* OWN live resolve (`resolveAutoEngine` picks the node's runtime from the local
-* kernel each boot; `reprobeEngine` persists an explicit probe under
-* `<key>@<node>`). Serving a bare value to any node
-* would leak one node's hardware pick (e.g. `openvino/auto`) onto a node that
-* cannot run it (the CB3 "Mac runs OpenVINO" / N100 AUTO-device bug). This
-* mirrors the decoder's `readNodeDecoderBackend` no-fallback rule.
+* The legacy per-node engine CASCADE keys (`engineBackend` / `engineDevice` /
+* `probedBestEngine`) were removed together with the operator-facing engine
+* election: each node now runs a device-array of inference pools balanced
+* per-session, and the node-default pool is derived live from the node's own
+* hardware (`resolveAutoEngine`). All that survives from the old cascade module
+* is the node-id normaliser, still used to target the platform-probe per node.
 */
-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`.
+* Normalise a raw kernel node id to the bare node id. `localNodeId` can carry a
+* `<node>/<addon>` suffix; probe targeting 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 `undefined` — for EVERY node, the hub included. There is no
-* fallback to the legacy un-scoped key: a bare value in the store is inert.
-* A node with no scoped key gets `undefined` so its own platform-driven
-* auto-pick runs and persists a real per-node selection under `<key>@<node>`.
-* (A bare fallback would leak one node's engine selection cluster-wide — CB3.)
-*/
-function readNodeEngineValue(store, base, nodeId) {
-	return store[nodeEngineKey(base, nodeId)];
-}
-/**
-* 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/default-detection-model.ts
 /** The object-detection step id — the only slot this resolver applies to. */
@@ -1542,28 +1449,17 @@ var EngineFactory = class {
 //#endregion
 //#region src/detection-pipeline/engine/resolve-device-engine.ts
 /**
-* Backend → model format for a device pool. Mirrors the Phase-1 device
-* enumeration (`enumerateInferenceDevices`) and the pool-runtime mapping.
-*/
-var BACKEND_FORMAT = {
-	openvino: "openvino",
-	edgetpu: "tflite",
-	onnx: "onnx",
-	cpu: "onnx",
-	cuda: "onnx",
-	coreml: "coreml"
-};
-/**
 * Resolve a Phase-1 device key (`<backend>:<device>`, or bare `cpu`) into the
 * {@link PipelineEngineChoice} used to build that device's inference pool.
 * Throws on an unknown backend token so a bad `deviceKey` fails loud rather
-* than silently building a wrong pool.
+* than silently building a wrong pool. Format comes from the shared
+* {@link DEVICE_BACKEND_TO_FORMAT} SSOT (`@camstack/types`) — no local copy.
 */
 function resolveDeviceEngine(deviceKey) {
 	const colon = deviceKey.indexOf(":");
 	const backend = colon >= 0 ? deviceKey.slice(0, colon) : deviceKey;
 	const device = colon >= 0 ? deviceKey.slice(colon + 1) : deviceKey;
-	const format = BACKEND_FORMAT[backend];
+	const format = DEVICE_BACKEND_TO_FORMAT[backend];
 	if (format === void 0) throw new Error(`resolveDeviceEngine: unknown backend "${backend}" in deviceKey "${deviceKey}"`);
 	return {
 		runtime: "python",
@@ -1573,6 +1469,69 @@ function resolveDeviceEngine(deviceKey) {
 	};
 }
 //#endregion
+//#region src/detection-pipeline/engine/idle-pool-reaper.ts
+var IdlePoolReaper = class {
+	lastUsed = /* @__PURE__ */ new Map();
+	timers = /* @__PURE__ */ new Map();
+	ttlMs;
+	disposeFn;
+	now;
+	setTimer;
+	clearTimer;
+	onError;
+	constructor(opts) {
+		this.ttlMs = opts.ttlMs;
+		this.disposeFn = opts.dispose;
+		this.now = opts.now ?? (() => Date.now());
+		this.setTimer = opts.setTimer ?? ((fn, ms) => setTimeout(fn, ms));
+		this.clearTimer = opts.clearTimer ?? ((t) => clearTimeout(t));
+		this.onError = opts.onError;
+	}
+	/** Record a use of `key` and (re)arm its idle-eviction timer. */
+	touch(key) {
+		this.lastUsed.set(key, this.now());
+		this.arm(key);
+	}
+	/** Stop tracking `key` (the pool was disposed/removed elsewhere). */
+	cancel(key) {
+		const timer = this.timers.get(key);
+		if (timer) this.clearTimer(timer);
+		this.timers.delete(key);
+		this.lastUsed.delete(key);
+	}
+	/** Clear every timer (shutdown). Does not dispose pools — the caller does. */
+	disposeAll() {
+		for (const timer of this.timers.values()) this.clearTimer(timer);
+		this.timers.clear();
+		this.lastUsed.clear();
+	}
+	arm(key) {
+		const existing = this.timers.get(key);
+		if (existing) this.clearTimer(existing);
+		this.timers.set(key, this.setTimer(() => {
+			this.reap(key);
+		}, this.ttlMs));
+	}
+	async reap(key) {
+		const last = this.lastUsed.get(key);
+		if (last === void 0) return;
+		const idleMs = this.now() - last;
+		if (idleMs < this.ttlMs) {
+			this.timers.set(key, this.setTimer(() => {
+				this.reap(key);
+			}, this.ttlMs - idleMs));
+			return;
+		}
+		this.timers.delete(key);
+		this.lastUsed.delete(key);
+		try {
+			await this.disposeFn(key);
+		} catch (err) {
+			this.onError?.(key, err);
+		}
+	}
+};
+//#endregion
 //#region src/detection-pipeline/engine-provisioner.ts
 /** Incremental backoff growing to a ~5 min cap; retries indefinitely at cap. */
 var BACKOFF_SCHEDULE_MS = [
@@ -3929,26 +3888,6 @@ var PROBE_DIRECT_RPC_TIMEOUT_MS = 6e4;
 * result is identical (onnx / cpu) but is now derived through the shared rules
 * instead of duplicated inline.
 */
-function onnxFloorPick() {
-	return ONNX_FLOOR;
-}
-/**
-* The platform-deterministic engine pick computed SYNCHRONOUSLY from this node's
-* own `process.platform`/`arch` alone (no probe): darwin → coreml, else → onnx
-* (gpu-dependent openvino/cuda need the probe and converge via the auto-pick).
-* Used as the ENGINE fallback when a persisted selection is unsupported on this
-* node — so a stale GLOBAL engine config (e.g. the cluster's OpenVINO choice)
-* can never force an impossible engine onto a node whose platform rejects it.
-*/
-function platformDefaultPick() {
-	const pick = pickBestRuntime(runtimeEnvFromProcess(null), null);
-	return {
-		runtime: "python",
-		backend: pick.runtimeId,
-		format: modelFormatFor(pick.runtimeId),
-		device: pick.device
-	};
-}
 /**
 * Is `backend` even POSSIBLE on this node's OS/arch (ignoring gpu detail)?
 * coreml ⇒ darwin only; openvino ⇒ x64 non-darwin only; onnx ⇒ anywhere. Used to
@@ -4064,6 +4003,22 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	*/
 	overrideCache = null;
 	overrideCacheTimer = null;
+	/**
+	* Idle-TTL for a per-device inference pool (multi-device C3). A device pool
+	* with no dispatch for this long is disposed and recreated on next use — the
+	* memory guardrail that keeps `factoriesByDevice` from accumulating warm pools
+	* forever. Longer than the override cache (60s) since a device pool is heavier
+	* to respin; still well above any real inter-session gap for an active camera.
+	*/
+	static DEVICE_POOL_IDLE_TTL_MS = 12e4;
+	deviceReaper = new IdlePoolReaper({
+		ttlMs: DetectionPipelineProvider.DEVICE_POOL_IDLE_TTL_MS,
+		dispose: (deviceKey) => this.disposeDevicePool(deviceKey),
+		onError: (deviceKey, err) => this.log.warn("Idle device pool dispose failed", { meta: {
+			deviceKey,
+			error: err instanceof Error ? err.message : String(err)
+		} })
+	});
 	static OVERRIDE_CACHE_TTL_MS = 6e4;
 	/** Read the addon settings store (all keys). */
 	readStore;
@@ -4091,20 +4046,15 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 			format: this.currentEngine.format
 		} });
 	}
-	/** Load persisted engine choice. Call after construction. */
+	/**
+	* Call after construction. The node-default engine is always DERIVED live
+	* from this node's own hardware (there is no persisted operator override
+	* anymore — the elected single-engine cascade was removed). Defer the derive
+	* to `setApi()` where the probe cap / kernel resolver is reachable.
+	*/
 	async init() {
-		const stored = await this.loadEngine();
-		if (stored) {
-			this.currentEngine = stored;
-			this.log.info("Engine loaded (persisted)", { meta: {
-				runtime: stored.runtime,
-				backend: stored.backend,
-				format: stored.format
-			} });
-		} else {
-			this.needsAutoPick = true;
-			this.log.info("No persisted engine — auto-pick deferred to setApi()");
-		}
+		this.needsAutoPick = true;
+		this.log.info("Node-default engine derive deferred to setApi()");
 	}
 	/**
 	* Lazy-install the pip requirements file matching `engine.backend` into
@@ -4178,6 +4128,9 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 		await this.resolveAutoEngine();
 		this.needsAutoPick = false;
 		this.startProvisioningForCurrentEngine();
+		await this.recomputeConfigIssues().catch((err) => {
+			this.log.warn("config-issue recompute failed after node-default derive", { meta: { error: errMsg(err) } });
+		});
 	}
 	/**
 	* Authoritative platform-probe reconcile: query the probe provider
@@ -4205,34 +4158,38 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 		}
 	}
 	/**
-	* Resolve the `'auto'` engine LIVE from this node's own kernel inference
+	* Derive the node-default engine LIVE from this node's own kernel inference
 	* resolver (`ctx.kernel.inferenceEngine`) — the runtime mirror of
 	* `ctx.kernel.hwaccel`. Each node (hub + forked worker + remote agent)
 	* resolves its OWN accelerators in-process, so a forked agent child never
 	* adopts the hub's runtime from the `platform-probe` singleton.
 	*
-	* NEVER persists. `'auto'` is a live-resolved sentinel: the pick is recomputed
-	* every boot from the local hardware, so it is inherently self-healing — the
-	* old `autoPickAndPersist` sticky-onnx bug (a premature onnx pick persisted
-	* during a boot race, then locked forever) cannot recur because the store is
-	* never written here. Only an explicit operator override is persisted, and
-	* that write happens through the settings UI, not this path.
+	* The default is the TOP-SCORED CONCRETE device from the SAME
+	* `enumerateInferenceDevices` enumeration the orchestrator balances over
+	* (e.g. `openvino:npu`, not `openvino:auto`) — NOT `pickBestRuntime`, whose
+	* `defaultDeviceFor('openvino')` is the abstract `'auto'` sentinel. This is
+	* load-bearing for pool COLLAPSE (D2/NEW-1): a `deviceKey`-less/lone session
+	* routes through the default pool, and a balanced session that picks the same
+	* top device (`openvino:npu`) must reuse THAT pool via `resolveDeviceFactory`'s
+	* `enginesEqual(engine, currentEngine)` check — which only matches when the
+	* default carries the concrete device, not `'auto'`. An abstract `'auto'`
+	* default would spawn a THIRD pool contending with the per-device npu/gpu pools
+	* on the same physical accelerators (double model load / VRAM). Falls back to
+	* the onnx/cpu floor when the enumeration is empty. NEVER persists — recomputed
+	* every boot from the local hardware, inherently self-healing.
 	*/
 	async resolveAutoEngine() {
 		let hardware = null;
 		try {
 			hardware = await this.addonCtx?.kernel?.inferenceEngine?.resolveHardware() ?? null;
 		} catch {}
-		const pick = pickBestRuntime(runtimeEnvFromProcess(hardware ? toProbedHardware(hardware) : null), null);
-		this.currentEngine = {
-			runtime: "python",
-			backend: pick.runtimeId,
-			format: modelFormatFor(pick.runtimeId),
-			device: pick.device
-		};
-		this.log.info("Resolved auto engine (local kernel)", { meta: {
-			backend: pick.runtimeId,
-			device: pick.device,
+		const devices = enumerateInferenceDevices(envToHardwareInfo(runtimeEnvFromProcess(hardware ? toProbedHardware(hardware) : null)));
+		const top = devices.find((d) => d.available) ?? devices[0];
+		this.currentEngine = top ? resolveDeviceEngine(top.key) : ONNX_FLOOR;
+		this.log.info("Derived node-default engine (local kernel)", { meta: {
+			deviceKey: top?.key ?? "onnx:cpu(floor)",
+			backend: this.currentEngine.backend,
+			device: this.currentEngine.device ?? null,
 			hadHardware: hardware !== null
 		} });
 	}
@@ -4311,33 +4268,6 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 		this.provisioner.select(runtimeId, device);
 	}
 	/**
-	* Re-trigger provisioning after the operator changes the engine
-	* cascade (`engineBackend`/`engineDevice`). Reloads the persisted
-	* selection into `this.currentEngine`, then `select()`s it — the
-	* machine cancels any superseded provisioning and drives the new
-	* runtime through installing → verifying → ready.
-	*/
-	async onEngineSelectionChanged() {
-		const prev = this.currentEngine;
-		const stored = await this.loadEngine();
-		if (stored) this.currentEngine = stored;
-		else await this.resolveAutoEngine();
-		const engineChanged = prev.runtime !== this.currentEngine.runtime || prev.backend !== this.currentEngine.backend || prev.format !== this.currentEngine.format || (prev.device ?? "") !== (this.currentEngine.device ?? "");
-		if (engineChanged && this.engineFactory) {
-			this.log.info("engine selection changed — rebuilding pool in place", { meta: {
-				from: `${prev.backend}/${prev.device ?? "default"}`,
-				to: `${this.currentEngine.backend}/${this.currentEngine.device ?? "default"}`
-			} });
-			try {
-				await this.engineFactory.dispose();
-			} catch {}
-			this.engineFactory = null;
-			this.executor = null;
-		}
-		this.startProvisioningForCurrentEngine();
-		if (engineChanged) await this.recomputeConfigIssues();
-	}
-	/**
 	* Gate A (config-correctness gate at engine change) — eagerly re-resolve
 	* the node-default step tree for `this.currentEngine.format` and compute
 	* human-readable config issues from the result:
@@ -5781,6 +5711,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 			this.engineFactory = null;
 			this.executor = null;
 		}
+		this.deviceReaper.disposeAll();
 		const deviceFactories = Array.from(this.factoriesByDevice.values());
 		this.factoriesByDevice.clear();
 		await Promise.all(deviceFactories.map((f) => f.dispose().catch(() => void 0)));
@@ -5924,7 +5855,10 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 			return this.engineFactory;
 		}
 		const existing = this.factoriesByDevice.get(deviceKey);
-		if (existing) return existing;
+		if (existing) {
+			this.deviceReaper.touch(deviceKey);
+			return existing;
+		}
 		const inflight = this.deviceFactoryInflight.get(deviceKey);
 		if (inflight) return inflight;
 		const creation = (async () => {
@@ -5945,6 +5879,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 				throw err;
 			}
 			this.factoriesByDevice.set(deviceKey, factory);
+			this.deviceReaper.touch(deviceKey);
 			return factory;
 		})();
 		this.deviceFactoryInflight.set(deviceKey, creation);
@@ -5955,66 +5890,22 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 		}
 	}
 	/**
-	* Phase 2b — resolve the engine from the addon's new schema-backed
-	* fields (`engineRuntime`, `engineBackend`, `engineDevice`). The legacy
-	* `pipelineEngine` JSON-blob fallback was removed with the executor seed
-	* (any store predating the per-node cascade simply re-runs auto-pick).
-	*
-	* The `'auto'` sentinel is treated as NO override (returns null) so the
-	* caller re-resolves LIVE via `resolveAutoEngine()` — `'auto'` is the
-	* self-healing default, never a persisted concrete backend. An explicit
-	* concrete backend (onnx/openvino/coreml) is honored as an operator override.
-	* Returns null when neither source has a concrete selection; the caller keeps
-	* the onnx floor set at construction until `resolveAutoEngine()` runs.
+	* Dispose a single idle device pool (invoked by the {@link deviceReaper} when
+	* `deviceKey` has had no dispatch for the idle-TTL). Removed from the map
+	* FIRST so a concurrent `resolveDeviceFactory` recreates it fresh via the
+	* single-flight guard rather than handing back the disposing instance.
 	*/
-	async loadEngine() {
-		const store = await this.readStore();
-		const storedRuntime = store["engineRuntime"];
-		const node = this.localProbeNodeId();
-		const storedBackend = readNodeEngineValue(store, "engineBackend", node);
-		if (storedBackend === "auto") return null;
-		if (typeof storedBackend === "string" && storedBackend.length > 0 && storedBackend !== "auto") {
-			const backend = storedBackend;
-			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 (!backendPossibleOnPlatform(migratedBackend)) {
-				const platformDefault = platformDefaultPick();
-				this.log.warn("Stored engine backend impossible on this platform — using platform default", { meta: {
-					stored: migratedBackend,
-					fallback: platformDefault.backend
-				} });
-				this.writeStore({
-					[nodeEngineKey("engineBackend", node)]: platformDefault.backend,
-					...platformDefault.device !== void 0 ? { [nodeEngineKey("engineDevice", node)]: platformDefault.device } : {}
-				}).catch((err) => {
-					this.log.warn("Failed to persist platform-default engine after impossible stored pick", { meta: { error: err instanceof Error ? err.message : String(err) } });
-				});
-				return platformDefault;
-			}
-			const device = storedDevice || floor.device;
-			return {
-				runtime: "python",
-				backend: migratedBackend,
-				format: backendToFormat(migratedBackend),
-				...device ? { device } : {}
-			};
-		}
-		return null;
+	async disposeDevicePool(deviceKey) {
+		const factory = this.factoriesByDevice.get(deviceKey);
+		if (!factory) return;
+		this.factoriesByDevice.delete(deviceKey);
+		await factory.dispose();
+		this.log.info("Idle device pool evicted", { meta: {
+			deviceKey,
+			idleTtlMs: DetectionPipelineProvider.DEVICE_POOL_IDLE_TTL_MS
+		} });
 	}
 	/**
-	* Re-run the platform probe for the inference engine and persist the
-	* result into the addon's own global-settings keys. Because those
-	* fields are declared `requiresRestart: true`, the
-	* `updateGlobalSettings` pathway auto-schedules an addon restart —
-	* here we do the write directly via the settings store and trigger
-	* restart manually through the addons cap.
-	*
-	* Returns the chosen engine so the UI can confirm the pick without a
-	* second round-trip.
-	*/
-	/**
 	* Phase 2c — flat per-addonId map holding the video-pipeline step
 	* config (`modelId` / `settings`). No `enabled` field: whether an
 	* addon step runs is a capability-binding concern, not a
@@ -6199,35 +6090,6 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 		} });
 		return { success: true };
 	}
-	async reprobeEngine() {
-		let hardware = null;
-		try {
-			hardware = await this.addonCtx?.kernel?.inferenceEngine?.resolveHardware() ?? null;
-		} catch {}
-		const env = runtimeEnvFromProcess(hardware ? toProbedHardware(hardware) : null);
-		const pick = pickBestRuntime(env, null);
-		const best = {
-			runtime: "python",
-			backend: pick.runtimeId,
-			format: modelFormatFor(pick.runtimeId),
-			device: pick.device
-		};
-		const deviceSeq = engineDeviceSequence(pick.runtimeId, env);
-		const probedLabel = deviceSeq.length > 1 ? `${best.backend}/${best.device ?? "default"} [${deviceSeq.join(", ")}]` : `${best.backend}/${best.device ?? "default"}`;
-		const rpNode = this.localProbeNodeId();
-		if (pick.runtimeId !== "onnx" || hardware !== null) {
-			await this.writeStore({ [nodeEngineKey("probedBestEngine", rpNode)]: probedLabel });
-			this.log.info("Re-probed engine (local kernel) — updated probedBestEngine hint", { meta: {
-				backend: best.backend,
-				device: best.device ?? null,
-				probedBestEngine: probedLabel
-			} });
-		} else this.log.info("Re-probe: onnx floor pending gpu probe — hint NOT persisted", { meta: {
-			backend: best.backend,
-			device: best.device ?? null
-		} });
-		return best;
-	}
 	async getReferenceAudioFiles() {
 		const dir = resolveReferenceAudioDir();
 		if (!dir) return [];
@@ -6582,47 +6444,6 @@ function resolveAddonPythonDir() {
 	for (const c of candidates) if (fs.existsSync(path$1.join(c, "inference_pool.py"))) return c;
 	throw new Error(`addon-pipeline/detection-pipeline: python/ dir not found. Searched:\n${candidates.join("\n")}`);
 }
-var BACKEND_TO_FORMAT = {
-	cpu: "onnx",
-	coreml: "coreml",
-	openvino: "openvino",
-	onnx: "onnx",
-	edgetpu: "tflite"
-};
-/**
-* Every runtime the registry knows about, in offer order. Used only to build
-* the STATIC base schema (returned by `globalSettingsSchema()` before a live
-* ctx exists, e.g. addon-registry boot introspection). The live, hardware-
-* gated subset is injected by `getGlobalSettings()` via `supportedRuntimes(env)`.
-*/
-var ALL_RUNTIME_IDS = [
-	"onnx",
-	"openvino",
-	"coreml",
-	"edgetpu"
-];
-/**
-* Narrow an arbitrary stored backend string to a known `RuntimeId`. Legacy or
-* unknown values (e.g. the removed `'cpu'` backend) fall back to the `onnx`
-* floor so the registry lookup never throws.
-*/
-function toRuntimeId(backend) {
-	return ALL_RUNTIME_IDS.find((id) => id === backend) ?? "onnx";
-}
-/** Static universe of backend options (every runtime). Labels from the registry. */
-var STATIC_BACKEND_OPTIONS = ALL_RUNTIME_IDS.map((id) => ({
-	value: id,
-	label: runtimeLabel(id)
-}));
-/**
-* Static device options for the schema's default backend. The live device
-* list per the selected backend + probed hardware is injected by
-* `getGlobalSettings()` via `runtimeDevices(backend, hardware)`.
-*/
-var STATIC_DEFAULT_DEVICE_OPTIONS = runtimeDevices(ALL_RUNTIME_IDS[0], null).map((d) => ({
-	value: d.value,
-	label: d.label
-}));
 var DEFAULT_CONFIG = {
 	concurrency: 0,
 	batchMode: "",
@@ -6631,17 +6452,8 @@ var DEFAULT_CONFIG = {
 	numStreams: 0,
 	intraOpThreads: 0,
 	numWorkers: 0,
-	engineRuntime: "python",
-	engineBackend: "auto",
-	engineDevice: "cpu",
-	probedBestEngine: "",
-	activeEngine: "",
 	activeModelSubstitutions: ""
 };
-/** Derive the model-format from a backend value. Called by the provider. */
-function backendToFormat(backend) {
-	return BACKEND_TO_FORMAT[backend] ?? "onnx";
-}
 /**
 * Cadence for the per-node engine-inventory snapshot. Engines change
 * slowly (manual spin/kill, idle eviction, attach/detach). 5 s strikes
@@ -6734,63 +6546,18 @@ var DetectionPipelineAddon = class DetectionPipelineAddon extends BaseAddon {
 			tab: "engine",
 			order: 0,
 			description: "Vision-detection execution provider (object detection, face detection, plate OCR). Inference always runs via the embedded Python runtime. Provider and hardware options are gated by what the platform probe reports as available on this host. Changes restart the addon.",
-			fields: [
-				this.field({
-					type: "text",
-					key: "probedBestEngine",
-					label: "Probed best",
-					description: "Auto-detected best engine for this host (format: provider/device, e.g. \"openvino/npu\"). Click the refresh icon to re-run the probe — the detected provider and hardware device are written back into the two fields below, overwriting any manual override.",
-					readonlyField: true,
-					default: "",
-					perNode: true,
-					actions: [{
-						action: "reprobe-engine",
-						icon: "refresh-cw",
-						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: "text",
-					key: "activeModelSubstitutions",
-					label: "Model substitutions",
-					description: "Node-local model substitutions currently in effect: a step's chosen model has no build for this node's engine format, so a compatible default is running instead (format: \"step: chosen→running\"). Hidden when every step matches.",
-					readonlyField: true,
-					default: "",
-					showWhen: {
-						field: "activeModelSubstitutions",
-						notEquals: ""
-					}
-				}),
-				this.field({
-					type: "select",
-					key: "engineBackend",
-					label: "Execution provider",
-					options: [{
-						value: "auto",
-						label: "Auto (best for this node)"
-					}, ...STATIC_BACKEND_OPTIONS],
-					default: DEFAULT_CONFIG.engineBackend,
-					immediate: true,
-					perNode: true
-				}),
-				this.field({
-					type: "select",
-					key: "engineDevice",
-					label: "Hardware device",
-					options: [...STATIC_DEFAULT_DEVICE_OPTIONS],
-					default: DEFAULT_CONFIG.engineDevice,
-					immediate: true,
-					perNode: true
-				})
-			]
+			fields: [this.field({
+				type: "text",
+				key: "activeModelSubstitutions",
+				label: "Model substitutions",
+				description: "Node-local model substitutions currently in effect: a step's chosen model has no build for this node's engine format, so a compatible default is running instead (format: \"step: chosen→running\"). Hidden when every step matches.",
+				readonlyField: true,
+				default: "",
+				showWhen: {
+					field: "activeModelSubstitutions",
+					notEquals: ""
+				}
+			})]
 		}, {
 			id: "inference-executor",
 			title: "Inference executor",
@@ -6819,15 +6586,7 @@ var DetectionPipelineAddon = class DetectionPipelineAddon extends BaseAddon {
 							label: "Window (cross-camera accumulator)"
 						}
 					],
-					default: "",
-					showWhen: {
-						field: "engineBackend",
-						in: [
-							"coreml",
-							"onnx",
-							"cpu"
-						]
-					}
+					default: ""
 				}),
 				this.field({
 					type: "slider",
@@ -6893,59 +6652,31 @@ var DetectionPipelineAddon = class DetectionPipelineAddon extends BaseAddon {
 		}] });
 	}
 	/**
-	* Override to inject the hardware-driven backend + device options.
+	* Override to inject the read-only model-substitution status + the
+	* per-backend tuning-slider defaults.
 	*
-	* The OFFERED backend list comes from `supportedRuntimes(env)` — platform,
-	* arch and probed hardware ONLY, never from which Python packages are
-	* installed. A host's hardware is what it can physically run; install state
-	* is provisioned on demand (Phase 2). Device options come from
-	* `runtimeDevices(backend, hardware)` (probe-driven; default-only when the
-	* probe is unreachable). Stored backend / device snap back to the registry
-	* floor / default when they fall outside the offered set.
+	* Engine SELECTION is no longer operator-facing (the elected single-engine
+	* cascade was removed): each node runs a device-array of inference pools
+	* balanced per-session, and the node-default pool is derived live from the
+	* node's own hardware. So this override no longer offers a backend/device
+	* dropdown or a probed/active-engine readout — it only:
+	*   1. resolves the node's derived-default backend (via the probe) to suggest
+	*      the matrix-tuned slider defaults that won the bench for that backend, and
+	*   2. surfaces the live `activeModelSubstitutions` readout.
 	*/
 	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,
+			...rawStored,
 			...overlay
-		} : stored;
-		const env = await this.probeHardwareEnv(targetNode);
-		const hardware = env.hardware;
-		const offered = supportedRuntimes(env);
-		const runtimeBackends = [{
-			value: "auto",
-			label: "Auto (best for this node)"
-		}, ...offered.map((id) => ({
-			value: id,
-			label: runtimeLabel(id)
-		}))];
-		const storedBackend = typeof merged.engineBackend === "string" ? merged.engineBackend : "";
-		const isAuto = storedBackend === "auto";
-		const backend = (() => {
-			if (isAuto) return pickBestRuntime(env, null).runtimeId;
-			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})` : "";
+		} : rawStored;
+		const backend = pickBestRuntime(await this.probeHardwareEnv(targetNode), null).runtimeId;
 		const substitutions = this.provider?.getActiveModelSubstitutions() ?? [];
 		const activeModelSubstitutions = substitutions.length === 0 ? "" : substitutions.map((s) => `${s.addonId}: ${s.chosen}→${s.running}`).join(", ");
-		const displayBackend = isAuto ? "auto" : backend;
 		const raw = {
 			...merged,
-			engineBackend: displayBackend,
-			engineDevice: device,
-			activeEngine,
 			activeModelSubstitutions
 		};
 		const schema = this.globalSettingsSchema();
@@ -6957,18 +6688,6 @@ var DetectionPipelineAddon = class DetectionPipelineAddon extends BaseAddon {
 				...section,
 				fields: section.fields.map((field) => {
 					if (field.type === "select") {
-						if (field.key === "engineBackend") return {
-							...field,
-							options: [...runtimeBackends]
-						};
-						if (field.key === "engineDevice") return {
-							...field,
-							options: deviceOptions.map((d) => ({
-								value: d.value,
-								label: d.label
-							})),
-							default: defaultDeviceFor(backend)
-						};
 						if (field.key === "batchMode" && tuning["batchMode"] !== void 0) return {
 							...field,
 							default: tuning["batchMode"]
@@ -7101,7 +6820,7 @@ var DetectionPipelineAddon = class DetectionPipelineAddon extends BaseAddon {
 	* a reason to disagree.
 	*/
 	resolveBackendTuning() {
-		const t = tuningFor(this.config.engineBackend === "auto" ? this.provider?.resolvedEngineBackend() ?? "onnx" : toRuntimeId(this.config.engineBackend));
+		const t = tuningFor(this.provider?.resolvedEngineBackend() ?? "onnx");
 		const num = (v, dflt) => typeof v === "number" && v > 0 ? v : dflt;
 		const batch = (v, dflt) => v === "none" || v === "list" || v === "window" ? v : dflt;
 		return {
@@ -7164,9 +6883,6 @@ var DetectionPipelineAddon = class DetectionPipelineAddon extends BaseAddon {
 			await this.provider.init();
 			await this.provider.setApi(this.ctx);
 		}
-		if (!this.config.probedBestEngine) 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();
 		this.engineMetricsTimer = setInterval(() => this.emitEngineMetricsSnapshot(), ENGINE_METRICS_SNAPSHOT_INTERVAL_MS);
 		this.lastAppliedPoolConfig = this.snapshotPoolConfig();
@@ -7280,21 +6996,18 @@ var DetectionPipelineAddon = class DetectionPipelineAddon extends BaseAddon {
 	}
 	/**
 	* BaseAddon calls `onConfigChanged` after every settings write. This is the
-	* SOLE apply path for engine + tuning changes — none of those fields declare
+	* SOLE apply path for tuning changes — none of those fields declare
 	* `requiresRestart` anymore (an addon restart re-probes hardware + reloads
-	* every model on every set, which is exactly what we want to avoid). Instead:
-	*  - Pool-bound tuning (`concurrency`/`batchMode`/`windowMs`/…) → in-place
-	*    pool respawn when the snapshot flips (`poolConfigChanged` below).
-	*  - Engine cascade (`engineBackend`/`engineDevice`) → the provider's
-	*    `onEngineSelectionChanged` disposes the device-bound factory so the next
-	*    runPipeline rebuilds the pool on the new selection, in place.
-	* Both apply optimistically — the inference gate stays closed for the short
-	* re-spin, frames are dropped (never crashed), no addon bounce.
+	* every model on every set, which is exactly what we want to avoid): pool-bound
+	* tuning (`concurrency`/`batchMode`/`windowMs`/…) drives an in-place pool
+	* respawn when the snapshot flips (`poolConfigChanged` below). The engine
+	* SELECTION is no longer operator-facing — the node-default backend is derived
+	* once at boot (`setApi` → `resolveAutoEngine`) from static hardware, so there
+	* is no per-write engine re-select. The respawn applies optimistically — the
+	* inference gate stays closed for the short re-spin, frames are dropped (never
+	* crashed), no addon bounce.
 	*/
 	async onConfigChanged() {
-		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) } });
-		});
 		if (!this.poolConfigChanged()) return;
 		if (!this.provider) {
 			this.lastAppliedPoolConfig = this.snapshotPoolConfig();
@@ -7319,4 +7032,4 @@ var DetectionPipelineAddon = class DetectionPipelineAddon extends BaseAddon {
 	}
 };
 //#endregion
-export { ALL_STEPS, DetectionPipelineProvider, backendToFormat, DetectionPipelineAddon as default, getDefaultModelForFormat, getStepDefinition, shouldInstallOpenvino };
+export { ALL_STEPS, DetectionPipelineProvider, DetectionPipelineAddon as default, getDefaultModelForFormat, getStepDefinition, shouldInstallOpenvino };