@camstack/addon-pipeline 1.0.1 → 1.0.3

package/dist/audio-analyzer/index.js

@@ -3,12 +3,12 @@ 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 _camstack_core = require("@camstack/core");
+let _camstack_system = require("@camstack/system");
 //#region src/audio-analyzer/audio-pipeline.ts
 /**
 * Create the appropriate audio pipeline.
@@ -27,7 +27,7 @@ async function createAudioPipeline(modelsDir, logger, options) {
 * Canonical model URLs on the camstack HuggingFace mirror. Mirrors the
 * convention every detection model follows (single point of truth =
 * `HF_BASE_URL` from `@camstack/types`); the auto-download path uses
-* `downloadFile` from `@camstack/core`, the SAME helper detection-
+* `downloadFile` from `@camstack/system`, the SAME helper detection-
 * pipeline uses to materialise its YOLO/face/plate models.
 *
 *   {domain}/{family}/{format}/{filename}
@@ -83,7 +83,7 @@ var YamnetPythonPipeline = class {
 				url: YAMNET_MODEL_URL,
 				dest: modelPath
 			} });
-			await (0, _camstack_core.downloadFile)(YAMNET_MODEL_URL, modelPath);
+			await (0, _camstack_system.downloadFile)(YAMNET_MODEL_URL, modelPath);
 			this.log.info("YAMNet ONNX model downloaded", { meta: { sizeBytes: node_fs.statSync(modelPath).size } });
 		}
 		if (!node_fs.existsSync(labelsPath)) {
@@ -91,7 +91,7 @@ var YamnetPythonPipeline = class {
 				url: YAMNET_LABELS_URL,
 				dest: labelsPath
 			} });
-			await (0, _camstack_core.downloadFile)(YAMNET_LABELS_URL, labelsPath);
+			await (0, _camstack_system.downloadFile)(YAMNET_LABELS_URL, labelsPath);
 		}
 		const pythonDir = resolveAudioPythonDir();
 		if (this.installPythonRequirements) await this.installPythonRequirements(node_path.join(pythonDir, "requirements-audio.txt"));

package/dist/audio-analyzer/index.mjs

@@ -1,8 +1,8 @@
 import { t as __require } from "../chunk-BdkLduGY.mjs";
-import { L as mapAudioLabelToMacro, P as hydrateSchema, S as audioAnalyzerCapability, c as DEFAULT_AUDIO_ANALYZER_CONFIG, i as BaseAddon, j as errMsg, m as HF_BASE_URL, n as AUDIO_BACKEND_CHOICES, x as audioAnalysisCapability } from "../dist-C5jnNl0n.mjs";
+import { L as mapAudioLabelToMacro, P as hydrateSchema, S as audioAnalyzerCapability, c as DEFAULT_AUDIO_ANALYZER_CONFIG, i as BaseAddon, j as errMsg, m as HF_BASE_URL, n as AUDIO_BACKEND_CHOICES, x as audioAnalysisCapability } from "../dist-XRXnZrVC.mjs";
 import * as fs from "node:fs";
 import * as path$1 from "node:path";
-import { downloadFile } from "@camstack/core";
+import { downloadFile } from "@camstack/system";
 //#region src/audio-analyzer/audio-pipeline.ts
 /**
 * Create the appropriate audio pipeline.
@@ -21,7 +21,7 @@ async function createAudioPipeline(modelsDir, logger, options) {
 * Canonical model URLs on the camstack HuggingFace mirror. Mirrors the
 * convention every detection model follows (single point of truth =
 * `HF_BASE_URL` from `@camstack/types`); the auto-download path uses
-* `downloadFile` from `@camstack/core`, the SAME helper detection-
+* `downloadFile` from `@camstack/system`, the SAME helper detection-
 * pipeline uses to materialise its YOLO/face/plate models.
 *
 *   {domain}/{family}/{format}/{filename}

package/dist/audio-codec-nodeav/index.js

@@ -2,7 +2,7 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-const require_dist = require("../dist-7ewQjTle.js");
+const require_dist = require("../dist-C1goFC50.js");
 const require_codec_runtime = require("../codec-runtime-BOk-13PN.js");
 let node_crypto = require("node:crypto");
 //#region src/audio-codec-nodeav/addon/index.ts

package/dist/audio-codec-nodeav/index.mjs

@@ -1,4 +1,4 @@
-import { C as audioCodecCapability, i as BaseAddon, j as errMsg } from "../dist-C5jnNl0n.mjs";
+import { C as audioCodecCapability, i as BaseAddon, j as errMsg } from "../dist-XRXnZrVC.mjs";
 import { t as DecodeRuntime } from "../codec-runtime-BsqlEjPi.mjs";
 import { randomUUID } from "node:crypto";
 //#region src/audio-codec-nodeav/addon/index.ts

package/dist/decoder-nodeav/index.js

@@ -2,7 +2,7 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-const require_dist = require("../dist-7ewQjTle.js");
+const require_dist = require("../dist-C1goFC50.js");
 let _camstack_shm_ring = require("@camstack/shm-ring");
 let node_crypto = require("node:crypto");
 //#region src/decoder-nodeav/frame-ring-sink.ts

package/dist/decoder-nodeav/index.mjs

@@ -1,4 +1,4 @@
-import { O as decoderCapability, _ as RingBuffer, h as HWACCEL_OPTIONS, i as BaseAddon, j as errMsg, l as DEFAULT_DECODER_HWACCEL_CONFIG } from "../dist-C5jnNl0n.mjs";
+import { O as decoderCapability, _ as RingBuffer, h as HWACCEL_OPTIONS, i as BaseAddon, j as errMsg, l as DEFAULT_DECODER_HWACCEL_CONFIG } from "../dist-XRXnZrVC.mjs";
 import { FrameRingReaderCache, FrameRingWriter, MIN_RING_SLOTS, computeSegmentSize, computeSlotByteLength, createSegment, deriveSlotCount } from "@camstack/shm-ring";
 import { randomUUID } from "node:crypto";
 //#region src/decoder-nodeav/frame-ring-sink.ts

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);
@@ -3873,6 +3873,18 @@ 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: "python",
 			backend: "onnx",
@@ -3884,22 +3896,68 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	async setApi(addonCtx) {
 		this.addonCtx = addonCtx;
 	}
+	/**
+	* Fetch platform-probe data for engine + device gating. Returns null for
+	* both fields when the probe cap is not yet reachable (cold-start / probe
+	* addon not installed), so callers fall back to the full static catalog.
+	*/
+	async fetchProbeGatingData() {
+		try {
+			const api = this.addonCtx?.api;
+			if (!api) return {
+				availableBackends: null,
+				hardware: null
+			};
+			const caps = await api.platformProbe.getCapabilities.query();
+			if (!caps?.scores) return {
+				availableBackends: null,
+				hardware: null
+			};
+			return {
+				availableBackends: caps.scores.filter((s) => s.runtime === "python" && s.available).map((s) => s.backend),
+				hardware: caps.hardware ?? null
+			};
+		} catch {
+			return {
+				availableBackends: null,
+				hardware: null
+			};
+		}
+	}
 	async getSchema(engine) {
 		if (!engine || !engine.runtime) engine = await this.getSelectedEngine();
 		const format = engine.format;
 		const slots = buildSchemaSlots(format, this.modelsDir);
+		const { availableBackends, hardware } = await this.fetchProbeGatingData();
 		return {
-			availableEngines: this.getAvailableEnginesWithDevices(),
+			availableEngines: this.getAvailableEnginesWithDevices(availableBackends, hardware),
 			selectedEngine: { ...engine },
 			slots
 		};
 	}
 	async getAvailableEngines() {
-		return this.getAvailableEnginesWithDevices().map((e) => e.engine);
+		const { availableBackends, hardware } = await this.fetchProbeGatingData();
+		return this.getAvailableEnginesWithDevices(availableBackends, hardware).map((e) => e.engine);
 	}
