@camstack/addon-pipeline 1.2.621 → 1.2.623

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-ClkumZgv.js");
-const require_node = require("../node-0O_61WVW.js");
-const require_custom_model_catalog = require("../custom-model-catalog-Il8UY4D4.js");
+const require_dist = require("../dist-BVo3wa7s.js");
+const require_node = require("../node-DqLsuN_A.js");
+const require_custom_model_catalog = require("../custom-model-catalog-BTBdgN2p.js");
 const require_lazy_sharp = require("../lazy-sharp-BuwKlQLR.js");
-const require_process_memory = require("../process-memory-DdIOhjYB.js");
+const require_process_memory = require("../process-memory-DyxG-0mG.js");
 let node_os = require("node:os");
 node_os = require_chunk.__toESM(node_os);
 let node_fs = require("node:fs");
@@ -357,84 +357,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, require_dist.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
@@ -769,122 +691,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).
@@ -3269,6 +3075,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. */
@@ -3953,7 +3767,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,
@@ -3964,7 +3780,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, require_custom_model_catalog.resolveModelDefaultConfidence(def, modelEntry)),
 		nmsIouThreshold: resolvePoolDecodeSettings({
 			def,
@@ -4229,6 +4045,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();
@@ -4809,14 +4648,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
@@ -7872,16 +7712,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 require_dist.applyModelBoundSettings(settings, require_dist.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) {
@@ -8570,7 +8400,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.
 	*/
@@ -8672,20 +8502,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;
@@ -8694,18 +8510,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: require_dist.errMsg(err) }
-			})
-		});
 		this.currentEngine = ONNX_FLOOR;
 		this.log.info("Engine pick pending (placeholder until probe / persisted selection)", { meta: {
 			runtime: this.currentEngine.runtime,
@@ -9008,7 +8812,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
@@ -9023,7 +8827,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})`);
@@ -9071,7 +8875,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;
@@ -9244,10 +9048,6 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 			defaultDevice: e.engine.device
 		};
 	}
-	async getDefaultSteps(engine) {
-		const detectionModelId = require_custom_model_catalog.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`
@@ -9290,18 +9090,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 = require_custom_model_catalog.resolveDefaultDetectionModel(this.currentEngine.backend, this.currentEngine.device ?? null, this.currentEngine.format);
 		const defaults = buildDefaultStepTree(this.currentEngine.format, detectionModelId);
@@ -9309,10 +9110,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
@@ -9895,7 +9692,9 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 		this.executor = executor;
 		const dispatchEngine = dispatchDeviceKey ? require_custom_model_catalog.resolveDeviceEngine(dispatchDeviceKey) : runEngine;
 		const benchmark = isBenchmarkRun(input);
-		const dispatchFactory = benchmark ? await this.benchmarkPools.acquire(require_custom_model_catalog.deviceKeyOf(dispatchEngine), dispatchEngine) : dispatchDeviceKey ? await this.resolveDeviceFactory(dispatchDeviceKey) : this.engineFactory;
+		const placement = benchmarkPlacementOf(benchmark, require_custom_model_catalog.deviceKeyOf(dispatchEngine));
+		if (benchmark && placement === "live-pool") this.log.info("Benchmark on an exclusive device — served by the live pool", { meta: { deviceKey: require_custom_model_catalog.deviceKeyOf(dispatchEngine) } });
+		const dispatchFactory = placement === "benchmark-pool" ? await this.benchmarkPools.acquire(require_custom_model_catalog.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);
@@ -9936,21 +9735,21 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 				}, dispatchDeviceKeyLabel, [model], model, "not-warm", require_dist.errMsg(failure.error));
 			}
 		}
-		const rootModelId = resolveTreeRootModelId(tree.roots);
+		const treeRoot = resolveTreeRoot(tree.roots);
 		const rootDeviceKey = require_custom_model_catalog.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")) {
@@ -11285,102 +11084,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: require_dist.collectModelBoundKeys(require_custom_model_catalog.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: require_dist.errMsg(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: require_dist.errMsg(err)
-				}
-			});
-		}
-		return cleared;
-	}
 	async listLoadedEngines() {
 		const out = [];
 		if (this.engineFactory) {
@@ -11627,7 +11330,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 } : {}
@@ -11675,7 +11377,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).
@@ -11717,27 +11419,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);
@@ -11798,22 +11479,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
 /**
@@ -11928,20 +11593,6 @@ function isProfileSliderKey(key) {
 }
 var DetectionPipelineAddon = class extends require_dist.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.