@camstack/addon-pipeline 1.0.5 → 1.0.6

package/dist/detection-pipeline/index.mjs

@@ -1,5 +1,5 @@
 import { t as __require } from "../chunk-BdkLduGY.mjs";
-import { A as detectionPipelineCapability, E as createEvent, M as evaluateZoneRules, N as hfModelUrl, P as hydrateSchema, U as pipelineExecutorCapability, V as parseJsonUnknown, i as BaseAddon, j as errMsg, o as COCO_80_LABELS, p as EventCategory, q as sleep, r as AUDIO_MACRO_LABELS, s as COCO_TO_MACRO, t as APPLE_SA_TO_MACRO, v as YAMNET_TO_MACRO } from "../dist-CP2uP-D8.mjs";
+import { A as detectionPipelineCapability, E as createEvent, M as evaluateZoneRules, N as hfModelUrl, P as hydrateSchema, U as pipelineExecutorCapability, V as parseJsonUnknown, i as BaseAddon, j as errMsg, o as COCO_80_LABELS, p as EventCategory, q as sleep, r as AUDIO_MACRO_LABELS, s as COCO_TO_MACRO, t as APPLE_SA_TO_MACRO, v as YAMNET_TO_MACRO } from "../dist-DsDFrG0I.mjs";
 import * as fs from "node:fs";
 import * as path$1 from "node:path";
 import * as os from "node:os";
@@ -3527,7 +3527,273 @@ function walkFieldsForDefaults(fields, out) {
 	}
 }
 //#endregion
+//#region src/detection-pipeline/runtimes.ts
+var AUTO = {
+	value: "auto",
+	label: "Auto"
+};
+var CPU = {
+	value: "cpu",
+	label: "CPU"
+};
+var RUNTIMES = [
+	{
+		id: "onnx",
+		label: "ONNX Runtime",
+		supports: () => true,
+		devices: (hw) => {
+			if (!hw) return [CPU];
+			const out = [CPU];
+			if (hw.gpu?.type === "nvidia") out.push({
+				value: "cuda",
+				label: "CUDA"
+			});
+			if (hw.npu?.type === "apple-ane") out.push({
+				value: "coreml",
+				label: "CoreML EP"
+			});
+			return out;
+		},
+		defaultDevice: "cpu",
+		modelFormat: "onnx",
+		pythonRequirements: ["requirements.txt", "requirements-onnxruntime.txt"],
+		tuning: {
+			concurrency: 4,
+			batchMode: "list",
+			maxBatchSize: 8,
+			intraOpThreads: 0
+		}
+	},
+	{
+		id: "openvino",
+		label: "OpenVINO",
+		supports: (env) => env.arch === "x64" && env.platform !== "darwin" && env.hardware?.gpu?.type === "intel",
+		devices: (hw) => {
+			if (!hw) return [AUTO];
+			const out = [AUTO, CPU];
+			if (hw.gpu?.type === "intel") out.push({
+				value: "gpu",
+				label: "GPU"
+			});
+			if (hw.npu?.type === "intel-npu") out.push({
+				value: "npu",
+				label: "NPU"
+			});
+			return out;
+		},
+		defaultDevice: "auto",
+		modelFormat: "openvino",
+		pythonRequirements: ["requirements.txt", "requirements-openvino.txt"],
+		tuning: {
+			concurrency: 1,
+			batchMode: "none",
+			numStreams: 0
+		}
+	},
+	{
+		id: "coreml",
+		label: "CoreML",
+		supports: (env) => env.platform === "darwin",
+		devices: (hw) => {
+			const all = {
+				value: "all",
+				label: "All (ANE + GPU + CPU)"
+			};
+			if (!hw) return [all];
+			const out = [all];
+			if (hw.npu?.type === "apple-ane") out.push({
+				value: "ane",
+				label: "Apple Neural Engine"
+			});
+			out.push({
+				value: "gpu",
+				label: "GPU"
+			}, CPU);
+			return out;
+		},
+		defaultDevice: "all",
+		modelFormat: "coreml",
+		pythonRequirements: ["requirements.txt", "requirements-coreml.txt"],
+		tuning: {
+			concurrency: 1,
+			batchMode: "none",
+			windowMs: 8,
+			maxBatchSize: 8,
+			numWorkers: 1
+		}
+	}
+];
+function def(id) {
+	const d = RUNTIMES.find((r) => r.id === id);
+	if (!d) throw new Error(`Unknown runtime: ${id}`);
+	return d;
+}
+function supportedRuntimes(env) {
+	return RUNTIMES.filter((r) => r.supports(env)).map((r) => r.id);
+}
+function runtimeDevices(id, hardware) {
+	return def(id).devices(hardware);
+}
+function defaultDeviceFor(id) {
+	return def(id).defaultDevice;
+}
+function pythonRequirementsFor(id) {
+	return def(id).pythonRequirements;
+}
+function modelFormatFor(id) {
+	return def(id).modelFormat;
+}
+function tuningFor(id) {
+	return def(id).tuning;
+}
+function runtimeLabel(id) {
+	return def(id).label;
+}
+/**
+* Proactive-install hint kept for back-compat (re-exported from index.ts).
+* Intel on Linux warrants installing openvino; coremltools covers macOS;
+* openvino has no AMD/NVIDIA backend.
+*/
+function shouldInstallOpenvino(env) {
+	if (env.platform === "darwin") return false;
+	return env.gpu?.type === "intel" || env.npu?.type === "intel-npu";
+}
+//#endregion
+//#region src/detection-pipeline/engine-provisioner.ts
+/** Incremental backoff growing to a ~5 min cap; retries indefinitely at cap. */
+var BACKOFF_SCHEDULE_MS = [
+	5e3,
+	15e3,
+	3e4,
+	6e4,
+	12e4,
+	3e5
+];
+var IDLE_STATE = {
+	runtimeId: null,
+	device: null,
+	state: "idle"
+};
+var EngineProvisioner = class {
+	fx;
+	current = IDLE_STATE;
+	/** Bumped on every select/dispose — stale async results (old generation) are ignored. */
+	generation = 0;
+	cancelTimer = null;
+	retryIndex = 0;
+	constructor(fx) {
+		this.fx = fx;
+	}
+	get state() {
+		return this.current;
+	}
+	isReady() {
+		return this.current.state === "ready";
+	}
+	select(runtimeId, device) {
+		this.generation++;
+		this.retryIndex = 0;
+		this.clearTimer();
+		this.transition({
+			runtimeId,
+			device,
+			state: "installing",
+			progress: 0
+		});
+		this.provision(this.generation, runtimeId, device);
+	}
+	dispose() {
+		this.generation++;
+		this.clearTimer();
+	}
+	clearTimer() {
+		if (this.cancelTimer !== null) {
+			this.cancelTimer();
+			this.cancelTimer = null;
+		}
+	}
+	transition(next) {
+		this.current = next;
+		this.fx.onChange(next);
+	}
+	async provision(gen, runtimeId, device) {
+		try {
+			await Promise.all([this.fx.installRequirements(this.fx.requirementsFor(runtimeId)), this.fx.ensureModelForFormat(this.fx.modelFormatFor(runtimeId))]);
+			if (gen !== this.generation) return;
+			this.transition({
+				runtimeId,
+				device,
+				state: "verifying",
+				progress: 100
+			});
+			await this.fx.verify(runtimeId, device);
+			if (gen !== this.generation) return;
+			this.retryIndex = 0;
+			this.transition({
+				runtimeId,
+				device,
+				state: "ready"
+			});
+		} catch (err) {
+			if (gen !== this.generation) return;
+			const message = err instanceof Error ? err.message : String(err);
+			const delay = BACKOFF_SCHEDULE_MS[Math.min(this.retryIndex, BACKOFF_SCHEDULE_MS.length - 1)];
+			this.retryIndex++;
+			const nextRetryAt = this.fx.now() + delay;
+			this.transition({
+				runtimeId,
+				device,
+				state: "failed",
+				error: message,
+				nextRetryAt
+			});
+			this.cancelTimer = this.fx.setTimer(delay, () => {
+				if (gen !== this.generation) return;
+				this.cancelTimer = null;
+				this.transition({
+					runtimeId,
+					device,
+					state: "installing",
+					progress: 0
+				});
+				this.provision(gen, runtimeId, device);
+			});
+		}
+	}
+};
+//#endregion
+//#region src/detection-pipeline/auto-pick.ts
+var PREFERENCE = [
+	"coreml",
+	"openvino",
+	"onnx"
+];
+/**
+* Pure function — picks the best supported runtime for the given hardware env.
+*
+* Logic:
+* 1. If `bestBackendHint` is in the supported set, use it.
+* 2. Otherwise, walk PREFERENCE order and pick the first supported runtime.
+* 3. Floor to `'onnx'` (always supported).
+*
+* Device is always `defaultDeviceFor(chosen)`.
+*/
+function pickBestRuntime(env, bestBackendHint) {
+	const supported = supportedRuntimes(env);
+	const chosen = supported.find((id) => id === bestBackendHint) ?? PREFERENCE.find((id) => supported.includes(id)) ?? "onnx";
+	return {
+		runtimeId: chosen,
+		device: defaultDeviceFor(chosen)
+	};
+}
+//#endregion
 //#region src/detection-pipeline/provider.ts