-	getAvailableEnginesWithDevices() {
-		const engines = [];
-		if (process.platform === "darwin") engines.push({
+	/**
+	* Build the engine catalog filtered by probe data.
+	*
+	* When `availableBackends` is not null, only engines whose backend is
+	* reported as available by the platform-probe cap are included. This
+	* prevents the benchmark picker from offering (e.g.) CoreML on an Intel
+	* Linux host where the Python coremltools package is absent.
+	*
+	* When `hardware` is not null, the per-engine device list is narrowed to
+	* entries that are valid on this host's hardware (no Intel NPU → no 'npu'
+	* device for OpenVINO, no NVIDIA GPU → no 'cuda' for ONNX, etc.).
+	*
+	* When either argument is null (probe unreachable / cold-start), the full
+	* static catalog is returned unchanged — conservative fallback so the UI
+	* still renders all options rather than going blank.
+	*/
+	getAvailableEnginesWithDevices(availableBackends, hardware) {
+		const allEngines = [];
+		if (process.platform === "darwin") allEngines.push({
 			engine: {
 				runtime: "python",
 				backend: "coreml",
@@ -3908,7 +3966,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 			devices: COREML_DEVICES,
 			defaultDevice: "all"
 		});
-		engines.push({
+		allEngines.push({
 			engine: {
 				runtime: "python",
 				backend: "openvino",
@@ -3917,7 +3975,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 			devices: OPENVINO_DEVICES,
 			defaultDevice: "auto"
 		});
-		engines.push({
+		allEngines.push({
 			engine: {
 				runtime: "python",
 				backend: "onnx",
@@ -3926,7 +3984,19 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 			devices: ONNX_PYTHON_DEVICES,
 			defaultDevice: "cpu"
 		});
-		return engines;
+		if (!availableBackends) return allEngines;
+		return allEngines.filter((e) => availableBackends.includes(e.engine.backend)).map((e) => {
+			if (!hardware) return e;
+			const filtered = filterDeviceOptionsByHardware(e.devices.map((d) => ({
+				value: d.id,
+				label: d.label
+			})), e.engine.backend, hardware);
+			const allowedIds = new Set(filtered.map((o) => o.value));
+			return {
+				...e,
+				devices: e.devices.filter((d) => allowedIds.has(d.id))
+			};
+		});
 	}
 	async getDefaultSteps(engine) {
 		return buildDefaultStepTree(engine.format);
@@ -4001,7 +4071,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,
@@ -4018,7 +4088,8 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 				};
 			})
 		}));
-		const engines = this.getAvailableEnginesWithDevices();
+		const { availableBackends, hardware } = await this.fetchProbeGatingData();
+		const engines = this.getAvailableEnginesWithDevices(availableBackends, hardware);
 		const nodeBackends = [];
 		const pythonBackends = [];
 		for (const e of engines) if (e.engine.runtime === "node") nodeBackends.push({
@@ -4128,7 +4199,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
@@ -4583,7 +4654,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,
@@ -4608,7 +4679,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) {
@@ -5083,11 +5154,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);
@@ -5119,19 +5190,20 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	*/
 	async loadEngine() {
 		const store = await this.readStore();
-		const runtime = store["engineRuntime"];
-		const backend = store["engineBackend"];
-		if (typeof runtime === "string" && typeof backend === "string" && runtime && backend) {
+		const storedRuntime = store["engineRuntime"];
+		const storedBackend = store["engineBackend"];
+		if (typeof storedBackend === "string" && storedBackend.length > 0) {
+			const backend = storedBackend;
 			const storedDevice = typeof store["engineDevice"] === "string" ? String(store["engineDevice"]) : "";
 			const detected = DetectionPipelineProvider.detectBestEngine();
-			if (runtime === "python" && !DetectionPipelineProvider.isPythonBackendAvailable(backend, this.executorOptions.pythonPath ?? "")) {
+			const migratedBackend = typeof storedRuntime === "string" && storedRuntime === "node" && backend === "cpu" ? "onnx" : backend;
+			if (!DetectionPipelineProvider.isPythonBackendAvailable(migratedBackend, this.executorOptions.pythonPath ?? "")) {
 				this.log.warn("Stored engine backend unavailable on this node — falling back to detected best", { meta: {
-					stored: `${runtime}/${backend}`,
-					fallback: `${detected.runtime}/${detected.backend}`
+					stored: migratedBackend,
+					fallback: `${detected.backend}`
 				} });
 				return detected;
 			}
-			const migratedBackend = runtime === "node" && backend === "cpu" ? "onnx" : backend;
 			const device = storedDevice || detected.device;
 			return {
 				runtime: "python",
@@ -5301,11 +5373,42 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 		return { success: true };
 	}
 	async reprobeEngine() {
-		const best = DetectionPipelineProvider.detectBestEngine();
-		const probedLabel = `${best.runtime}/${best.backend}/${best.device ?? "default"}`;
-		await this.writeStore({ probedBestEngine: probedLabel });
-		this.log.info("Re-probed engine", { meta: {
-			runtime: best.runtime,
+		const api = this.addonCtx?.api;
+		let best;
+		if (api) try {
+			const caps = await api.platformProbe.getCapabilities.query();
+			const bs = caps?.bestScore;
+			if (bs && bs.runtime === "python") {
+				const probeBackend = bs.backend;
+				const probeDevice = (() => {
+					const hw = caps.hardware;
+					if (probeBackend === "coreml") return hw?.npu?.type === "apple-ane" ? "ane" : "all";
+					if (probeBackend === "openvino") {
+						if (hw?.npu?.type === "intel-npu") return "npu";
+						if (hw?.gpu?.type === "intel") return "gpu";
+						return "auto";
+					}
+					if (probeBackend === "onnx") return hw?.gpu?.type === "nvidia" ? "cuda" : "cpu";
+					return "cpu";
+				})();
+				best = {
+					runtime: "python",
+					backend: probeBackend,
+					format: backendToFormat(probeBackend),
+					device: probeDevice
+				};
+			} else best = DetectionPipelineProvider.detectBestEngine();
+		} catch {
+			best = DetectionPipelineProvider.detectBestEngine();
+		}
+		else best = DetectionPipelineProvider.detectBestEngine();
+		const probedLabel = `${best.backend}/${best.device ?? "default"}`;
+		await this.writeStore({
+			probedBestEngine: probedLabel,
+			engineBackend: best.backend,
+			engineDevice: best.device ?? "cpu"
+		});
+		this.log.info("Re-probed engine — wrote back engineBackend + engineDevice", { meta: {
 			backend: best.backend,
 			device: best.device ?? null,
 			probedBestEngine: probedLabel
@@ -5467,7 +5570,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
 				}]))
 			})),
@@ -5701,10 +5804,34 @@ 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")}`);
 }
-var RUNTIMES = [{
-	value: "python",
-	label: "Python (CoreML / OpenVINO / ONNX Runtime)"
-}];
+/**
+* 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;
+}
+/**
+* Full catalog of execution providers. The settings UI only shows the subset
+* reported as available by the platform-probe cap (`getGlobalSettings` gates
+* options by probe scores). Kept as the static universe so the static schema
+* (returned before a live ctx is available) still lists all fields.
+*/
 var BACKENDS_BY_RUNTIME = { python: [
 	{
 		value: "coreml",
@@ -5775,6 +5902,53 @@ var DEVICES_BY_BACKEND = {
 		label: "CPU"
 	}]
 };
+/**
+* Filter the per-backend device option list by what the platform probe
+* reports as available hardware on this host. Rules (derived from the
+* confirmed target model):
+*
+*  coreml:
+*    - `ane` only when `hardware.npu?.type === 'apple-ane'`
+*    - `gpu` and `all` always shown (CPU+GPU present on every Mac)
+*    - `cpu` always shown
+*
+*  openvino:
+*    - `npu` only when `hardware.npu?.type === 'intel-npu'`
+*    - `gpu` only when `hardware.gpu?.type === 'intel'`
+*    - `auto` and `cpu` always shown
+*
+*  onnx:
+*    - `cuda` only when `hardware.gpu?.type === 'nvidia'`
+*    - `coreml` only when `hardware.npu?.type === 'apple-ane'` (CoreML EP)
+*    - `cpu` always shown
+*
+* When `hardware` is null (probe unreachable), the full catalog is returned
+* unchanged so the UI still renders all options.
+*/
+function filterDeviceOptionsByHardware(options, backend, hardware) {
+	if (!hardware) return options;
+	const hasAppleAne = hardware.npu?.type === "apple-ane";
+	const hasIntelNpu = hardware.npu?.type === "intel-npu";
+	const hasIntelGpu = hardware.gpu?.type === "intel";
+	const hasNvidiaGpu = hardware.gpu?.type === "nvidia";
+	switch (backend) {
+		case "coreml": return options.filter((o) => {
+			if (o.value === "ane") return hasAppleAne;
+			return true;
+		});
+		case "openvino": return options.filter((o) => {
+			if (o.value === "npu") return hasIntelNpu;
+			if (o.value === "gpu") return hasIntelGpu;
+			return true;
+		});
+		case "onnx": return options.filter((o) => {
+			if (o.value === "cuda") return hasNvidiaGpu;
+			if (o.value === "coreml") return hasAppleAne;
+			return true;
+		});
+		default: return options;
+	}
+}
 var BACKEND_TO_FORMAT = {
 	cpu: "onnx",
 	coreml: "coreml",
@@ -5906,13 +6080,13 @@ var DetectionPipelineAddon = class extends require_dist.BaseAddon {
 			title: "Object detection",
 			tab: "engine",
 			order: 0,
-			description: "Vision-detection backend (object detection, face detection, plate OCR). Chain: runtime → backend → hardware. Backend options depend on runtime; hardware options depend on backend. All three restart the addon on change.",
+			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: runtime/backend/device). Click the refresh icon to re-run the probe — the detected values get written back into the three fields below.",
+					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: "",
 					actions: [{
@@ -5921,19 +6095,10 @@ var DetectionPipelineAddon = class extends require_dist.BaseAddon {
 						tooltip: "Re-probe engine"
 					}]
 				}),
-				this.field({
-					type: "select",
-					key: "engineRuntime",
-					label: "Runtime",
-					options: [...RUNTIMES],
-					default: DEFAULT_CONFIG.engineRuntime,
-					immediate: true,
-					requiresRestart: true
-				}),
 				this.field({
 					type: "select",
 					key: "engineBackend",
-					label: "Backend",
+					label: "Execution provider",
 					options: [...BACKENDS_BY_RUNTIME.python],
 					default: DEFAULT_CONFIG.engineBackend,
 					immediate: true,
@@ -6071,14 +6236,16 @@ var DetectionPipelineAddon = class extends require_dist.BaseAddon {
 			...overlay
 		} : stored;
 		const runtime = "python";
-		const availableBackends = await this.resolveAvailableBackends(ctx, runtime);
+		const probeResult = await this.resolveProbeData(ctx, runtime);
+		const availableBackends = probeResult.availableBackends;
+		const hardware = probeResult.hardware;
 		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 : "";
-		const backend = runtimeBackends.find((b) => b.value === storedBackend)?.value ?? runtimeBackends[0]?.value ?? "coreml";
-		const deviceOptions = DEVICES_BY_BACKEND[backend] ?? [{
+		const backend = runtimeBackends.find((b) => b.value === storedBackend)?.value ?? probeResult.bestBackend ?? runtimeBackends[0]?.value ?? "coreml";
+		const deviceOptions = filterDeviceOptionsByHardware(DEVICES_BY_BACKEND[backend] ?? [{
 			value: "cpu",
 			label: "CPU"
-		}];
+		}], backend, hardware);
 		const storedDevice = typeof merged.engineDevice === "string" ? merged.engineDevice : "";
 		const device = deviceOptions.find((d) => d.value === storedDevice)?.value ?? deviceOptions[0]?.value ?? "cpu";
 		const raw = {
@@ -6128,28 +6295,47 @@ var DetectionPipelineAddon = class extends require_dist.BaseAddon {
 		}, raw);
 	}
 	/**
-	* Ask the platform-probe cap which backends are actually installable
-	* on this node (checks for `openvino`, `coremltools`, `onnxruntime`
-	* Python modules + hardware presence). Returns a subset of the static
-	* catalog; an empty list signals the probe wasn't available so the
-	* caller should fall back to the full catalog rather than hiding
-	* every option.
+	* Fetch the platform-probe capabilities and return:
+	* - `availableBackends`: backends the probe reports as available for `runtime`
+	*   (empty → caller falls back to full catalog).
+	* - `hardware`: the probed hardware info (null when probe not reachable).
+	* - `bestBackend`: the backend from the probe's `bestScore` (null when unavailable).
+	*
+	* A single probe call is made so both backend AND device gating use the
+	* same snapshot without doubling the cap round-trip.
 	*/
-	async resolveAvailableBackends(ctx, runtime) {
+	async resolveProbeData(ctx, runtime) {
 		try {
 			const api = ctx?.api;
-			if (!api) return [];
+			if (!api) return {
+				availableBackends: [],
+				hardware: null,
+				bestBackend: null
+			};
 			const caps = await api.platformProbe.getCapabilities.query();
-			if (!caps?.scores) return [];
+			if (!caps?.scores) return {
+				availableBackends: [],
+				hardware: null,
+				bestBackend: null
+			};
 			const out = /* @__PURE__ */ new Set();
 			for (const s of caps.scores) {
 				if (s.runtime !== runtime) continue;
 				if (!s.available) continue;
 				out.add(s.backend);
 			}
-			return [...out];
+			const bestBackend = caps.bestScore?.runtime === runtime ? caps.bestScore.backend ?? null : null;
+			return {
+				availableBackends: [...out],
+				hardware: caps.hardware ?? null,
+				bestBackend
+			};
 		} catch {
-			return [];
+			return {
+				availableBackends: [],
+				hardware: null,
+				bestBackend: null
+			};
 		}
 	}
 	/**
@@ -6190,6 +6376,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,
@@ -6255,6 +6442,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);
@@ -6347,5 +6560,7 @@ exports.ALL_STEPS = ALL_STEPS;
 exports.DetectionPipelineProvider = DetectionPipelineProvider;
 exports.backendToFormat = backendToFormat;
 exports.default = DetectionPipelineAddon;
+exports.filterDeviceOptionsByHardware = filterDeviceOptionsByHardware;
 exports.getDefaultModelForFormat = getDefaultModelForFormat;
 exports.getStepDefinition = getStepDefinition;
+exports.shouldInstallOpenvino = shouldInstallOpenvino;