@camstack/addon-pipeline 1.2.621 → 1.2.623

package/dist/detection-pipeline/index.mjs

@@ -1,9 +1,9 @@
 import { n as __require } from "../chunk-DnnnRqeS.mjs";
-import { $t as pipelineExecutorCapability, Ct as enumerateInferenceDevices, F as PoolMemoryWatchdog, Hn as createEvent, In as BaseAddon, It as linkedLabelStepId, Jn as hydrateSchema, Jt as overlayClusterStepSettings, Kt as modelBindingKey, O as LABEL_SUPPLY_MACRO, Pn as errMsg$1, Rt as loadContributionCapability, Sn as supportedRuntimes$1, X as applyModelBoundSettings, Xt as pickClusterStepSettings, _n as stepModelRunsOnFormat, _r as EventCategory, _t as detectionPipelineCapability, bt as edgetpuDelegateDevice, ct as containingParentIndex, d as CLUSTER_MODEL_SCOPED_STEPS, dn as resolvePoolMemoryPolicy, er as nodePin, fr as object, ft as defaultDeviceFor$1, g as DEFAULT_CLUSTER_STEP_SETTINGS, gr as union, hn as runtimeDevices$1, hr as string, mn as rootSuppliesOf, n as APPLE_SA_TO_MACRO, on as resolveClusterStepModelId, or as array, q as YAMNET_TO_MACRO, qn as hfModelUrl, rr as sleep, st as collectModelBoundKeys, wt as evaluateZoneRules } from "../dist-DHqkQhTQ.mjs";
-import { c as readProcessCost } from "../node-CkJLxlWI.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-0_SnSXzN.mjs";
+import { $ as applyModelBoundSettings, Cn as runtimeDevices$1, Dt as enumerateInferenceDevices, En as stepModelRunsOnFormat, Er as EventCategory, Gn as BaseAddon, I as PoolMemoryWatchdog, O as LABEL_SUPPLY_MACRO, Ot as evaluateZoneRules, Qt as overlayClusterStepSettings, Sn as rootSuppliesOf, Tr as union, Un as errMsg, Ut as loadContributionCapability, Vt as linkedLabelStepId, Y as YAMNET_TO_MACRO, Zn as createEvent, d as CLUSTER_MODEL_SCOPED_STEPS, dt as containingParentIndex, en as pickClusterStepSettings, fr as sleep, g as DEFAULT_CLUSTER_STEP_SETTINGS, gt as defaultDeviceFor$1, hr as array, jn as supportedRuntimes$1, lr as nodePin, mn as resolveClusterStepModelId, n as APPLE_SA_TO_MACRO, nr as hfModelUrl, rn as pipelineExecutorCapability, rr as hydrateSchema, ut as collectModelBoundKeys, wr as string, wt as edgetpuDelegateDevice, xr as object, xt as detectionPipelineCapability, yn as resolvePoolMemoryPolicy } from "../dist-opSx6v5i.mjs";
+import { c as readProcessCost } from "../node-CGIYuJMN.mjs";
+import { S as resolveModelDefaultConfidence, _ as getDefaultModelForFormat, b as resolveModelForFormat, c as resolveDefaultDetectionModel, d as localFrameRegistry, g as ALL_STEPS, h as ALL_PIPELINE_STEPS, l as macroGateVerdict, n as mergeCustomModels, o as deviceKeyOf, r as buildSubtreeCanRun, s as resolveDeviceEngine, t as CustomModelCatalog, v as getStep, x as landmarkPrecisionVerdict, y as getStepDefinition } from "../custom-model-catalog-D5zTw1LU.mjs";
 import { t as getSharp } from "../lazy-sharp-DXsqwpph.mjs";
-import { n as pickNodePlatformArch, t as readProcessMemory } from "../process-memory-Dj3UgL1e.mjs";
+import { n as pickNodePlatformArch, t as readProcessMemory } from "../process-memory-Bd-TuWfM.mjs";
 import * as os$1 from "node:os";
 import * as fs from "node:fs";
 import * as path$1 from "node:path";
@@ -350,84 +350,6 @@ function normalizeEngineNodeId(rawNodeId) {
 	return raw.includes("/") ? raw.split("/")[0] ?? "hub" : raw;
 }
 //#endregion
