@camstack/addon-pipeline 1.1.68 → 1.1.70

package/dist/audio-analyzer/index.js

@@ -3,7 +3,7 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 const require_chunk = require("../chunk-D6vf50IK.js");
-const require_dist = require("../dist-BxxVKcnw.js");
+const require_dist = require("../dist-BWn5k0A5.js");
 const require_node_topology_platform = require("../node-topology-platform-CFZ7F4xW.js");
 const require_model_download_service_Cp9f4dk6 = require("../model-download-service-Cp9f4dk6-Dv-oFwjN.js");
 let node_fs = require("node:fs");

package/dist/audio-analyzer/index.mjs

@@ -1,5 +1,5 @@
 import { t as __require } from "../chunk-BdkLduGY.mjs";
-import { B as errMsg, K as hydrateSchema, T as mapAudioLabelToMacro, V as BaseAddon, _ as audioAnalyzerCapability, g as audioAnalysisCapability, n as AUDIO_BACKEND_CHOICES, o as DEFAULT_AUDIO_ANALYZER_CONFIG, u as HF_BASE_URL } from "../dist-DkGHtAaK.mjs";
+import { B as errMsg, K as hydrateSchema, T as mapAudioLabelToMacro, V as BaseAddon, _ as audioAnalyzerCapability, g as audioAnalysisCapability, n as AUDIO_BACKEND_CHOICES, o as DEFAULT_AUDIO_ANALYZER_CONFIG, u as HF_BASE_URL } from "../dist-CurVt3xC.mjs";
 import { t as pickNodePlatformArch } from "../node-topology-platform-BkR_k6WT.mjs";
 import { i as downloadFile } from "../model-download-service-Cp9f4dk6-CwUb5v3Y.mjs";
 import * as fs from "node:fs";

package/dist/detection-pipeline/index.js

@@ -3,8 +3,8 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 const require_chunk = require("../chunk-D6vf50IK.js");
-const require_dist = require("../dist-BxxVKcnw.js");
-const require_step_definitions = require("../step-definitions-CAs0RD2N.js");
+const require_dist = require("../dist-BWn5k0A5.js");
+const require_step_definitions = require("../step-definitions-B7e8rPe3.js");
 const require_node_topology_platform = require("../node-topology-platform-CFZ7F4xW.js");
 const require_model_download_service_Cp9f4dk6 = require("../model-download-service-Cp9f4dk6-Dv-oFwjN.js");
 let node_child_process = require("node:child_process");
@@ -318,16 +318,16 @@ function projectNodeEngine(store, nodeId) {
 /** The object-detection step id — the only slot this resolver applies to. */
 var OBJECT_DETECTION_STEP_ID$1 = "object-detection";
 /**
-* Balanced default object-detection model per accelerator class (measured on
-* COCO val2017). `'cpu'` maps to `null` → the caller substitutes the step's
-* own `defaultModelId` (`yolo26n`), the safe nano that does not collapse on
-* small objects. The three accelerated ids are reduced-input YOLO26 variants
-* shipped in the catalog (onnx + coreml + openvino builds each).
+* Balanced default object-detection model per accelerator class. `'cpu'` maps to
+* `null` → the caller substitutes the step's own `defaultModelId` (`yolo26n`).
+* INTEL NPU + iGPU default to OUR YOLOv9 (int8 @320): yolo26 does NOT compile on
+* the Intel NPU (arch incompat → 0 frames), while yolov9 runs on it (~298 fps
+* measured). Apple ANE stays on yolo26 until the CoreML yolov9 build lands.
 */
 var MODEL_BY_CLASS = {
-	"apple-ane": "yolo26l-256",
-	"intel-npu": "yolo26m-320",
-	"intel-gpu": "yolo26m-256",
+	"apple-ane": "yolov9m-320",
+	"intel-npu": "yolov9m-320-int8",
+	"intel-gpu": "yolov9m-320-int8",
 	cpu: null
 };
 /**
@@ -567,6 +567,7 @@ var PoolWorker = class {
 			concurrency: this.opts.concurrency,
 			models: initialModels.map((m) => serializeModelConfig(m))
 		};
+		if (this.opts.device) config["device"] = this.opts.device;
 		if (this.opts.tuning) {
 			config["batch_mode"] = this.opts.tuning.batchMode;
 			config["window_ms"] = this.opts.tuning.windowMs;
@@ -814,7 +815,9 @@ var SharedInferencePool = class {
 		this.concurrency = Math.max(1, options.concurrency ?? 1);
 		this.tuning = options.tuning ?? null;
 		this.numWorkers = Math.max(1, options.numWorkers ?? 1);
+		this.device = options.device;
 	}
+	device;
 	/** Pid of the first worker (for legacy callers). Use `getPids()` for all. */
 	getPid() {
 		return this.workers[0]?.getPid() ?? null;
@@ -836,7 +839,8 @@ var SharedInferencePool = class {
 			concurrency: this.concurrency,
 			tuning: this.tuning,
 			logger: this.log,
-			workerLabel: `w${i}`
+			workerLabel: `w${i}`,
+			...this.device ? { device: this.device } : {}
 		}));
 		const t0 = performance.now();
 		const results = await Promise.all(this.workers.map((w) => w.initialize(initialModels)));