+/**
+* DetectionPipelineProvider — implements IPipelineExecutorProvider.
+*
+* This is the main provider that consumers (DetectionWiring, Benchmark, tRPC)
+* interact with. It manages the engine factory, pipeline executor, and config persistence.
+*/
 var KEY_STEPS = "pipelineSteps";
 var KEY_ENGINE = "pipelineEngine";
 var KEY_TEMPLATES = "pipelineTemplates";
@@ -3706,6 +3972,22 @@ function parseWavToAudioChunk(filePath) {
 function enginesEqual(a, b) {
 	return a.runtime === b.runtime && a.backend === b.backend && a.format === b.format && (a.device ?? null) === (b.device ?? null);
 }
+/** Build a `RuntimeEnv` from the running process + probed hardware. */
+function runtimeEnvFromProcess(hardware) {
+	return {
+		platform: process.platform,
+		arch: process.arch,
+		hardware
+	};
+}
+/** Normalize the loose probe hardware shape into a typed `ProbedHardware`. */
+function toProbedHardware(hw) {
+	if (!hw) return null;
+	return {
+		npu: hw.npu ? { type: hw.npu.type } : null,
+		gpu: hw.gpu ? { type: hw.gpu.type } : null
+	};
+}
 var DetectionPipelineProvider = class DetectionPipelineProvider {
 	modelsDir;
 	eventBus;
@@ -3746,6 +4028,24 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	*/
 	ready = false;
 	/**
+	* Lazy detection-engine runtime provisioner (Phase 2). Owns the
+	* idle → installing → verifying → ready state machine for the
+	* currently-selected engine and is the SOLE authority the inference
+	* gate (`assertEngineReady`) and the cap snapshot
+	* (`getEngineProvisioning`) read from. Built lazily once the addon
+	* context is wired (real effects need `ctx.deps` + the python dir),
+	* so it is null on a freshly-constructed provider — in which case the
+	* gate reports the cold `idle` state and refuses inference.
+	*/
+	provisioner = null;
+	/**
+	* True when `init()` found no persisted engine choice (first boot).
+	* `setApi()` reads this flag and auto-picks the best supported runtime
+	* using probe data (hardware + bestScore hint), persists the selection,
+	* then clears the flag.
+	*/
+	needsAutoPick = false;
+	/**
 	* Warm cache for benchmark engine-override runs.
 	*
 	* Each override rebuild costs a full Python pool spin-up (~300-500ms)
@@ -3794,6 +4094,9 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 				backend: stored.backend,
 				format: stored.format
 			} });
+		} else {
+			this.needsAutoPick = true;
+			this.log.info("No persisted engine — auto-pick deferred to setApi()");
 		}
 	}
 	/**
@@ -3830,6 +4133,10 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	* on a warmed pool.
 	*/
 	async warmPool() {
+		if (this.getEngineProvisioning().state !== "ready") {
+			this.log.info("warmPool deferred — engine not provisioned yet", { meta: { state: this.getEngineProvisioning().state } });
+			return;
+		}
 		await this.ensureEngineFactory();
 	}
 	/** True when the engine + model pool are fully warmed and inference-ready. */
@@ -3887,108 +4194,281 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	/** Store the addon context. ctx.api is a lazy getter resolved at call time. */
 	async setApi(addonCtx) {
 		this.addonCtx = addonCtx;
+		if (this.needsAutoPick) {
+			await this.autoPickAndPersist();
+			this.needsAutoPick = false;
+		}
+		this.startProvisioningForCurrentEngine();
+	}
+	/**
+	* Auto-pick the best supported runtime at first boot (no stored engine).
+	* Uses the platform-probe cap's hardware + bestScore hint when available;
+	* falls back to platform/arch when the probe cap is not yet reachable.
+	* Persists the selection as `engineBackend` + `engineDevice` so subsequent
+	* boots load it via `loadEngine()` and skip this path.
+	*/
+	async autoPickAndPersist() {
+		let hardware = null;
+		let bestBackendHint = null;
+		try {
+			const api = this.addonCtx?.api;
+			if (api) {
+				const caps = await api.platformProbe.getCapabilities.query();
+				hardware = caps?.hardware ?? null;
+				const bs = caps?.bestScore;
+				if (bs && bs.runtime === "python") bestBackendHint = bs.backend;
+			}
+		} catch {}
+		const pick = pickBestRuntime(runtimeEnvFromProcess(toProbedHardware(hardware)), bestBackendHint);
+		const engine = {
+			runtime: "python",
+			backend: pick.runtimeId,
+			format: modelFormatFor(pick.runtimeId),
+			device: pick.device
+		};
+		this.currentEngine = engine;
+		await this.writeStore({
+			engineBackend: pick.runtimeId,
+			engineDevice: pick.device
+		});
+		this.log.info("Auto-picked engine at first boot", { meta: {
+			backend: pick.runtimeId,
+			device: pick.device,
+			hint: bestBackendHint ?? "none"
+		} });
+	}
+	/** Map a backend string to a known RuntimeId, flooring to onnx. */
+	toRuntimeId(backend) {
+		return [
+			"onnx",
+			"openvino",
+			"coreml"
+		].find((id) => id === backend) ?? "onnx";
+	}
+	/**
+	* Build the {@link EngineProvisioner} with REAL effects. Built lazily
+	* (effects need `addonCtx.deps` + the python dir), so the machine only
+	* exists once the context is wired. The machine is the SOLE authority
+	* the inference gate and the cap snapshot read.
+	*/
+	buildProvisioner() {
+		return new EngineProvisioner({
+			requirementsFor: pythonRequirementsFor,
+			modelFormatFor,
+			installRequirements: async (files) => {
+				const pythonAddonDir = this.executorOptions.pythonAddonDir;
+				if (!pythonAddonDir || !this.addonCtx) return;
+				for (const basename of files) {
+					const file = path$1.join(pythonAddonDir, basename);
+					if (!fs.existsSync(file)) continue;
+					await this.addonCtx.deps.installPythonRequirements(file);
+				}
+			},
+			ensureModelForFormat: async (format) => {
+				await this.ensureModelsForCurrentSteps(format);
+			},
+			verify: async (backend, device) => {
+				await this.verifyEngine(backend, device);
+			},
+			now: () => Date.now(),
+			setTimer: (ms, cb) => {
+				const t = setTimeout(cb, ms);
+				return () => clearTimeout(t);
+			},
+			onChange: (state) => {
+				this.log.info("engine provisioning", { meta: { ...state } });
+				this.emitEngineProvisioning(state);
+			}
+		});
+	}
+	/**
+	* (Re)build the provisioner and `select()` the engine currently held in
+	* `this.currentEngine`. Idempotent: a fresh `select()` bumps the
+	* machine's generation so any in-flight provisioning for a superseded
+	* engine is ignored. No-op for non-python engines (nothing to install /
+	* verify — the gate treats them as ready immediately below).
+	*/
+	startProvisioningForCurrentEngine() {
+		if (!this.provisioner) this.provisioner = this.buildProvisioner();
+		const engine = this.currentEngine;
+		const runtimeId = this.toRuntimeId(engine.backend);
+		const device = engine.device ?? "cpu";
+		const snapshot = this.provisioner.state;
+		if (snapshot.runtimeId === runtimeId && snapshot.device === device && snapshot.state !== "idle") return;
+		this.provisioner.select(runtimeId, device);
+	}
+	/**
+	* Re-trigger provisioning after the operator changes the engine
+	* cascade (`engineBackend`/`engineDevice`). Reloads the persisted
+	* selection into `this.currentEngine`, then `select()`s it — the
+	* machine cancels any superseded provisioning and drives the new
+	* runtime through installing → verifying → ready.
+	*/
+	async onEngineSelectionChanged() {
+		const stored = await this.loadEngine();
+		if (stored) this.currentEngine = stored;
+		this.startProvisioningForCurrentEngine();
+	}
+	/**
+	* Per-node engine-provisioning snapshot. The cap routes `{ nodeId }` for
+	* provider resolution only (the router strips it); each node returns its
+	* own local machine state. Cold (pre-`setApi`) provider → `idle`.
+	*/
+	getEngineProvisioning() {
+		return this.provisioner?.state ?? {
+			runtimeId: null,
+			device: null,
+			state: "idle"
+		};
+	}
+	/**
+	* Inference gate. Rejects with the current phase/error unless the engine
+	* provisioning machine is `ready`. Callers (`ensureExecutor`) surface the
+	* state and skip inference for the cycle rather than falling back — the
+	* cross-process frame caller (`pipeline-runner.runInference`) already
+	* catches and drops the frame, so a throw here never crash-loops.
+	*/
+	async assertEngineReady() {
+		const s = this.getEngineProvisioning();
+		if (s.state !== "ready") throw new Error(`Detection engine not ready: ${s.state}${s.error ? ` — ${s.error}` : ""}`);
+	}
+	/**
+	* Download the model artifacts for `format` needed by the currently
+	* configured steps. Reuses the existing model-download path
+	* (`ensureModelsForSteps`/`downloadWithRetry`), specialised to the
+	* provisioning format by temporarily projecting the current engine onto
+	* `format` for the download fan-out.
+	*/
+	async ensureModelsForCurrentSteps(format) {
+		const steps = await this.getGlobalSteps();
+		if (!steps || steps.length === 0) return;
+		for (const step of flattenSteps(steps)) {
+			if (!step.enabled) continue;
+			const modelEntry = getStepDefinition(step.addonId).models.find((m) => m.id === step.modelId);
+			if (!modelEntry) continue;
+			if (isModelDownloaded(this.modelsDir, modelEntry, format)) continue;
+			await this.downloadWithRetry(modelEntry, format, 3);
+		}
+	}
+	/**
+	* 1-shot import + compile probe for `(backend, device)`. Spawns a
+	* throwaway Python inference pool with EMPTY steps via the existing
+	* `EngineFactory.initialize([])` path — this imports the selected
+	* runtime (onnxruntime / openvino / coremltools) and throws on a
+	* `ModuleNotFoundError` or a runtime-load/compile error — then disposes
+	* the pool. No models are loaded; the probe only proves the runtime is
+	* importable on this host. No-op (resolves) for non-python engines.
+	*/
+	async verifyEngine(backend, device) {
+		if (!this.executorOptions.pythonPath) throw new Error("verifyEngine: pythonPath not resolved — embedded Python unavailable");
+		const probe = new EngineFactory({
+			engine: {
+				runtime: "python",
+				backend,
+				format: modelFormatFor(backend),
+				device
+			},
+			modelsDir: this.modelsDir,
+			logger: this.log.child("engine-verify"),
+			pythonPath: this.executorOptions.pythonPath,
+			concurrency: 1,
+			numWorkers: 1
+		});
+		try {
+			await probe.initialize([]);
+		} finally {
+			await probe.dispose().catch(() => void 0);
+		}
+	}
+	/**
+	* Emit the {@link EventCategory.PipelineEngineProvisioning} telemetry
+	* event on every machine transition so the Pipeline page can drive a
+	* live per-node indicator without polling the cap snapshot.
+	*/
+	emitEngineProvisioning(state) {
+		const eventBus = this.addonCtx?.eventBus ?? this.eventBus;
+		if (!eventBus) return;
+		const rawNodeId = this.addonCtx?.kernel?.localNodeId ?? "hub";
+		const nodeId = rawNodeId.includes("/") ? rawNodeId.split("/")[0] : rawNodeId;
+		eventBus.emit(createEvent(EventCategory.PipelineEngineProvisioning, {
+			type: "node",
+			id: nodeId,
+			nodeId
+		}, { ...state }));
 	}
 	/**
-	* 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.
+	* Fetch the probed HARDWARE for engine + device gating. Returns null when the
+	* probe cap is not yet reachable (cold-start / probe addon not installed), so
+	* callers fall back to the registry's safe minimum. The engine OFFER derives
+	* from hardware ONLY — install state (probe `scores`) never gates it.
 	*/
 	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
-			};
+			if (!api) return { hardware: null };
+			return { hardware: (await api.platformProbe.getCapabilities.query())?.hardware ?? null };
 		} catch {
-			return {
-				availableBackends: null,
-				hardware: null
-			};
+			return { 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();
+		const { hardware } = await this.fetchProbeGatingData();
+		const env = runtimeEnvFromProcess(toProbedHardware(hardware));
 		return {
-			availableEngines: this.getAvailableEnginesWithDevices(availableBackends, hardware),
+			availableEngines: this.getAvailableEnginesWithDevices(env).map((e) => this.toAvailableEngine(e)),
 			selectedEngine: { ...engine },
 			slots
 		};
 	}
 	async getAvailableEngines() {
-		const { availableBackends, hardware } = await this.fetchProbeGatingData();
-		return this.getAvailableEnginesWithDevices(availableBackends, hardware).map((e) => e.engine);
+		const { hardware } = await this.fetchProbeGatingData();
+		const env = runtimeEnvFromProcess(toProbedHardware(hardware));
+		return this.getAvailableEnginesWithDevices(env).map((e) => ({ ...e.engine }));
 	}
 	/**
-	* 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.).
+	* Build the engine catalog from the HARDWARE-supported runtime set.
 	*
-	* 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.
+	* The offered backend list comes from `supportedRuntimes(env)` — platform,
+	* arch and probed hardware ONLY, never from which Python packages are
+	* installed (install state is provisioned on demand in Phase 2). Each
+	* engine's device list is `runtimeDevices(backend, env.hardware)` (probe-
+	* driven; default-only when `env.hardware` is null). The result is
+	* conservative when the probe is unreachable: onnx floor + default device.
 	*/
-	getAvailableEnginesWithDevices(availableBackends, hardware) {
-		const allEngines = [];
-		if (process.platform === "darwin") allEngines.push({
+	getAvailableEnginesWithDevices(env) {
+		return supportedRuntimes(env).map((id) => ({
 			engine: {
 				runtime: "python",
-				backend: "coreml",
-				format: "coreml"
+				backend: id,
+				format: modelFormatFor(id),
+				device: defaultDeviceFor(id)
 			},
-			devices: COREML_DEVICES,
-			defaultDevice: "all"
-		});
-		allEngines.push({
-			engine: {
-				runtime: "python",
-				backend: "openvino",
-				format: "openvino"
-			},
-			devices: OPENVINO_DEVICES,
-			defaultDevice: "auto"
-		});
-		allEngines.push({
+			devices: runtimeDevices(id, env.hardware).map((d) => ({
+				id: d.value,
+				label: d.label
+			}))
+		}));
+	}
+	/**
+	* Adapt an {@link EngineWithDevices} (registry shape) to the wire
+	* {@link AvailableEngine} consumed by `PipelineSchema.availableEngines`.
+	*/
+	toAvailableEngine(e) {
+		return {
 			engine: {
-				runtime: "python",
-				backend: "onnx",
-				format: "onnx"
+				runtime: e.engine.runtime,
+				backend: e.engine.backend,
+				format: e.engine.format
 			},
-			devices: ONNX_PYTHON_DEVICES,
-			defaultDevice: "cpu"
-		});
-		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,
+			devices: e.devices.map((d) => ({
+				id: 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))
-			};
-		});
+			})),
+			defaultDevice: e.engine.device
+		};
 	}
 	async getDefaultSteps(engine) {
 		return buildDefaultStepTree(engine.format);
@@ -4080,21 +4560,16 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 				};
 			})
 		}));