-//#region src/detection-pipeline/model-bound-device-overrides.ts
-/**
-* Auto tune (D745), the executor leg: list — and optionally remove — the
-* MODEL-BOUND thresholds stored in this addon's per-camera settings (the
-* object-detection root's `bindsToModel` keys and their binding keys, D738).
-* Every other key of a camera's store is kept.
-*
-* The device store only MERGES on write, so a removal is clear + write of the
-* kept keys — the idiom `migrate-hardware-state.ts` uses. Both run in this
-* process, serialized per camera; a write that fails after the clear restores
-* the original row, and the camera is reported `refused` rather than clean. A
-* store that cannot be read is `refused` too: a failed read is never "nothing
-* to clear" (D393).
-*/
-function errMsg(err) {
-	return err instanceof Error ? err.message : String(err);
-}
-/** The stored keys among `boundKeys` (values and bindings), sorted. */
-function presentBoundKeys(row, boundKeys) {
-	return boundKeys.flatMap((k) => [k, modelBindingKey(k)]).filter((k) => k in row).toSorted();
-}
-async function clearModelBoundDeviceOverrides(deps, input) {
-	const ids = input.deviceIds ?? await deps.listDeviceIds();
-	const entries = [];
-	const refused = [];
-	for (const deviceId of [...ids].toSorted((a, b) => a - b)) {
-		let row;
-		try {
-			row = await deps.readDeviceStore(deviceId);
-		} catch (err) {
-			refused.push({
-				deviceId,
-				reason: `read failed: ${errMsg(err)}`
-			});
-			continue;
-		}
-		const keys = presentBoundKeys(row, deps.boundKeys);
-		if (keys.length === 0) continue;
-		if (input.dryRun) {
-			entries.push({
-				deviceId,
-				keys
-			});
-			continue;
-		}
-		const kept = { ...row };
-		for (const k of keys) delete kept[k];
-		try {
-			await deps.clearDeviceStore(deviceId);
-		} catch (err) {
-			refused.push({
-				deviceId,
-				reason: `clear failed: ${errMsg(err)}`
-			});
-			continue;
-		}
-		try {
-			if (Object.keys(kept).length > 0) await deps.writeDeviceStore(deviceId, kept);
-			entries.push({
-				deviceId,
-				keys
-			});
-		} catch (err) {
-			await deps.writeDeviceStore(deviceId, row).catch(() => void 0);
-			refused.push({
-				deviceId,
-				reason: `write failed, row restored: ${errMsg(err)}`
-			});
-		} finally {
-			deps.invalidate(deviceId);
-		}
-	}
-	return {
-		entries,
-		refused
-	};
-}
-//#endregion
 //#region src/detection-pipeline/model-format-facts.ts
 /**
 * Two per-format facts `getSchema` reports beside `downloaded`, for Model
@@ -762,122 +684,6 @@ var ClusterUnknownRefusalLog = class {
 	}
 };
 //#endregion
-//#region src/detection-pipeline/device-override-mirror.ts
-/**
-* The per-device detection overrides, kept fresh OFF the frame path.
-*
-* ## The read this replaces
-*
-* `runPipeline` resolved a device's overrides by calling
-* `settings.readDeviceStore(deviceId)` on **every inference frame**. Measured
-* on the live hub 2026-08-25: `get detection-pipeline:addon-devices`, 1 143
-* calls a minute at 0.44 rows per call — the disk asked, nineteen times a
-* second, whether an operator has ever changed a threshold.
-*
-* ## Why this is not "a cache in the consumer" (D224)
-*
-* D224 forbids a SECOND authority over a fact that belongs to somebody else:
-* the failure it records is a consumer caching a value whose write path does
-* not run through that consumer, so an operator's own change is the one read
-* the cache gets wrong.
-*
-* This addon OWNS the row. `<addonId>:addon-devices` is detection-pipeline's
-* own store, and the only writers are this addon's `updateDeviceSettings` and
-* its `clearDeviceOverrides` — both of which call {@link invalidate}. A write
-* is therefore its own invalidation, exactly as D224 requires, and the window
-* below governs only the case nobody writes through this process.
-*
-* ## The window, declared
-*
-* {@link DEVICE_OVERRIDE_STALE_MS} is what an operator's change costs on a node
-* that did NOT serve the write — this addon runs per node, and a settings write
-* lands on one of them. Thirty seconds is the trade: it removes 99.9% of the
-* reads (one per device per window instead of one per frame) and it is short
-* enough that "I moved the threshold and nothing happened" is not a support
-* question. Ten minutes — {@link OPERATOR_WRITTEN_STALE_MS}, the constant for a
-* cap whose value only an operator changes — is right for a POLLED reader that
-* costs a camera round trip; this read costs one local SQLite `get`, and the
-* cheap read buys a short window.
-*
-* A stale entry is SERVED and revalidated behind the caller, never awaited: a
-* frame that waits for the settings store is a frame the pipeline dropped, and
-* the reader is by definition about to ask again.
-*/
-/**
-* How long a mirrored entry is served before a refresh is started behind the
-* next reader. See the module doc for why it is 30 s and not ten minutes.
-*/
-var DEVICE_OVERRIDE_STALE_MS = 3e4;
-/**
-* How long a FAILED refresh is not retried.
-*
-* A refresh that throws leaves `fetchedAt` where it was, so without a cooldown
-* every subsequent frame would start another one — a broken settings store
-* would be hammered at frame rate by the very mechanism built to stop that.
-*/
-var DEVICE_OVERRIDE_MISS_COOLDOWN_MS = 5e3;
-var DeviceOverrideMirror = class {
-	deps;
-	staleMs;
-	missCooldownMs;
-	entries = /* @__PURE__ */ new Map();
-	/** In-flight reads, so a burst of frames on a cold device costs ONE read and
-	*  not one per frame — the exact failure this class exists to remove. */
-	inFlight = /* @__PURE__ */ new Map();
-	now;
-	constructor(deps, staleMs = DEVICE_OVERRIDE_STALE_MS, missCooldownMs = DEVICE_OVERRIDE_MISS_COOLDOWN_MS) {
-		this.deps = deps;
-		this.staleMs = staleMs;
-		this.missCooldownMs = missCooldownMs;
-		this.now = deps.now ?? (() => Date.now());
-	}
-	/**
-	* The device's overrides.
-	*
-	* COLD awaits — the first frame on a camera has to get the real answer, and a
-	* default is exactly what "the operator lowered this threshold" looks like.
-	* WARM returns immediately, stale or not, and starts the refresh behind the
-	* caller.
-	*/
-	async resolve(deviceId) {
-		const entry = this.entries.get(deviceId);
-		if (entry === void 0) return this.load(deviceId);
-		if (this.now() - entry.fetchedAt >= this.staleMs) this.load(deviceId);
-		return entry.value;
-	}
-	/** Drop a device's entry. Called by every writer in this process, so an
-	*  operator's own change is never served from the mirror. */
-	invalidate(deviceId) {
-		this.entries.delete(deviceId);
-	}
-	invalidateAll() {
-		this.entries.clear();
-	}
-	async load(deviceId) {
-		const pending = this.inFlight.get(deviceId);
-		if (pending !== void 0) return pending;
-		const run = this.deps.read(deviceId).then((value) => {
-			this.entries.set(deviceId, {
-				value,
-				fetchedAt: this.now()
-			});
-			return value;
-		}).catch((err) => {
-			this.deps.onRefreshFailed?.(deviceId, err);
-			const existing = this.entries.get(deviceId);
-			if (existing !== void 0) {
-				existing.fetchedAt = this.now() - this.staleMs + this.missCooldownMs;
-				return existing.value;
-			}
-			return {};
-		}).finally(() => {
-			this.inFlight.delete(deviceId);
-		});
-		this.inFlight.set(deviceId, run);
-		return run;
-	}
-};
-//#endregion
 //#region src/detection-pipeline/engine/pool-worker-health.ts
 /**
 * The one table of load bounds (D653, fix round 1).
@@ -3262,6 +3068,14 @@ var PipelineModelManager = class {
 	}
 };
 //#endregion
+//#region src/detection-pipeline/engine/labels-for-decoder.ts
+/** Labels forwarded to the Python pool — SSD stock Coral keeps COCO-90 in Python. */
+function labelsForDecoder(postprocessor, modelLabels, stepLabels) {
+	if (modelLabels !== void 0 && modelLabels.length > 0) return modelLabels;
+	if (postprocessor === "ssd") return;
+	return stepLabels;
+}
+//#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. */
@@ -3946,7 +3760,9 @@ function buildPoolModelConfigForStep(inputs) {
 	const inputSize = Math.max(inputWidth, inputHeight);
 	const inputChannels = modelEntry.inputChannels ?? 3;
 	const entryLabels = modelEntry.labels.length > 0 ? modelEntry.labels.map((l) => l.id) : void 0;
-	const labels = readModelLabels(modelsDir, modelEntry) ?? entryLabels ?? def.labels;
+	const modelLabels = readModelLabels(modelsDir, modelEntry) ?? entryLabels;
+	const effectivePostprocessor = resolveEffectivePostprocessorForEntry(def, modelEntry);
+	const labels = labelsForDecoder(effectivePostprocessor, modelLabels, def.labels);
 	return {
 		path: modelPath,
 		inputSize,
@@ -3957,7 +3773,7 @@ function buildPoolModelConfigForStep(inputs) {
 		inputNormalization: modelEntry.inputNormalization,
 		outputProbabilities: modelEntry.outputProbabilities,
 		...modelEntry.gpuInferencePrecision !== void 0 ? { gpuInferencePrecision: modelEntry.gpuInferencePrecision } : {},
-		postprocessor: resolveEffectivePostprocessorForEntry(def, modelEntry),
+		postprocessor: effectivePostprocessor,
 		confidence: resolvePoolConfidenceFloor(stepId, resolveModelDefaultConfidence(def, modelEntry)),
 		nmsIouThreshold: resolvePoolDecodeSettings({
 			def,
@@ -4222,6 +4038,29 @@ function benchmarkKeyOf(deviceKey) {
 function isBenchmarkRun(input) {
 	return input.frame === void 0 && input.frameRef === void 0 && input.deviceId === void 0 && input.replay !== true;
 }
+/**
+* Backends whose device opens in ONE process at a time. libedgetpu holds an
+* Edge TPU exclusively for the process that opened it, so a second pool on a
+* Coral the cameras' pool already holds cannot open it at all — every
+* benchmark and auto-benchmark (D913) of an in-use Coral failed that way on
+* the dev hub (1.2.619). Every other backend this node builds (OpenVINO,
+* CoreML, CUDA, ONNX, CPU) shares its device between processes.
+*/
+var EXCLUSIVE_BACKENDS = new Set(["edgetpu"]);
+/** True when the device behind `deviceKey` (`<backend>:<device>`) cannot be opened by a second pool. */
+function isExclusiveDevice(deviceKey) {
+	const colon = deviceKey.indexOf(":");
+	const backend = colon >= 0 ? deviceKey.slice(0, colon) : deviceKey;
+	return EXCLUSIVE_BACKENDS.has(backend);
+}
+/**
+* A benchmark on an EXCLUSIVE device is the one benchmark that goes to the
+* live pool: the separate pool could not open the device, so the choice is
+* between measuring through the cameras' pool and not measuring at all.
+*/
+function benchmarkPlacementOf(benchmark, deviceKey) {
+	return benchmark && !isExclusiveDevice(deviceKey) ? "benchmark-pool" : "live-pool";
+}
 var BenchmarkPools = class {
 	options;
 	pools = /* @__PURE__ */ new Map();
@@ -4802,14 +4641,15 @@ var PRIMARY_ROOT_STEP = "object-detection";
 /**
 * The same rule over an EXECUTABLE tree's roots (D658): their model ids are the
 * pool variants that will run — after resolution, per-step loads and drops —
-* so this is what a live `runPipeline` stamps. The tree holds only enabled
-* video roots already.
-*/
-function resolveTreeRootModelId(roots) {
-	return primaryRootModelId(roots);
-}
-function primaryRootModelId(roots) {
-	return (roots.find((s) => s.stepId === PRIMARY_ROOT_STEP) ?? roots[0])?.modelId;
+* so this is what a live `runPipeline` stamps, with the root's step id beside
+* the model (D925). The tree holds only enabled video roots already.
+*/
+function resolveTreeRoot(roots) {
+	const root = roots.find((s) => s.stepId === PRIMARY_ROOT_STEP) ?? roots[0];
+	return root === void 0 ? void 0 : {
+		stepId: root.stepId,
+		modelId: root.modelId
+	};
 }
 //#endregion
 //#region src/detection-pipeline/engine-provisioner.ts
@@ -7189,7 +7029,7 @@ var PipelineExecutor = class {
 								rootStepId: rootStep.stepId,
 								parentClass: mutable.macroClass,
 								parentScore: mutable.score,
-								error: errMsg$1(err)
+								error: errMsg(err)
 							}
 						});
 					}
@@ -7320,7 +7160,7 @@ var PipelineExecutor = class {
 							rootStepId: rootStep.stepId,
 							parentClass: mutable.macroClass,
 							parentScore: mutable.score,
-							error: errMsg$1(err)
+							error: errMsg(err)
 						}
 					});
 				}
@@ -7419,7 +7259,7 @@ var PipelineExecutor = class {
 				]
 			};
 		} catch (err) {
-			this.throttledWarn(`crop-zone-prep:${deviceId}`, 3e4, "crop-zone frame preparation failed — running package-detection full-frame", { error: errMsg$1(err) }, deviceId);
+			this.throttledWarn(`crop-zone-prep:${deviceId}`, 3e4, "crop-zone frame preparation failed — running package-detection full-frame", { error: errMsg(err) }, deviceId);
 			return null;
 		}
 	}