@@ -1495,7 +1499,8 @@ var EngineFactory = class {
 		this.pool = new SharedInferencePool(pythonPath, poolRuntime, this.log.child("pool"), {
 			concurrency,
 			tuning: resolvedTuning,
-			numWorkers
+			numWorkers,
+			...this.opts.engine.device ? { device: this.opts.engine.device } : {}
 		});
 		this.poolManager = new PipelineModelManager(this.pool, (stepId, modelId) => this.buildPoolModelConfig(stepId, modelId, poolRuntime), this.log.child("model-mgr"));
 		await this.pool.initialize([]);
@@ -1543,6 +1548,39 @@ 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.
+*/
+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];
+	if (format === void 0) throw new Error(`resolveDeviceEngine: unknown backend "${backend}" in deviceKey "${deviceKey}"`);
+	return {
+		runtime: "python",
+		backend,
+		format,
+		device
+	};
+}
+//#endregion
 //#region src/detection-pipeline/engine-provisioner.ts
 /** Incremental backoff growing to a ~5 min cap; retries indefinitely at cap. */
 var BACKOFF_SCHEDULE_MS = [
@@ -3938,6 +3976,15 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	detectionConfigSchemaSource;
 	executorOptions;
 	engineFactory = null;
+	/**
+	* Per-device engine factories (Phase 2 multi-device), keyed by deviceKey
+	* (`<backend>:<device>`, e.g. `openvino:npu`, `edgetpu:usb`). Each is its own
+	* inference pool, warm CONCURRENTLY — so the node runs detection on NPU + iGPU
+	* + Coral in parallel. The default (node current-engine) pool stays
+	* `this.engineFactory`; device routing is a LOCAL per-dispatch choice that
+	* never mutates shared state, so concurrent multi-device sessions don't race.
+	*/
+	factoriesByDevice = /* @__PURE__ */ new Map();
 	executor = null;
 	currentSteps = null;
 	currentEngine;
@@ -5056,8 +5103,12 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 			emit(`Image: ${imageWidth}×${imageHeight}`);
 		}
 		decodeMs = performance.now() - decodeT0;
-		const resolveFormat = input.engine?.format ?? this.currentEngine.format;
-		const resolveEngine = input.engine ? {
+		const deviceEngine = input.deviceKey ? resolveDeviceEngine(input.deviceKey) : void 0;
+		const resolveFormat = deviceEngine?.format ?? input.engine?.format ?? this.currentEngine.format;
+		const resolveEngine = deviceEngine ? {
+			backend: deviceEngine.backend,
+			device: deviceEngine.device ?? null
+		} : input.engine ? {
 			backend: input.engine.backend,
 			device: input.engine.device ?? null
 		} : {
@@ -5158,7 +5209,9 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 				logger: this.log
 			});
 			this.executor = executor;
