@camstack/addon-pipeline 1.2.333 → 1.2.335

package/dist/detection-pipeline/index.js

@@ -3,11 +3,11 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 const require_chunk = require("../chunk-emK7D4bc.js");
-const require_dist = require("../dist-DJV7Z6Bb.js");
-const require_node = require("../node-CkmucLYG.js");
-const require_default_detection_model = require("../default-detection-model-Biwf5-ML.js");
+const require_dist = require("../dist-C5DlS_lW.js");
+const require_node = require("../node-BUafKArW.js");
+const require_custom_model_catalog = require("../custom-model-catalog-CL-xJa8w.js");
 const require_lazy_sharp = require("../lazy-sharp-BuwKlQLR.js");
-const require_process_memory = require("../process-memory-BJb7Ihdp.js");
+const require_process_memory = require("../process-memory-DWOQCbg5.js");
 let node_os = require("node:os");
 node_os = require_chunk.__toESM(node_os);
 let node_fs = require("node:fs");
@@ -2250,6 +2250,7 @@ function describeCommand(cmd) {
 		model: typeof modelPath === "string" && modelPath.length > 0 ? node_path.basename(modelPath, node_path.extname(modelPath)) : null
 	};
 }
+/** The wire form of a model config — the keys the Python pool reads. Exported for tests. */
 function serializeModelConfig(config) {
 	const result = {
 		path: config.path,
@@ -2261,6 +2262,7 @@ function serializeModelConfig(config) {
 	if (config.nmsIouThreshold !== void 0) result["nmsIouThreshold"] = config.nmsIouThreshold;
 	if (config.inputNormalization !== void 0) result["inputNormalization"] = config.inputNormalization;
 	if (config.outputProbabilities !== void 0) result["outputProbabilities"] = config.outputProbabilities;
+	if (config.gpuInferencePrecision !== void 0) result["gpuInferencePrecision"] = config.gpuInferencePrecision;
 	if (config.inputWidth !== void 0) result["inputWidth"] = config.inputWidth;
 	if (config.inputHeight !== void 0) result["inputHeight"] = config.inputHeight;
 	if (config.inputChannels !== void 0) result["inputChannels"] = config.inputChannels;
@@ -2451,25 +2453,43 @@ function collectClassMapDropWarning(def, entry) {
 function toApplicability(acc) {
 	const hasInapplicable = Object.keys(acc.inapplicable).length > 0;
 	const hasOptions = Object.keys(acc.optionsByModel).length > 0;
-	if (!hasInapplicable && !hasOptions) return void 0;
+	const hasDefaults = Object.keys(acc.defaultByModel).length > 0;
+	if (!hasInapplicable && !hasOptions && !hasDefaults) return void 0;
 	return {
 		...hasInapplicable ? { inapplicable: acc.inapplicable } : {},
-		...hasOptions ? { optionsByModel: acc.optionsByModel } : {}
+		...hasOptions ? { optionsByModel: acc.optionsByModel } : {},
+		...hasDefaults ? { defaultByModel: acc.defaultByModel } : {}
 	};
 }
+/** The `default` of `key` in a schema, groups flattened; `undefined` when absent. */
+function defaultOfKey(fields, key) {
+	for (const field of fields) {
+		if (field.type === "group") {
+			const nested = defaultOfKey(field.fields, key);
+			if (nested !== void 0) return nested;
+			continue;
+		}
+		if ("key" in field && field.key === key && "default" in field) return field.default;
+	}
+}
 function isAnnotatable(field) {
 	return field.type === "slider" || field.type === "number" || field.type === "multiselect" || field.type === "select" || field.type === "boolean";
 }
 function annotateField(field, inputs) {
 	if (!isAnnotatable(field)) return field;
-	const { def, models, customModelIds } = inputs;
+	const { def, models, customModelIds, schemaForModel } = inputs;
 	const acc = {
 		inapplicable: {},
-		optionsByModel: {}
+		optionsByModel: {},
+		defaultByModel: {}
 	};
 	const macroKey = macroOfMinConfidenceKey(field.key);
 	for (const entry of models) {
 		const postprocessor = resolveEffectivePostprocessorForEntry(def, entry);
+		if (field.bindsToModel === true && schemaForModel !== void 0) {
+			const modelDefault = defaultOfKey(schemaForModel(entry), field.key);
+			if (modelDefault !== void 0 && modelDefault !== field.default) acc.defaultByModel[entry.id] = modelDefault;
+		}
 		if (field.key === "nmsIouThreshold" && !postprocessorConsumesNms(postprocessor)) {
 			acc.inapplicable[entry.id] = `NMS is fused inside this model's "${postprocessor}" export — the pipeline IoU threshold is not consulted.`;
 			continue;
@@ -2518,6 +2538,55 @@ function annotateField(field, inputs) {
 function annotateConfigSchemaForModels(inputs) {
 	return inputs.configSchema.map((field) => annotateField(field, inputs));
 }
+/** The slider that governs a root-supplied fine label (D741) — the step's own threshold. */
+var SUPPLIED_LABEL_FLOOR_KEY = "minConfidence";
+/**
+* D741 — when a ROOT detector supplies a step's fine label (species, vehicle
+* type), the step's `minConfidence` slider is the floor on the root's
+* DETECTION score for that label, bound to the root model. So for each root
+* model that supplies `stepId`'s labels, the slider's default under that model
+* is the root's `suppliedLabelFloors[stepId]`, or 0 (no floor beyond the macro
+* floor). Added to `modelApplicability.defaultByModel`, keyed by root model id,
+* so the editor — which shows the slider under the ROOT's id while the root
+* supplies the step — shows the floor the runner applies. A step no root
+* supplies a fine label for is returned untouched.
+*/
+function withRootSuppliedLabelDefaults(stepId, configSchema, rootModels) {
+	if (!isFineLabelSupplyStep(stepId)) return [...configSchema];
+	const rootDef = require_custom_model_catalog.getStepDefinition(ROOT_STEP_ID);
+	const defaults = {};
+	for (const root of rootModels) {
+		if (!require_dist.rootSuppliesOf(root, {
+			labels: rootDef.labels ?? [],
+			...rootDef.classMap !== void 0 ? { classMap: rootDef.classMap } : {}
+		}).some((s) => s.kind === "label" && s.stepId === stepId)) continue;
+		defaults[root.id] = root.suppliedLabelFloors?.[stepId] ?? 0;
+	}
+	if (Object.keys(defaults).length === 0) return [...configSchema];
+	return configSchema.map((field) => {
+		if (field.type !== "slider" || field.key !== SUPPLIED_LABEL_FLOOR_KEY) return field;
+		return {
+			...field,
+			modelApplicability: {
+				...field.modelApplicability,
+				defaultByModel: {
+					...field.modelApplicability?.defaultByModel,
+					...defaults
+				}
+			}
+		};
+	});
+}
+/** The camera root the supplies are read from. */
+var ROOT_STEP_ID = "object-detection";
+/**
+* A label-supply step whose effect is FINER than its macro (species, vehicle
+* type). `package-detection` is a label supply too, but its effect IS its
+* macro: it has no fine label and its threshold is `minConfidencePackage`.
+*/
+function isFineLabelSupplyStep(stepId) {
+	return Object.keys(require_dist.LABEL_SUPPLY_MACRO).includes(stepId) && stepId !== "package-detection";
+}
 /**
 * A persisted settings blob is external data — it survives schema changes,
 * hand edits and migrations. Accept only a finite IoU in the open (0,1)
@@ -3001,38 +3070,6 @@ var PipelineModelManager = class {
 	}
 };
 //#endregion
-//#region src/detection-pipeline/engine/resolve-device-engine.ts
-/**
-* Resolve a Phase-1 device key (`<backend>:<device>`, or bare `cpu`) into the
-* {@link PipelineEngineChoice} used to build that device's inference pool.
-* Throws on an unknown backend token so a bad `deviceKey` fails loud rather
-* than silently building a wrong pool. Format comes from the shared
-* {@link DEVICE_BACKEND_TO_FORMAT} SSOT (`@camstack/types`) — no local copy.
-*/
-function resolveDeviceEngine(deviceKey) {
-	const colon = deviceKey.indexOf(":");
-	const backend = colon >= 0 ? deviceKey.slice(0, colon) : deviceKey;
-	const device = colon >= 0 ? deviceKey.slice(colon + 1) : deviceKey;
-	const format = require_dist.DEVICE_BACKEND_TO_FORMAT[backend];
-	if (format === void 0) throw new Error(`resolveDeviceEngine: unknown backend "${backend}" in deviceKey "${deviceKey}"`);
-	return {
-		runtime: "python",
-		backend,
-		format,
-		device
-	};
-}
-/**
-* The inverse of {@link resolveDeviceEngine}: the `<backend>:<device>` key that
-* names the pool an engine belongs to. Every pool-level log line carries this —
-* without it a default pool logs anonymously and six hours of logs cannot tell
-* "the NPU is unused" from "the NPU IS the anonymous default pool".
-* Falls back to the bare backend when the engine carries no device.
-*/
-function deviceKeyOf(engine) {
-	return engine.device ? `${engine.backend}:${engine.device}` : engine.backend;
-}
-//#endregion
 //#region src/detection-pipeline/engine/coral-cocompiled-set.ts
 var ROOT_DETECTOR_STEP_ID = "object-detection";
 /** The models a dispatch places on the pool that runs it: every enabled video step. */
@@ -3380,7 +3417,7 @@ var EngineFactory = class {
 	constructor(opts) {
 		this.opts = opts;
 		this.log = opts.logger;
-		this.deviceKey = deviceKeyOf(opts.engine);
+		this.deviceKey = require_custom_model_catalog.deviceKeyOf(opts.engine);
 		this.resolvedProvisioning = resolvePoolProvisioning(opts.engine, opts.provisioning);
 		this.coralSets = BACKEND_TO_POOL_RUNTIME[opts.engine.backend] === "edgetpu" ? new CoralSetPlanner(opts.coCompiledSets ?? EDGETPU_COCOMPILED_SETS) : null;
 	}
@@ -3651,7 +3688,7 @@ var EngineFactory = class {
 	* to `buildConfig`, which throws the message naming the step and the model.
 	*/
 	resolveDecode(stepId, modelId, settings) {
-		const def = require_default_detection_model.getStepDefinition(stepId);
+		const def = require_custom_model_catalog.getStepDefinition(stepId);
 		const modelEntry = def.models.find((m) => m.id === modelId) ?? this.opts.resolveCustomModel?.(stepId, modelId);
 		if (!modelEntry) return null;
 		return resolvePoolDecodeSettings({
@@ -3696,7 +3733,7 @@ var EngineFactory = class {
 */
 function buildPoolModelConfigForStep(inputs) {
 	const { stepId, modelId, poolRuntime, modelsDir } = inputs;
-	const def = require_default_detection_model.getStepDefinition(stepId);
+	const def = require_custom_model_catalog.getStepDefinition(stepId);
 	const resolvedEntry = def.models.find((m) => m.id === modelId) ?? inputs.resolveCustomModel?.(stepId, modelId);
 	if (!resolvedEntry) throw new Error(`Model "${modelId}" not found in step "${stepId}" catalog (static or custom registry)`);
 	const modelEntry = inputs.entryForPool?.(stepId, resolvedEntry) ?? resolvedEntry;
@@ -3727,8 +3764,9 @@ function buildPoolModelConfigForStep(inputs) {
 		preprocessMode: modelEntry.preprocessMode ?? "letterbox",
 		inputNormalization: modelEntry.inputNormalization,
 		outputProbabilities: modelEntry.outputProbabilities,
+		...modelEntry.gpuInferencePrecision !== void 0 ? { gpuInferencePrecision: modelEntry.gpuInferencePrecision } : {},
 		postprocessor: resolveEffectivePostprocessorForEntry(def, modelEntry),
-		confidence: resolvePoolConfidenceFloor(stepId, require_default_detection_model.resolveModelDefaultConfidence(def, modelEntry)),
+		confidence: resolvePoolConfidenceFloor(stepId, require_custom_model_catalog.resolveModelDefaultConfidence(def, modelEntry)),
 		nmsIouThreshold: resolvePoolDecodeSettings({
 			def,
 			modelEntry,
@@ -6586,7 +6624,7 @@ function linkedLabelsFor(supplies, rawClass, macroClass, modelId) {
 		if (require_dist.LABEL_SUPPLY_MACRO[supply.stepId] !== macroClass) continue;
 		const effect = supply.labelToEffect[rawClass];
 		if (effect === void 0 || effect === macroClass) continue;
-		const tier = require_default_detection_model.getStepDefinition(supply.stepId).labelTier;
+		const tier = require_custom_model_catalog.getStepDefinition(supply.stepId).labelTier;
 		out.push({
 			label: effect,
 			score: 0,
@@ -7182,7 +7220,15 @@ var PipelineExecutor = class {
 			if (plane === "frame" && child.definition.inputClasses !== null) continue;
 			if (!this.matchesInputClasses(parentDetection.macroClass, child.inputClasses)) continue;
 			const minParentScore = child.settings?.minParentScore ?? child.definition?.defaultMinParentScore;
-			if (typeof minParentScore === "number" && parentDetection.score < minParentScore) continue;
+			if (typeof minParentScore === "number" && parentDetection.score < minParentScore) {
+				if (child.definition.models.find((m) => m.id === child.modelId)?.faceAlignment === true) this.throttledWarn(`face-embed-score-floor:${child.stepId}:${deviceId}`, 3e4, "face detected but below the embedding score floor — no embedding", {
+					step: child.stepId,
+					model: child.modelId,
+					faceScore: parentDetection.score,
+					minParentScore
+				}, deviceId);
+				continue;
+			}
 			if (isBboxDegenerate(parentDetection.bbox)) continue;
 			try {
 				const childStart = Date.now();
@@ -7198,7 +7244,7 @@ var PipelineExecutor = class {
 						this.warnFaceTooSmall(child, detShortSide, minFaceSize, void 0, deviceId);
 						continue;
 					}
-					const precision = require_default_detection_model.landmarkPrecisionVerdict({
+					const precision = require_custom_model_catalog.landmarkPrecisionVerdict({
 						detectionShortSidePx: detShortSide,
 						floorPx: numericSetting(child.settings, "minLandmarkFaceSize", 24)
 					});
@@ -7391,7 +7437,7 @@ var PipelineExecutor = class {
 	*   - `minConfidence<Macro>`: number (e.g. `minConfidencePerson: 0.5`)
 	*/
 	macroFilterVerdict(macroClass, score, settings) {
-		return require_default_detection_model.macroGateVerdict(macroClass, score, settings);
+		return require_custom_model_catalog.macroGateVerdict(macroClass, score, settings);
 	}
 };
 //#endregion
@@ -7469,13 +7515,16 @@ function buildChild(child, parentStepId, getEngine, resolveModel, onMissingVaria
 	return buildNode(child, getEngine, resolveModel, onMissingVariant, variant);
 }
 function buildNode(step, getEngine, resolveModel, onMissingVariant, resolved) {
-	const definition = require_default_detection_model.getStepDefinition(step.addonId);
+	const definition = require_custom_model_catalog.getStepDefinition(step.addonId);
 	const variant = resolved ?? getEngine(step.addonId, step.modelId);
 	const children = (step.children ?? []).filter((c) => c.enabled).map((c) => buildChild(c, step.addonId, getEngine, resolveModel, onMissingVariant)).filter((c) => c !== null);
 	const modelEntry = resolveModelEntry(definition, variant.modelId, resolveModel);
+	const schema = require_custom_model_catalog.getStep(step.addonId).getConfigSchema(modelEntry);
+	const schemaDefaults = collectSchemaDefaults(schema);
+	const operatorSettings = require_dist.applyModelBoundSettings(step.settings, collectModelBoundKeys(schema), variant.modelId);
 	const mergedSettings = {
-		...collectSchemaDefaults(step.addonId, modelEntry),
-		...step.settings
+		...schemaDefaults,
+		...operatorSettings
 	};
 	const effectiveClassMap = modelEntry?.classMap ?? definition.classMap;
 	return {
@@ -7501,17 +7550,33 @@ function rootSuppliesField(definition, modelEntry) {
 	return supplies.length > 0 ? { rootSupplies: supplies } : {};
 }
 /**
-* Walk the step's declared `getConfigSchema()` and collect every field
-* with a primitive `default` value into a plain record. Group fields
-* are flattened — a nested `{ type: 'group', fields: [...] }` is
-* entered recursively. Fields without a declared default are skipped.
+* Collect every field of a step's `getConfigSchema(model)` with a primitive
+* `default` value into a plain record. Group fields are flattened — a nested
+* `{ type: 'group', fields: [...] }` is entered recursively. Fields without a
+* declared default are skipped.
 */
-function collectSchemaDefaults(stepId, model) {
-	const schema = require_default_detection_model.getStep(stepId).getConfigSchema(model);
+function collectSchemaDefaults(schema) {
 	const out = {};
 	walkFieldsForDefaults(schema, out);
 	return out;
 }
+/** The keys of every `bindsToModel` field of a schema, groups flattened (D738). */
+function collectModelBoundKeys(fields) {
+	return fields.flatMap((field) => {
+		if (field.type === "group") return collectModelBoundKeys(field.fields);
+		return "key" in field && "bindsToModel" in field && field.bindsToModel === true ? [field.key] : [];
+	});
+}
+/**
+* The operator settings of `stepId` as the model that RUNS sees them (D738):
+* a model-bound value made for another model is dropped and binding keys are
+* stripped. For a settings layer merged AFTER the tree is built (the
+* executor's per-device store, `applyDeviceOverridesToTree`), so it obeys the
+* same binding as the layers `buildNode` merges.
+*/
+function resolveOperatorSettingsForModel(stepId, settings, runningModelId) {
+	return require_dist.applyModelBoundSettings(settings, collectModelBoundKeys(require_custom_model_catalog.getStep(stepId).getConfigSchema()), runningModelId) ?? {};
+}
 function walkFieldsForDefaults(fields, out) {
 	for (const field of fields) {
 		if ("type" in field && field.type === "group" && "fields" in field) {
@@ -7564,7 +7629,7 @@ function walkFieldsForDefaults(fields, out) {
 */
 var defaultLookup = (stepId) => {
 	try {
-		return require_default_detection_model.getStepDefinition(stepId);
+		return require_custom_model_catalog.getStepDefinition(stepId);
 	} catch {
 		return null;
 	}
@@ -7613,7 +7678,7 @@ function collectSubstitutions(steps, format) {
 	for (const step of steps) {
 		const chosen = step.modelId;
 		if (chosen != null) {
-			const running = require_default_detection_model.resolveModelForFormat(step.addonId, chosen, format);
+			const running = require_custom_model_catalog.resolveModelForFormat(step.addonId, chosen, format);
 			if (running !== chosen) result.push({
 				addonId: step.addonId,
 				chosen,
@@ -7641,7 +7706,7 @@ function collectSubstitutions(steps, format) {
 * black-box test. Unknown/custom addonIds (no registered `StepDefinition`)
 * are skipped, never thrown.
 */
-function collectZeroBuildIssues(steps, format, getStepDef = require_default_detection_model.getStepDefinition) {
+function collectZeroBuildIssues(steps, format, getStepDef = require_custom_model_catalog.getStepDefinition) {
 	const result = [];
 	for (const step of steps) {
 		let def;
@@ -7667,7 +7732,7 @@ function collectZeroBuildIssues(steps, format, getStepDef = require_default_dete
 * tests can exercise the unknown-addon branch with a fabricated resolver
 * without `vi.mock`.
 */
-function collectUnknownAddonIssues(steps, getStepDef = require_default_detection_model.getStepDefinition) {
+function collectUnknownAddonIssues(steps, getStepDef = require_custom_model_catalog.getStepDefinition) {
 	const result = [];
 	for (const step of steps) {
 		try {
@@ -7717,7 +7782,7 @@ function resolveInputSteps(steps, format, engine, clusterModels, clusterSettings
 	for (const s of steps) {
 		let def;
 		try {
-			def = require_default_detection_model.getStepDefinition(s.addonId);
+			def = require_custom_model_catalog.getStepDefinition(s.addonId);
 		} catch {
 			unknownAddonIds.push(s.addonId);
 			continue;
@@ -7752,7 +7817,7 @@ function resolveInputSteps(steps, format, engine, clusterModels, clusterSettings
 			}
 		}
 		const chosenModelId = s.modelId ?? null;
-		const runningModelId = chosenModelId === null && engine !== void 0 && s.addonId === "object-detection" ? require_default_detection_model.resolveDefaultDetectionModel(engine.backend, engine.device, format) : require_default_detection_model.resolveModelForFormat(s.addonId, chosenModelId, format);
+		const runningModelId = chosenModelId === null && engine !== void 0 && s.addonId === "object-detection" ? require_custom_model_catalog.resolveDefaultDetectionModel(engine.backend, engine.device, format) : require_custom_model_catalog.resolveModelForFormat(s.addonId, chosenModelId, format);
 		if (chosenModelId !== null && runningModelId !== chosenModelId) substitutions.push({
 			addonId: s.addonId,
 			chosen: chosenModelId,
@@ -8185,7 +8250,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	* 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.
 	*/
-	customModels = new require_default_detection_model.CustomModelCatalog({ warn: (message, extras) => this.log.warn(message, extras) });
+	customModels = new require_custom_model_catalog.CustomModelCatalog({ warn: (message, extras) => this.log.warn(message, extras) });
 	/**
 	* SYNC custom-model lookup handed to every live {@link EngineFactory} so
 	* `buildPoolModelConfigForStep` can resolve an operator-registered model at
@@ -8323,7 +8388,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	listGuardedPools() {
 		const pools = [];
 		if (this.engineFactory) pools.push({
-			key: `default:${deviceKeyOf(this.currentEngine)}`,
+			key: `default:${require_custom_model_catalog.deviceKeyOf(this.currentEngine)}`,
 			factory: this.engineFactory
 		});
 		for (const [deviceKey, factory] of this.factoriesByDevice) pools.push({
@@ -8585,7 +8650,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 		} catch {}
 		const devices = require_dist.enumerateInferenceDevices(envToHardwareInfo(runtimeEnvFromProcess(hardware ? toProbedHardware(hardware) : null)));
 		const top = devices.find((d) => d.available) ?? devices[0];
-		this.currentEngine = top ? resolveDeviceEngine(top.key) : ONNX_FLOOR;
+		this.currentEngine = top ? require_custom_model_catalog.resolveDeviceEngine(top.key) : ONNX_FLOOR;
 		this.log.info("Derived node-default engine (local kernel)", { meta: {
 			deviceKey: top?.key ?? "onnx:cpu(floor)",
 			backend: this.currentEngine.backend,
@@ -8844,7 +8909,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	* first, then the custom registry. Returns undefined if neither has it.
 	*/
 	async resolveModelEntry(addonId, modelId) {
-		const fromCatalog = require_default_detection_model.getStepDefinition(addonId).models.find((m) => m.id === modelId);
+		const fromCatalog = require_custom_model_catalog.getStepDefinition(addonId).models.find((m) => m.id === modelId);
 		if (fromCatalog) return fromCatalog;
 		return (await this.getCustomModels()).get(addonId)?.find((m) => m.id === modelId);
 	}
@@ -8909,7 +8974,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 		};
 	}
 	async getDefaultSteps(engine) {
-		const detectionModelId = require_default_detection_model.resolveDefaultDetectionModel(engine.backend, engine.device ?? null, engine.format);
+		const detectionModelId = require_custom_model_catalog.resolveDefaultDetectionModel(engine.backend, engine.device ?? null, engine.format);
 		return buildDefaultStepTree(engine.format, detectionModelId);
 	}
 	/**
@@ -8940,7 +9005,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	/** Pure recursive resolver — builds the resolved step tree without touching `modelSubstitutions`. */
 	resolveStepModelTree(steps, format) {
 		return steps.map((step) => {
-			const resolved = require_default_detection_model.resolveModelForFormat(step.addonId, step.modelId ?? null, format);
+			const resolved = require_custom_model_catalog.resolveModelForFormat(step.addonId, step.modelId ?? null, format);
 			const children = step.children?.length ? this.resolveStepModelTree([...step.children], format) : step.children;
 			return resolved === step.modelId && children === step.children ? step : {
 				...step,
@@ -8967,7 +9032,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	*/
 	async getGlobalSteps() {
 		if (this.currentSteps) return this.currentSteps;
-		const detectionModelId = require_default_detection_model.resolveDefaultDetectionModel(this.currentEngine.backend, this.currentEngine.device ?? null, this.currentEngine.format);
+		const detectionModelId = require_custom_model_catalog.resolveDefaultDetectionModel(this.currentEngine.backend, this.currentEngine.device ?? null, this.currentEngine.format);
 		const defaults = buildDefaultStepTree(this.currentEngine.format, detectionModelId);
 		if (defaults.length === 0) return null;
 		this.currentSteps = this.resolveStepModels(defaults);
@@ -9013,7 +9078,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 		let format = this.currentEngine.format;
 		try {
 			if (input.deviceKey !== void 0) try {
-				format = resolveDeviceEngine(input.deviceKey).format;
+				format = require_custom_model_catalog.resolveDeviceEngine(input.deviceKey).format;
 			} catch (err) {
 				return {
 					ok: false,
@@ -9102,7 +9167,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 			for (const step of nodes) {
 				if (!step.enabled) continue;
 				try {
-					if (require_default_detection_model.getStepDefinition(step.addonId).slot === "audio-classifier") continue;
+					if (require_custom_model_catalog.getStepDefinition(step.addonId).slot === "audio-classifier") continue;
 				} catch {
 					continue;
 				}
@@ -9122,7 +9187,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	async getCapabilities(_forceRefresh) {
 		const agentId = (this.addonCtx?.kernel?.cluster?.broker)?.nodeID ?? node_os.hostname();
 		const agentName = agentId;
-		const addons = require_default_detection_model.ALL_PIPELINE_STEPS.map((s) => ({
+		const addons = require_custom_model_catalog.ALL_PIPELINE_STEPS.map((s) => ({
 			id: s.definition.id,
 			name: s.definition.name,
 			models: s.definition.models.filter((m) => m.legacy !== true).map((m) => {
@@ -9524,7 +9589,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 				executing: input.plane === "frame" ? collectFramePlaneSteps(benchmarkSteps, isDetailPlaneStep) : enabledSteps,
 				requestedDeviceKey: input.deviceKey,
 				dispatchDeviceKey,
-				format: dispatchDeviceKey ? resolveDeviceEngine(dispatchDeviceKey).format : this.currentEngine.format
+				format: dispatchDeviceKey ? require_custom_model_catalog.resolveDeviceEngine(dispatchDeviceKey).format : this.currentEngine.format
 			});
 			if (verdict.kind === "refused") {
 				this.log.warn("replay refused — the node cannot run exactly what was pinned", {
@@ -9556,13 +9621,13 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 			logger: this.log
 		});
 		this.executor = executor;
-		const dispatchEngine = dispatchDeviceKey ? resolveDeviceEngine(dispatchDeviceKey) : runEngine;
+		const dispatchEngine = dispatchDeviceKey ? require_custom_model_catalog.resolveDeviceEngine(dispatchDeviceKey) : runEngine;
 		const dispatchFactory = dispatchDeviceKey ? await this.resolveDeviceFactory(dispatchDeviceKey) : this.engineFactory;
 		const needed = enabledSteps.filter((s) => dispatchFactory.needsPoolUpdate(s));
 		let runSteps = benchmarkSteps;
 		const loadPolicy = dispatchLoadPolicyOf(input);
 		if (needed.length > 0) {
-			const dispatchDeviceKeyLabel = deviceKeyOf(dispatchEngine);
+			const dispatchDeviceKeyLabel = require_custom_model_catalog.deviceKeyOf(dispatchEngine);
 			const toIssue = needed.filter((s) => this.loadGovernor.check(dispatchFactory, dispatchDeviceKeyLabel, [stepModelKey(s)]).kind === "go");
 			if (toIssue.length > 0) this.log.info("Benchmark: models to load", { meta: {
 				count: toIssue.length,
@@ -9588,7 +9653,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 		}));
 		if (notWarm.length > 0) {
 			if (loadPolicy === "all-or-nothing") throw new DispatchStepsNotLoadedError(notWarm);
-			const dispatchDeviceKeyLabel = deviceKeyOf(dispatchEngine);
+			const dispatchDeviceKeyLabel = require_custom_model_catalog.deviceKeyOf(dispatchEngine);
 			for (const failure of notWarm) {
 				const model = stepModelKey(failure.step);
 				this.reportDispatchLoadLoss({
@@ -9618,7 +9683,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 		let frameViewResolver;
 		let rootInputViewProvider;
 		if (runtimeFrameRef) {
-			frameViewResolver = createRootFrameViewResolver(require_default_detection_model.localFrameRegistry, runtimeFrameRef);
+			frameViewResolver = createRootFrameViewResolver(require_custom_model_catalog.localFrameRegistry, runtimeFrameRef);
 			rootInputViewProvider = async (root, crop) => {
 				const view = await frameViewResolver(root, crop ? {
 					left: crop[0],
@@ -9804,7 +9869,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 			device: this.currentEngine.device ?? null
 		};
 		const nodeEngineLabel = `${nodeEngine.backend}/${nodeEngine.device ?? "default"} (${nodeFormat})`;
-		const deviceEngine = deviceKey ? resolveDeviceEngine(deviceKey) : void 0;
+		const deviceEngine = deviceKey ? require_custom_model_catalog.resolveDeviceEngine(deviceKey) : void 0;
 		if (deviceKey === void 0 || deviceEngine === void 0) {
 			const refusals = [];
 			const steps = this.inputStepsToPipelineSteps(args.steps, nodeFormat, nodeEngine, refusals);
@@ -9832,7 +9897,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 					steps
 				};
 			}
-			const pruneResult = pruneUnrunnableDetailSteps(steps, isDetailPlaneStep, (subtree) => !require_default_detection_model.buildSubtreeCanRun(subtree, this.mergedStepDef)(deviceFormat));
+			const pruneResult = pruneUnrunnableDetailSteps(steps, isDetailPlaneStep, (subtree) => !require_custom_model_catalog.buildSubtreeCanRun(subtree, this.mergedStepDef)(deviceFormat));
 			if (pruneResult.prunedAddonIds.length > 0) {
 				const prunedList = pruneResult.prunedAddonIds.join(",");
 				this.logLiveDispatchIssueOnce(`detail-defer:${deviceKey}:${deviceFormat}:${prunedList}`, () => this.log.info("Detail steps have no model build for the dispatch device format — deferred to the detail-plane device jump", {
@@ -9957,7 +10022,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	async noteCoralPlacement(steps, factory, format, context) {
 		const change = factory.notePlacement(placedModelsOf(steps));
 		if (change.kind === "unchanged") return;
-		const deviceKey = context.deviceKey ?? deviceKeyOf(this.currentEngine);
+		const deviceKey = context.deviceKey ?? require_custom_model_catalog.deviceKeyOf(this.currentEngine);
 		const tags = context.deviceId !== void 0 ? { tags: { deviceId: context.deviceId } } : {};
 		const placed = change.placed.map((p) => `${p.stepId}/${p.modelId}`);
 		if (change.to.kind === "set") this.log.info("Coral pool loads a co-compiled set — the models placed on it share the parameter cache", {
@@ -10018,7 +10083,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 		const needed = this.stepsNeedingLoad(steps, factory);
 		if (needed.length === 0) return;
 		const pool = factory ?? this.nullPoolKey;
-		const deviceKey = context.deviceKey ?? deviceKeyOf(this.currentEngine);
+		const deviceKey = context.deviceKey ?? require_custom_model_catalog.deviceKeyOf(this.currentEngine);
 		const models = needed.map(stepModelKey);
 		const refusal = this.loadRefusal(pool, deviceKey, models);
 		if (refusal !== null) {
@@ -10300,7 +10365,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 			plane: void 0
 		});
 		const dispatchDeviceKey = dispatchResolution.deviceKey;
-		const resolveFormat = dispatchDeviceKey ? resolveDeviceEngine(dispatchDeviceKey).format : this.currentEngine.format;
+		const resolveFormat = dispatchDeviceKey ? require_custom_model_catalog.resolveDeviceEngine(dispatchDeviceKey).format : this.currentEngine.format;
 		const benchmarkSteps = dispatchResolution.steps;
 		const enabledSteps = flattenEnabledVideoSteps(benchmarkSteps);
 		if (enabledSteps.length === 0) throw new Error("runPipelineBatch: no enabled steps");
@@ -10323,7 +10388,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 		await this.ensureEngineFactory();
 		const factory = dispatchDeviceKey ? await this.resolveDeviceFactory(dispatchDeviceKey) : this.engineFactory;
 		if (!factory) throw new Error("runPipelineBatch: factory not initialised");
-		if (enabledSteps.filter((s) => factory.needsPoolUpdate(s)).length > 0) await this.ensureModelsForSteps(benchmarkSteps, factory, resolveFormat, { deviceKey: dispatchDeviceKey ?? deviceKeyOf(this.currentEngine) });
+		if (enabledSteps.filter((s) => factory.needsPoolUpdate(s)).length > 0) await this.ensureModelsForSteps(benchmarkSteps, factory, resolveFormat, { deviceKey: dispatchDeviceKey ?? require_custom_model_catalog.deviceKeyOf(this.currentEngine) });
 		const canFastPath = singleRoot && allRaw && uniformDims && factory.supportsBatch();
 		this.log.info("runPipelineBatch path decision", { meta: {
 			phase: "batch",
@@ -10556,7 +10621,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	* pool that ran the work (D646).
 	*/
 	async getEffectiveTuning(input = {}) {
-		const p = resolvePoolProvisioning(input.deviceKey !== void 0 ? resolveDeviceEngine(input.deviceKey) : this.currentEngine, this.executorOptions.provisioning);
+		const p = resolvePoolProvisioning(input.deviceKey !== void 0 ? require_custom_model_catalog.resolveDeviceEngine(input.deviceKey) : this.currentEngine, this.executorOptions.provisioning);
 		return {
 			deviceKey: input.deviceKey ?? null,
 			runtime: p.runtime,
@@ -10573,7 +10638,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	* If global steps exist, initializes with them. Otherwise, creates an empty pool.
 	*/
 	async ensureEngineFactory() {
-		const defaultDeviceKey = deviceKeyOf(this.currentEngine);
+		const defaultDeviceKey = require_custom_model_catalog.deviceKeyOf(this.currentEngine);
 		this.refuseIfDeviceUnusable(defaultDeviceKey);
 		if (this.engineFactory) {
 			if (this.engineFactory.isReady()) return;
@@ -10773,7 +10838,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	async getInferenceDeviceHealth() {
 		const byKey = /* @__PURE__ */ new Map();
 		for (const entry of this.deviceLiveness.unhealthy()) byKey.set(entry.deviceKey, entry);
-		const live = [...this.factoriesByDevice, ...this.engineFactory ? [[deviceKeyOf(this.currentEngine), this.engineFactory]] : []];
+		const live = [...this.factoriesByDevice, ...this.engineFactory ? [[require_custom_model_catalog.deviceKeyOf(this.currentEngine), this.engineFactory]] : []];
 		for (const [deviceKey, factory] of live) {
 			if (factory.isReady() || byKey.has(deviceKey)) continue;
 			byKey.set(deviceKey, {
@@ -10809,7 +10874,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 		return { rearmed };
 	}
 	async resolveDeviceFactory(deviceKey) {
-		const engine = resolveDeviceEngine(deviceKey);
+		const engine = require_custom_model_catalog.resolveDeviceEngine(deviceKey);
 		if (enginesEqual(engine, this.currentEngine)) {
 			await this.ensureEngineFactory();
 			return this.engineFactory;
@@ -10993,7 +11058,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 			});
 		}
 		for (const [deviceKey, factory] of this.factoriesByDevice) {
-			const eng = resolveDeviceEngine(deviceKey);
+			const eng = require_custom_model_catalog.resolveDeviceEngine(deviceKey);
 			const loaded = factory.listLoaded();
 			out.push({
 				engineKey: `${eng.runtime}/${eng.backend}/${eng.device ?? "default"} [${deviceKey}]`,
@@ -11176,9 +11241,9 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 function buildSchemaSlots(formats, modelsDir, customByStep) {
 	const slotMap = /* @__PURE__ */ new Map();
 	const formatList = [...formats];
-	for (const pipelineStep of require_default_detection_model.ALL_PIPELINE_STEPS) {
+	for (const pipelineStep of require_custom_model_catalog.ALL_PIPELINE_STEPS) {
 		const step = pipelineStep.definition;
-		const availableModels = require_default_detection_model.mergeCustomModels(step.models, customByStep?.get(step.id) ?? []).filter((m) => m.legacy !== true && formatList.some((f) => m.formats[f]));
+		const availableModels = require_custom_model_catalog.mergeCustomModels(step.models, customByStep?.get(step.id) ?? []).filter((m) => m.legacy !== true && formatList.some((f) => m.formats[f]));
 		if (availableModels.length === 0) continue;
 		const slot = step.slot;
 		if (!slotMap.has(slot)) slotMap.set(slot, []);
@@ -11187,8 +11252,10 @@ function buildSchemaSlots(formats, modelsDir, customByStep) {
 			def: step,
 			configSchema: pipelineStep.getConfigSchema(),
 			models: availableModels,
-			customModelIds: customIds
+			customModelIds: customIds,
+			schemaForModel: (entry) => pipelineStep.getConfigSchema(entry)
 		});
+		const configSchemaWithRoots = withRootSuppliedLabelDefaults(step.id, configSchema, require_custom_model_catalog.mergeCustomModels(require_custom_model_catalog.getStepDefinition("object-detection").models, customByStep?.get("object-detection") ?? []));
 		slotMap.get(slot).push({
 			id: step.id,
 			name: step.name,
@@ -11206,7 +11273,7 @@ function buildSchemaSlots(formats, modelsDir, customByStep) {
 				...m.group ? { group: m.group } : {},
 				...m.legacy !== void 0 ? { legacy: m.legacy } : {},
 				provider: m.provider ?? "camstack",
-				defaultConfidence: require_default_detection_model.resolveModelDefaultConfidence(step, m),
+				defaultConfidence: require_custom_model_catalog.resolveModelDefaultConfidence(step, m),
 				...modelSuppliesField(step, m)
 			})),
 			defaultModelId: step.defaultModelId,
@@ -11215,7 +11282,7 @@ function buildSchemaSlots(formats, modelsDir, customByStep) {
 			...step.backfillIntoExistingOverrides !== void 0 ? { backfillIntoExistingOverrides: step.backfillIntoExistingOverrides } : {},
 			defaultConfidence: step.defaultConfidence,
 			...step.group ? { group: step.group } : {},
-			...configSchema.length > 0 ? { configSchema: [...configSchema] } : {}
+			...configSchemaWithRoots.length > 0 ? { configSchema: configSchemaWithRoots } : {}
 		});
 	}
 	const slotPriority = {
@@ -11259,20 +11326,15 @@ function resolveChildSlots(slot) {
 	}
 }
 /**
-* V2 default: lightweight pipeline with minimal enabled steps.
-*
-* Only object detection (yolov9t, 4-8 MB) + face detection (scrfd, 1.7 MB) enabled.
-* All other steps are present in the tree but DISABLED — user enables via UI.
-* Total model footprint: ~10 MB (CoreML), ~11 MB (ONNX)
-*
-* Why:
-* - Fast startup (seconds, not minutes of model downloads)
-* - Covers 90% of NVR use cases (person/vehicle/animal detection + face detection)
-* - Users opt-in to heavy classifiers (vehicle type, plate OCR, bird species) when needed
+* V2 default: the node-default step tree (never persisted — see
+* `getGlobalSteps`). The core detection + recognition steps are enabled; every
+* optional step is present with its catalog `enabledByDefault` (the animal and
+* vehicle classifiers on — their answer comes from the root model when it
+* declares them, D736 — the bird classifier and segmentation off).
 */
 function buildDefaultStepTree(format, objectDetectionModelId) {
 	const makeStep = (stepId, children, opts) => {
-		const def = require_default_detection_model.getStepDefinition(stepId);
+		const def = require_custom_model_catalog.getStepDefinition(stepId);
 		if (!def.models.some((m) => m.formats[format])) return null;
 		return {
 			addonId: def.id,
@@ -11281,7 +11343,7 @@ function buildDefaultStepTree(format, objectDetectionModelId) {
 			inputClasses: def.inputClasses ?? [],
 			outputClasses: def.outputClasses,
 			enabled: opts?.enabled ?? true,
-			modelId: opts?.modelId ?? require_default_detection_model.getDefaultModelForFormat(stepId, format),
+			modelId: opts?.modelId ?? require_custom_model_catalog.getDefaultModelForFormat(stepId, format),
 			children,
 			...def.group ? { group: def.group } : {}
 		};
@@ -11289,14 +11351,17 @@ function buildDefaultStepTree(format, objectDetectionModelId) {
 	const faceEmbedding = makeStep("face-embedding", []);
 	const faceDetection = makeStep("face-detection", faceEmbedding ? [faceEmbedding] : []);
 	const plateOcr = makeStep("plate-ocr", []);
+	const plateDetection = makeStep("plate-detection", plateOcr ? [plateOcr] : []);
+	const clipEmbedding = makeStep("clip-embedding", []);
+	const byCatalogDefault = (stepId) => ({ enabled: require_custom_model_catalog.getStepDefinition(stepId).enabledByDefault ?? true });
 	const root = makeStep("object-detection", [
 		faceDetection,
-		makeStep("plate-detection", plateOcr ? [plateOcr] : []),
-		makeStep("clip-embedding", []),
-		makeStep("animal-classifier", [], { enabled: false }),
-		makeStep("bird-classifier", [], { enabled: false }),
-		makeStep("vehicle-classifier", [], { enabled: false }),
-		makeStep("segmentation", [], { enabled: false })
+		plateDetection,
+		clipEmbedding,
+		makeStep("animal-classifier", [], byCatalogDefault("animal-classifier")),
+		makeStep("bird-classifier", [], byCatalogDefault("bird-classifier")),
+		makeStep("vehicle-classifier", [], byCatalogDefault("vehicle-classifier")),
+		makeStep("segmentation", [], byCatalogDefault("segmentation"))
 	].filter((s) => s !== null), objectDetectionModelId !== void 0 ? { modelId: objectDetectionModelId } : void 0);
 	const audioStep = makeStep("audio-classifier", []);
 	const steps = [];
@@ -11338,7 +11403,7 @@ function flattenSteps(steps) {
 */
 function isDetailPlaneStep(addonId) {
 	try {
-		return require_default_detection_model.getStepDefinition(addonId).inputClasses !== null;
+		return require_custom_model_catalog.getStepDefinition(addonId).inputClasses !== null;
 	} catch {
 		return false;
 	}
@@ -11377,7 +11442,7 @@ function stepsSurvivingLoad(steps, failures, policy) {
 */
 function availableFormatsForStep(addonId) {
 	try {
-		const def = require_default_detection_model.getStepDefinition(addonId);
+		const def = require_custom_model_catalog.getStepDefinition(addonId);
 		const formats = /* @__PURE__ */ new Set();
 		for (const model of def.models) for (const format of Object.keys(model.formats)) formats.add(format);
 		return Array.from(formats).toSorted();
@@ -11389,14 +11454,15 @@ function availableFormatsForStep(addonId) {
 * Return a shallow-cloned executable tree with `rootStepId`'s `settings`
 * merged with `overrides` (per-device values win). Non-matching root steps
 * pass through unchanged. Used by `runFrame` to apply per-device detection
-* settings without rebuilding the tree per frame.
+* settings without rebuilding the tree per frame. A model-bound value (D738)
+* applies only while the model it was made for is the one the root RUNS.
 */
 function applyDeviceOverridesToTree(tree, rootStepId, overrides) {
 	return { roots: tree.roots.map((root) => root.stepId === rootStepId ? {
 		...root,
 		settings: {
 			...root.settings,
-			...overrides
+			...resolveOperatorSettingsForModel(rootStepId, overrides, root.modelId)
 		}
 	} : root) };
 }
@@ -11946,7 +12012,7 @@ var DetectionPipelineAddon = class extends require_dist.BaseAddon {
 		}).catch(() => {});
 	}
 	getModelCatalog() {
-		return require_default_detection_model.ALL_STEPS.flatMap((s) => s.models.filter((m) => m.legacy !== true));
+		return require_custom_model_catalog.ALL_STEPS.flatMap((s) => s.models.filter((m) => m.legacy !== true));
 	}
 	/**
 	* Proactively install the OpenVINO Python package when Intel hardware
@@ -12032,9 +12098,9 @@ var DetectionPipelineAddon = class extends require_dist.BaseAddon {
 	}
 };
 //#endregion
-exports.ALL_STEPS = require_default_detection_model.ALL_STEPS;
+exports.ALL_STEPS = require_custom_model_catalog.ALL_STEPS;
 exports.DetectionPipelineProvider = DetectionPipelineProvider;
 exports.default = DetectionPipelineAddon;
-exports.getDefaultModelForFormat = require_default_detection_model.getDefaultModelForFormat;
-exports.getStepDefinition = require_default_detection_model.getStepDefinition;
+exports.getDefaultModelForFormat = require_custom_model_catalog.getDefaultModelForFormat;
+exports.getStepDefinition = require_custom_model_catalog.getStepDefinition;
 exports.shouldInstallOpenvino = shouldInstallOpenvino;