@@ -7431,7 +7271,7 @@ var PipelineExecutor = class {
 		try {
 			engineOutput = await step.engine.infer(input);
 		} catch (err) {
-			const errorMsg = errMsg$1(err);
+			const errorMsg = errMsg(err);
 			const errorOutput = {
 				kind: "detections",
 				detections: []
@@ -7718,7 +7558,7 @@ var PipelineExecutor = class {
 				this.throttledWarn(`child-fail:${child.stepId}:${deviceId}`, 15e3, "pipeline child step failed", {
 					step: child.stepId,
 					model: child.modelId,
-					error: errMsg$1(err)
+					error: errMsg(err)
 				}, deviceId);
 			}
 		}
@@ -7865,16 +7705,6 @@ function collectSchemaDefaults(schema) {
 	walkFieldsForDefaults(schema, out);
 	return out;
 }
-/**
-* 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) {
@@ -8563,7 +8393,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	* node-default tree against `this.currentEngine.format`. Recomputed
 	* EAGERLY by {@link recomputeConfigIssues} whenever the engine actually
 	* changes (see `onEngineSelectionChanged`), rather than relying on a
-	* `getGlobalSteps()` call that may never happen on a camera-only node.
+	* `nodeDefaultSteps()` call that may never happen on a camera-only node.
 	* Merged into {@link getEngineProvisioning}'s snapshot; never consulted by
 	* `assertEngineReady` — this gate SURFACES, it does not block inference.
 	*/
@@ -8665,20 +8495,6 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	readStore;
 	/** Write a patch to the addon settings store. */
 	writeStore;
-	/** Read per-device settings. */
-	readDeviceStore;
-	/** Delete all per-device settings for a device (used by `clearDeviceOverrides`). */
-	clearDeviceStore;
-	/** Merge a patch into one device's settings (Auto tune' keep-the-rest rewrite, D745). */
-	writeDeviceStore;
-	/**
-	* The per-device overrides the FRAME path reads, kept fresh off that path.
-	*
-	* Public so the addon class can drop a device on its own
-	* `updateDeviceSettings` — the write and the mirror have to be the same
-	* process's, or the mirror becomes the second authority D224 forbids.
-	*/
-	deviceOverrides;
 	constructor(settings, modelsDir, logger, eventBus = null, detectionConfigSchemaSource = null, executorOptions = {}) {
 		this.modelsDir = modelsDir;
 		this.eventBus = eventBus;
@@ -8687,18 +8503,6 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 		this.log = logger;
 		this.readStore = () => settings.readAddonStore();
 		this.writeStore = (patch) => settings.writeAddonStore(patch);
-		this.readDeviceStore = settings.readDeviceStore ?? (async () => ({}));
-		const clearDeviceStore = settings.clearDeviceStore;
-		this.clearDeviceStore = clearDeviceStore ? (deviceId) => clearDeviceStore.call(settings, deviceId) : async () => void 0;
-		const writeDeviceStore = settings.writeDeviceStore;
-		this.writeDeviceStore = writeDeviceStore ? (deviceId, patch) => writeDeviceStore.call(settings, deviceId, patch) : async () => void 0;
-		this.deviceOverrides = new DeviceOverrideMirror({
-			read: (deviceId) => this.readDeviceStore(deviceId),
-			onRefreshFailed: (deviceId, err) => this.log.warn("per-device detection overrides refresh failed — serving the last value", {
-				tags: { deviceId },
-				meta: { error: errMsg$1(err) }
-			})
-		});
 		this.currentEngine = ONNX_FLOOR;
 		this.log.info("Engine pick pending (placeholder until probe / persisted selection)", { meta: {
 			runtime: this.currentEngine.runtime,
@@ -8722,7 +8526,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 				stale: report.stale
 			} });
 		}, (err) => {
-			this.log.warn("Model revision check failed — copies are proven on their next download", { meta: { error: errMsg$1(err) } });
+			this.log.warn("Model revision check failed — copies are proven on their next download", { meta: { error: errMsg(err) } });
 		});
 	}
 	/**
@@ -8832,14 +8636,14 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 			else this.log.warn("platform-probe readiness gate timed out — conservative engine pick (floor is not persisted)", { meta: {
 				nodeId,
 				timeoutMs: PROBE_READY_TIMEOUT_MS,
-				error: errMsg$1(err)
+				error: errMsg(err)
 			} });
 		}
 		await this.resolveAutoEngine();
 		this.needsAutoPick = false;
 		this.startProvisioningForCurrentEngine();
 		await this.recomputeConfigIssues().catch((err) => {
-			this.log.warn("config-issue recompute failed after node-default derive", { meta: { error: errMsg$1(err) } });
+			this.log.warn("config-issue recompute failed after node-default derive", { meta: { error: errMsg(err) } });
 		});
 	}
 	/**
@@ -9001,7 +8805,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	* the node-default step tree for `this.currentEngine.format` and compute
 	* human-readable config issues from the result:
 	*   - model substitutions (`getActiveModelSubstitutions()`, populated as a
-	*     side effect of the `getGlobalSteps()` re-resolve below) — a step's
+	*     side effect of the `nodeDefaultSteps()` re-resolve below) — a step's
 	*     chosen model lacks a build for this format, so the format default
 	*     runs instead (degraded but loadable).
 	*   - zero-build steps (`collectZeroBuildIssues`) — a step whose FULL
@@ -9016,7 +8820,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	async recomputeConfigIssues() {
 		this.configIssues = [];
 		try {
-			const steps = await this.getGlobalSteps();
+			const steps = await this.nodeDefaultSteps();
 			if (!steps) return;
 			const format = this.currentEngine.format;
 			const substitutionIssues = this.getActiveModelSubstitutions().map((s) => `${s.addonId}: chose ${s.chosen}, running ${s.running} (${s.format})`);
@@ -9024,7 +8828,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 			this.configIssues = [...substitutionIssues, ...zeroBuildIssues];
 		} catch (err) {
 			this.configIssues = [];
-			this.log.warn("engine-change config gate failed — no config issues surfaced", { meta: { error: errMsg$1(err) } });
+			this.log.warn("engine-change config gate failed — no config issues surfaced", { meta: { error: errMsg(err) } });
 		}
 	}
 	/**
@@ -9064,7 +8868,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	* `format` for the download fan-out.
 	*/
 	async ensureModelsForCurrentSteps(format) {
-		const steps = await this.getGlobalSteps();
+		const steps = await this.nodeDefaultSteps();
 		if (!steps || steps.length === 0) return;
 		for (const step of flattenSteps(steps)) {
 			if (!step.enabled) continue;
@@ -9237,10 +9041,6 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 			defaultDevice: e.engine.device
 		};
 	}