-			const needed = enabledSteps.filter((s) => !this.engineFactory?.isLoadedWithModel(s.addonId, s.modelId));
+			const dispatchEngine = input.deviceKey ? resolveDeviceEngine(input.deviceKey) : runEngine;
+			const dispatchFactory = input.deviceKey ? await this.resolveDeviceFactory(input.deviceKey) : this.engineFactory;
+			const needed = enabledSteps.filter((s) => !dispatchFactory.isLoadedWithModel(s.addonId, s.modelId));
 			if (needed.length > 0) {
 				this.log.info("Benchmark: models to load", { meta: {
 					count: needed.length,
@@ -5169,11 +5222,11 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 					addonId: s.addonId,
 					modelId: s.modelId
 				});
-				await this.ensureModelsForSteps(benchmarkSteps);
+				await this.ensureModelsForSteps(benchmarkSteps, dispatchFactory, dispatchEngine.format);
 				emit(`All models loaded`);
 			}
 			emit("Running inference...");
-			const tree = buildExecutableTree(benchmarkSteps, (stepId) => this.engineFactory.getEngine(stepId));
+			const tree = buildExecutableTree(benchmarkSteps, (stepId) => dispatchFactory.getEngine(stepId));
 			setupMs = performance.now() - wallT0 - decodeMs;
 			const isRuntime = Boolean(runtimeFrame);
 			const effectiveDeviceId = input.deviceId ?? 0;
@@ -5417,19 +5470,20 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	* before any of them committed via `stepToLoaded.set`.
 	*/
 	modelLoadInFlight = null;
-	/** Ensure all models needed by steps are downloaded and loaded in the engine pool. */
-	async ensureModelsForSteps(steps) {
+	/** Ensure all models needed by steps are downloaded and loaded in the engine pool.
+	* `factory`/`format` default to the node's engine; a per-device dispatch passes
+	* that device's factory + format (Phase 2 multi-device). */
+	async ensureModelsForSteps(steps, factory = this.engineFactory, format = this.currentEngine?.format ?? "onnx") {
 		while (this.modelLoadInFlight) await this.modelLoadInFlight;
 		const allEnabled = flattenSteps(steps);
 		const needed = [];
 		for (const step of allEnabled) {
 			if (!step.enabled) continue;
-			if (this.engineFactory?.isLoadedWithModel(step.addonId, step.modelId)) continue;
+			if (factory?.isLoadedWithModel(step.addonId, step.modelId)) continue;
 			needed.push(step);
 		}
 		if (needed.length === 0) return;
 		const work = (async () => {
-			const format = this.currentEngine?.format ?? "onnx";
 			for (const step of needed) {
 				const modelEntry = await this.resolveModelEntry(step.addonId, step.modelId);
 				if (modelEntry && !require_model_download_service_Cp9f4dk6.isModelDownloaded(this.modelsDir, modelEntry, format)) {
@@ -5445,7 +5499,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 				count: needed.length,
 				models: needed.map((s) => `${s.addonId}/${s.modelId}`)
 			} });
-			await this.engineFactory.loadAdditional(needed);
+			await factory.loadAdditional(needed);
 		})();
 		this.modelLoadInFlight = work;
 		try {
@@ -5550,8 +5604,12 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	}
 	async runPipelineBatchImpl(input) {
 		if (input.frames.length === 0) return { results: [] };
-		const resolveFormat = input.engine?.format ?? this.currentEngine.format;
-		const resolveEngine = input.engine ? {
+		const deviceEngine = input.deviceKey ? resolveDeviceEngine(input.deviceKey) : void 0;
+		const resolveFormat = deviceEngine?.format ?? input.engine?.format ?? this.currentEngine.format;
+		const resolveEngine = deviceEngine ? {
+			backend: deviceEngine.backend,
+			device: deviceEngine.device ?? null
+		} : input.engine ? {
 			backend: input.engine.backend,
 			device: input.engine.device ?? null
 		} : {
@@ -5580,9 +5638,9 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 		await this.ensureEngineFactory();
 		const restoreEngine = await this.applyEngineOverride(input.engine);
 		try {
-			const factory = this.engineFactory;
+			const factory = input.deviceKey ? await this.resolveDeviceFactory(input.deviceKey) : this.engineFactory;
 			if (!factory) throw new Error("runPipelineBatch: factory not initialised");
-			if (enabledSteps.filter((s) => !factory.isLoadedWithModel(s.addonId, s.modelId)).length > 0) await this.ensureModelsForSteps(benchmarkSteps);
+			if (enabledSteps.filter((s) => !factory.isLoadedWithModel(s.addonId, s.modelId)).length > 0) await this.ensureModelsForSteps(benchmarkSteps, factory, resolveFormat);
 			const canFastPath = singleRoot && allRaw && uniformDims && factory.supportsBatch();
 			this.log.info("runPipelineBatch path decision", { meta: {
 				phase: "batch",
@@ -5596,7 +5654,8 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 				steps: input.steps,
 				frame,
 				deviceId: input.deviceId,
-				sessionId: input.sessionId
+				sessionId: input.sessionId,
+				deviceKey: input.deviceKey
 			}))) };
 			const items = input.frames.map((frame) => ({
 				raw: Buffer.from(frame.data),
@@ -5730,6 +5789,9 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 			this.engineFactory = null;
 			this.executor = null;
 		}
+		const deviceFactories = Array.from(this.factoriesByDevice.values());
+		this.factoriesByDevice.clear();
+		await Promise.all(deviceFactories.map((f) => f.dispose().catch(() => void 0)));
 		for (const id of Array.from(this.deviceProxies.keys())) this.releaseDeviceProxy(id);
 	}
 	/**
@@ -5849,6 +5911,58 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 		await this.engineFactory.initialize([]);
 	}
 	/**
+	* Get (or lazily build) the inference-pool factory for an explicit device
+	* (`<backend>:<device>`, e.g. `openvino:npu`, `edgetpu:usb`) — Phase 2
+	* multi-device. Each device runs its OWN pool concurrently. Never mutates
+	* `this.engineFactory`; when the requested device equals the node's current
+	* engine the default pool is reused (no duplicate pool for the same device).
+	*/
+	/**
+	* In-flight device-pool creations, keyed by deviceKey. Single-flights
+	* `resolveDeviceFactory` so two concurrent calls for the SAME device never
+	* both spawn a pool — critical for single-context accelerators like the Coral
+	* Edge TPU, where two pools racing to `load_delegate` on the one USB unit both
+	* fail (the loser can't claim the already-held device).
+	*/
+	deviceFactoryInflight = /* @__PURE__ */ new Map();
+	async resolveDeviceFactory(deviceKey) {
+		const engine = resolveDeviceEngine(deviceKey);
+		if (enginesEqual(engine, this.currentEngine)) {
+			await this.ensureEngineFactory();
+			return this.engineFactory;
+		}
+		const existing = this.factoriesByDevice.get(deviceKey);
+		if (existing) return existing;
+		const inflight = this.deviceFactoryInflight.get(deviceKey);
+		if (inflight) return inflight;
+		const creation = (async () => {
+			await this.ensureBackendDeps(engine);
+			const factory = new EngineFactory({
+				engine,
+				modelsDir: this.modelsDir,
+				logger: this.log.child(`engine:${deviceKey}`),
+				pythonPath: this.executorOptions.pythonPath ?? "",
+				concurrency: this.executorOptions.concurrency,
+				tuning: this.executorOptions.tuning,
+				numWorkers: this.executorOptions.numWorkers
+			});
+			try {
+				await factory.initialize([]);
+			} catch (err) {
+				await factory.dispose().catch(() => void 0);
+				throw err;
+			}
+			this.factoriesByDevice.set(deviceKey, factory);
+			return factory;
+		})();
+		this.deviceFactoryInflight.set(deviceKey, creation);
+		try {
+			return await creation;
+		} finally {
+			this.deviceFactoryInflight.delete(deviceKey);
+		}
+	}
+	/**
 	* 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
@@ -6039,6 +6153,20 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 				idleTtlMs: DetectionPipelineProvider.OVERRIDE_CACHE_TTL_MS
 			});
 		}
+		for (const [deviceKey, factory] of this.factoriesByDevice) {
+			const eng = resolveDeviceEngine(deviceKey);
+			const loaded = factory.listLoaded();
+			out.push({
+				engineKey: `${eng.runtime}/${eng.backend}/${eng.device ?? "default"} [${deviceKey}]`,
+				engine: eng,
+				modelsLoaded: loaded.map((l) => `${l.stepId}/${l.modelId}`),
+				inUseByCameras: [],
+				kind: "device-pool",
+				poolPid: factory.getPoolPid(),
+				idleMs: null,
+				idleTtlMs: null
+			});
+		}
 		return out;
 	}
 	async spinEngine(input) {

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-DkGHtAaK.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-Delhq28w.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 { 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";
@@ -310,16 +310,16 @@ function projectNodeEngine(store, nodeId) {
 /** The object-detection step id — the only slot this resolver applies to. */
 var OBJECT_DETECTION_STEP_ID$1 = "object-detection";
 /**
-* Balanced default object-detection model per accelerator class (measured on
-* COCO val2017). `'cpu'` maps to `null` → the caller substitutes the step's
-* own `defaultModelId` (`yolo26n`), the safe nano that does not collapse on
-* small objects. The three accelerated ids are reduced-input YOLO26 variants
-* shipped in the catalog (onnx + coreml + openvino builds each).
+* Balanced default object-detection model per accelerator class. `'cpu'` maps to
+* `null` → the caller substitutes the step's own `defaultModelId` (`yolo26n`).
+* INTEL NPU + iGPU default to OUR YOLOv9 (int8 @320): yolo26 does NOT compile on
+* the Intel NPU (arch incompat → 0 frames), while yolov9 runs on it (~298 fps
+* measured). Apple ANE stays on yolo26 until the CoreML yolov9 build lands.
 */
 var MODEL_BY_CLASS = {
-	"apple-ane": "yolo26l-256",
-	"intel-npu": "yolo26m-320",
-	"intel-gpu": "yolo26m-256",
+	"apple-ane": "yolov9m-320",
+	"intel-npu": "yolov9m-320-int8",
+	"intel-gpu": "yolov9m-320-int8",
 	cpu: null
 };
 /**
@@ -559,6 +559,7 @@ var PoolWorker = class {
 			concurrency: this.opts.concurrency,
 			models: initialModels.map((m) => serializeModelConfig(m))
 		};
+		if (this.opts.device) config["device"] = this.opts.device;
 		if (this.opts.tuning) {
 			config["batch_mode"] = this.opts.tuning.batchMode;
 			config["window_ms"] = this.opts.tuning.windowMs;
@@ -806,7 +807,9 @@ var SharedInferencePool = class {
 		this.concurrency = Math.max(1, options.concurrency ?? 1);
 		this.tuning = options.tuning ?? null;
 		this.numWorkers = Math.max(1, options.numWorkers ?? 1);
+		this.device = options.device;
 	}
+	device;
 	/** Pid of the first worker (for legacy callers). Use `getPids()` for all. */
 	getPid() {
 		return this.workers[0]?.getPid() ?? null;
@@ -828,7 +831,8 @@ var SharedInferencePool = class {
 			concurrency: this.concurrency,
 			tuning: this.tuning,
 			logger: this.log,
-			workerLabel: `w${i}`
+			workerLabel: `w${i}`,
+			...this.device ? { device: this.device } : {}
 		}));
 		const t0 = performance.now();
 		const results = await Promise.all(this.workers.map((w) => w.initialize(initialModels)));
@@ -1487,7 +1491,8 @@ var EngineFactory = class {
 		this.pool = new SharedInferencePool(pythonPath, poolRuntime, this.log.child("pool"), {
 			concurrency,
 			tuning: resolvedTuning,
-			numWorkers
+			numWorkers,
+			...this.opts.engine.device ? { device: this.opts.engine.device } : {}
 		});
 		this.poolManager = new PipelineModelManager(this.pool, (stepId, modelId) => this.buildPoolModelConfig(stepId, modelId, poolRuntime), this.log.child("model-mgr"));
 		await this.pool.initialize([]);
@@ -1535,6 +1540,39 @@ 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.
+*/
+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];
+	if (format === void 0) throw new Error(`resolveDeviceEngine: unknown backend "${backend}" in deviceKey "${deviceKey}"`);
+	return {
+		runtime: "python",
+		backend,
+		format,
+		device
+	};
+}
+//#endregion
 //#region src/detection-pipeline/engine-provisioner.ts
 /** Incremental backoff growing to a ~5 min cap; retries indefinitely at cap. */
 var BACKOFF_SCHEDULE_MS = [
@@ -3930,6 +3968,15 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	detectionConfigSchemaSource;
 	executorOptions;
 	engineFactory = null;
+	/**
+	* Per-device engine factories (Phase 2 multi-device), keyed by deviceKey
+	* (`<backend>:<device>`, e.g. `openvino:npu`, `edgetpu:usb`). Each is its own
+	* inference pool, warm CONCURRENTLY — so the node runs detection on NPU + iGPU
+	* + Coral in parallel. The default (node current-engine) pool stays
+	* `this.engineFactory`; device routing is a LOCAL per-dispatch choice that
+	* never mutates shared state, so concurrent multi-device sessions don't race.
+	*/
+	factoriesByDevice = /* @__PURE__ */ new Map();
 	executor = null;
 	currentSteps = null;
 	currentEngine;
@@ -5048,8 +5095,12 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 			emit(`Image: ${imageWidth}×${imageHeight}`);
 		}
 		decodeMs = performance.now() - decodeT0;
-		const resolveFormat = input.engine?.format ?? this.currentEngine.format;
-		const resolveEngine = input.engine ? {
+		const deviceEngine = input.deviceKey ? resolveDeviceEngine(input.deviceKey) : void 0;
+		const resolveFormat = deviceEngine?.format ?? input.engine?.format ?? this.currentEngine.format;
+		const resolveEngine = deviceEngine ? {
+			backend: deviceEngine.backend,
+			device: deviceEngine.device ?? null
+		} : input.engine ? {
 			backend: input.engine.backend,
 			device: input.engine.device ?? null
 		} : {
@@ -5150,7 +5201,9 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 				logger: this.log
 			});
 			this.executor = executor;
-			const needed = enabledSteps.filter((s) => !this.engineFactory?.isLoadedWithModel(s.addonId, s.modelId));
+			const dispatchEngine = input.deviceKey ? resolveDeviceEngine(input.deviceKey) : runEngine;
+			const dispatchFactory = input.deviceKey ? await this.resolveDeviceFactory(input.deviceKey) : this.engineFactory;
+			const needed = enabledSteps.filter((s) => !dispatchFactory.isLoadedWithModel(s.addonId, s.modelId));
 			if (needed.length > 0) {
 				this.log.info("Benchmark: models to load", { meta: {
 					count: needed.length,
@@ -5161,11 +5214,11 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 					addonId: s.addonId,
 					modelId: s.modelId
 				});
-				await this.ensureModelsForSteps(benchmarkSteps);
+				await this.ensureModelsForSteps(benchmarkSteps, dispatchFactory, dispatchEngine.format);
 				emit(`All models loaded`);
 			}
 			emit("Running inference...");
-			const tree = buildExecutableTree(benchmarkSteps, (stepId) => this.engineFactory.getEngine(stepId));
+			const tree = buildExecutableTree(benchmarkSteps, (stepId) => dispatchFactory.getEngine(stepId));
 			setupMs = performance.now() - wallT0 - decodeMs;
 			const isRuntime = Boolean(runtimeFrame);
 			const effectiveDeviceId = input.deviceId ?? 0;
@@ -5409,19 +5462,20 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	* before any of them committed via `stepToLoaded.set`.
 	*/
 	modelLoadInFlight = null;
-	/** Ensure all models needed by steps are downloaded and loaded in the engine pool. */
-	async ensureModelsForSteps(steps) {
+	/** Ensure all models needed by steps are downloaded and loaded in the engine pool.
+	* `factory`/`format` default to the node's engine; a per-device dispatch passes
+	* that device's factory + format (Phase 2 multi-device). */
+	async ensureModelsForSteps(steps, factory = this.engineFactory, format = this.currentEngine?.format ?? "onnx") {
 		while (this.modelLoadInFlight) await this.modelLoadInFlight;
 		const allEnabled = flattenSteps(steps);
 		const needed = [];
 		for (const step of allEnabled) {
 			if (!step.enabled) continue;
-			if (this.engineFactory?.isLoadedWithModel(step.addonId, step.modelId)) continue;
+			if (factory?.isLoadedWithModel(step.addonId, step.modelId)) continue;
 			needed.push(step);
 		}
 		if (needed.length === 0) return;
 		const work = (async () => {
-			const format = this.currentEngine?.format ?? "onnx";
 			for (const step of needed) {
 				const modelEntry = await this.resolveModelEntry(step.addonId, step.modelId);
 				if (modelEntry && !isModelDownloaded(this.modelsDir, modelEntry, format)) {
@@ -5437,7 +5491,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 				count: needed.length,
 				models: needed.map((s) => `${s.addonId}/${s.modelId}`)
 			} });
-			await this.engineFactory.loadAdditional(needed);
+			await factory.loadAdditional(needed);
 		})();
 		this.modelLoadInFlight = work;
 		try {
@@ -5542,8 +5596,12 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	}
 	async runPipelineBatchImpl(input) {
 		if (input.frames.length === 0) return { results: [] };
-		const resolveFormat = input.engine?.format ?? this.currentEngine.format;
-		const resolveEngine = input.engine ? {
+		const deviceEngine = input.deviceKey ? resolveDeviceEngine(input.deviceKey) : void 0;
+		const resolveFormat = deviceEngine?.format ?? input.engine?.format ?? this.currentEngine.format;
+		const resolveEngine = deviceEngine ? {
+			backend: deviceEngine.backend,
+			device: deviceEngine.device ?? null
+		} : input.engine ? {
 			backend: input.engine.backend,
 			device: input.engine.device ?? null
 		} : {
@@ -5572,9 +5630,9 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 		await this.ensureEngineFactory();
 		const restoreEngine = await this.applyEngineOverride(input.engine);
 		try {
-			const factory = this.engineFactory;
+			const factory = input.deviceKey ? await this.resolveDeviceFactory(input.deviceKey) : this.engineFactory;
 			if (!factory) throw new Error("runPipelineBatch: factory not initialised");
-			if (enabledSteps.filter((s) => !factory.isLoadedWithModel(s.addonId, s.modelId)).length > 0) await this.ensureModelsForSteps(benchmarkSteps);
+			if (enabledSteps.filter((s) => !factory.isLoadedWithModel(s.addonId, s.modelId)).length > 0) await this.ensureModelsForSteps(benchmarkSteps, factory, resolveFormat);
 			const canFastPath = singleRoot && allRaw && uniformDims && factory.supportsBatch();
 			this.log.info("runPipelineBatch path decision", { meta: {
 				phase: "batch",
@@ -5588,7 +5646,8 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 				steps: input.steps,
 				frame,
 				deviceId: input.deviceId,
-				sessionId: input.sessionId
+				sessionId: input.sessionId,
+				deviceKey: input.deviceKey
 			}))) };
 			const items = input.frames.map((frame) => ({
 				raw: Buffer.from(frame.data),
@@ -5722,6 +5781,9 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 			this.engineFactory = null;
 			this.executor = null;
 		}
+		const deviceFactories = Array.from(this.factoriesByDevice.values());
+		this.factoriesByDevice.clear();
+		await Promise.all(deviceFactories.map((f) => f.dispose().catch(() => void 0)));
 		for (const id of Array.from(this.deviceProxies.keys())) this.releaseDeviceProxy(id);
 	}
 	/**
@@ -5841,6 +5903,58 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 		await this.engineFactory.initialize([]);
 	}
 	/**
+	* Get (or lazily build) the inference-pool factory for an explicit device
+	* (`<backend>:<device>`, e.g. `openvino:npu`, `edgetpu:usb`) — Phase 2
+	* multi-device. Each device runs its OWN pool concurrently. Never mutates
+	* `this.engineFactory`; when the requested device equals the node's current
+	* engine the default pool is reused (no duplicate pool for the same device).
+	*/
+	/**
+	* In-flight device-pool creations, keyed by deviceKey. Single-flights
+	* `resolveDeviceFactory` so two concurrent calls for the SAME device never
+	* both spawn a pool — critical for single-context accelerators like the Coral
+	* Edge TPU, where two pools racing to `load_delegate` on the one USB unit both
+	* fail (the loser can't claim the already-held device).
+	*/
+	deviceFactoryInflight = /* @__PURE__ */ new Map();
+	async resolveDeviceFactory(deviceKey) {
+		const engine = resolveDeviceEngine(deviceKey);
+		if (enginesEqual(engine, this.currentEngine)) {
+			await this.ensureEngineFactory();
+			return this.engineFactory;
+		}
+		const existing = this.factoriesByDevice.get(deviceKey);
+		if (existing) return existing;
+		const inflight = this.deviceFactoryInflight.get(deviceKey);
+		if (inflight) return inflight;
+		const creation = (async () => {
+			await this.ensureBackendDeps(engine);
+			const factory = new EngineFactory({
+				engine,
+				modelsDir: this.modelsDir,
+				logger: this.log.child(`engine:${deviceKey}`),
+				pythonPath: this.executorOptions.pythonPath ?? "",
+				concurrency: this.executorOptions.concurrency,
+				tuning: this.executorOptions.tuning,
+				numWorkers: this.executorOptions.numWorkers
+			});
+			try {
+				await factory.initialize([]);
+			} catch (err) {
+				await factory.dispose().catch(() => void 0);
+				throw err;
+			}
+			this.factoriesByDevice.set(deviceKey, factory);
+			return factory;
+		})();
+		this.deviceFactoryInflight.set(deviceKey, creation);
+		try {
+			return await creation;
+		} finally {
+			this.deviceFactoryInflight.delete(deviceKey);
+		}
+	}
+	/**
 	* 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
@@ -6031,6 +6145,20 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 				idleTtlMs: DetectionPipelineProvider.OVERRIDE_CACHE_TTL_MS
 			});
 		}
+		for (const [deviceKey, factory] of this.factoriesByDevice) {
+			const eng = resolveDeviceEngine(deviceKey);
+			const loaded = factory.listLoaded();
+			out.push({
+				engineKey: `${eng.runtime}/${eng.backend}/${eng.device ?? "default"} [${deviceKey}]`,
+				engine: eng,
+				modelsLoaded: loaded.map((l) => `${l.stepId}/${l.modelId}`),
+				inUseByCameras: [],
+				kind: "device-pool",
+				poolPid: factory.getPoolPid(),
+				idleMs: null,
+				idleTtlMs: null
+			});
+		}
 		return out;
 	}
 	async spinEngine(input) {