@camstack/addon-pipeline 1.0.0 → 1.0.2

package/dist/detection-pipeline/index.js

@@ -3,14 +3,14 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 const require_chunk = require("../chunk-D6vf50IK.js");
-const require_dist = require("../dist-7ewQjTle.js");
+const require_dist = require("../dist-C1goFC50.js");
 let node_fs = require("node:fs");
 node_fs = require_chunk.__toESM(node_fs);
 let node_path = require("node:path");
 node_path = require_chunk.__toESM(node_path);
 let node_os = require("node:os");
 node_os = require_chunk.__toESM(node_os);
-let _camstack_core = require("@camstack/core");
+let _camstack_system = require("@camstack/system");
 let node_child_process = require("node:child_process");
 let sharp = require("sharp");
 sharp = require_chunk.__toESM(sharp);
@@ -1963,215 +1963,6 @@ function getDefaultModelForFormat(stepId, format) {
 	})[0].id;
 }
 //#endregion
-//#region src/detection-pipeline/engine/node-engine-manager.ts
-var NodeEngineManager = class {
-	backend;
-	resolveModelPath;
-	createEngine;
-	engines = /* @__PURE__ */ new Map();
-	log;
-	constructor(backend, resolveModelPath, createEngine, logger) {
-		this.backend = backend;
-		this.resolveModelPath = resolveModelPath;
-		this.createEngine = createEngine;
-		this.log = logger;
-	}
-	/**
-	* Apply a new pipeline configuration.
-	* Loads/unloads engines for steps that changed.
-	*/
-	async applyConfig(newSteps) {
-		const enabledSteps = flattenEnabledVideoSteps(newSteps);
-		const desiredMap = /* @__PURE__ */ new Map();
-		for (const step of enabledSteps) desiredMap.set(step.addonId, step);
-		for (const [stepId, loaded] of this.engines) if (!desiredMap.has(stepId)) {
-			this.log.info("Unloading ONNX engine for step", { meta: { step: stepId } });
-			await loaded.engine.dispose();
-			this.engines.delete(stepId);
-		}
-		for (const [stepId, step] of desiredMap) {
-			const existing = this.engines.get(stepId);
-			if (existing && existing.modelId === step.modelId) continue;
-			if (existing) {
-				this.log.info("Replacing ONNX engine for step", { meta: {
-					step: stepId,
-					fromModelId: existing.modelId,
-					toModelId: step.modelId
-				} });
-				await existing.engine.dispose();
-			} else this.log.info("Loading ONNX engine for step", { meta: {
-				step: stepId,
-				modelId: step.modelId
-			} });
-			const modelEntry = getStepDefinition(stepId).models.find((m) => m.id === step.modelId);
-			if (!modelEntry) throw new Error(`Model "${step.modelId}" not found in step "${stepId}" catalog`);
-			const modelPath = this.resolveModelPath(stepId, step.modelId);
-			const meta = {
-				inputSize: modelEntry.inputSize,
-				inputNormalization: modelEntry.inputNormalization ?? "zero-one",
-				inputLayout: modelEntry.inputLayout ?? "nchw",
-				preprocessMode: modelEntry.preprocessMode ?? "letterbox"
-			};
-			const engine = await this.createEngine(modelPath, this.backend, meta, this.log.child(stepId));
-			this.engines.set(stepId, {
-				stepId,
-				modelId: step.modelId,
-				engine
-			});
-		}
-	}
-	/**
-	* Get an IInferenceEngine for a step.
-	* @throws if the step is not loaded.
-	*/
-	getEngine(stepId) {
-		const loaded = this.engines.get(stepId);
-		if (!loaded) throw new Error(`ONNX engine for step "${stepId}" is not loaded`);
-		return loaded.engine;
-	}
-	isLoaded(stepId) {
-		return this.engines.has(stepId);
-	}
-	isLoadedWithModel(stepId, modelId) {
-		const loaded = this.engines.get(stepId);
-		return loaded !== void 0 && loaded.modelId === modelId;
-	}
-	async loadAdditional(steps) {
-		const enabledSteps = flattenEnabledVideoSteps(steps);
-		for (const step of enabledSteps) {
-			const existing = this.engines.get(step.addonId);
-			if (existing && existing.modelId === step.modelId) continue;
-			if (existing) {
-				this.log.info("Replacing ONNX engine for step", { meta: {
-					step: step.addonId,
-					fromModelId: existing.modelId,
-					toModelId: step.modelId
-				} });
-				await existing.engine.dispose();
-			} else this.log.info("Loading additional ONNX engine for step", { meta: {
-				step: step.addonId,
-				modelId: step.modelId
-			} });
-			const modelEntry = getStepDefinition(step.addonId).models.find((m) => m.id === step.modelId);
-			if (!modelEntry) throw new Error(`Model "${step.modelId}" not found in step "${step.addonId}" catalog`);
-			const modelPath = this.resolveModelPath(step.addonId, step.modelId);
-			const meta = {
-				inputSize: modelEntry.inputSize,
-				inputNormalization: modelEntry.inputNormalization ?? "zero-one",
-				inputLayout: modelEntry.inputLayout ?? "nchw",
-				preprocessMode: modelEntry.preprocessMode ?? "letterbox"
-			};
-			const engine = await this.createEngine(modelPath, this.backend, meta, this.log.child(step.addonId));
-			this.engines.set(step.addonId, {
-				stepId: step.addonId,
-				modelId: step.modelId,
-				engine
-			});
-		}
-	}
-	listLoaded() {
-		return [...this.engines.values()].map((l) => ({
-			stepId: l.stepId,
-			modelId: l.modelId
-		}));
-	}
-	async disposeAll() {
-		for (const [, loaded] of this.engines) await loaded.engine.dispose();
-		this.engines.clear();
-	}
-};
-//#endregion
-//#region src/detection-pipeline/engine/model-shape-validator.ts
-/**
-* Runtime input-shape validator for ONNX models.
-*
-* Reads the actual graph input dimensions from a locally-downloaded
-* ONNX model and compares them against the catalog declaration. Used
-* by the engine factory at load time so a converter regression or a
-* stale catalog entry surfaces as a one-line warning rather than
-* silent incorrect inference (preprocess uses one size, the model
-* expects another → garbage detections).
-*
-* Only ONNX is validated here. CoreML and OpenVINO converters in our
-* pipeline derive shape from the same source ONNX, so a passing ONNX
-* check covers all three formats. If they ever diverge, extend with a
-* format-specific reader (Manifest.json for .mlpackage, root <input>
-* tag for OpenVINO XML).
-*/
-/**
-* Probe an ONNX file for its first input's shape. Returns null if the
-* file is missing or unparseable — callers should treat null as
-* "validation skipped" (not a mismatch).
-*
-* Implementation: uses `onnxruntime-node` to create a session and read
-* `inputMetadata`. The session is released immediately after probing.
-*/
-async function readOnnxInputShape(onnxPath) {
-	if (!node_fs.existsSync(onnxPath)) return null;
-	try {
-		const session = await (await import("onnxruntime-node")).InferenceSession.create(onnxPath);
-		const firstInputName = session.inputNames[0];
-		if (!firstInputName) return null;
-		const numeric = (session.inputMetadata?.[firstInputName]?.dimensions ?? []).map((d) => typeof d === "number" ? d : null);
-		let height = null;
-		let width = null;
-		if (numeric.length === 4) {
-			const candidates = numeric.map((v, i) => ({
-				v,
-				i
-			})).filter((e) => typeof e.v === "number" && e.v > 4).toSorted((a, b) => b.v - a.v);
-			if (candidates.length >= 2) {
-				const sorted = candidates.slice(0, 2).toSorted((a, b) => a.i - b.i);
-				height = sorted[0]?.v ?? null;
-				width = sorted[1]?.v ?? null;
-			}
-		}
-		if (typeof session.release === "function") await session.release();
-		return {
-			height,
-			width
-		};
-	} catch {
-		return null;
-	}
-}
-/**
-* Check the catalog `expected` size against the actual ONNX input shape.
-* Returns a ShapeMismatch when the actual shape is known and disagrees;
-* returns null when the file is missing, unparseable, or matches.
-*/
-async function validateOnnxInputShape(opts) {
-	const actual = await readOnnxInputShape(opts.modelPath);
-	if (!actual) return null;
-	const matchesH = actual.height === null || actual.height === opts.expected.height;
-	const matchesW = actual.width === null || actual.width === opts.expected.width;
-	if (matchesH && matchesW) return null;
-	return {
-		modelId: opts.modelId,
-		modelPath: opts.modelPath,
-		expected: opts.expected,
-		actual
-	};
-}
-/**
-* Convenience wrapper: validate, log on mismatch via the supplied
-* logger. Returns true when validation passed (or was skipped) so
-* callers can keep loading; mismatches do not throw — they warn.
-*/
-async function checkAndLogModelShape(opts, logger) {
-	const mismatch = await validateOnnxInputShape(opts);
-	if (!mismatch) return true;
-	logger.warn("Model input shape mismatch — catalog declaration disagrees with model file", { meta: {
-		modelId: mismatch.modelId,
-		expectedWidth: mismatch.expected.width,
-		expectedHeight: mismatch.expected.height,
-		actualWidth: mismatch.actual.width,
-		actualHeight: mismatch.actual.height,
-		modelPath: mismatch.modelPath
-	} });
-	return false;
-}
-//#endregion
 //#region src/detection-pipeline/engine/engine-factory.ts
 var BACKEND_TO_POOL_RUNTIME = {
 	coreml: "coreml",
@@ -2188,32 +1979,29 @@ var RUNTIME_TO_FORMAT = {
 var EngineFactory = class {
 	pool = null;
 	poolManager = null;
-	nodeManager = null;
 	log;
 	opts;
 	constructor(opts) {
 		this.opts = opts;
 		this.log = opts.logger;
 	}
-	/** Whether this factory uses a Python pool (vs Node.js ONNX). */
+	/** Detection always uses the Python pool. */
 	get usesPythonPool() {
-		return this.opts.engine.runtime === "python";
+		return true;
 	}
 	/**
 	* Initialize the engine layer and apply initial pipeline config.
 	*/
 	async initialize(steps) {
-		if (this.usesPythonPool) await this.initPythonPool(steps);
-		else await this.initNodeEngines(steps);
+		await this.initPythonPool(steps);
 	}
 	/**
 	* Apply a new pipeline config (hot swap).
 	* Only loads/unloads models that changed.
 	*/
 	async applyConfig(steps) {
-		if (this.poolManager) await this.poolManager.applyConfig(steps);
-		else if (this.nodeManager) await this.nodeManager.applyConfig(steps);
-		else throw new Error("EngineFactory not initialized");
+		if (!this.poolManager) throw new Error("EngineFactory not initialized");
+		await this.poolManager.applyConfig(steps);
 	}
 	/**
 	* Get an IInferenceEngine for a pipeline step. Without `modelId`,
@@ -2224,49 +2012,35 @@ var EngineFactory = class {
 	* @throws if step not loaded with the requested (or active) model.
 	*/
 	getEngine(stepId, modelId) {
-		if (this.poolManager) return this.poolManager.getHandle(stepId, modelId);
-		if (this.nodeManager) return this.nodeManager.getEngine(stepId);
-		throw new Error("EngineFactory not initialized");
+		if (!this.poolManager) throw new Error("EngineFactory not initialized");
+		return this.poolManager.getHandle(stepId, modelId);
 	}
 	/** Check if a step is loaded (any variant). */
 	isLoaded(stepId) {
-		if (this.poolManager) return this.poolManager.isLoaded(stepId);
-		if (this.nodeManager) return this.nodeManager.isLoaded(stepId);
-		return false;
+		return this.poolManager?.isLoaded(stepId) ?? false;
 	}
 	/** Check if a specific (stepId, modelId) variant is resident. */
 	isLoadedWithModel(stepId, modelId) {
-		if (this.poolManager) return this.poolManager.isLoadedWithModel(stepId, modelId);
-		if (this.nodeManager) return this.nodeManager.isLoadedWithModel(stepId, modelId);
-		return false;
+		return this.poolManager?.isLoadedWithModel(stepId, modelId) ?? false;
 	}
 	/**
-	* List every loaded (stepId, modelId) variant — the pool path
-	* surfaces each warm slot independently (including bench overrides);
-	* the Node path surfaces just the active model per step.
+	* List every loaded (stepId, modelId) variant — the pool surfaces each
+	* warm slot independently (including bench overrides).
 	*/
 	listLoaded() {
-		if (this.poolManager) return this.poolManager.getLoadedSteps().map((l) => ({
+		if (!this.poolManager) return [];
+		return this.poolManager.getLoadedSteps().map((l) => ({
 			stepId: l.stepId,
 			modelId: l.modelId,
 			active: l.active
 		}));
-		if (this.nodeManager) return this.nodeManager.listLoaded().map((l) => ({
-			...l,
-			active: true
-		}));
-		return [];
 	}
 	/** Native pid of the underlying Python pool, if any. */
 	getPoolPid() {
 		return this.pool?.getPid() ?? null;
 	}
 	/**
-	* Whether this factory exposes the batched fast path
-	* (`batchInferRaw`). Only the Python pool path supports it today —
-	* Node.js ONNX engines run one inference per call with their own
-	* thread pool inside InferenceSession, so batching at this layer
-	* would just queue serially.
+	* Whether this factory exposes the batched fast path (`batchInferRaw`).
 	*/
 	supportsBatch() {
 		return this.poolManager !== null;
@@ -2280,7 +2054,7 @@ var EngineFactory = class {
 	* in one IPC round-trip, amortising the per-call envelope overhead.
 	*/
 	async batchInferRaw(stepId, items, modelId) {
-		if (!this.poolManager) throw new Error("EngineFactory.batchInferRaw: pool path not available (Node ONNX factory)");
+		if (!this.poolManager) throw new Error("EngineFactory.batchInferRaw: pool not initialized");
 		const idx = this.poolManager.getPoolIndex(stepId, modelId);
 		if (idx === null) throw new Error(`EngineFactory.batchInferRaw: step "${stepId}"${modelId ? ` (model "${modelId}")` : ""} is not loaded`);
 		return this.poolManager.getPool().inferBatch(idx, items);
@@ -2302,7 +2076,6 @@ var EngineFactory = class {
 	/** Load additional models without unloading existing ones (for benchmark/test). */
 	async loadAdditional(steps) {
 		if (this.poolManager) await this.poolManager.loadAdditional(steps);
-		else if (this.nodeManager) await this.nodeManager.loadAdditional(steps);
 	}
 	/** Shut down all engines and the pool process. */
 	async dispose() {
@@ -2311,14 +2084,10 @@ var EngineFactory = class {
 			this.pool = null;
 			this.poolManager = null;
 		}
-		if (this.nodeManager) {
-			await this.nodeManager.disposeAll();
-			this.nodeManager = null;
-		}
 	}
 	async initPythonPool(steps) {
 		const pythonPath = this.opts.pythonPath;
-		if (!pythonPath) throw new Error("EngineFactory: pythonPath is required for runtime=\"python\" — the addon must call ctx.deps.ensurePython() and pass the result. The embedded portable Python download likely failed; check the addon logs for the download error.");
+		if (!pythonPath) throw new Error("EngineFactory: pythonPath is required — the addon must call ctx.deps.ensurePython() and pass the result. The embedded portable Python download likely failed; check the addon logs for the download error.");
 		const poolRuntime = BACKEND_TO_POOL_RUNTIME[this.opts.engine.backend];
 		if (!poolRuntime) throw new Error(`No pool runtime mapping for backend "${this.opts.engine.backend}"`);
 		const concurrency = this.opts.concurrency ?? {
@@ -2369,16 +2138,6 @@ var EngineFactory = class {
 		const filename = urlParts[urlParts.length - 1] ?? `${modelId}.${format}`;
 		const modelPath = `${this.opts.modelsDir}/${filename}`;
 		const inputSize = Math.max(modelEntry.inputSize.width, modelEntry.inputSize.height);
-		const onnxEntry = modelEntry.formats.onnx;
-		if (onnxEntry) {
-			const onnxUrlParts = onnxEntry.url.split("/");
-			const onnxFilename = onnxUrlParts[onnxUrlParts.length - 1] ?? `${modelId}.onnx`;
-			checkAndLogModelShape({
-				modelId,
-				modelPath: `${this.opts.modelsDir}/${onnxFilename}`,
-				expected: modelEntry.inputSize
-			}, this.log);
-		}
 		let labels = def.labels;
 		if (!labels && modelEntry.extraFiles) {
 			const labelsFile = modelEntry.extraFiles.find((f) => f.filename.endsWith("-labels.json"));
@@ -2405,20 +2164,6 @@ var EngineFactory = class {
 			device: this.opts.engine.device ?? (poolRuntime === "coreml" ? "all" : void 0)
 		};
 	}
-	async initNodeEngines(steps) {
-		if (!this.opts.createNodeEngine) throw new Error("createNodeEngine function required for nodejs+onnx backend");
-		this.nodeManager = new NodeEngineManager(this.opts.engine.backend, (stepId, modelId) => this.resolveOnnxModelPath(stepId, modelId), this.opts.createNodeEngine, this.log.child("onnx-mgr"));
-		await this.nodeManager.applyConfig(steps);
-	}
-	resolveOnnxModelPath(stepId, modelId) {
-		const modelEntry = getStepDefinition(stepId).models.find((m) => m.id === modelId);
-		if (!modelEntry) throw new Error(`Model "${modelId}" not found in step "${stepId}" catalog`);
-		const onnxFormat = modelEntry.formats["onnx"];
-		if (!onnxFormat) throw new Error(`Model "${modelId}" has no ONNX format`);
-		const urlParts = onnxFormat.url.split("/");
-		const filename = urlParts[urlParts.length - 1] ?? `${modelId}.onnx`;
-		return `${this.opts.modelsDir}/${filename}`;
-	}
 };
 //#endregion
 //#region src/detection-pipeline/postprocess/dispatch.ts
@@ -4128,10 +3873,23 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 				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: "node",
-			backend: "cpu",
-			format: "onnx"
+			runtime: "python",
+			backend: "onnx",
+			format: "onnx",
+			device: "cpu"
 		};
 	}
 	/** Store the addon context. ctx.api is a lazy getter resolved at call time. */
@@ -4152,18 +3910,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 		return this.getAvailableEnginesWithDevices().map((e) => e.engine);
 	}
 	getAvailableEnginesWithDevices() {
-		const engines = [{
-			engine: {
-				runtime: "node",
-				backend: "cpu",
-				format: "onnx"
-			},
-			devices: [{
-				id: "cpu",
-				label: "CPU"
-			}],
-			defaultDevice: "cpu"
-		}];
+		const engines = [];
 		if (process.platform === "darwin") engines.push({
 			engine: {
 				runtime: "python",
@@ -4216,11 +3963,11 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 				if (audioDef.models.some((m) => m.formats[format])) {
 					const modelId = getDefaultModelForFormat("audio-classifier", format);
 					const audioEngine = modelId === "apple-soundanalysis" ? {
-						runtime: "node",
+						runtime: "python",
 						backend: "coreml",
 						format: "coreml"
 					} : {
-						runtime: "node",
+						runtime: "python",
 						backend: "cpu",
 						format: "onnx"
 					};
@@ -4266,7 +4013,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 				const formats = {};
 				for (const [formatKey, entry] of Object.entries(m.formats)) {
 					if (!entry) continue;
-					const downloaded = (0, _camstack_core.isModelDownloaded)(this.modelsDir, m, formatKey);
+					const downloaded = (0, _camstack_system.isModelDownloaded)(this.modelsDir, m, formatKey);
 					formats[formatKey] = {
 						url: entry.url,
 						sizeMB: entry.sizeMB,
@@ -4393,7 +4140,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 		const { modelId, format, addonId } = input;
 		const modelEntry = getStepDefinition(addonId).models.find((m) => m.id === modelId);
 		if (!modelEntry) throw new Error(`Model "${modelId}" not found in step "${addonId}" catalog`);
-		if (!(0, _camstack_core.deleteModelFromDisk)(this.modelsDir, modelEntry, format)) throw new Error(`Model "${modelId}" (${format}) is not downloaded — nothing to delete`);
+		if (!(0, _camstack_system.deleteModelFromDisk)(this.modelsDir, modelEntry, format)) throw new Error(`Model "${modelId}" (${format}) is not downloaded — nothing to delete`);
 		this.log.info("Model deleted from disk", { meta: {
 			modelId,
 			format
@@ -4848,7 +4595,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 			const format = this.currentEngine?.format ?? "onnx";
 			for (const step of needed) {
 				const modelEntry = getStepDefinition(step.addonId).models.find((m) => m.id === step.modelId);
-				if (modelEntry && !(0, _camstack_core.isModelDownloaded)(this.modelsDir, modelEntry, format)) {
+				if (modelEntry && !(0, _camstack_system.isModelDownloaded)(this.modelsDir, modelEntry, format)) {
 					this.log.info("Downloading model for step", { meta: {
 						modelId: step.modelId,
 						format,
@@ -4873,7 +4620,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	/** Download a model with retry + exponential backoff */
 	async downloadWithRetry(entry, format, maxRetries, onProgress) {
 		for (let attempt = 1; attempt <= maxRetries; attempt++) try {
-			await (0, _camstack_core.ensureModel)(this.modelsDir, entry, format, onProgress);
+			await (0, _camstack_system.ensureModel)(this.modelsDir, entry, format, onProgress);
 			this.log.info("Model downloaded successfully", { meta: { modelId: entry.id } });
 			return;
 		} catch (err) {
@@ -5348,11 +5095,11 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 				} });
 				continue;
 			}
-			if (!(0, _camstack_core.isModelDownloaded)(this.modelsDir, modelEntry, format)) this.log.info("Downloading model", { meta: {
+			if (!(0, _camstack_system.isModelDownloaded)(this.modelsDir, modelEntry, format)) this.log.info("Downloading model", { meta: {
 				modelId: step.modelId,
 				format
 			} });
-			downloads.push((0, _camstack_core.ensureModel)(this.modelsDir, modelEntry, format).then(() => {}));
+			downloads.push((0, _camstack_system.ensureModel)(this.modelsDir, modelEntry, format).then(() => {}));
 		}
 		await Promise.all(downloads);
 		await this.ensureBackendDeps(this.currentEngine);
@@ -5389,18 +5136,19 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 		if (typeof runtime === "string" && typeof backend === "string" && runtime && backend) {
 			const storedDevice = typeof store["engineDevice"] === "string" ? String(store["engineDevice"]) : "";
 			const detected = DetectionPipelineProvider.detectBestEngine();
-			if (runtime === "python" && !DetectionPipelineProvider.isPythonBackendAvailable(backend)) {
+			if (runtime === "python" && !DetectionPipelineProvider.isPythonBackendAvailable(backend, this.executorOptions.pythonPath ?? "")) {
 				this.log.warn("Stored engine backend unavailable on this node — falling back to detected best", { meta: {
 					stored: `${runtime}/${backend}`,
 					fallback: `${detected.runtime}/${detected.backend}`
 				} });
 				return detected;
 			}
+			const migratedBackend = runtime === "node" && backend === "cpu" ? "onnx" : backend;
 			const device = storedDevice || detected.device;
 			return {
-				runtime: runtime === "node" ? "node" : "python",
-				backend,
-				format: backendToFormat(backend),
+				runtime: "python",
+				backend: migratedBackend,
+				format: backendToFormat(migratedBackend),
 				...device ? { device } : {}
 			};
 		}
@@ -5409,13 +5157,21 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	}
 	/**
 	* Synchronous availability probe for a Python inference backend. Runs a
-	* short `python3 -c "import <mod>"` with a 3s timeout. Used at
+	* short `<python> -c "import <mod>"` with a 3s timeout. Used at
 	* `loadEngine` time to reject a persisted backend choice the Python
 	* interpreter on this host can't actually import — without this the
 	* detection-pipeline child process exits with code 1 the moment
 	* `inference_pool.py` hits its `from openvino.runtime import Core`.
+	*
+	* MUST probe the EMBEDDED portable interpreter (`pythonPath`, resolved via
+	* `ctx.deps.ensurePython()`) — that's where `installPythonRequirements`
+	* puts the backend packages and what `SharedInferencePool` actually spawns.
+	* Probing the system `python3` checks the wrong site-packages (and on a
+	* slim container there is no system python3 at all → every backend would
+	* be reported unavailable, silently disabling ML). Falls back to `python3`
+	* only when no embedded interpreter is resolved.
 	*/
-	static isPythonBackendAvailable(backend) {
+	static isPythonBackendAvailable(backend, pythonPath) {
 		const mod = {
 			coreml: "coremltools",
 			openvino: "openvino.runtime",
@@ -5425,7 +5181,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 		if (!mod) return false;
 		try {
 			const { execFileSync } = require("node:child_process");
-			execFileSync("python3", ["-c", `import ${mod}`], {
+			execFileSync(pythonPath || "python3", ["-c", `import ${mod}`], {
 				timeout: 3e3,
 				stdio: "pipe"
 			});
@@ -5723,7 +5479,7 @@ function buildSchemaSlots(format, modelsDir) {
 				id: m.id,
 				name: m.name,
 				formats: Object.fromEntries(Object.entries(m.formats).map(([f, entry]) => [f, {
-					downloaded: (0, _camstack_core.isModelDownloaded)(modelsDir, m, f),
+					downloaded: (0, _camstack_system.isModelDownloaded)(modelsDir, m, f),
 					sizeMB: entry.sizeMB
 				}]))
 			})),
@@ -5816,11 +5572,11 @@ function buildDefaultStepTree(format) {
 		makeStep("instance-segmentation", [], { enabled: false })
 	].filter((s) => s !== null));
 	const audioEngine = getDefaultModelForFormat("audio-classifier", format) === "apple-soundanalysis" ? {
-		runtime: "node",
+		runtime: "python",
 		backend: "coreml",
 		format: "coreml"
 	} : {
-		runtime: "node",
+		runtime: "python",
 		backend: "cpu",
 		format: "onnx"
 	};
@@ -5957,33 +5713,46 @@ function resolveAddonPythonDir() {
 	for (const c of candidates) if (node_fs.existsSync(node_path.join(c, "inference_pool.py"))) return c;
 	throw new Error(`addon-pipeline/detection-pipeline: python/ dir not found. Searched:\n${candidates.join("\n")}`);
 }
+/**
+* Returns true when proactive OpenVINO installation is warranted.
+*
+* Gate: Linux host + Intel iGPU or Intel NPU detected.
+*
+* Intentionally addon-local — addons are self-contained and cannot import
+* `@camstack/system` internals (see architecture invariant: no cross-addon
+* imports). This mirrors the logic in `resolveRuntimePackages` from that
+* package without importing it.
+*
+* darwin is never true: coremltools handles Apple Silicon + Intel Mac.
+* linux-amd (or any non-Intel linux GPU) is never true: the openvino
+* package has no AMD backend and would fail at import time.
+*
+* @internal exported only for unit tests in the same package
+*/
+function shouldInstallOpenvino(hardware) {
+	if (hardware.platform !== "linux") return false;
+	const hasIntelGpu = hardware.gpu?.type === "intel";
+	const hasIntelNpu = hardware.npu?.type === "intel-npu";
+	return hasIntelGpu || hasIntelNpu;
+}
 var RUNTIMES = [{
 	value: "python",
 	label: "Python (CoreML / OpenVINO / ONNX Runtime)"
-}, {
-	value: "node",
-	label: "Node.js (onnxruntime-node)"
 }];
-var BACKENDS_BY_RUNTIME = {
-	python: [
-		{
-			value: "coreml",
-			label: "CoreML"
-		},
-		{
-			value: "openvino",
-			label: "OpenVINO"
-		},
-		{
-			value: "onnx",
-			label: "ONNX Runtime"
-		}
-	],
-	node: [{
-		value: "cpu",
-		label: "CPU (onnxruntime-node)"
-	}]
-};
+var BACKENDS_BY_RUNTIME = { python: [
+	{
+		value: "coreml",
+		label: "CoreML"
+	},
+	{
+		value: "openvino",
+		label: "OpenVINO"
+	},
+	{
+		value: "onnx",
+		label: "ONNX Runtime"
+	}
+] };
 var DEVICES_BY_BACKEND = {
 	coreml: [
 		{
@@ -6335,7 +6104,7 @@ var DetectionPipelineAddon = class extends require_dist.BaseAddon {
 			...stored,
 			...overlay
 		} : stored;
-		const runtime = merged.engineRuntime === "node" ? "node" : "python";
+		const runtime = "python";
 		const availableBackends = await this.resolveAvailableBackends(ctx, runtime);
 		const runtimeBackends = availableBackends.length > 0 ? BACKENDS_BY_RUNTIME[runtime].filter((b) => availableBackends.includes(b.value)) : BACKENDS_BY_RUNTIME[runtime];
 		const storedBackend = typeof merged.engineBackend === "string" ? merged.engineBackend : "";
@@ -6455,6 +6224,7 @@ var DetectionPipelineAddon = class extends require_dist.BaseAddon {
 		const pythonPath = await this.ctx.deps.ensurePython();
 		if (pythonPath) this.pythonPath = pythonPath;
 		else this.ctx.logger.warn("Embedded Python unavailable — runtime=\"python\" pipelines will fail until the download succeeds.");
+		await this.proactivelyInstallOpenvino();
 		const effectiveTuning = this.resolveBackendTuning();
 		this.provider = new DetectionPipelineProvider(this.ctx.settings, modelsDir, this.ctx.logger, this.ctx.eventBus ?? null, () => ({ sections: [] }), {
 			concurrency: effectiveTuning.concurrency,
@@ -6520,6 +6290,32 @@ var DetectionPipelineAddon = class extends require_dist.BaseAddon {
 	getModelCatalog() {
 		return ALL_STEPS.flatMap((s) => [...s.models]);
 	}
+	/**
+	* 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.
+	*
+	* 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 —
+	* if the platform-probe cap isn't wired yet the error is caught here.
+	*/
+	async proactivelyInstallOpenvino() {
+		if (!this.pythonAddonDir || !this.pythonPath) return;
+		try {
+			const hardware = await this.ctx.api.platformProbe.getHardware.query();
+			if (!shouldInstallOpenvino(hardware)) return;
+			this.ctx.logger.info("Intel hardware detected — proactively installing OpenVINO Python package", { meta: {
+				gpu: hardware.gpu?.type ?? null,
+				npu: hardware.npu?.type ?? null
+			} });
+			const requirementsFile = node_path.join(this.pythonAddonDir, "requirements-openvino.txt");
+			await this.ctx.deps.installPythonRequirements(requirementsFile);
+			this.ctx.logger.info("Proactive OpenVINO install complete");
+		} catch (err) {
+			this.ctx.logger.warn("Proactive OpenVINO install failed — falling back to onnx-cpu baseline", { meta: { error: err instanceof Error ? err.message : String(err) } });
+		}
+	}
 	async onShutdown() {
 		if (this.engineMetricsTimer) {
 			clearInterval(this.engineMetricsTimer);
@@ -6614,3 +6410,4 @@ exports.backendToFormat = backendToFormat;
 exports.default = DetectionPipelineAddon;
 exports.getDefaultModelForFormat = getDefaultModelForFormat;
 exports.getStepDefinition = getStepDefinition;
+exports.shouldInstallOpenvino = shouldInstallOpenvino;