-	async getDefaultSteps(engine) {
-		const detectionModelId = resolveDefaultDetectionModel(engine.backend, engine.device ?? null, engine.format);
-		return buildDefaultStepTree(engine.format, detectionModelId);
-	}
 	/**
 	* Resolve every step's model for this node's engine format via the shared
 	* `resolveModelForFormat`, and surface any substitution. `step.engine?.format`
@@ -9283,18 +9083,19 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 		return [...this.modelSubstitutions.values()];
 	}
 	/**
-	* PURE node-default step tree — computed on demand, never persisted.
+	* PURE node-default step tree — computed on demand, never persisted, and
+	* PRIVATE (D927): it is not the model any camera ran, so no caller outside
+	* this provider may read it. It serves Gate A's config-issue probe and the
+	* engine provisioning's model download.
 	*
 	* The object-detection default is hardware-aware (this node's resolved
 	* backend + device via `resolveDefaultDetectionModel`); every other step
 	* keeps its flat per-format default. The result is cached in
 	* `currentSteps` only as a memo — the cache is dropped whenever the
 	* engine (hence model format) changes, so a re-read always reflects the
-	* live engine. Nothing in the live per-camera dispatch path reads this:
-	* it exists as the benchmark fallback (empty input steps), the Gate-A
-	* config-issue probe, and the "effective post-reset model" probe.
+	* live engine.
 	*/
