@camstack/addon-pipeline 1.1.0 → 1.1.2

package/dist/detection-pipeline/index.mjs

@@ -1,6 +1,6 @@
 import { t as __require } from "../chunk-BdkLduGY.mjs";
-import { A as nodePin, B as BaseAddon, C as detectionPipelineCapability, J as hydrateSchema, L as supportedRuntimes$1, P as runtimeDevices$1, T as hfModelUrl, W as EventCategory, Z as parseJsonUnknown, a as COCO_TO_MACRO, et as sleep, i as COCO_80_LABELS, j as pipelineExecutorCapability, p as YAMNET_TO_MACRO, q as createEvent, r as AUDIO_MACRO_LABELS, t as APPLE_SA_TO_MACRO, w as evaluateZoneRules, x as defaultDeviceFor$1, z as errMsg } from "../dist-BA6DR_jV.mjs";
-import { a as isModelDownloaded, i as ensureModel, n as deleteModelFromDisk } from "../model-download-service-RxAOiYvX-CMAvhgO7.mjs";
+import { A as nodePin, B as BaseAddon, C as detectionPipelineCapability, J as hydrateSchema, L as supportedRuntimes$1, P as runtimeDevices$1, T as hfModelUrl, W as EventCategory, Z as parseJsonUnknown, a as COCO_TO_MACRO, et as sleep, i as COCO_80_LABELS, j as pipelineExecutorCapability, p as YAMNET_TO_MACRO, q as createEvent, r as AUDIO_MACRO_LABELS, t as APPLE_SA_TO_MACRO, w as evaluateZoneRules, x as defaultDeviceFor$1, z as errMsg } from "../dist-BWc-HYQz.mjs";
+import { a as isModelDownloaded, i as ensureModel, n as deleteModelFromDisk } from "../model-download-service-C-IHWnXx-3Mmeob3l.mjs";
 import * as fs from "node:fs";
 import * as path$1 from "node:path";
 import * as os from "node:os";