-		const { availableBackends, hardware } = await this.fetchProbeGatingData();
-		const engines = this.getAvailableEnginesWithDevices(availableBackends, hardware);
+		const { hardware } = await this.fetchProbeGatingData();
+		const env = runtimeEnvFromProcess(toProbedHardware(hardware));
+		const engines = this.getAvailableEnginesWithDevices(env);
 		const nodeBackends = [];
 		const pythonBackends = [];
-		for (const e of engines) if (e.engine.runtime === "node") nodeBackends.push({
+		for (const e of engines) pythonBackends.push({
 			id: e.engine.backend,
 			label: e.engine.backend.toUpperCase(),
 			available: true,
-			device: e.defaultDevice ?? e.devices[0]?.id ?? "cpu"
-		});
-		else pythonBackends.push({
-			id: e.engine.backend,
-			label: e.engine.backend.toUpperCase(),
-			available: true,
-			device: e.defaultDevice ?? e.devices[0]?.id ?? "cpu",
+			device: e.engine.device || e.devices[0]?.id || "cpu",
 			modelFormat: e.engine.format,
 			pythonModule: pythonModuleForBackend(e.engine.backend)
 		});
@@ -5101,6 +5576,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	async ensureEngineFactory() {
 		if (this.initPromise) await this.initPromise;
 		if (this.engineFactory) return;
+		await this.assertEngineReady();
 		await this.ensureBackendDeps(this.currentEngine);
 		this.engineFactory = new EngineFactory({
 			engine: this.currentEngine,
@@ -5116,6 +5592,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	async ensureExecutor() {
 		if (this.initPromise) await this.initPromise;
 		if (!this.engineFactory) {
+			await this.assertEngineReady();
 			this.initPromise = this.doInitialize();
 			try {
 				await this.initPromise;
@@ -5714,70 +6191,45 @@ function applyDeviceOverridesToTree(tree, rootStepId, overrides) {
 		}
 	} : root) };
 }
-var COREML_DEVICES = [
-	{
-		id: "all",
-		label: "All (CPU + GPU + Neural Engine)",
-		description: "CoreML auto-selects the best available compute unit"
-	},
-	{
-		id: "ane",
-		label: "Neural Engine",
-		description: "Apple Neural Engine — fastest, lowest power"
-	},
-	{
-		id: "gpu",
-		label: "GPU",
-		description: "Apple GPU — good for larger models"
-	},
-	{
-		id: "cpu",
-		label: "CPU only",
-		description: "CPU fallback — slowest but always available"
-	}
-];
-var OPENVINO_DEVICES = [
-	{
-		id: "auto",
-		label: "Auto",
-		description: "OpenVINO auto-selects best device (recommended)"
-	},
-	{
-		id: "cpu",
-		label: "CPU",
-		description: "Intel CPU with AVX/SSE optimizations"
-	},
-	{
-		id: "gpu",
-		label: "GPU (Intel)",
-		description: "Intel integrated/discrete GPU via OpenCL"
-	},
-	{
-		id: "npu",
-		label: "NPU (Intel)",
-		description: "Intel Neural Processing Unit (Meteor Lake+)"
-	}
-];
-var ONNX_PYTHON_DEVICES = [
-	{
-		id: "cpu",
-		label: "CPU",
-		description: "ONNX Runtime CPU provider"
-	},
-	{
-		id: "cuda",
-		label: "CUDA (NVIDIA)",
-		description: "NVIDIA GPU via CUDA"
-	},
-	{
-		id: "coreml",
-		label: "CoreML",
-		description: "Apple CoreML execution provider (macOS)"
+//#endregion
+//#region src/detection-pipeline/python-readiness.ts
+/**
+* Resolve the embedded Python once, turning the null/throw failure modes into
+* an explicit, logged result. Python is a hard prerequisite for every runtime;
+* a silent miss here is what produced the "probe empty → bad offer" symptom.
+*/
+async function ensurePythonReady(deps, log) {
+	try {
+		const pythonPath = await deps.ensurePython();
+		if (!pythonPath) {
+			log.error("Embedded Python unavailable — inference runtimes cannot be provisioned", {});
+			return {
+				pythonPath: null,
+				ok: false
+			};
+		}
+		log.info("Embedded Python ready", { meta: { pythonPath } });
+		return {
+			pythonPath,
+			ok: true
+		};
+	} catch (err) {
+		log.error("Embedded Python provisioning threw", { meta: { error: err instanceof Error ? err.message : String(err) } });
+		return {
+			pythonPath: null,
+			ok: false
+		};
 	}
-];
+}
 //#endregion
 //#region src/detection-pipeline/index.ts
 /**
+* addon-detection-pipeline — unified detection pipeline for CamStack.
+*
+* Single addon replaces 13 separate vision addon classes.
+* Each pipeline step is a class implementing IPipelineStep.
+*/
+/**
 * Locate the addon's bundled `python/` dir at runtime. Mirrors the
 * resolution done in `shared-inference-pool.ts:resolveScriptPath` —
 * tries the published package first (resolves through node_modules),
@@ -5796,151 +6248,6 @@ function resolveAddonPythonDir() {
 	for (const c of candidates) if (fs.existsSync(path$1.join(c, "inference_pool.py"))) return c;
 	throw new Error(`addon-pipeline/detection-pipeline: python/ dir not found. Searched:\n${candidates.join("\n")}`);
 }
-/**
-* 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",
-		label: "CoreML"
-	},
-	{
-		value: "openvino",
-		label: "OpenVINO"
-	},
-	{
-		value: "onnx",
-		label: "ONNX Runtime"
-	}
-] };
-var DEVICES_BY_BACKEND = {
-	coreml: [
-		{
-			value: "all",
-			label: "All (ANE + GPU + CPU)"
-		},
-		{
-			value: "ane",
-			label: "Apple Neural Engine"
-		},
-		{
-			value: "gpu",
-			label: "GPU"
-		},
-		{
-			value: "cpu",
-			label: "CPU"
-		}
-	],
-	openvino: [
-		{
-			value: "auto",
-			label: "Auto"
-		},
-		{
-			value: "cpu",
-			label: "CPU"
-		},
-		{
-			value: "gpu",
-			label: "GPU"
-		},
-		{
-			value: "npu",
-			label: "NPU"
-		}
-	],
-	onnx: [
-		{
-			value: "cpu",
-			label: "CPU"
-		},
-		{
-			value: "cuda",
-			label: "CUDA"
-		},
-		{
-			value: "coreml",
-			label: "CoreML EP"
-		}
-	],
-	cpu: [{
-		value: "cpu",
-		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",
@@ -5948,37 +6255,38 @@ var BACKEND_TO_FORMAT = {
 	onnx: "onnx"
 };
 /**
-* Per-backend tuning defaults — derived from the matrix sweep
-* (`scripts/bench-pool-matrix.py` + `bench-coreml-patterns.py`).
-* Applied by `getGlobalSettings(overlay)` so the UI defaults track
-* the currently-selected backend instead of a single global value.
+* Every runtime the registry knows about, in offer order. Used only to build
+* the STATIC base schema (returned by `globalSettingsSchema()` before a live
+* ctx exists, e.g. addon-registry boot introspection). The live, hardware-
+* gated subset is injected by `getGlobalSettings()` via `supportedRuntimes(env)`.
 */
-var TUNING_DEFAULTS = {
-	coreml: {
-		concurrency: 1,
-		batchMode: "none",
-		windowMs: 8,
-		maxBatchSize: 8,
-		numWorkers: 1
-	},
-	openvino: {
-		concurrency: 1,
-		batchMode: "none",
-		numStreams: 0
-	},
-	onnx: {
-		concurrency: 4,
-		batchMode: "list",
-		maxBatchSize: 8,
-		intraOpThreads: 0
-	},
-	cpu: {
-		concurrency: 4,
-		batchMode: "list",
-		maxBatchSize: 8,
-		intraOpThreads: 0
-	}
-};
+var ALL_RUNTIME_IDS = [
+	"onnx",
+	"openvino",
+	"coreml"
+];
+/**
+* Narrow an arbitrary stored backend string to a known `RuntimeId`. Legacy or
+* unknown values (e.g. the removed `'cpu'` backend) fall back to the `onnx`
+* floor so the registry lookup never throws.
+*/
+function toRuntimeId(backend) {
+	return ALL_RUNTIME_IDS.find((id) => id === backend) ?? "onnx";
+}
+/** Static universe of backend options (every runtime). Labels from the registry. */
+var STATIC_BACKEND_OPTIONS = ALL_RUNTIME_IDS.map((id) => ({
+	value: id,
+	label: runtimeLabel(id)
+}));
+/**
+* Static device options for the schema's default backend. The live device
+* list per the selected backend + probed hardware is injected by
+* `getGlobalSettings()` via `runtimeDevices(backend, hardware)`.
+*/
+var STATIC_DEFAULT_DEVICE_OPTIONS = runtimeDevices(ALL_RUNTIME_IDS[0], null).map((d) => ({
+	value: d.value,
+	label: d.label
+}));
 var DEFAULT_CONFIG = {
 	concurrency: 0,
 	batchMode: "",
@@ -5988,8 +6296,8 @@ var DEFAULT_CONFIG = {
 	intraOpThreads: 0,
 	numWorkers: 0,
 	engineRuntime: "python",
-	engineBackend: "coreml",
-	engineDevice: "all",
+	engineBackend: "onnx",
+	engineDevice: "cpu",
 	probedBestEngine: ""
 };
 /** Derive the model-format from a backend value. Called by the provider. */
@@ -6091,7 +6399,7 @@ var DetectionPipelineAddon = class extends BaseAddon {
 					type: "select",
 					key: "engineBackend",
 					label: "Execution provider",
-					options: [...BACKENDS_BY_RUNTIME.python],
+					options: [...STATIC_BACKEND_OPTIONS],
 					default: DEFAULT_CONFIG.engineBackend,
 					immediate: true,
 					requiresRestart: true
@@ -6100,7 +6408,7 @@ var DetectionPipelineAddon = class extends BaseAddon {
 					type: "select",
 					key: "engineDevice",
 					label: "Hardware device",
-					options: [...DEVICES_BY_BACKEND.coreml],
+					options: [...STATIC_DEFAULT_DEVICE_OPTIONS],
 					default: DEFAULT_CONFIG.engineDevice,
 					immediate: true,
 					requiresRestart: true
@@ -6213,12 +6521,15 @@ var DetectionPipelineAddon = class extends BaseAddon {
 		}] });
 	}
 	/**
-	* Override to inject dynamic backend + device options based on the
-	* currently-stored runtime + backend. The base schema ships with
-	* placeholder lists; here we replace them with the valid subset for
-	* whatever the operator has picked. Combined with `immediate: true`
-	* on the selects, the UI can refetch after each change and see the
-	* next level's options narrow down.
+	* Override to inject the hardware-driven backend + device options.
+	*
+	* The OFFERED backend list comes from `supportedRuntimes(env)` — platform,
+	* arch and probed hardware ONLY, never from which Python packages are
+	* installed. A host's hardware is what it can physically run; install state
+	* is provisioned on demand (Phase 2). Device options come from
+	* `runtimeDevices(backend, hardware)` (probe-driven; default-only when the
+	* probe is unreachable). Stored backend / device snap back to the registry
+	* floor / default when they fall outside the offered set.
 	*/
 	async getGlobalSettings(overlay) {
 		const ctx = this.ctxIfReady;
@@ -6227,19 +6538,18 @@ var DetectionPipelineAddon = class extends BaseAddon {
 			...stored,
 			...overlay
 		} : stored;
-		const runtime = "python";
-		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 env = await this.probeHardwareEnv();
+		const hardware = env.hardware;
+		const offered = supportedRuntimes(env);
+		const runtimeBackends = offered.map((id) => ({
+			value: id,
+			label: runtimeLabel(id)
+		}));
 		const storedBackend = typeof merged.engineBackend === "string" ? merged.engineBackend : "";
-		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 backend = offered.find((id) => id === storedBackend) ?? offered[0] ?? "onnx";
+		const deviceOptions = runtimeDevices(backend, hardware);
 		const storedDevice = typeof merged.engineDevice === "string" ? merged.engineDevice : "";
-		const device = deviceOptions.find((d) => d.value === storedDevice)?.value ?? deviceOptions[0]?.value ?? "cpu";
+		const device = deviceOptions.find((d) => d.value === storedDevice)?.value ?? defaultDeviceFor(backend);
 		const raw = {
 			...merged,
 			engineBackend: backend,
@@ -6247,7 +6557,7 @@ var DetectionPipelineAddon = class extends BaseAddon {
 		};
 		const schema = this.globalSettingsSchema();
 		if (!schema) return { sections: [] };
-		const tuning = TUNING_DEFAULTS[backend] ?? {};
+		const tuning = tuningFor(backend);
 		return hydrateSchema({
 			...schema,
 			sections: schema.sections.map((section) => ({
@@ -6260,12 +6570,15 @@ var DetectionPipelineAddon = class extends BaseAddon {
 						};
 						if (field.key === "engineDevice") return {
 							...field,
-							options: [...deviceOptions],
-							default: deviceOptions[0]?.value ?? "cpu"
+							options: deviceOptions.map((d) => ({
+								value: d.value,
+								label: d.label
+							})),
+							default: defaultDeviceFor(backend)
 						};
-						if (field.key === "batchMode" && tuning.batchMode !== void 0) return {
+						if (field.key === "batchMode" && tuning["batchMode"] !== void 0) return {
 							...field,
-							default: tuning.batchMode
+							default: tuning["batchMode"]
 						};
 					}
 					if (field.type === "slider" && "key" in field) {
@@ -6287,55 +6600,47 @@ var DetectionPipelineAddon = class extends BaseAddon {
 		}, raw);
 	}
 	/**
-	* 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).
+	* Resolve the runtime env (platform + arch + probed hardware) used to derive
+	* the OFFERED backend list. The hardware comes from the platform-probe cap
+	* (`getCapabilities`); when the cap isn't reachable yet (cold-start / probe
+	* addon not installed) `hardware` is null, which the registry collapses to
+	* the safe minimum (onnx floor; default-only devices).
 	*
-	* A single probe call is made so both backend AND device gating use the
-	* same snapshot without doubling the cap round-trip.
+	* Protected seam — overridable by tests (canned hardware) and reused by the
+	* Phase 2 auto-pick path. NEVER reads install state.
+	*/
+	async probeHardwareEnv() {
+		const hardware = await this.resolveProbeHardware();
+		return {
+			platform: process.platform,
+			arch: process.arch,
+			hardware
+		};
+	}
+	/**
+	* Fetch the probed hardware from the platform-probe cap. Returns null when
+	* the cap is not reachable (caller falls back to the registry's safe minimum).
 	*/
-	async resolveProbeData(ctx, runtime) {
+	async resolveProbeHardware() {
 		try {
-			const api = ctx?.api;
-			if (!api) return {
-				availableBackends: [],
-				hardware: null,
-				bestBackend: null
-			};
-			const caps = await api.platformProbe.getCapabilities.query();
-			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);
-			}
-			const bestBackend = caps.bestScore?.runtime === runtime ? caps.bestScore.backend ?? null : null;
+			const api = this.ctxIfReady?.api;
+			if (!api) return null;
+			const hw = (await api.platformProbe.getCapabilities.query())?.hardware;
+			if (!hw) return null;
 			return {
-				availableBackends: [...out],
-				hardware: caps.hardware ?? null,
-				bestBackend
+				npu: hw.npu ? { type: hw.npu.type } : null,
+				gpu: hw.gpu ? { type: hw.gpu.type } : null
 			};
 		} catch {
-			return {
-				availableBackends: [],
-				hardware: null,
-				bestBackend: null
-			};
+			return null;
 		}
 	}
 	/**
 	* Resolve the effective pool tuning for the configured backend.
 	*
-	* Reads `TUNING_DEFAULTS[backend]` and ignores any persisted override
-	* for `concurrency / batchMode / windowMs / maxBatchSize / numStreams /
-	* intraOpThreads`. Stored values are quietly discarded so an old
+	* Reads the registry's `tuningFor(backend)` and ignores any persisted
+	* override for `concurrency / batchMode / windowMs / maxBatchSize /
+	* numStreams / intraOpThreads`. Stored values are quietly discarded so an old
 	* suboptimal user-override (saved when the UI exposed these knobs)
 	* cannot resurrect itself after a restart.
 	*
@@ -6344,18 +6649,17 @@ var DetectionPipelineAddon = class extends BaseAddon {
 	* a reason to disagree.
 	*/
 	resolveBackendTuning() {
-		const t = TUNING_DEFAULTS[this.config.engineBackend ?? DEFAULT_CONFIG.engineBackend] ?? TUNING_DEFAULTS["onnx"];
-		const tAny = t;
+		const t = tuningFor(toRuntimeId(this.config.engineBackend ?? DEFAULT_CONFIG.engineBackend));
 		const num = (v, dflt) => typeof v === "number" && v > 0 ? v : dflt;
-		const str = (v, dflt) => typeof v === "string" && v !== "" ? v : dflt;
+		const batch = (v, dflt) => v === "none" || v === "list" || v === "window" ? v : dflt;
 		return {
-			concurrency: num(t.concurrency, 1),
-			batchMode: str(t.batchMode, "window"),
-			windowMs: num(t.windowMs, 2),
-			maxBatchSize: num(t.maxBatchSize, 8),
-			numStreams: num(t.numStreams, 0),
-			intraOpThreads: num(t.intraOpThreads, 0),
-			numWorkers: num(tAny["numWorkers"], 1)
+			concurrency: num(t["concurrency"], 1),
+			batchMode: batch(t["batchMode"], "window"),
+			windowMs: num(t["windowMs"], 2),
+			maxBatchSize: num(t["maxBatchSize"], 8),
+			numStreams: num(t["numStreams"], 0),
+			intraOpThreads: num(t["intraOpThreads"], 0),
+			numWorkers: num(t["numWorkers"], 1)
 		};
 	}
 	async onInitialize() {
@@ -6365,9 +6669,9 @@ var DetectionPipelineAddon = class extends BaseAddon {
 		}).catch(() => "camstack-data/models");
 		if (!this.ctx.settings) throw new Error("DetectionPipelineAddon: ctx.settings not available");
 		this.pythonAddonDir = resolveAddonPythonDir();
-		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.");
+		const py = await ensurePythonReady(this.ctx.deps, this.ctx.logger);
+		if (py.ok && py.pythonPath) this.pythonPath = py.pythonPath;
+		else this.ctx.logger.warn("Detection engine boot continues without Python — selection will provision on demand", {});
 		await this.proactivelyInstallOpenvino();
 		const effectiveTuning = this.resolveBackendTuning();
 		this.provider = new DetectionPipelineProvider(this.ctx.settings, modelsDir, this.ctx.logger, this.ctx.eventBus ?? null, () => ({ sections: [] }), {
@@ -6474,7 +6778,7 @@ var DetectionPipelineAddon = class extends BaseAddon {
 	* Snapshot the pool-bound subset of the EFFECTIVE tuning (post-
 	* `resolveBackendTuning`). Stored config values for these fields are
 	* ignored, so this snapshot only changes when `engineBackend` flips
-	* onto a different `TUNING_DEFAULTS` row.
+	* onto a different `tuningFor` row.
 	*/
 	snapshotPoolConfig() {
 		const t = this.resolveBackendTuning();
@@ -6507,6 +6811,9 @@ var DetectionPipelineAddon = class extends BaseAddon {
 	* lifecycle (engineFactory rebuild on next runPipeline).
 	*/
 	async onConfigChanged() {
+		if (this.provider) await this.provider.onEngineSelectionChanged().catch((err) => {
+			this.ctx.logger.warn("engine provisioning re-select failed on config change", { meta: { error: err instanceof Error ? err.message : String(err) } });
+		});
 		if (!this.poolConfigChanged()) return;
 		if (!this.provider) {
 			this.lastAppliedPoolConfig = this.snapshotPoolConfig();
@@ -6548,4 +6855,4 @@ var DetectionPipelineAddon = class extends BaseAddon {
 	}
 };
 //#endregion
-export { ALL_STEPS, DetectionPipelineProvider, backendToFormat, DetectionPipelineAddon as default, filterDeviceOptionsByHardware, getDefaultModelForFormat, getStepDefinition, shouldInstallOpenvino };
+export { ALL_STEPS, DetectionPipelineProvider, backendToFormat, DetectionPipelineAddon as default, getDefaultModelForFormat, getStepDefinition, shouldInstallOpenvino };