-	async getGlobalSteps() {
+	async nodeDefaultSteps() {
 		if (this.currentSteps) return this.currentSteps;
 		const detectionModelId = resolveDefaultDetectionModel(this.currentEngine.backend, this.currentEngine.device ?? null, this.currentEngine.format);
 		const defaults = buildDefaultStepTree(this.currentEngine.format, detectionModelId);
@@ -9302,10 +9103,6 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 		this.currentSteps = this.resolveStepModels(defaults);
 		return this.currentSteps;
 	}
-	async getGlobalPipelineConfig() {
-		if (!this.currentSteps) return null;
-		return stepsToPipelineConfig(this.currentSteps, this.currentEngine);
-	}
 	/**
 	* Task G5 (Gate B) — pre-init config-correctness gate. PURE COMPUTE
 	* against `this.currentEngine.format`: resolves `steps` the same way the
@@ -9349,7 +9146,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 					issues: [{
 						addonId: "*",
 						kind: "unknown-device",
-						detail: errMsg$1(err)
+						detail: errMsg(err)
 					}],
 					substitutions: [],
 					format
@@ -9376,7 +9173,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 				format
 			};
 		} catch (err) {
-			this.log.warn("validatePipeline failed — reporting a clean result", { meta: { error: errMsg$1(err) } });
+			this.log.warn("validatePipeline failed — reporting a clean result", { meta: { error: errMsg(err) } });
 			return {
 				ok: true,
 				issues: [],
@@ -9568,7 +9365,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 				durationMs
 			};
 		} catch (err) {
-			const msg = errMsg$1(err);
+			const msg = errMsg(err);
 			this.log.error("Model download failed", { meta: {
 				error: msg,
 				modelId,
@@ -9888,7 +9685,9 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 		this.executor = executor;
 		const dispatchEngine = dispatchDeviceKey ? resolveDeviceEngine(dispatchDeviceKey) : runEngine;
 		const benchmark = isBenchmarkRun(input);
-		const dispatchFactory = benchmark ? await this.benchmarkPools.acquire(deviceKeyOf(dispatchEngine), dispatchEngine) : dispatchDeviceKey ? await this.resolveDeviceFactory(dispatchDeviceKey) : this.engineFactory;
+		const placement = benchmarkPlacementOf(benchmark, deviceKeyOf(dispatchEngine));
+		if (benchmark && placement === "live-pool") this.log.info("Benchmark on an exclusive device — served by the live pool", { meta: { deviceKey: deviceKeyOf(dispatchEngine) } });
+		const dispatchFactory = placement === "benchmark-pool" ? await this.benchmarkPools.acquire(deviceKeyOf(dispatchEngine), dispatchEngine) : dispatchDeviceKey ? await this.resolveDeviceFactory(dispatchDeviceKey) : this.engineFactory;
 		const needed = enabledSteps.filter((s) => dispatchFactory.needsPoolUpdate(s));
 		let runSteps = benchmarkSteps;
 		const loadPolicy = dispatchLoadPolicyOf(input);
@@ -9926,24 +9725,24 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 					...input.deviceId !== void 0 ? { deviceId: input.deviceId } : {},
 					deviceKey: dispatchDeviceKeyLabel,
 					outcome: "step-dropped"
-				}, dispatchDeviceKeyLabel, [model], model, "not-warm", errMsg$1(failure.error));
+				}, dispatchDeviceKeyLabel, [model], model, "not-warm", errMsg(failure.error));
 			}
 		}
-		const rootModelId = resolveTreeRootModelId(tree.roots);
+		const treeRoot = resolveTreeRoot(tree.roots);
 		const rootDeviceKey = deviceKeyOf(dispatchEngine);
-		const stampRoot = (r) => rootModelId === void 0 ? {
+		const stampRoot = (r) => treeRoot === void 0 ? {
 			...r,
 			rootDeviceKey
 		} : {
 			...r,
-			rootModelId,
+			rootModelId: treeRoot.modelId,
+			rootStepId: treeRoot.stepId,
 			rootDeviceKey
 		};
 		if (input.replay !== true) this.clusterModelSwitchLog.note(input.deviceId ?? 0, tree);
 		setupMs = performance.now() - wallT0 - decodeMs;
 		const effectiveDeviceId = input.deviceId ?? 0;
-		const deviceOverrides = effectiveDeviceId > 0 ? await this.deviceOverrides.resolve(effectiveDeviceId) : {};
-		const effectiveTree = Object.keys(deviceOverrides).length > 0 ? applyDeviceOverridesToTree(tree, "object-detection", deviceOverrides) : tree;
+		const effectiveTree = tree;
 		const nativeCropProvider = this.buildNativeCropProviderFromRef(input.nativeCropRef) ?? this.buildNativeFaceCropProvider(input.frameHandle);
 		let cropZoneBbox;
 		if (appliesCameraGates && effectiveDeviceId > 0 && effectiveTree.roots.some((r) => r.definition.extractMode === "crop-zone")) {
@@ -10339,7 +10138,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 				...tags,
 				meta: {
 					deviceKey,
-					error: errMsg$1(err)
+					error: errMsg(err)
 				}
 			});
 		});
@@ -10376,7 +10175,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 				throw err;
 			}
 			const failed = failedModelOf(err) ?? models[0] ?? "";
-			this.reportDispatchLoadLoss(context, deviceKey, models, failed, `failed:${flight.generation ?? "unknown"}`, errMsg$1(err));
+			this.reportDispatchLoadLoss(context, deviceKey, models, failed, `failed:${flight.generation ?? "unknown"}`, errMsg(err));
 			throw err;
 		}
 	}
@@ -10473,13 +10272,13 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 		const poolModel = err instanceof StepVariantLoadError ? err.poolModel : null;
 		let generation = 0;
 		for (const model of failedModels) {
-			const outcome = this.loadGovernor.recordFailure(pool, deviceKey, model, errMsg$1(err), compileTimeout, Date.now(), poolModel, err instanceof StepVariantLoadError ? err.reason : null);
+			const outcome = this.loadGovernor.recordFailure(pool, deviceKey, model, errMsg(err), compileTimeout, Date.now(), poolModel, err instanceof StepVariantLoadError ? err.reason : null);
 			generation = outcome.generation;
 			if (outcome.refusedNow) this.log.error("model REFUSED on this device — its compile timed out repeatedly", { meta: {
 				deviceKey,
 				model,
 				compileTimeouts: outcome.compileTimeouts,
-				error: errMsg$1(err),
+				error: errMsg(err),
 				device: "keeps serving every other model",
 				rearm: "pipelineExecutor.rearmInferenceDevice"
 			} });
@@ -10540,7 +10339,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 			this.log.info("Model downloaded successfully", { meta: { modelId: entry.id } });
 			return;
 		} catch (err) {
-			const msg = errMsg$1(err);
+			const msg = errMsg(err);
 			if (attempt < maxRetries) {
 				const delayMs = 2e3 * Math.pow(2, attempt - 1);
 				this.log.warn("Model download failed — retrying", { meta: {
@@ -10616,7 +10415,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 		try {
 			return await this.runPipelineBatchImpl(input);
 		} catch (err) {
-			const msg = errMsg$1(err);
+			const msg = errMsg(err);
 			const stack = err instanceof Error ? err.stack : void 0;
 			this.log.error("runPipelineBatch failed", { meta: {
 				phase: "batch",
@@ -10901,9 +10700,9 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 					deviceKey: defaultDeviceKey,
 					backend: this.currentEngine.backend,
 					device: this.currentEngine.device ?? null,
-					error: errMsg$1(err)
+					error: errMsg(err)
 				} });
-				this.noteDeviceDeath(defaultDeviceKey, errMsg$1(err));
+				this.noteDeviceDeath(defaultDeviceKey, errMsg(err));
 				throw err;
 			}
 			this.engineFactory = factory;
@@ -11165,7 +10964,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 			await factory.dispose().catch(() => void 0);
 			this.log.error("Benchmark pool failed to initialize", { meta: {
 				deviceKey,
-				error: errMsg$1(err)
+				error: errMsg(err)
 			} });
 			throw err;
 		}
@@ -11212,7 +11011,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 					error: err instanceof Error ? err.message : String(err)
 				} });
 				await factory.dispose().catch(() => void 0);
-				this.noteDeviceDeath(deviceKey, errMsg$1(err));
+				this.noteDeviceDeath(deviceKey, errMsg(err));
 				throw err;
 			}
 			this.factoriesByDevice.set(deviceKey, factory);
@@ -11278,102 +11077,6 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 		this.log.info("videoPipelineSteps updated", { meta: { addons: Object.keys(sanitized).length } });
 		return { success: true };
 	}
-	/**
-	* Clear THIS node's executor-side PER-DEVICE settings stores — the
-	* per-camera step overrides the object-detection root reads via
-	* `applyDeviceOverridesToTree`.
-	*
-	* Node-routed (the cap's default `nodeIdMode: 'routing'`): the generated
-	* cap-router strips `nodeId` and dispatches to the target node, so this
-	* method runs ON the node being cleared and takes no argument.
-	*
-	* This is the slimmed executor leg of the orchestrator's
-	* `resetNodePipelineDefaults` flow. The legacy `resetToDefault` — which
-	* also reset a persisted GLOBAL step-tree seed nothing in the live
-	* per-camera path read — was removed together with that seed
-	* (`getGlobalSteps` is pure now, so there is nothing node-global left to
-	* reset here).
-	*
-	* Idempotent: clearing already-empty per-device stores is a no-op.
-	*/
-	async clearDeviceOverrides() {
-		const clearedDevices = await this.clearAllDeviceOverrides();
-		this.log.info("executor per-device overrides cleared", { meta: { clearedDevices } });
-		return {
-			success: true,
-			clearedDevices
-		};
-	}
-	/**
-	* Auto tune (D745): list — or, unless `dryRun`, remove — the model-bound
-	* thresholds of the per-camera detector store. See
-	* `model-bound-device-overrides.ts`.
-	*/
-	async clearModelBoundDeviceOverrides(input) {
-		const result = await clearModelBoundDeviceOverrides({
-			listDeviceIds: async () => {
-				const api = this.addonCtx?.api;
-				if (!api) throw new Error("clearModelBoundDeviceOverrides: ctx.api unavailable");
-				return (await api.deviceManager.listAll.query({ projection: "slim" })).map((d) => d.id);
-			},
-			readDeviceStore: (deviceId) => this.readDeviceStore(deviceId),
-			clearDeviceStore: (deviceId) => this.clearDeviceStore(deviceId),
-			writeDeviceStore: (deviceId, patch) => this.writeDeviceStore(deviceId, patch),
-			invalidate: (deviceId) => this.deviceOverrides.invalidate(deviceId),
-			boundKeys: collectModelBoundKeys(getStep("object-detection").getConfigSchema())
-		}, input);
-		if (!input.dryRun) for (const entry of result.entries) this.log.info("auto tune: per-camera detector thresholds cleared", {
-			tags: { deviceId: entry.deviceId },
-			meta: {
-				deviceId: entry.deviceId,
-				keys: entry.keys
-			}
-		});
-		for (const r of result.refused) this.log.warn("auto tune: per-camera detector thresholds not cleared", {
-			tags: { deviceId: r.deviceId },
-			meta: {
-				deviceId: r.deviceId,
-				reason: r.reason,
-				dryRun: input.dryRun
-			}
-		});
-		return result;
-	}
-	/**
-	* Clear the per-device pipeline-step overrides for every known device.
-	* Returns the count of devices whose store was cleared. There is no
-	* bulk-list primitive over the per-device store, so devices are
-	* enumerated via the device-manager and cleared one by one
-	* (`clearDeviceStore` is idempotent — a device with no overrides is a
-	* no-op). Never throws: a device-manager outage degrades to "cleared
-	* nothing" so the reset flow still completes.
-	*/
-	async clearAllDeviceOverrides() {
-		const api = this.addonCtx?.api;
-		if (!api) return 0;
-		let devices = [];
-		try {
-			devices = await api.deviceManager.listAll.query({ projection: "slim" });
-		} catch (err) {
-			this.log.warn("clearDeviceOverrides: device enumeration failed — skipping per-device clear", { meta: { error: errMsg$1(err) } });
-			return 0;
-		}
-		let cleared = 0;
-		for (const device of devices) try {
-			await this.clearDeviceStore(device.id);
-			this.deviceOverrides.invalidate(device.id);
-			cleared++;
-		} catch (err) {
-			this.log.warn("clearDeviceOverrides: failed to clear per-device overrides for device", {
-				tags: { deviceId: device.id },
-				meta: {
-					deviceId: device.id,
-					error: errMsg$1(err)
-				}
-			});
-		}
-		return cleared;
-	}
 	async listLoadedEngines() {
 		const out = [];
 		if (this.engineFactory) {
@@ -11560,7 +11263,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 				frame
 			};
 		} catch (err) {
-			const msg = errMsg$1(err);
+			const msg = errMsg(err);
 			this.log.error("failed", { meta: {
 				phase: "audio-test",
 				error: msg
@@ -11620,7 +11323,6 @@ function buildSchemaSlots(formats, modelsDir, customByStep) {
 			defaultModelId: step.defaultModelId,
 			...step.defaultModelIdByFormat ? { defaultModelIdByFormat: { ...step.defaultModelIdByFormat } } : {},
 			...step.enabledByDefault !== void 0 ? { enabledByDefault: step.enabledByDefault } : {},
-			...step.backfillIntoExistingOverrides !== void 0 ? { backfillIntoExistingOverrides: step.backfillIntoExistingOverrides } : {},
 			defaultConfidence: step.defaultConfidence,
 			...step.group ? { group: step.group } : {},
 			...configSchemaWithRoots.length > 0 ? { configSchema: configSchemaWithRoots } : {}
@@ -11668,7 +11370,7 @@ function resolveChildSlots(slot) {
 }
 /**
 * V2 default: the node-default step tree (never persisted — see
-* `getGlobalSteps`). The core detection + recognition steps are enabled; every
+* `nodeDefaultSteps`). 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).
@@ -11710,27 +11412,6 @@ function buildDefaultStepTree(format, objectDetectionModelId) {
 	if (audioStep) steps.push(audioStep);
 	return steps;
 }
-function stepsToPipelineConfig(steps, engine) {
-	const toNode = (step) => ({
-		step: step.addonId,
-		addon: step.addonId,
-		configOverride: {
-			modelId: step.modelId,
-			...step.settings
-		},
-		children: step.children.map(toNode)
-	});
-	const videoSteps = steps.filter((s) => s.slot !== "audio-classifier");
-	const audioStep = steps.find((s) => s.slot === "audio-classifier" && s.enabled);
-	return {
-		engine,
-		video: videoSteps.map(toNode),
-		...audioStep ? {
-			audio: toNode(audioStep),
-			audioEngine: engine
-		} : {}
-	};
-}
 /** Flatten a step tree into a flat list (DFS) — delegates to shared utility. */
 function flattenSteps(steps) {
 	return flattenEnabledVideoSteps(steps);
@@ -11791,22 +11472,6 @@ function availableFormatsForStep(addonId) {
 		return [];
 	}
 }
-/**
-* 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. 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,
-			...resolveOperatorSettingsForModel(rootStepId, overrides, root.modelId)
-		}
-	} : root) };
-}
 //#endregion
 //#region src/detection-pipeline/python-readiness.ts
 /**
@@ -11921,20 +11586,6 @@ function isProfileSliderKey(key) {
 }
 var DetectionPipelineAddon = class extends BaseAddon {
 	provider = null;
-	/**
-	* An operator's own write drops the mirror the frame path reads.
-	*
-	* This override is the half of `device-override-mirror.ts` that keeps it from
-	* being the second authority D224 forbids: `BaseAddon.updateDeviceSettings`
-	* writes THIS addon's `<addonId>:addon-devices` row, so the write and the
-	* mirror are in one process and the write invalidates. Without it the
-	* operator's own change would be the one read the mirror got wrong, which is
-	* the exact failure D224 records.
-	*/
-	async updateDeviceSettings(deviceId, patch) {
-		await super.updateDeviceSettings(deviceId, patch);
-		this.provider?.deviceOverrides.invalidate(deviceId);
-	}
 	/** Last non-null probed hardware PER NODE — reused when the probe transiently
 	*  returns null so offered backends / device lists don't collapse. Keyed by
 	*  node because the hub addon probes other nodes when serving their config.