@@ -114,7 +114,6 @@ function npuInfoFrom(hw) {
 	return { type };
 }
 function envToHardwareInfo(env) {
-	if (!env.hardware) return null;
 	return {
 		platform: toKnownPlatform(env.platform),
 		arch: toKnownArch(env.arch),
@@ -122,8 +121,8 @@ function envToHardwareInfo(env) {
 		cpuCores: 0,
 		totalRAM_MB: 0,
 		availableRAM_MB: 0,
-		gpu: gpuInfoFrom(env.hardware),
-		npu: npuInfoFrom(env.hardware)
+		gpu: env.hardware ? gpuInfoFrom(env.hardware) : null,
+		npu: env.hardware ? npuInfoFrom(env.hardware) : null
 	};
 }
 function probedToHardwareInfo(hw) {
@@ -1036,6 +1035,26 @@ var ovFormat = (url, sizeMB) => {
 		...files ? { files } : {}
 	};
 };
+/**
+* Build a precision-variant catalog entry (OpenVINO-only) derived from a base
+* detection model. fp16 halves the weights (Intel iGPU/NPU sweet spot); int8 is
+* NNCF post-training-quantized (~4× smaller, fastest on CPU/iGPU at a small
+* accuracy cost). The IRs live next to the base `.xml` on HF as
+* `camstack-<id>-<precision>.xml`. Lets an operator scale the model to the node
+* (e.g. yolo26x-int8 on a 265K, yolo26n-int8 on an N100).
+*/
+var ovPrecisionVariant = (baseId, ovDir, baseName, precision, sizeMB) => ({
+	id: `${baseId}-${precision}`,
+	name: `${baseName} (${precision.toUpperCase()})`,
+	description: `${baseName} — OpenVINO ${precision.toUpperCase()} variant for Intel iGPU/NPU; scale by hardware`,
+	inputSize: {
+		width: 640,
+		height: 640
+	},
+	labels: [],
+	preprocessMode: "letterbox",
+	formats: { openvino: ovFormat(hf(`${ovDir}/camstack-${baseId}-${precision}.xml`), sizeMB) }
+});
 var MLPACKAGE_FILES = [
 	"Manifest.json",
 	"Data/com.apple.CoreML/model.mlmodel",
@@ -1341,7 +1360,21 @@ var OBJECT_DETECTION_MODELS = [
 			},
 			openvino: ovFormat(hf("objectDetection/scrypted-yolov9-relu/openvino/scrypted_yolov9m_relu.xml"), 38)
 		}
-	}
+	},
+	ovPrecisionVariant("yolov9t", "objectDetection/yolov9/openvino", "YOLOv9 Tiny", "fp16", 5),
+	ovPrecisionVariant("yolov9t", "objectDetection/yolov9/openvino", "YOLOv9 Tiny", "int8", 3),
+	ovPrecisionVariant("yolov9s", "objectDetection/yolov9/openvino", "YOLOv9 Small", "fp16", 15),
+	ovPrecisionVariant("yolov9s", "objectDetection/yolov9/openvino", "YOLOv9 Small", "int8", 8),
+	ovPrecisionVariant("yolo26n", "objectDetection/yolo26/openvino", "YOLO26 Nano", "fp16", 5),
+	ovPrecisionVariant("yolo26n", "objectDetection/yolo26/openvino", "YOLO26 Nano", "int8", 3),
+	ovPrecisionVariant("yolo26s", "objectDetection/yolo26/openvino", "YOLO26 Small", "fp16", 19),
+	ovPrecisionVariant("yolo26s", "objectDetection/yolo26/openvino", "YOLO26 Small", "int8", 10),
+	ovPrecisionVariant("yolo26m", "objectDetection/yolo26/openvino", "YOLO26 Medium", "fp16", 41),
+	ovPrecisionVariant("yolo26m", "objectDetection/yolo26/openvino", "YOLO26 Medium", "int8", 21),
+	ovPrecisionVariant("yolo26l", "objectDetection/yolo26/openvino", "YOLO26 Large", "fp16", 50),
+	ovPrecisionVariant("yolo26l", "objectDetection/yolo26/openvino", "YOLO26 Large", "int8", 25),
+	ovPrecisionVariant("yolo26x", "objectDetection/yolo26/openvino", "YOLO26 XLarge", "fp16", 112),
+	ovPrecisionVariant("yolo26x", "objectDetection/yolo26/openvino", "YOLO26 XLarge", "int8", 56)
 ];
 var FACE_DETECTION_MODELS = [{
 	id: "scrfd-2.5g",
@@ -1788,7 +1821,7 @@ var ObjectDetectionStep = class {
 			"animal"
 		],
 		models: [...OBJECT_DETECTION_MODELS],
-		defaultModelId: "yolov9s",
+		defaultModelId: "yolo26n",
 		defaultConfidence: .5,
 		labels: COCO_80_LABELS.map((l) => l.id),
 		classMap: COCO_TO_MACRO
@@ -2037,9 +2070,9 @@ var STEP_VEHICLE_CLASSIFIER = new ClassifierWithMinConfidence({
 	enabledByDefault: false,
 	defaultConfidence: .3
 });
-var STEP_SEGMENTATION_REFINER = new PipelineStepBase({
-	id: "segmentation-refiner",
-	name: "Saliency Segmentation",
+var STEP_SEGMENTATION = new PipelineStepBase({
+	id: "segmentation",
+	name: "Segmentation",
 	slot: "refiner",
 	postprocessor: "saliency",
 	extractMode: "crop-roi",
@@ -2051,7 +2084,7 @@ var STEP_SEGMENTATION_REFINER = new PipelineStepBase({
 	defaultConfidence: 0,
 	group: "Segmentation"
 });
-var STEP_INSTANCE_SEGMENTATION = new PipelineStepBase({
+new PipelineStepBase({
 	id: "instance-segmentation",
 	name: "Instance Segmentation",
 	slot: "refiner",
@@ -2078,8 +2111,7 @@ var ALL_PIPELINE_STEPS = [
 	new AnimalClassifierStep(),
 	STEP_BIRD_CLASSIFIER,
 	STEP_VEHICLE_CLASSIFIER,
-	STEP_SEGMENTATION_REFINER,
-	STEP_INSTANCE_SEGMENTATION,
+	STEP_SEGMENTATION,
 	STEP_AUDIO_CLASSIFIER_INSTANCE
 ];
 /** Compat: flat array of StepDefinition for existing consumers */
@@ -3250,6 +3282,18 @@ function applyChildOutput(parent, childStep, output, stepLatencyMs, ctx) {
 			parent.mask = output.mask;
 			parent.maskWidth = output.maskWidth;
 			parent.maskHeight = output.maskHeight;
+			if (output.maskBbox !== void 0 && output.maskWidth > 0 && output.maskHeight > 0) {
+				const [px1, py1, px2, py2] = parent.bbox;
+				const parentW = px2 - px1;
+				const parentH = py2 - py1;
+				const [mbx, mby, mbw, mbh] = output.maskBbox;
+				parent.refinedBbox = [
+					px1 + mbx / output.maskWidth * parentW,
+					py1 + mby / output.maskHeight * parentH,
+					px1 + (mbx + mbw) / output.maskWidth * parentW,
+					py1 + (mby + mbh) / output.maskHeight * parentH
+				];
+			}
 			break;
 	}
 }
@@ -3300,6 +3344,12 @@ function buildFrameResult(input) {
 			macroClass: m.macroClass,
 			score: m.score,
 			bbox,
+			...m.refinedBbox !== void 0 ? { refinedBbox: bboxTupleToRect(m.refinedBbox) } : {},
+			...m.mask !== void 0 && m.maskWidth !== void 0 && m.maskHeight !== void 0 ? {
+				mask: m.mask,
+				maskWidth: m.maskWidth,
+				maskHeight: m.maskHeight
+			} : {},
 			labels,
 			...m.parentId !== void 0 ? { parentId: m.parentId } : {},
 			...embedding !== void 0 ? {
@@ -3790,6 +3840,40 @@ function walkFieldsForDefaults(fields, out) {
 	}
 }
 //#endregion
+//#region src/detection-pipeline/registry/custom-models.ts
+/**
+* Group a flat list of custom-model descriptors (as returned by the
+* `custom-model-registry` collection cap) into a `stepId → entries` map for
+* the picker / resolution union. Pure; order within a step preserved.
+*/
+function groupCustomModelsByStep(descriptors) {
+	const byStep = /* @__PURE__ */ new Map();
+	for (const d of descriptors) {
+		const arr = byStep.get(d.stepId) ?? [];
+		arr.push(d.entry);
+		byStep.set(d.stepId, arr);
+	}
+	return byStep;
+}
+/**
+* Union a step's static catalog models with operator-registered custom
+* models. On an `id` collision the static catalog entry wins — a custom
+* model can never shadow a built-in one.
+*
+* Pure + side-effect-free so it can be unit-tested in isolation and called
+* from the (free) `buildSchemaSlots` builder without any addon context.
+*/
+function mergeCustomModels(staticModels, customModels) {
+	const seen = new Set(staticModels.map((m) => m.id));
+	const merged = [...staticModels];
+	for (const m of customModels) {
+		if (seen.has(m.id)) continue;
+		seen.add(m.id);
+		merged.push(m);
+	}
+	return merged;
+}
+//#endregion
 //#region src/detection-pipeline/provider.ts
 /**
 * DetectionPipelineProvider — implements IPipelineExecutorProvider.
@@ -4004,6 +4088,17 @@ var ONNX_FLOOR = {
 * instead of duplicated inline.
 */
 function onnxFloorPick() {
+	return ONNX_FLOOR;
+}
+/**
+* The platform-deterministic engine pick computed SYNCHRONOUSLY from this node's
+* own `process.platform`/`arch` alone (no probe): darwin → coreml, else → onnx
+* (gpu-dependent openvino/cuda need the probe and converge via the auto-pick).
+* Used as the ENGINE fallback when a persisted selection is unsupported on this
+* node — so a stale GLOBAL engine config (e.g. the cluster's OpenVINO choice)
+* can never force an impossible engine onto a node whose platform rejects it.
+*/
+function platformDefaultPick() {
 	const pick = pickBestRuntime(runtimeEnvFromProcess(null), null);
 	return {
 		runtime: "python",
@@ -4012,6 +4107,19 @@ function onnxFloorPick() {
 		device: pick.device
 	};
 }
+/**
+* Is `backend` even POSSIBLE on this node's OS/arch (ignoring gpu detail)?
+* coreml ⇒ darwin only; openvino ⇒ x64 non-darwin only; onnx ⇒ anywhere. Used to
+* reject a persisted/global engine choice that the node's PLATFORM fundamentally
+* cannot run (e.g. the cluster's OpenVINO default landing on a Mac) — distinct
+* from the gpu-dependent support (linux without a probed Intel iGPU still keeps
+* openvino as a valid platform choice; the device falls back to cpu).
+*/
+function backendPossibleOnPlatform(backend) {
+	if (backend === "coreml") return process.platform === "darwin";
+	if (backend === "openvino") return process.arch === "x64" && process.platform !== "darwin";
+	return true;
+}
 var DetectionPipelineProvider = class DetectionPipelineProvider {
 	modelsDir;
 	eventBus;
@@ -4025,6 +4133,13 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	/** Addon context — ctx.api resolves lazily (direct caller created after boot) */
 	addonCtx = null;
 	/**
+	* Short-lived cache of custom models pulled from the `custom-model-registry`
+	* collection cap, grouped by step id. TTL-bounded so the picker / resolution
+	* paths don't issue a cap round-trip on every call. Empty map = no provider
+	* (or a query failure) → behaviour identical to the static-catalog-only path.
+	*/
+	customModelsCache = null;
+	/**
 	* Per-device {@link DeviceProxy} cache used for zone gating at the
 	* runtime path. Reads `state.zones.value` + `state.zoneRules.value`
 	* synchronously per frame so detections inside an `exclude` zone
@@ -4249,17 +4364,11 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	*/
 	async autoPickAndPersist() {
 		let hardware = null;
-		let bestBackendHint = null;
 		try {
 			const api = this.addonCtx?.api;
-			if (api) {
-				const caps = await api.platformProbe.getCapabilities.query({ nodeId: this.localProbeNodeId() });
-				hardware = caps?.hardware ?? null;
-				const bs = caps?.bestScore;
-				if (bs && bs.runtime === "python") bestBackendHint = bs.backend;
-			}
+			if (api) hardware = (await api.platformProbe.getCapabilities.query({ nodeId: this.localProbeNodeId() }))?.hardware ?? null;
 		} catch {}
-		const pick = pickBestRuntime(runtimeEnvFromProcess(toProbedHardware(hardware)), bestBackendHint);
+		const pick = pickBestRuntime(runtimeEnvFromProcess(toProbedHardware(hardware)), null);
 		const engine = {
 			runtime: "python",
 			backend: pick.runtimeId,
@@ -4267,8 +4376,8 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 			device: pick.device
 		};
 		this.currentEngine = engine;
-		if (!(hardware !== null || bestBackendHint !== null)) {
-			this.log.warn("Auto-pick: probe returned no hardware/hint — using onnx floor WITHOUT persisting", { meta: {
+		if (!(pick.runtimeId !== "onnx" || hardware !== null)) {
+			this.log.info("Auto-pick: onnx floor pending gpu probe — NOT persisting (re-pick on done)", { meta: {
 				backend: pick.runtimeId,
 				device: pick.device
 			} });
@@ -4279,10 +4388,10 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 			[nodeEngineKey("engineBackend", apNode)]: pick.runtimeId,
 			[nodeEngineKey("engineDevice", apNode)]: pick.device
 		});
-		this.log.info("Auto-picked engine at first boot", { meta: {
+		this.log.info("Auto-picked engine (platform-deterministic)", { meta: {
 			backend: pick.runtimeId,
 			device: pick.device,
-			hint: bestBackendHint ?? "none"
+			hadProbeHardware: hardware !== null
 		} });
 	}
 	/** Map a backend string to a known RuntimeId, flooring to onnx. */
@@ -4342,7 +4451,9 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 		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;
+		const sameSelection = snapshot.runtimeId === runtimeId && snapshot.device === device;
+		if (sameSelection && snapshot.state !== "idle") return;
+		if (!sameSelection) this.currentSteps = null;
 		this.provisioner.select(runtimeId, device);
 	}
 	/**
@@ -4353,8 +4464,20 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	* runtime through installing → verifying → ready.
 	*/
 	async onEngineSelectionChanged() {
+		const prev = this.currentEngine;
 		const stored = await this.loadEngine();
 		if (stored) this.currentEngine = stored;
+		if ((prev.runtime !== this.currentEngine.runtime || prev.backend !== this.currentEngine.backend || prev.format !== this.currentEngine.format || (prev.device ?? "") !== (this.currentEngine.device ?? "")) && this.engineFactory) {
+			this.log.info("engine selection changed — rebuilding pool in place", { meta: {
+				from: `${prev.backend}/${prev.device ?? "default"}`,
+				to: `${this.currentEngine.backend}/${this.currentEngine.device ?? "default"}`
+			} });
+			try {
+				await this.engineFactory.dispose();
+			} catch {}
+			this.engineFactory = null;
+			this.executor = null;
+		}
 		this.startProvisioningForCurrentEngine();
 	}
 	/**
@@ -4392,7 +4515,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 		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);
+			const modelEntry = await this.resolveModelEntry(step.addonId, step.modelId);
 			if (!modelEntry) continue;
 			if (isModelDownloaded(this.modelsDir, modelEntry, format)) continue;
 			await this.downloadWithRetry(modelEntry, format, 3);
@@ -4470,10 +4593,44 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 			return { hardware: null };
 		}
 	}
+	/**
+	* Pull custom models from the `custom-model-registry` collection cap,
+	* grouped by step id. 5s TTL cache. Fully graceful: when no provider is
+	* registered (or the query fails) it returns an empty map and logs at most
+	* a warning — callers then behave exactly like the static-catalog path.
+	*/
+	async getCustomModels() {
+		const now = Date.now();
+		if (this.customModelsCache && now - this.customModelsCache.at < 5e3) return this.customModelsCache.byStep;
+		let byStep = /* @__PURE__ */ new Map();
+		try {
+			const api = this.addonCtx?.api;
+			if (api) {
+				if ((await api.addons.listCapabilityProviders.query({ capName: "custom-model-registry" })).some((p) => p.isActive)) byStep = groupCustomModelsByStep(await api.customModelRegistry.listModels.query());
+			}
+		} catch (err) {
+			this.log.warn("custom-model-registry query failed — using static catalog only", { meta: { error: errMsg(err) } });
+		}
+		this.customModelsCache = {
+			at: now,
+			byStep
+		};
+		return byStep;
+	}
+	/**
+	* Resolve a model id within a step to a catalog entry — static catalog
+	* first, then the custom registry. Returns undefined if neither has it.
+	*/
+	async resolveModelEntry(addonId, modelId) {
+		const fromCatalog = getStepDefinition(addonId).models.find((m) => m.id === modelId);
+		if (fromCatalog) return fromCatalog;
+		return (await this.getCustomModels()).get(addonId)?.find((m) => m.id === modelId);
+	}
 	async getSchema(engine) {
 		if (!engine || !engine.runtime) engine = await this.getSelectedEngine();
 		const format = engine.format;
-		const slots = buildSchemaSlots(format, this.modelsDir);
+		const customByStep = await this.getCustomModels();
+		const slots = buildSchemaSlots(format, this.modelsDir, customByStep);
 		const { hardware } = await this.fetchProbeGatingData();
 		const env = runtimeEnvFromProcess(toProbedHardware(hardware));
 		return {
@@ -4532,13 +4689,52 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	async getDefaultSteps(engine) {
 		return buildDefaultStepTree(engine.format);
 	}
+	/**
+	* Substitute, AT RUNTIME ONLY (never persisted), any step whose configured
+	* model lacks a build for that step's active engine format. A GLOBAL pipeline
+	* config can pin a model that's valid on the cluster's Intel nodes (e.g. the
+	* OpenVINO-only `yolov9t-int8`) but impossible on a CoreML/ONNX node — without
+	* this the node crash-loops `Model "X" has no <format> format`. The operator's
+	* choice stays in the persisted config; this node just runs the smallest
+	* catalog model that DOES have its format. Mirrors the per-node engine
+	* fallback in `loadEngine`. Catalog models only — a custom model that lacks
+	* the format is left as-is (operator's responsibility).
+	*/
+	substituteIncompatibleModels(steps) {
+		const fix = (step) => {
+			const format = step.engine?.format ?? this.currentEngine.format;
+			let modelId = step.modelId;
+			try {
+				const entry = getStepDefinition(step.addonId).models.find((m) => m.id === step.modelId);
+				if (entry && !entry.formats[format]) {
+					const fallback = getDefaultModelForFormat(step.addonId, format);
+					if (fallback !== step.modelId) {
+						this.log.info("Step model lacks engine format — substituting format default (runtime)", { meta: {
+							step: step.addonId,
+							configured: step.modelId,
+							substitute: fallback,
+							format
+						} });
+						modelId = fallback;
+					}
+				}
+			} catch {}
+			const children = step.children?.length ? step.children.map(fix) : step.children;
+			return modelId === step.modelId && children === step.children ? step : {
+				...step,
+				modelId,
+				...children ? { children } : {}
+			};
+		};
+		return steps.map(fix);
+	}
 	async getGlobalSteps() {
 		if (this.currentSteps) return this.currentSteps;
 		const raw = (await this.readStore())[KEY_STEPS];
 		if (!raw) {
 			const defaults = buildDefaultStepTree(this.currentEngine.format);
 			if (defaults.length === 0) return null;
-			this.currentSteps = defaults;
+			this.currentSteps = this.substituteIncompatibleModels(defaults);
 			this.writeStore({ [KEY_STEPS]: JSON.stringify(defaults) });
 			this.log.info("Bootstrapped default pipeline — object-detection + face + plate recognition enabled by default", { meta: { rootSteps: defaults.length } });
 			return this.currentSteps;
@@ -4576,7 +4772,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 					this.log.info("Migration: added audio-classifier step to persisted pipeline config");
 				}
 			}
-			this.currentSteps = steps;
+			this.currentSteps = this.substituteIncompatibleModels(steps);
 			return this.currentSteps;
 		} catch {
 			throw new Error(`Failed to parse persisted pipeline steps: corrupt data in key "${KEY_STEPS}"`);
@@ -4660,7 +4856,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	}
 	async downloadModel(input) {
 		const { modelId, format, addonId } = input;
-		const modelEntry = getStepDefinition(addonId).models.find((m) => m.id === modelId);
+		const modelEntry = await this.resolveModelEntry(addonId, modelId);
 		if (!modelEntry) throw new Error(`Model "${modelId}" not found in step "${addonId}" catalog`);
 		const formatEntry = modelEntry.formats[format];
 		if (!formatEntry) throw new Error(`Model "${modelId}" has no ${format} format. Available: ${Object.keys(modelEntry.formats).join(", ")}`);
@@ -4723,7 +4919,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	}
 	async deleteModel(input) {
 		const { modelId, format, addonId } = input;
-		const modelEntry = getStepDefinition(addonId).models.find((m) => m.id === modelId);
+		const modelEntry = await this.resolveModelEntry(addonId, modelId);
 		if (!modelEntry) throw new Error(`Model "${modelId}" not found in step "${addonId}" catalog`);
 		if (!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: {
@@ -5179,7 +5375,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 		const work = (async () => {
 			const format = this.currentEngine?.format ?? "onnx";
 			for (const step of needed) {
-				const modelEntry = getStepDefinition(step.addonId).models.find((m) => m.id === step.modelId);
+				const modelEntry = await this.resolveModelEntry(step.addonId, step.modelId);
 				if (modelEntry && !isModelDownloaded(this.modelsDir, modelEntry, format)) {
 					this.log.info("Downloading model for step", { meta: {
 						modelId: step.modelId,
@@ -5674,7 +5870,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 		const format = this.currentEngine.format;
 		const downloads = [];
 		for (const step of flattenSteps(steps)) {
-			const modelEntry = getStepDefinition(step.addonId).models.find((m) => m.id === step.modelId);
+			const modelEntry = await this.resolveModelEntry(step.addonId, step.modelId);
 			if (!modelEntry) {
 				this.log.warn("Model not found in step catalog — skipping download", { meta: {
 					modelId: step.modelId,
@@ -5727,12 +5923,13 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 			const storedDevice = typeof storedDeviceRaw === "string" ? storedDeviceRaw : "";
 			const floor = onnxFloorPick();
 			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 onnx floor", { meta: {
+			if (!backendPossibleOnPlatform(migratedBackend)) {
+				const platformDefault = platformDefaultPick();
+				this.log.warn("Stored engine backend impossible on this platform — using platform default", { meta: {
 					stored: migratedBackend,
-					fallback: `${floor.backend}`
+					fallback: platformDefault.backend
 				} });
-				return floor;
+				return platformDefault;
 			}
 			const device = storedDevice || floor.device;
 			return {
@@ -5904,44 +6101,61 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	}
 	async reprobeEngine() {
 		const api = this.addonCtx?.api;
-		let best;
+		let hardware = null;
 		if (api) try {
-			const caps = await api.platformProbe.getCapabilities.query({ nodeId: this.localProbeNodeId() });
-			const bs = caps?.bestScore;
-			if (bs && bs.runtime === "python") {
-				const probeBackend = bs.backend;
-				const probeDevice = (() => {
-					const hw = caps.hardware;
-					if (probeBackend === "openvino") return defaultDeviceFor("openvino");
-					if (probeBackend === "coreml") return defaultDeviceFor("coreml");
-					if (probeBackend === "onnx") return hw?.gpu?.type === "nvidia" ? "cuda" : "cpu";
-					return "cpu";
-				})();
-				best = {
-					runtime: "python",
-					backend: probeBackend,
-					format: backendToFormat(probeBackend),
-					device: probeDevice
-				};
-			} else best = onnxFloorPick();
-		} catch {
-			best = onnxFloorPick();
-		}
-		else best = onnxFloorPick();
+			hardware = (await api.platformProbe.getCapabilities.query({ nodeId: this.localProbeNodeId() }))?.hardware ?? null;
+		} catch {}
+		const pick = pickBestRuntime(runtimeEnvFromProcess(toProbedHardware(hardware)), null);
+		const best = {
+			runtime: "python",
+			backend: pick.runtimeId,
+			format: modelFormatFor(pick.runtimeId),
+			device: pick.device
+		};
 		const probedLabel = `${best.backend}/${best.device ?? "default"}`;
 		const rpNode = this.localProbeNodeId();
-		await this.writeStore({
-			[nodeEngineKey("probedBestEngine", rpNode)]: probedLabel,
-			[nodeEngineKey("engineBackend", rpNode)]: best.backend,
-			[nodeEngineKey("engineDevice", rpNode)]: best.device ?? "cpu"
-		});
-		this.log.info("Re-probed engine — wrote back engineBackend + engineDevice", { meta: {
+		if (pick.runtimeId !== "onnx" || hardware !== null) {
+			await this.writeStore({
+				[nodeEngineKey("probedBestEngine", rpNode)]: probedLabel,
+				[nodeEngineKey("engineBackend", rpNode)]: best.backend,
+				[nodeEngineKey("engineDevice", rpNode)]: best.device ?? "cpu"
+			});
+			this.log.info("Re-probed engine (platform-deterministic) — wrote back", { meta: {
+				backend: best.backend,
+				device: best.device ?? null,
+				probedBestEngine: probedLabel
+			} });
+		} else this.log.info("Re-probe: onnx floor pending gpu probe — NOT persisting (re-pick on done)", { meta: {
 			backend: best.backend,
-			device: best.device ?? null,
-			probedBestEngine: probedLabel
+			device: best.device ?? null
 		} });
 		return best;
 	}
+	/**
+	* Re-pick the engine when the platform-probe finishes its async hardware +
+	* Python detection (the `platform-probe.phase` `done` event). At boot the
+	* probe's accelerator result may not be ready yet, so the engine floored to
+	* onnx; once the probe answers (e.g. a Mac's CoreML/ANE surfaces after the
+	* embedded Python is installed) this re-runs the probe-driven pick and
+	* re-provisions. Idempotent: `startProvisioningForCurrentEngine` skips a
+	* no-op when the selection is unchanged.
+	*/
+	async repickEngineOnProbeReady() {
+		const before = `${this.currentEngine.backend}/${this.currentEngine.device ?? "default"}`;
+		await this.reprobeEngine();
+		const stored = await this.loadEngine();
+		if (stored) {
+			this.currentEngine = stored;
+			this.needsAutoPick = false;
+			this.cancelDeferredAutoPick();
+		}
+		const after = `${this.currentEngine.backend}/${this.currentEngine.device ?? "default"}`;
+		if (before !== after) this.log.info("Engine re-picked after platform-probe completed", { meta: {
+			before,
+			after
+		} });
+		this.startProvisioningForCurrentEngine();
+	}
 	async getReferenceAudioFiles() {
 		const dir = resolveReferenceAudioDir();
 		if (!dir) return [];
@@ -6077,11 +6291,11 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 		}
 	}
 };
-function buildSchemaSlots(format, modelsDir) {
+function buildSchemaSlots(format, modelsDir, customByStep) {
 	const slotMap = /* @__PURE__ */ new Map();
 	for (const pipelineStep of ALL_PIPELINE_STEPS) {
 		const step = pipelineStep.definition;
-		const availableModels = step.models.filter((m) => m.formats[format]);
+		const availableModels = mergeCustomModels(step.models, customByStep?.get(step.id) ?? []).filter((m) => m.formats[format]);
 		if (availableModels.length === 0) continue;
 		const slot = step.slot;
 		if (!slotMap.has(slot)) slotMap.set(slot, []);
@@ -6186,8 +6400,7 @@ function buildDefaultStepTree(format) {
 		makeStep("animal-classifier", [], { enabled: false }),
 		makeStep("bird-classifier", [], { enabled: false }),
 		makeStep("vehicle-classifier", [], { enabled: false }),
-		makeStep("segmentation-refiner", [], { enabled: false }),
-		makeStep("instance-segmentation", [], { enabled: false })
+		makeStep("segmentation", [], { enabled: false })
 	].filter((s) => s !== null));
 	const audioEngine = getDefaultModelForFormat("audio-classifier", format) === "apple-soundanalysis" ? {
 		runtime: "python",
@@ -6410,6 +6623,7 @@ var DetectionPipelineAddon = class extends BaseAddon {
 	nodeEngineBackend = DEFAULT_CONFIG.engineBackend;
 	nodeProbedBestEngine = "";
 	engineMetricsTimer = null;
+	probePhaseUnsub = null;
 	/** Snapshot-equality cache for engine-metrics emit. Most ticks
 	*  the engine inventory is unchanged (no model load/unload), so
 	*  we skip the bus emit and let the heartbeat re-emit at
@@ -6477,8 +6691,7 @@ var DetectionPipelineAddon = class extends BaseAddon {
 					label: "Execution provider",
 					options: [...STATIC_BACKEND_OPTIONS],
 					default: DEFAULT_CONFIG.engineBackend,
-					immediate: true,
-					requiresRestart: true
+					immediate: true
 				}),
 				this.field({
 					type: "select",
@@ -6486,8 +6699,7 @@ var DetectionPipelineAddon = class extends BaseAddon {
 					label: "Hardware device",
 					options: [...STATIC_DEFAULT_DEVICE_OPTIONS],
 					default: DEFAULT_CONFIG.engineDevice,
-					immediate: true,
-					requiresRestart: true
+					immediate: true
 				})
 			]
 		}, {
@@ -6526,8 +6738,7 @@ var DetectionPipelineAddon = class extends BaseAddon {
 							"onnx",
 							"cpu"
 						]
-					},
-					requiresRestart: true
+					}
 				}),
 				this.field({
 					type: "slider",
@@ -6544,8 +6755,7 @@ var DetectionPipelineAddon = class extends BaseAddon {
 					showWhen: {
 						field: "batchMode",
 						notEquals: "none"
-					},
-					requiresRestart: true
+					}
 				}),
 				this.field({
 					type: "slider",
@@ -6562,8 +6772,7 @@ var DetectionPipelineAddon = class extends BaseAddon {
 					showWhen: {
 						field: "batchMode",
 						notEquals: "none"
-					},
-					requiresRestart: true
+					}
 				}),
 				this.field({
 					type: "slider",
@@ -6576,8 +6785,7 @@ var DetectionPipelineAddon = class extends BaseAddon {
 					default: void 0,
 					showValue: true,
 					nullable: true,
-					nullLabel: "Auto",
-					requiresRestart: true
+					nullLabel: "Auto"
 				}),
 				this.field({
 					type: "slider",
@@ -6590,8 +6798,7 @@ var DetectionPipelineAddon = class extends BaseAddon {
 					default: void 0,
 					showValue: true,
 					nullable: true,
-					nullLabel: "Auto",
-					requiresRestart: true
+					nullLabel: "Auto"
 				})
 			]
 		}] });
@@ -6823,11 +7030,35 @@ var DetectionPipelineAddon = class extends BaseAddon {
 			numWorkers: num(t["numWorkers"], 1)
 		};
 	}
-	async onInitialize() {
-		const modelsDir = await this.ctx.api.storage.resolve.query({
+	/**
+	* Resolve the directory models are downloaded into, resilient across nodes.
+	* The `models` storage location is GLOBAL (hub-seeded) and can resolve to a
+	* path that exists only on the hub — e.g. Docker's `/data/models`, which an
+	* agent on a different filesystem (a Mac) cannot create (`ENOENT mkdir
+	* /data/models`). Verify the resolved dir is creatable; otherwise fall back to
+	* this node's LOCAL addon data-dir so models always land on writable disk.
+	*/
+	async resolveModelsDir() {
+		const fallback = path$1.join(this.ctx.dataDir, "models");
+		const candidate = await this.ctx.api.storage.resolve.query({
 			location: "models",
 			relativePath: ""
-		}).catch(() => "camstack-data/models");
+		}).catch(() => null) ?? fallback;
+		try {
+			await fs.promises.mkdir(candidate, { recursive: true });
+			return candidate;
+		} catch (err) {
+			this.ctx.logger.warn("models dir not creatable on this node — using local data-dir", { meta: {
+				resolved: candidate,
+				fallback,
+				error: err instanceof Error ? err.message : String(err)
+			} });
+			await fs.promises.mkdir(fallback, { recursive: true });
+			return fallback;
+		}
+	}
+	async onInitialize() {
+		const modelsDir = await this.resolveModelsDir();
 		if (!this.ctx.settings) throw new Error("DetectionPipelineAddon: ctx.settings not available");
 		await this.refreshNodeEngineFromStore();
 		this.pythonAddonDir = resolveAddonPythonDir();
@@ -6857,6 +7088,12 @@ var DetectionPipelineAddon = class extends BaseAddon {
 		await this.provider.ensureBootEngineProvisioned().catch((err) => {
 			this.ctx.logger.warn("ensureBootEngineProvisioned failed", { meta: { error: err instanceof Error ? err.message : String(err) } });
 		});
+		this.probePhaseUnsub = this.ctx.eventBus?.subscribe({ category: EventCategory.PlatformProbePhase }, (event) => {
+			if (event.data?.phase !== "done") return;
+			this.provider.repickEngineOnProbeReady().catch((err) => {
+				this.ctx.logger.warn("repick on platform-probe done failed", { meta: { error: err instanceof Error ? err.message : String(err) } });
+			});
+		}) ?? null;
 		await this.provider.warmPool();
 		this.engineMetricsTimer = setInterval(() => this.emitEngineMetricsSnapshot(), ENGINE_METRICS_SNAPSHOT_INTERVAL_MS);
 		this.lastAppliedPoolConfig = this.snapshotPoolConfig();
@@ -6930,6 +7167,10 @@ var DetectionPipelineAddon = class extends BaseAddon {
 		}
 	}
 	async onShutdown() {
+		if (this.probePhaseUnsub) {
+			this.probePhaseUnsub();
+			this.probePhaseUnsub = null;
+		}
 		if (this.engineMetricsTimer) {
 			clearInterval(this.engineMetricsTimer);
 			this.engineMetricsTimer = null;
@@ -6964,16 +7205,17 @@ var DetectionPipelineAddon = class extends BaseAddon {
 		return false;
 	}
 	/**
-	* BaseAddon calls `onConfigChanged` after every settings write.
-	* Group-runner addons can't honour the schema's `requiresRestart:
-	* true` flag (the restart cap returns "process not found" for
-	* processes spawned in a kernel group worker). To make tuning
-	* changes actually take effect, watch the pool-bound subset and
-	* respawn the provider in place when it flips.
-	*
-	* Engine cascade (`engineRuntime/Backend/Device`) and audio
-	* settings don't require this — those still rely on the addon
-	* lifecycle (engineFactory rebuild on next runPipeline).
+	* BaseAddon calls `onConfigChanged` after every settings write. This is the
+	* SOLE apply path for engine + tuning changes — none of those fields declare
+	* `requiresRestart` anymore (an addon restart re-probes hardware + reloads
+	* every model on every set, which is exactly what we want to avoid). Instead:
+	*  - Pool-bound tuning (`concurrency`/`batchMode`/`windowMs`/…) → in-place
+	*    pool respawn when the snapshot flips (`poolConfigChanged` below).
+	*  - Engine cascade (`engineBackend`/`engineDevice`) → the provider's
+	*    `onEngineSelectionChanged` disposes the device-bound factory so the next
+	*    runPipeline rebuilds the pool on the new selection, in place.
+	* Both apply optimistically — the inference gate stays closed for the short
+	* re-spin, frames are dropped (never crashed), no addon bounce.
 	*/
 	async onConfigChanged() {
 		await this.refreshNodeEngineFromStore();
@@ -6994,10 +7236,7 @@ var DetectionPipelineAddon = class extends BaseAddon {
 		} catch (err) {
 			this.ctx.logger.warn("provider shutdown failed during tuning respawn", { meta: { error: err instanceof Error ? err.message : String(err) } });
 		}
-		const modelsDir = await this.ctx.api.storage.resolve.query({
-			location: "models",
-			relativePath: ""
-		}).catch(() => "camstack-data/models");
+		const modelsDir = await this.resolveModelsDir();
 		if (!this.ctx.settings) throw new Error("DetectionPipelineAddon: ctx.settings not available during respawn");
 		const effectiveTuning = this.resolveBackendTuning();
 		this.provider = new DetectionPipelineProvider(this.ctx.settings, modelsDir, this.ctx.logger, this.ctx.eventBus ?? null, () => ({ sections: [] }), {