@camstack/addon-pipeline 1.2.333 → 1.2.335

package/dist/detection-pipeline/index.mjs

@@ -1,9 +1,9 @@
 import { n as __require } from "../chunk-DnnnRqeS.mjs";
-import { $n as union, Cn as errMsg, Dt as linkedLabelStepId, G as YAMNET_TO_MACRO, Ln as nodePin, N as PoolMemoryWatchdog, Nn as hydrateSchema, O as LABEL_SUPPLY_MACRO, Qn as string, Rn as parseJsonUnknown, Tn as BaseAddon, Un as array, Vn as sleep, Vt as pickClusterStepSettings, Wt as pipelineExecutorCapability, Yn as object, Zt as resolveClusterStepModelId, an as runtimeDevices$1, b as DEVICE_BACKEND_TO_FORMAT, d as CLUSTER_MODEL_SCOPED_STEPS, dn as supportedRuntimes$1, dt as detectionPipelineCapability, er as EventCategory, g as DEFAULT_CLUSTER_STEP_SETTINGS, ht as evaluateZoneRules, in as rootSuppliesOf, kn as createEvent, kt as loadContributionCapability, mt as enumerateInferenceDevices, n as APPLE_SA_TO_MACRO, nt as containingParentIndex, on as stepModelRunsOnFormat, ot as defaultDeviceFor$1, tn as resolvePoolMemoryPolicy, wt as hfModelUrl, zt as overlayClusterStepSettings } from "../dist-BsT15i7i.mjs";
-import { s as readProcessCost } from "../node-Crsi_8ea.mjs";
-import { _ as getStep, a as buildSubtreeCanRun, b as landmarkPrecisionVerdict, c as macroGateVerdict, g as getDefaultModelForFormat, h as ALL_STEPS, i as mergeCustomModels, m as ALL_PIPELINE_STEPS, n as resolveDefaultDetectionModel, r as CustomModelCatalog, u as localFrameRegistry, v as getStepDefinition, x as resolveModelDefaultConfidence, y as resolveModelForFormat } from "../default-detection-model-CDffuH2m.mjs";
+import { At as loadContributionCapability, Bn as parseJsonUnknown, Bt as overlayClusterStepSettings, Dn as BaseAddon, Fn as hydrateSchema, G as YAMNET_TO_MACRO, Gn as array, Gt as pipelineExecutorCapability, Ht as pickClusterStepSettings, J as applyModelBoundSettings, N as PoolMemoryWatchdog, O as LABEL_SUPPLY_MACRO, Ot as linkedLabelStepId, Qt as resolveClusterStepModelId, Tn as errMsg, Tt as hfModelUrl, Un as sleep, Zn as object, cn as stepModelRunsOnFormat, d as CLUSTER_MODEL_SCOPED_STEPS, er as string, ft as detectionPipelineCapability, g as DEFAULT_CLUSTER_STEP_SETTINGS, gt as evaluateZoneRules, ht as enumerateInferenceDevices, jn as createEvent, n as APPLE_SA_TO_MACRO, nr as EventCategory, on as rootSuppliesOf, pn as supportedRuntimes$1, rn as resolvePoolMemoryPolicy, rt as containingParentIndex, sn as runtimeDevices$1, st as defaultDeviceFor$1, tr as union, zn as nodePin } from "../dist-CPhDwlSN.mjs";
+import { s as readProcessCost } from "../node-DYfEOwjW.mjs";
+import { C as resolveModelDefaultConfidence, S as landmarkPrecisionVerdict, _ as ALL_STEPS, b as getStepDefinition, f as localFrameRegistry, g as ALL_PIPELINE_STEPS, l as resolveDefaultDetectionModel, n as mergeCustomModels, o as deviceKeyOf, r as buildSubtreeCanRun, s as resolveDeviceEngine, t as CustomModelCatalog, u as macroGateVerdict, v as getDefaultModelForFormat, x as resolveModelForFormat, y as getStep } from "../custom-model-catalog-Buehc666.mjs";
 import { t as getSharp } from "../lazy-sharp-DXsqwpph.mjs";
-import { n as pickNodePlatformArch, t as readProcessMemory } from "../process-memory-1mAUV8S1.mjs";
+import { n as pickNodePlatformArch, t as readProcessMemory } from "../process-memory-WPRYnN8c.mjs";
 import * as os from "node:os";
 import * as fs from "node:fs";
 import * as path$1 from "node:path";
@@ -2243,6 +2243,7 @@ function describeCommand(cmd) {
 		model: typeof modelPath === "string" && modelPath.length > 0 ? path$1.basename(modelPath, path$1.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,
@@ -2254,6 +2255,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;
@@ -2444,25 +2446,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;
@@ -2511,6 +2531,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 = getStepDefinition(ROOT_STEP_ID);
+	const defaults = {};
+	for (const root of rootModels) {
+		if (!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(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)
@@ -2994,38 +3063,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 = 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. */
@@ -3720,6 +3757,7 @@ 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, resolveModelDefaultConfidence(def, modelEntry)),
 		nmsIouThreshold: resolvePoolDecodeSettings({
@@ -7175,7 +7213,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();
@@ -7466,9 +7512,12 @@ function buildNode(step, getEngine, resolveModel, onMissingVariant, resolved) {
 	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 = getStep(step.addonId).getConfigSchema(modelEntry);
+	const schemaDefaults = collectSchemaDefaults(schema);
+	const operatorSettings = applyModelBoundSettings(step.settings, collectModelBoundKeys(schema), variant.modelId);
 	const mergedSettings = {
-		...collectSchemaDefaults(step.addonId, modelEntry),
-		...step.settings
+		...schemaDefaults,
+		...operatorSettings
 	};
 	const effectiveClassMap = modelEntry?.classMap ?? definition.classMap;
 	return {
@@ -7494,17 +7543,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 = 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 applyModelBoundSettings(settings, collectModelBoundKeys(getStep(stepId).getConfigSchema()), runningModelId) ?? {};
+}
 function walkFieldsForDefaults(fields, out) {
 	for (const field of fields) {
 		if ("type" in field && field.type === "group" && "fields" in field) {
@@ -11180,8 +11245,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, mergeCustomModels(getStepDefinition("object-detection").models, customByStep?.get("object-detection") ?? []));
 		slotMap.get(slot).push({
 			id: step.id,
 			name: step.name,
@@ -11208,7 +11275,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 = {
@@ -11252,16 +11319,11 @@ 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) => {
@@ -11282,14 +11344,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: 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 = [];
@@ -11382,14 +11447,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) };
 }

package/dist/{dist-DJV7Z6Bb.js → dist-C5DlS_lW.js}

@@ -12608,8 +12608,19 @@ var LABEL_SUPPLY_STEP_IDS = [
 ];
 /** Steps whose box a root detection can BE. */
 var CROP_SUPPLY_STEP_IDS = ["plate-detection", "face-detection"];
+/**
+* Steps whose per-detection MASK a root detection can carry (D737). The live
+* mask step is `segmentation` — a frame-plane refiner that runs its own model
+* once per detection crop. (`instance-segmentation` is a dormant step id that
+* no camera tree carries.)
+*/
+var MASK_SUPPLY_STEP_IDS = ["segmentation"];
 /** Every step a root model can supply. */
-var ROOT_SUPPLIABLE_STEP_IDS = [...LABEL_SUPPLY_STEP_IDS, ...CROP_SUPPLY_STEP_IDS];
+var ROOT_SUPPLIABLE_STEP_IDS = [
+	...LABEL_SUPPLY_STEP_IDS,
+	...CROP_SUPPLY_STEP_IDS,
+	...MASK_SUPPLY_STEP_IDS
+];
 /** Narrow a step id to a label-kind one. */
 function isLabelSupplyStepId(value) {
 	return LABEL_SUPPLY_STEP_IDS.some((id) => id === value);
@@ -12690,7 +12701,12 @@ var CROP_SUPPLY_SOURCES = {
 * Whether an operator intends a step to take the root's output when the
 * root declares it — the default of the `useRootModel` flag. The label kinds
 * default ON: the detector's answer is the cheaper one and the classifier
-* keeps its model for the day the root changes. The crop kinds default OFF: a
+* keeps its model for the day the root changes. The animal and vehicle
+* classifiers are also ENABLED by default (their catalog `enabledByDefault`,
+* D736), so out of the box a root that declares them names animals and
+* vehicles and a root that does not runs the classifier; `package-detection`
+* stays zone-driven and takes this default whenever a zone switches it on.
+* The crop kinds default OFF: a
 * root plate box has an uncalibrated OCR margin, and root-face refinement has
 * not run on live traffic yet.
 */
@@ -12699,7 +12715,8 @@ var USE_ROOT_MODEL_DEFAULTS = {
 	"vehicle-classifier": true,
 	"package-detection": true,
 	"plate-detection": false,
-	"face-detection": false
+	"face-detection": false,
+	segmentation: true
 };
 /** The step-settings key the flag is stored under (DeviceStepConfig.settings, camera overrides). */
 var USE_ROOT_MODEL_SETTING_KEY = "useRootModel";
@@ -12776,13 +12793,32 @@ function deriveRootSupplies(labels, classMap) {
 	return supplies;
 }
 /**
+* The decodes that emit an instance mask with every detection — a fact of the
+* model's OUTPUT, read from its postprocessor (`yolo-seg`: per-instance mask
+* coefficients times the prototype masks), never assumed per family.
+*/
+var MASK_EMITTING_POSTPROCESSORS = ["yolo-seg"];
+/**
+* The mask supplies a root declares from its decode: `segmentation` when the
+* postprocessor emits a mask per detection, nothing otherwise.
+*/
+function deriveMaskSupplies(postprocessor) {
+	if (postprocessor === void 0 || !MASK_EMITTING_POSTPROCESSORS.includes(postprocessor)) return [];
+	return MASK_SUPPLY_STEP_IDS.map((stepId) => ({
+		kind: "mask",
+		stepId
+	}));
+}
+/**
 * The supplies a root model declares. A row registered with a declaration
 * carries it (`suppliesSteps`, computed at import from the model's own
 * labelmap); a row without one — a built-in entry, or a custom row registered
 * before the field existed — is derived here, on read, from the same inputs.
 */
 function rootSuppliesOf(entry, stepDefaults) {
-	const declared = entry?.suppliesSteps ?? deriveRootSupplies(entry !== void 0 && entry.labels.length > 0 ? entry.labels.map((l) => l.id) : stepDefaults.labels, entry?.classMap ?? stepDefaults.classMap);
+	const fromLabels = entry?.suppliesSteps ?? deriveRootSupplies(entry !== void 0 && entry.labels.length > 0 ? entry.labels.map((l) => l.id) : stepDefaults.labels, entry?.classMap ?? stepDefaults.classMap);
+	const masks = deriveMaskSupplies(entry?.postprocessor).filter((m) => !fromLabels.some((s) => s.stepId === m.stepId));
+	const declared = masks.length > 0 ? [...fromLabels, ...masks] : fromLabels;
 	const inputPx = entry !== void 0 ? Math.min(entry.inputSize.width, entry.inputSize.height) : void 0;
 	if (inputPx === void 0) return declared;
 	return declared.map((s) => s.kind === "crop" ? {
@@ -13019,25 +13055,36 @@ var ModelLicenseSchema = preprocess((value) => typeof value === "string" ? { wei
 * - `crop`: the root draws the box the step would have found (`license_plate`
 *   for plate-detection, `face` for face-detection). The box becomes a detail
 *   child of the `parentMacro` detection that contains it — never a track.
+* - `mask`: the root's decode emits an instance mask with every detection (a
+*   YOLO26-seg root, D737) — the `segmentation` step's result, carried on the
+*   detection in the shape that step produces. Derived from the model's
+*   postprocessor on read, never stored by an import.
 */
-var RootStepSupplySchema = discriminatedUnion("kind", [object({
-	kind: literal("label"),
-	stepId: _enum(LABEL_SUPPLY_STEP_IDS),
-	labelToEffect: record(string(), string()),
-	uncovered: array(string()).readonly()
-}), object({
-	kind: literal("crop"),
-	stepId: _enum(CROP_SUPPLY_STEP_IDS),
-	rootLabels: array(string()).readonly(),
-	parentMacro: _enum(["vehicle", "person"]),
-	childClass: _enum(["plate", "face"]),
-	/**
-	* The root's smaller input side, stamped on read by `rootSuppliesOf` from
-	* the model entry — what a step's `minRootInputPx` gate judges. Never
-	* stored by an import.
-	*/
-	rootInputPx: number().int().positive().optional()
-})]);
+var RootStepSupplySchema = discriminatedUnion("kind", [
+	object({
+		kind: literal("label"),
+		stepId: _enum(LABEL_SUPPLY_STEP_IDS),
+		labelToEffect: record(string(), string()),
+		uncovered: array(string()).readonly()
+	}),
+	object({
+		kind: literal("crop"),
+		stepId: _enum(CROP_SUPPLY_STEP_IDS),
+		rootLabels: array(string()).readonly(),
+		parentMacro: _enum(["vehicle", "person"]),
+		childClass: _enum(["plate", "face"]),
+		/**
+		* The root's smaller input side, stamped on read by `rootSuppliesOf` from
+		* the model entry — what a step's `minRootInputPx` gate judges. Never
+		* stored by an import.
+		*/
+		rootInputPx: number().int().positive().optional()
+	}),
+	object({
+		kind: literal("mask"),
+		stepId: _enum(MASK_SUPPLY_STEP_IDS)
+	})
+]);
 var ModelCatalogEntrySchema = object({
 	id: string(),
 	name: string(),
@@ -13103,6 +13150,35 @@ var ModelCatalogEntrySchema = object({
 	*/
 	defaultConfidence: number().min(0).max(1).optional(),
 	/**
+	* Per-MODEL default of the per-class confidence floors (`minConfidence<Macro>`
+	* on a detector step), keyed by macro class: `{ person: 0.45 }`. A class
+	* absent here runs at the step slider's global default. The same row shape
+	* the floor measurement produces (`model-floors.json`: modelId → floors), so
+	* a measured table is copied in as-is. An operator override is bound to the
+	* model it was made for and does not survive a model change (D738). A custom
+	* / imported model may declare it; without it, the global defaults apply.
+	*/
+	defaultClassFloors: record(string(), number().min(0).max(1)).optional(),
+	/**
+	* The inference precision this model's OpenVINO IR needs on an Intel GPU.
+	* Absent ⇒ the device default (f16 on a GPU). Set to `'f32'` for an FP32 IR
+	* that produces invalid output at f16 — measured 2026-10-07 for YOLO26
+	* base IRs (`yolo26s`: 0 true / 146 false positives; `yolo26m*`: NaN
+	* scores) on the Core Ultra iGPU and the N100. Threaded to the pool as
+	* `PoolModelConfig.gpuInferencePrecision`; the pool sets
+	* INFERENCE_PRECISION_HINT on a GPU only. Costs ~60% latency on the GPU.
+	*/
+	gpuInferencePrecision: _enum(["f32", "f16"]).optional(),
+	/**
+	* ROOT detectors only: per supplied step (`animal-classifier`, …), the
+	* minimum DETECTION score from which this root's own fine label (species,
+	* vehicle type — D736 root supply) is taken (D741). Below it the detection
+	* keeps its macro class without the fine label. `1` = never take it from
+	* this root. Absent ⇒ no floor beyond the macro floor. The supplied step's
+	* `minConfidence` slider, bound to the ROOT model, overrides it.
+	*/
+	suppliedLabelFloors: record(string(), number().min(0).max(1)).optional(),
+	/**
 	* When true, the executor produces a landmark-aligned crop (similarity warp
 	* onto the canonical template) before this step runs, instead of a plain
 	* axis-aligned bbox crop. Required for face-recognition embedders (ArcFace):
@@ -41070,6 +41146,16 @@ DeviceType.Camera, method(object({
 	package: array(ZoneRuleSchema).readonly()
 });
 SOURCE_CAPS.filter((cap) => cap !== "switch" && cap !== "motion");
+Object.freeze({
+	person: .5,
+	vehicle: .5,
+	animal: .5
+});
+Object.freeze({
+	person: .65,
+	vehicle: .65,
+	animal: .65
+});
 var HF_BASE_URL = `https://huggingface.co/camstack/camstack-models/resolve/main`;
 /**
 * Accessory device helpers — shared across drivers.
@@ -53325,6 +53411,100 @@ function stepModelRunsOnFormat(models, modelId, format) {
 	}
 	return models.some((m) => m.legacy !== true && hasBuild(m, format));
 }
+/**
+* Model-bound step settings (D738): an operator value that is only meaningful
+* for ONE model, stored together with that model's id.
+*
+* The per-class confidence floors are the case it exists for. A score is a
+* property of one detector's output scale — on this hub the median score of a
+* correct person was 0.78 on `yolov9m-320-int8`, 0.68 on `yolo26s-320-int8`,
+* 0.40 on `yolo26n-320-int8` and 0.89 on `yolo26s` (640) — so a floor tuned on
+* one model is wrong on the next. The DEFAULT of such a field belongs to the
+* model (the catalog entry); an operator OVERRIDE belongs to the model it was
+* made for.
+*
+* The binding is checked at READ time against the model that RUNS, never
+* enforced by a write on the model-change path: a model can change without any
+* operator write at all (an unpinned root follows the elected device's
+* hardware-aware default, D736), and an event-driven reset could be dropped
+* (events are telemetry, D8/D11). So:
+*
+*   effective = override   when the stored binding names the running model
+*             | override   when no binding is stored (a legacy / programmatic
+*                          value — it applies to whatever runs, as before D738)
+*             | the running model's default, when it declares one
+*             | the field's global default.
+*
+* Storage shape: the value stays a plain number under its own key (every
+* reader of the raw settings bag keeps working), and the binding is a SIBLING
+* key, {@link modelBindingKey}. Both are flat so the shallow per-key merges of
+* the settings layers (node fold, camera override) carry a value and its
+* binding together whenever one layer writes both — which every writer here
+* does.
+*
+* Lives in the bare `@camstack/types` entry, which every addon bundles, so the
+* runner (`addon-pipeline`) and the editors (`ui-library`, `addon-admin-ui`)
+* apply the same rule.
+*/
+/** Suffix of the sibling key that names the model a stored value was made for. */
+var MODEL_BINDING_SUFFIX = "ModelId";
+/** `minConfidencePerson` → `minConfidencePersonModelId`. */
+function modelBindingKey(key) {
+	return `${key}${MODEL_BINDING_SUFFIX}`;
+}
+/** The model a stored value was made for, or `undefined` when unbound. */
+function storedBinding(settings, key) {
+	const binding = settings?.[modelBindingKey(key)];
+	return typeof binding === "string" && binding.length > 0 ? binding : void 0;
+}
+/**
+* The effective value of `key` for the model that runs (`runningModelId`,
+* `undefined` when unknown — it then matches no binding).
+*/
+function resolveModelBoundSetting(settings, key, runningModelId, modelDefault, globalDefault) {
+	const stored = settings?.[key];
+	const binding = storedBinding(settings, key);
+	if (stored !== void 0 && binding === void 0) return {
+		value: stored,
+		source: "override"
+	};
+	if (stored !== void 0 && binding !== void 0 && binding === runningModelId) return {
+		value: stored,
+		source: "override",
+		boundModelId: binding
+	};
+	const inapplicable = stored !== void 0 && binding !== void 0 ? { inapplicableOverride: {
+		value: stored,
+		modelId: binding
+	} } : {};
+	if (modelDefault !== void 0) return {
+		value: modelDefault,
+		source: "model-default",
+		...inapplicable
+	};
+	return {
+		value: globalDefault,
+		source: "global-default",
+		...inapplicable
+	};
+}
+/**
+* The OPERATOR layer of a step's settings as the running model sees it: every
+* model-bound value made for another model is removed (so the default
+* underneath — the running model's — wins the merge), and every binding key is
+* stripped. Unbound values are kept. Returns a fresh object; `undefined` stays
+* `undefined`.
+*/
+function applyModelBoundSettings(settings, boundKeys, runningModelId) {
+	if (settings === void 0) return void 0;
+	const out = { ...settings };
+	for (const key of boundKeys) {
+		const binding = storedBinding(settings, key);
+		if (binding !== void 0 && binding !== runningModelId) delete out[key];
+		delete out[modelBindingKey(key)];
+	}
+	return out;
+}
 /** Side of the square, as a multiple of the face box's longer side. */
 var ROOT_FACE_REFINE_SCALE = 1.6;
 /**
@@ -54891,6 +55071,12 @@ Object.defineProperty(exports, "allowedSuppliedEffect", {
 		return allowedSuppliedEffect;
 	}
 });
+Object.defineProperty(exports, "applyModelBoundSettings", {
+	enumerable: true,
+	get: function() {
+		return applyModelBoundSettings;
+	}
+});
 Object.defineProperty(exports, "array", {
 	enumerable: true,
 	get: function() {
@@ -55413,6 +55599,12 @@ Object.defineProperty(exports, "resolveLocationMode", {
 		return resolveLocationMode;
 	}
 });
+Object.defineProperty(exports, "resolveModelBoundSetting", {
+	enumerable: true,
+	get: function() {
+		return resolveModelBoundSetting;
+	}
+});
 Object.defineProperty(exports, "resolvePoolMemoryPolicy", {
 	enumerable: true,
 	get: function() {