@camstack/types 1.2.403 → 1.2.405

package/dist/index.js

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_sleep = require("./sleep-Ch67uumJ.js");
-const require_event_category = require("./event-category-7AwNbPjm.js");
+const require_sleep = require("./sleep-BKS4OPMo.js");
+const require_event_category = require("./event-category-CXrwjC3e.js");
 const require_composition = require("./composition-eoYYVfOp.js");
 const require_node_color = require("./node-color.js");
 const require_err_msg = require("./err-msg-BhVbr0NX.js");
@@ -2288,13 +2288,22 @@ var BirthDecisionRecordSchema = zod.z.object({
 	decidedByBirthEvidence: zod.z.boolean(),
 	/** Best class-compatible crop score, or `null` when nothing compatible was
 	*  found — deliberately not 0, which would be a measurement that never was.
-	*  Includes a box the detector's own per-class floor refused (reason
-	*  `below-detector-floor`, D922): that box never confirms, but it is the
-	*  score the crop really held. */
+	*  Includes a box the detector's own per-class floor refused (D922): since
+	*  D925 the gate's bar, not that floor, decides whether it confirms. */
 	bestScore: zod.z.number().nullable(),
 	/** The bar this candidate actually faced (the phantom-cell hook may raise it). */
 	appliedMinConfidence: zod.z.number().nullable(),
 	/**
+	* The detector the gate re-judged the birth WITH (D925): the session's own
+	* root model, inference-device pool and node — never a node default. `null`
+	* when the frame named no session detector or no gate ran, and on rows
+	* written before D925. A `session-device-unavailable` row names the session
+	* detector that could not be reached.
+	*/
+	detectorModelId: zod.z.string().nullable().default(null),
+	detectorDeviceKey: zod.z.string().nullable().default(null),
+	detectorNodeId: zod.z.string().nullable().default(null),
+	/**
 	* The track's own `firstSeen` — the candidate's first frame, which is where
 	* the timeline starts. `null` for a suppressed birth, which has no track.
 	*/
@@ -5416,6 +5425,27 @@ function pickClosestResolution(entries, target) {
 	}])].sort((a, b) => compareToTarget(a.pixels, b.pixels, targetPixels))[0]?.entry;
 }
 //#endregion
+//#region src/types/agent-pipeline-settings.ts
+/**
+* Is `key` a step setting that only the accelerator running the model may
+* carry (D927)? A model id, a model binding (`<key>ModelId`, D738) or a
+* confidence floor (`minConfidence*` — every `bindsToModel` field). A camera
+* layer never stores one: the floor of one model is wrong on the next, and a
+* camera does not know which accelerator — or which model — it lands on.
+* (Per-camera thresholds are a possible future extension, see D927.)
+*/
+function isModelScopedStepSettingKey(key) {
+	return key === "modelId" || key.endsWith("ModelId") || key.startsWith("minConfidence");
+}
+/** The keys of `bag` a camera layer may not carry ({@link isModelScopedStepSettingKey}), sorted. */
+function modelScopedStepSettingKeys(bag) {
+	return Object.keys(bag).filter(isModelScopedStepSettingKey).toSorted();
+}
+/** `bag` without its model-scoped keys — what a camera layer contributes at dispatch. Fresh object. */
+function cameraScopedStepSettings(bag) {
+	return Object.fromEntries(Object.entries(bag).filter(([key]) => !isModelScopedStepSettingKey(key)));
+}
+//#endregion
 //#region src/types/appearance.ts
 /**
 * A model-free appearance descriptor of one detection box (D683 §8).
@@ -12853,7 +12883,7 @@ function kindOfValue(value) {
 function only(kind) {
 	return new Set([kind]);
 }
-function union(...sets) {
+function union$1(...sets) {
 	return new Set(sets.flatMap((s) => [...s]));
 }
 function withoutNull(set) {
@@ -12881,8 +12911,8 @@ function callKinds(callee, args) {
 	const rule = BUILTIN_RESULT_KINDS[callee];
 	if (rule === void 0) throw new KindInferenceError(`no result-kind rule for builtin '${callee}'`);
 	if (rule.kind === "fixed") return new Set(rule.result);
-	const nonNull = union(...args.map(withoutNull));
-	return args.every((a) => a.has("null")) ? union(nonNull, only("null")) : nonNull;
+	const nonNull = union$1(...args.map(withoutNull));
+	return args.every((a) => a.has("null")) ? union$1(nonNull, only("null")) : nonNull;
 }
 function kindsOf(node, bindings) {
 	switch (node.kind) {
@@ -12895,8 +12925,8 @@ function kindsOf(node, bindings) {
 		}
 		case "unary": return only(node.op === "!" ? "boolean" : "number");
 		case "binary": return binaryKinds(node.op, kindsOf(node.left, bindings), kindsOf(node.right, bindings));
-		case "logical": return union(kindsOf(node.left, bindings), kindsOf(node.right, bindings));
-		case "conditional": return union(kindsOf(node.consequent, bindings), kindsOf(node.alternate, bindings));
+		case "logical": return union$1(kindsOf(node.left, bindings), kindsOf(node.right, bindings));
+		case "conditional": return union$1(kindsOf(node.consequent, bindings), kindsOf(node.alternate, bindings));
 		case "call": return callKinds(node.callee, node.args.map((a) => kindsOf(a, bindings)));
 	}
 }
@@ -47259,6 +47289,20 @@ var CAMERA_SENSORS_NOT_LOADED = Object.freeze({
 	reason: "camera sensor mappings not loaded"
 });
 //#endregion
+//#region src/capabilities/schemas/package-llm-verdict.ts
+/**
+* What the vision model must answer before a package event is emitted
+* when a packages rule has "Confirm with the LLM" on.
+*
+* `package` is the verdict. `confidence` is 0..1. `reason` is the model's
+* one-line explanation, stored on the event so a drop is not silent.
+*/
+var PackageLlmVerdictSchema = zod.z.object({
+	package: zod.z.boolean(),
+	confidence: zod.z.number().min(0).max(1),
+	reason: zod.z.string().min(1)
+});
+//#endregion
 //#region src/pipeline/cluster-model-scope.ts
 /**
 * A model choice has a SCOPE, and a scope change has a workflow.
@@ -48377,6 +48421,21 @@ var ObjectEventSchema = zod.z.object({
 	* pick-up written before D684 — UNKNOWN, never 0 and never `timestamp`.
 	*/
 	observedAt: zod.z.number().optional(),
+	/**
+	* The delivery was emitted without a vision-model yes (D931).
+	*
+	* Set only when the packages rule asked for an LLM confirm and the model
+	* was unreachable, timed out, or answered something that did not parse.
+	* A notification reads it so it can say "possible" instead of a definite
+	* delivery. Absent on every other row, and on a confirm that said yes.
+	*/
+	packagePossible: zod.z.boolean().optional(),
+	/**
+	* The vision model's verdict, when a packages rule asked for one and the
+	* model answered the schema (D931). A "no" never becomes a row — the
+	* detector drops it and logs the reason. Present on a yes.
+	*/
+	packageLlmVerdict: PackageLlmVerdictSchema.optional(),
 	/** The parent track's key-event importance [0,1], propagated to every object
 	*  event of the track (so an event row can be sorted by importance without a
 	*  track join). Absent on legacy rows / before the track was scored. */
@@ -51015,7 +51074,6 @@ var PipelineAddonSchemaSchema = zod.z.object({
 	defaultModelId: zod.z.string(),
 	defaultModelIdByFormat: zod.z.record(zod.z.string(), zod.z.string()).optional(),
 	enabledByDefault: zod.z.boolean().optional(),
-	backfillIntoExistingOverrides: zod.z.boolean().optional(),
 	defaultConfidence: zod.z.number(),
 	group: zod.z.string().optional(),
 	configSchema: zod.z.array(ConfigFieldBridge).readonly().optional()
@@ -51142,7 +51200,6 @@ var AudioTestResultSchema = zod.z.object({
 	error: zod.z.string().optional(),
 	frame: zod.z.custom().optional()
 });
-var PipelineConfigBridge = zod.z.custom();
 var ConfigUISchemaBridge = zod.z.custom();
 var ConfigUISchemaNullableBridge = zod.z.custom();
 var InferenceCapabilitiesBridge = zod.z.custom();
@@ -51167,7 +51224,6 @@ var pipelineExecutorCapability = {
 	methods: {
 		getAvailableEngines: require_sleep.method(zod.z.void(), zod.z.array(PipelineEngineChoiceSchema)),
 		getSelectedEngine: require_sleep.method(zod.z.void(), PipelineEngineChoiceSchema),
-		getDefaultSteps: require_sleep.method(PipelineEngineChoiceSchema, zod.z.array(PipelineDefaultStepSchema)),
 		/**
 		* Per-node detection-engine provisioning snapshot. Returns the live
 		* state of the lazy runtime-provisioning machine on `nodeId`
@@ -51189,54 +51245,6 @@ var pipelineExecutorCapability = {
 			auth: "admin"
 		}),
 		/**
-		* Clear THIS node's executor-side PER-DEVICE settings stores (the
-		* per-camera step overrides the object-detection root reads via
-		* `applyDeviceOverridesToTree`). `nodeId` is the ROUTING key — the
-		* generated cap-router strips it (default `nodeIdMode: 'routing'`) and
-		* dispatches to that node, so the provider method runs ON the target
-		* node and receives no `nodeId`.
-		*
-		* This is the slimmed executor leg of the orchestrator's
-		* `resetNodePipelineDefaults` flow (which owns the real reset: node
-		* addonDefaults pins + per-camera orchestrator overrides). The legacy
-		* `resetToDefault` — which reset a persisted global step-tree seed
-		* nothing in the live per-camera path read — was removed together with
-		* that seed.
-		*/
-		clearDeviceOverrides: require_sleep.method(zod.z.object({ nodeId: zod.z.string() }), zod.z.object({
-			success: zod.z.literal(true),
-			clearedDevices: zod.z.number()
-		}), {
-			kind: "mutation",
-			auth: "admin"
-		}),
-		/**
-		* Auto tune (D745): the MODEL-BOUND thresholds (`bindsToModel` keys of
-		* the object-detection root, and their binding keys) stored in THIS node's
-		* per-camera detector settings — and, unless `dryRun`, remove them so the
-		* running model's own defaults apply. Every other key of a camera's store
-		* is kept. `nodeId` is the ROUTING key. `deviceIds` absent ⇒ every camera
-		* with a store. A camera whose store could not be read is `refused`, never
-		* reported as clean.
-		*/
-		clearModelBoundDeviceOverrides: require_sleep.method(zod.z.object({
-			nodeId: zod.z.string(),
-			deviceIds: zod.z.array(zod.z.number()).readonly().optional(),
-			dryRun: zod.z.boolean()
-		}), zod.z.object({
-			entries: zod.z.array(zod.z.object({
-				deviceId: zod.z.number(),
-				keys: zod.z.array(zod.z.string()).readonly()
-			})).readonly(),
-			refused: zod.z.array(zod.z.object({
-				deviceId: zod.z.number(),
-				reason: zod.z.string()
-			})).readonly()
-		}), {
-			kind: "mutation",
-			auth: "admin"
-		}),
-		/**
 		* Which of THIS node's inference devices the executor currently refuses,
 		* and why. `nodeId` is the ROUTING key (stripped by the generated router).
 		*
@@ -51291,8 +51299,6 @@ var pipelineExecutorCapability = {
 			auth: "admin"
 		}),
 		getSchema: require_sleep.method(zod.z.void(), PipelineSchemaSchema),
-		getGlobalSteps: require_sleep.method(zod.z.void(), zod.z.array(PipelineDefaultStepSchema).readonly().nullable()),
-		getGlobalPipelineConfig: require_sleep.method(zod.z.void(), PipelineConfigBridge),
 		getOrchestratorConfigSchema: require_sleep.method(zod.z.void(), ConfigUISchemaBridge),
 		/**
 		* Gate B (pre-init config-correctness gate). PURE COMPUTE against this
@@ -51655,11 +51661,18 @@ var KeptReasonSchema = zod.z.enum(["custom-pin"]);
 * Where a choice's latency came from (D791): this node's own benchmark
 * result, or the hardware-class table. Measured on the node beats the table.
 */
-var LatencySourceSchema = zod.z.discriminatedUnion("kind", [zod.z.object({ kind: zod.z.literal("table") }), zod.z.object({
-	kind: zod.z.literal("node-benchmark"),
-	resultId: zod.z.string(),
-	measuredAtMs: zod.z.number()
-})]);
+var LatencySourceSchema = zod.z.discriminatedUnion("kind", [
+	zod.z.object({ kind: zod.z.literal("table") }),
+	zod.z.object({
+		kind: zod.z.literal("node-benchmark"),
+		resultId: zod.z.string(),
+		measuredAtMs: zod.z.number()
+	}),
+	zod.z.object({
+		kind: zod.z.literal("estimated"),
+		estimatedFrom: HardwareClassIdSchema
+	})
+]);
 var DeviceModelChoiceSchema = zod.z.object({
 	modelId: zod.z.string(),
 	p50Ms: zod.z.number(),
@@ -51667,6 +51680,11 @@ var DeviceModelChoiceSchema = zod.z.object({
 	measured: zod.z.boolean(),
 	/** Absent on a plan from before D791 — read as the table. */
 	source: LatencySourceSchema.optional(),
+	/**
+	* The measured class this latency was scaled from (D930). Absent when the
+	* cell is the table or a node benchmark.
+	*/
+	estimatedFrom: HardwareClassIdSchema.optional(),
 	/** Parallel sessions at the camera rate with the headroom kept free: ⌊fps × (1 − headroom) / camera fps⌋. */
 	capacitySessions: zod.z.number(),
 	personRecall: zod.z.number()
@@ -51706,40 +51724,20 @@ var NodeDeviceChangeSchema = zod.z.object({
 		keys: zod.z.array(zod.z.string()).readonly()
 	})).readonly()
 });
-var CameraOverrideClearSchema = zod.z.object({
-	deviceId: zod.z.number(),
-	source: zod.z.enum(["step-override", "wholesale"]),
+/**
+* Every model and model-bound threshold lives on the accelerator that runs it
+* (D927), so the plan writes node / device entries only — there is no camera
+* layer for it to clear.
+*/
+var AutoTuneWarningSchema = zod.z.discriminatedUnion("kind", [zod.z.object({
+	kind: zod.z.literal("custom-pin-kept"),
 	nodeId: zod.z.string(),
-	deviceKey: zod.z.string().nullable(),
-	stepId: zod.z.string(),
-	modelIdBefore: zod.z.string().nullable(),
-	keys: zod.z.array(zod.z.string()).readonly()
-});
-var DetectorStoreClearSchema = zod.z.object({
-	deviceId: zod.z.number(),
-	keys: zod.z.array(zod.z.string()).readonly()
-});
-var AutoTuneWarningSchema = zod.z.discriminatedUnion("kind", [
-	zod.z.object({
-		kind: zod.z.literal("detector-store-cluster-wide"),
-		skippedNodes: zod.z.array(zod.z.string()).readonly()
-	}),
-	zod.z.object({
-		kind: zod.z.literal("detector-store-unreadable"),
-		error: zod.z.string()
-	}),
-	zod.z.object({
-		kind: zod.z.literal("custom-pin-kept"),
-		nodeId: zod.z.string(),
-		deviceKey: zod.z.string().nullable(),
-		deviceId: zod.z.number().nullable(),
-		modelId: zod.z.string()
-	}),
-	zod.z.object({
-		kind: zod.z.literal("custom-registry-unreadable"),
-		error: zod.z.string()
-	})
-]);
+	deviceKey: zod.z.string(),
+	modelId: zod.z.string()
+}), zod.z.object({
+	kind: zod.z.literal("custom-registry-unreadable"),
+	error: zod.z.string()
+})]);
 var AutoTuneOptionsSchema = zod.z.object({
 	/** Share of each accelerator's throughput kept free (0.3–0.5). */
 	headroom: zod.z.number().min(.3).max(.5).default(.4),
@@ -51761,8 +51759,6 @@ var AutoTunePlanSchema = zod.z.object({
 	generatedAt: zod.z.number(),
 	nodes: zod.z.array(NodeRecommendationSchema).readonly(),
 	nodeChanges: zod.z.array(NodeDeviceChangeSchema).readonly(),
-	cameraClears: zod.z.array(CameraOverrideClearSchema).readonly(),
-	detectorStoreClears: zod.z.array(DetectorStoreClearSchema).readonly(),
 	warnings: zod.z.array(AutoTuneWarningSchema).readonly()
 });
 var AutoTuneApplyInputSchema = zod.z.object({
@@ -51773,8 +51769,6 @@ var AutoTuneApplyInputSchema = zod.z.object({
 var AutoTunePhaseResultSchema = zod.z.object({
 	phase: zod.z.enum([
 		"download",
-		"camera-overrides",
-		"detector-thresholds",
 		"node-models",
 		"redispatch"
 	]),
@@ -53966,6 +53960,12 @@ var AgentPipelineSettingsSchema = zod.z.object({
 	/** Hub-persisted UI colour (`--color-node-*` theme tokens). */
 	color: require_node_color.NodeColorIdSchema.optional(),
 	/**
+	* NODE-wide step settings (D927): `stepId → { key → value }`, applied on
+	* every accelerator of the node under the device's own settings. Never a
+	* model or a model-bound threshold. Written by `setNodeStepSettings`.
+	*/
+	stepSettings: zod.z.record(zod.z.string(), zod.z.record(zod.z.string(), zod.z.unknown()).readonly()).optional(),
+	/**
 	* Multi-device inference opt-in (Phase 4). Per-node map deviceKey → {enabled,
 	* weight, steps}. Absent / all-disabled ⇒ the node's single default
 	* accelerator (safe default); two+ enabled ⇒ the dispatcher balances
@@ -53981,17 +53981,6 @@ var AgentPipelineSettingsSchema = zod.z.object({
 		steps: zod.z.record(zod.z.string(), DeviceStepConfigSchema).optional()
 	})).optional()
 });
-var CameraPipelineForAgentSchema = zod.z.object({
-	steps: zod.z.array(PipelineStepInputSchema).readonly(),
-	audio: zod.z.object({
-		modelId: zod.z.string(),
-		enabled: zod.z.boolean()
-	}).nullable()
-});
-var CameraStepOverridePatchSchema = zod.z.object({
-	modelId: zod.z.string().optional(),
-	settings: zod.z.record(zod.z.string(), zod.z.unknown()).readonly().optional()
-});
 var CameraStepSettingsSchema = zod.z.record(zod.z.string(), zod.z.record(zod.z.string(), zod.z.unknown()).readonly());
 /** The three root-detector choices a camera has (D507: at most one root). */
 var CameraDetectionSourceSchema = zod.z.enum([
@@ -54001,9 +53990,7 @@ var CameraDetectionSourceSchema = zod.z.enum([
 ]);
 var CameraPipelineSettingsSchema = zod.z.object({
 	stepToggles: zod.z.record(zod.z.string(), zod.z.boolean()).optional(),
-	stepSettings: CameraStepSettingsSchema.optional(),
-	stepOverridesByDevice: zod.z.record(zod.z.string(), zod.z.record(zod.z.string(), zod.z.record(zod.z.string(), CameraStepOverridePatchSchema))).optional(),
-	pipelineByAgent: zod.z.record(zod.z.string(), CameraPipelineForAgentSchema).optional()
+	stepSettings: CameraStepSettingsSchema.optional()
 });
 /**
 * Pipeline placement record persisted by `addon-pipeline-orchestrator` via
@@ -54790,6 +54777,21 @@ var pipelineOrchestratorCapability = {
 			auth: "admin"
 		}),
 		/**
+		* Write or clear one step's NODE-wide settings (D927) — the content that
+		* holds on every accelerator of the node (`agentSettings[node].stepSettings`).
+		* `settings` is the whole bag for the step; `null` or `{}` clears it.
+		* REFUSES a model-scoped key (a model id, a binding, a `minConfidence*`
+		* floor): those are set on the accelerator (`setAgentInferenceDevices`).
+		*/
+		setNodeStepSettings: require_sleep.method(zod.z.object({
+			agentNodeId: zod.z.string(),
+			addonId: zod.z.string(),
+			settings: zod.z.record(zod.z.string(), zod.z.unknown()).nullable()
+		}), zod.z.object({ success: zod.z.literal(true) }), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		/**
 		* DEVICE-AWARE merged view of ONE node's inference accelerators. Joins each
 		* physical device the node HAS — probed live via a node-pinned
 		* `platformProbe.getCapabilities` (the platform-probe singleton is targeted
@@ -54823,23 +54825,17 @@ var pipelineOrchestratorCapability = {
 		*   (a) strips every `modelId` pin from that node's
 		*       `agentSettings.addonDefaults` (cells revert to Auto — the node
 		*       resolves its own hardware-aware format default at runtime);
-		*   (b) clears per-camera step overrides scoped to that node
-		*       (`stepOverridesByAgent[node]` + the wholesale
-		*       `pipelineByAgent[node]` escape hatch);
-		*   (c) clears the executor-side per-device settings stores on that node
-		*       (`pipelineExecutor.clearDeviceOverrides`);
-		*   (d) hot-reloads every camera assigned to the node.
+		*   (b) hot-reloads every camera assigned to the node.
+		* There is no per-camera model to clear (D927).
 		*
 		* Returns the EFFECTIVE post-reset object-detection model for the node
-		* (the executor's pure hardware-aware default) so the UI can report what
-		* will actually run — not a value that never reaches the live path.
+		* (the format default of the accelerator hosting the camera root) so the
+		* UI can report what will actually run.
 		*/
 		resetNodePipelineDefaults: require_sleep.method(zod.z.object({ agentNodeId: zod.z.string() }), zod.z.object({
 			success: zod.z.literal(true),
 			/** Hardware-aware default detection model now in effect on the node (null when unresolvable). */
-			effectiveModelId: zod.z.string().nullable(),
-			/** Number of cameras whose node-scoped overrides were cleared. */
-			clearedCameraOverrides: zod.z.number()
+			effectiveModelId: zod.z.string().nullable()
 		}), {
 			kind: "mutation",
 			auth: "admin"
@@ -54851,8 +54847,8 @@ var pipelineOrchestratorCapability = {
 		* that sustains at least `minSessionsPerDevice` parallel sessions at the
 		* camera rate with the headroom kept free (no load input), and lists every write
 		* the apply would make: the node model pins set, the enrichment pins and
-		* model-bound thresholds removed (node level and per camera), and the
-		* per-camera detector thresholds cleared. Writes nothing. Step
+		* model-bound thresholds removed — all on the accelerators, the only
+		* layer that carries a model (D927). Writes nothing. Step
 		* enablement, device enablement, pins, recording, notifications, zones and
 		* rules are never part of it. `planHash` names exactly this diff.
 		*/
@@ -55005,31 +55001,14 @@ var pipelineOrchestratorCapability = {
 			kind: "mutation",
 			auth: "admin"
 		}),
-		/** Read every per-(node,device) override map for a device. Null when device has no overrides. */
-		getCameraStepOverrides: require_sleep.method(zod.z.object({ deviceId: zod.z.number() }), zod.z.record(zod.z.string(), zod.z.record(zod.z.string(), zod.z.record(zod.z.string(), CameraStepOverridePatchSchema))).nullable()),
-		/**
-		* Write or clear the per-(camera,node,device) override for one addonId.
-		* `patch: null` clears the entry entirely for that (node, deviceKey, addon)
-		* triple (empty parents are pruned). Model/settings only — enablement is
-		* the per-camera `stepToggles` authority.
-		*/
-		setCameraStepOverride: require_sleep.method(zod.z.object({
-			deviceId: zod.z.number(),
-			agentNodeId: zod.z.string(),
-			deviceKey: zod.z.string(),
-			addonId: zod.z.string(),
-			patch: CameraStepOverridePatchSchema.nullable()
-		}), zod.z.object({ success: zod.z.literal(true) }), {
-			kind: "mutation",
-			auth: "admin"
-		}),
 		/**
-		* Write or clear one step's CAMERA-WIDE settings (D754) — the fields this
-		* camera overrides on every accelerator it runs on. `settings` is the
-		* whole field-level bag for that step (only the overridden keys; a
-		* model-bound field travels with its binding key); `null` or `{}` clears
-		* it. Merged at dispatch between the node base and the per-(node,device)
-		* override, key by key.
+		* Write or clear one step's CAMERA-WIDE settings (D754) — the
+		* camera-semantic fields this camera overrides on every accelerator it
+		* runs on. `settings` is the whole field-level bag for that step (only the
+		* overridden keys); `null` or `{}` clears it. Merged at dispatch over the
+		* node base, key by key. REFUSES a model-scoped key — a model id, a model
+		* binding or a `minConfidence*` floor (D927): those belong to the
+		* accelerator that runs the model.
 		*/
 		setCameraStepSettings: require_sleep.method(zod.z.object({
 			deviceId: zod.z.number(),
@@ -55039,15 +55018,6 @@ var pipelineOrchestratorCapability = {
 			kind: "mutation",
 			auth: "admin"
 		}),
-		/** Write or clear the wholesale per-agent pipeline override. Pass `pipeline: null` to drop the override. */
-		setCameraPipelineForAgent: require_sleep.method(zod.z.object({
-			deviceId: zod.z.number(),
-			agentNodeId: zod.z.string(),
-			pipeline: CameraPipelineForAgentSchema.nullable()
-		}), zod.z.object({ success: zod.z.literal(true) }), {
-			kind: "mutation",
-			auth: "admin"
-		}),
 		/** Resolve the effective pipeline for `(deviceId, agentNodeId?)` — walks the full precedence chain. Read-only preview used by the UI to show what will run. */
 		resolvePipeline: require_sleep.method(zod.z.object({
 			deviceId: zod.z.number(),
@@ -67733,352 +67703,1126 @@ includeCrops: zod.z.boolean().optional() }).optional(), zod.z.array(VehicleSchem
 	}
 };
 //#endregion
-//#region src/capabilities/platform-probe.cap.ts
-var ModelFormatSchema = zod.z.enum(require_sleep.MODEL_FORMATS);
-var HwAccelBackendInputSchema = zod.z.enum([
-	"videotoolbox",
-	"cuda",
-	"nvdec",
-	"vaapi",
-	"qsv",
-	"d3d11va",
-	"dxva2",
-	"amf",
-	"vdpau",
-	"drm",
-	"coreml",
-	"tensorrt",
-	"openvino",
-	"directml",
-	"webgpu",
-	"none"
-]).nullable().optional();
-var HwAccelResolutionSchema = zod.z.object({
-	preferred: zod.z.array(zod.z.string()).readonly(),
-	rationale: zod.z.string()
-});
-var HardwareEncoderIdSchema = zod.z.enum([
-	"h264_videotoolbox",
-	"hevc_videotoolbox",
-	"h264_vaapi",
-	"hevc_vaapi",
-	"h264_nvenc",
-	"hevc_nvenc",
-	"h264_qsv",
-	"hevc_qsv",
-	"h264_amf",
-	"hevc_amf",
-	"libx264",
-	"libx265"
-]);
-var HardwareEncoderProbeSchema = zod.z.object({
-	encoder: HardwareEncoderIdSchema,
-	codec: zod.z.enum(["H264", "H265"]),
-	family: zod.z.enum([
-		"videotoolbox",
-		"vaapi",
-		"nvenc",
-		"qsv",
-		"amf",
-		"software"
-	]),
-	available: zod.z.boolean(),
-	reason: zod.z.string().optional()
-});
-zod.z.object({
-	encoders: zod.z.array(HardwareEncoderProbeSchema).readonly(),
-	defaultH264: HardwareEncoderIdSchema,
-	defaultH265: HardwareEncoderIdSchema,
-	probedAt: zod.z.number()
-});
-zod.z.object({
-	methods: zod.z.array(zod.z.string()).readonly(),
-	probedAt: zod.z.number()
-});
-var HardwarePlatformSchema = zod.z.enum([
-	"darwin",
-	"linux",
-	"win32"
-]);
-var HardwareArchSchema = zod.z.enum(["arm64", "x64"]);
-var GpuInfoSchema = zod.z.object({
-	type: zod.z.enum([
-		"nvidia",
-		"amd",
-		"intel",
-		"apple"
-	]),
-	name: zod.z.string(),
-	memoryMB: zod.z.number().optional()
-});
-var NpuInfoSchema = zod.z.object({
-	type: zod.z.enum([
-		"apple-ane",
-		"intel-npu",
-		"amd-xdna"
-	]),
-	name: zod.z.string().optional(),
-	generation: zod.z.enum(["xdna1", "xdna2"]).optional()
-});
-var CoralBusSchema = zod.z.enum(["usb", "pci"]);
-var CoralInfoSchema = zod.z.object({
-	type: zod.z.literal("coral-edgetpu"),
-	/** Legacy single-bus report (older nodes) — read via `coralUsableUnits`. */
-	bus: zod.z.string().optional(),
-	/** Legacy USB unit count (older nodes) — read via `coralUsableUnits`. */
-	count: zod.z.number().int().nonnegative().optional(),
-	/** Usable units per bus — each one is its own `edgetpu:<bus>[:N]` device. */
-	units: zod.z.array(zod.z.object({
-		bus: CoralBusSchema,
-		count: zod.z.number().int().nonnegative()
-	})).readonly().optional(),
-	/** Present-but-unusable units, each with its typed reason (never "absent"). */
-	unavailable: zod.z.array(zod.z.object({
-		bus: CoralBusSchema,
-		count: zod.z.number().int().nonnegative(),
-		reason: zod.z.enum(["driver-missing", "device-not-accessible"])
-	})).readonly().optional()
-});
-var HardwareInfoSchema = zod.z.object({
-	platform: HardwarePlatformSchema,
-	arch: HardwareArchSchema,
-	cpuModel: zod.z.string(),
-	cpuCores: zod.z.number(),
-	totalRAM_MB: zod.z.number(),
-	availableRAM_MB: zod.z.number(),
-	gpu: GpuInfoSchema.nullable(),
-	npu: NpuInfoSchema.nullable(),
-	coral: CoralInfoSchema.nullable().optional()
-});
-var PlatformScoreSchema = zod.z.object({
-	runtime: zod.z.literal("python"),
-	backend: zod.z.string(),
-	format: zod.z.enum([
-		"onnx",
-		"coreml",
-		"openvino",
-		"tflite"
-	]),
-	score: zod.z.number(),
-	reason: zod.z.string(),
-	available: zod.z.boolean()
-});
-var InferenceDeviceDescriptorSchema = zod.z.object({
-	key: zod.z.string(),
-	backend: zod.z.string(),
-	device: zod.z.string(),
-	format: ModelFormatSchema,
-	runtime: zod.z.literal("python"),
-	score: zod.z.number(),
-	available: zod.z.boolean()
-});
-var PlatformCapabilitiesSchema = zod.z.object({
-	hardware: HardwareInfoSchema,
-	scores: zod.z.array(PlatformScoreSchema).readonly(),
-	bestScore: PlatformScoreSchema,
-	pythonPath: zod.z.string().nullable(),
-	devices: zod.z.array(InferenceDeviceDescriptorSchema).readonly()
-});
-var ModelRequirementSchema = zod.z.object({
-	modelId: zod.z.string(),
-	name: zod.z.string(),
-	minRAM_MB: zod.z.number(),
-	accuracyScore: zod.z.number(),
-	formats: zod.z.array(zod.z.string()).readonly()
-});
-var ResolvedInferenceConfigSchema = zod.z.object({
-	modelId: zod.z.string(),
-	runtime: zod.z.literal("python"),
-	backend: zod.z.string(),
-	format: ModelFormatSchema,
-	reason: zod.z.string()
-});
-/**
-* The answer of an accelerator rescan (D919): the node's device list after
-* the re-probe, what changed, and the evidence that decided the Coral answer
-* (`usbBus` — could the USB bus be read at all; `decidedBy` — USB ids, the PCI
-* bus, the installed-delegate fallback, or nothing).
-*/
-var AcceleratorRescanSchema = zod.z.object({
-	devices: zod.z.array(InferenceDeviceDescriptorSchema).readonly(),
-	appeared: zod.z.array(zod.z.string()).readonly(),
-	disappeared: zod.z.array(zod.z.string()).readonly(),
-	usbBus: zod.z.enum(["observed", "unobservable"]),
-	decidedBy: zod.z.enum([
-		"usb-ids",
-		"pci",
-		"delegate-fallback",
-		"none"
-	])
-});
-var platformProbeCapability = {
-	name: "platform-probe",
-	scope: "system",
-	mode: "singleton",
-	methods: {
-		getCapabilities: require_sleep.method(zod.z.void(), PlatformCapabilitiesSchema),
-		getHardware: require_sleep.method(zod.z.void(), HardwareInfoSchema),
-		resolveInferenceConfig: require_sleep.method(zod.z.object({ requirements: zod.z.array(ModelRequirementSchema).readonly() }), ResolvedInferenceConfigSchema),
-		resolveHwAccel: require_sleep.method(zod.z.object({ prefer: HwAccelBackendInputSchema }), HwAccelResolutionSchema),
-		/**
-		* Re-probe this node's accelerators NOW (Coral USB ids + PCIe apex units;
-		* `/sys` and `/dev` reads, no model load) and rebuild the device list that
-		* `getCapabilities` serves. The same re-probe runs every 60 s on its own;
-		* this is the operator's "rescan inference devices". Target a node with the
-		* `{ nodeId }` routing input, like `getCapabilities`.
-		*/
-		rescanAccelerators: require_sleep.method(zod.z.void(), AcceleratorRescanSchema, {
-			kind: "mutation",
-			auth: "admin"
-		})
-	}
-};
-//#endregion
-//#region src/capabilities/power-meter.cap.ts
-/**
-* Multi-metric electrical meter. One slice can carry any combination
-* of instantaneous power (W), cumulative energy (kWh), voltage (V),
-* and current (A) — all fields optional so a single-metric source
-* (HA `sensor` with `device_class: power`) populates only what it
-* has and aggregators (energy dashboards, billing exports) compose
-* across providers without needing one cap per metric.
-*
-* Trade-off acknowledged: a HomeKit export that wants to surface
-* "power" and "energy" as separate services has to crack open the
-* slice and emit two characteristics from one cap. Worth it to avoid
-* exploding the cap catalog with `power-w` / `energy-kwh` /
-* `voltage-v` / `current-a` quartets that always travel together
-* in real-world devices.
-*/
-var PowerMeterStatusSchema = zod.z.object({
-	/** Instantaneous power draw in watts. */
-	watts: zod.z.number().optional(),
-	/** Cumulative energy in kilowatt-hours since the meter was reset. */
-	kwhTotal: zod.z.number().optional(),
-	/** Voltage in volts. */
-	volts: zod.z.number().optional(),
-	/** Current in amperes. */
-	amps: zod.z.number().optional(),
-	/** Apparent power in volt-amperes (W × power-factor reciprocal). */
-	va: zod.z.number().optional(),
-	/** Power factor (0..1) if reported. */
-	powerFactor: zod.z.number().min(0).max(1).optional(),
-	/** Ms epoch when the slice was last updated. */
-	lastFetchedAt: zod.z.number(),
-	/** Live display unit of the single metric this slice carries (e.g. HA
-	*  `attributes.unit_of_measurement` → 'V' / 'A' / 'W' / 'kW' / 'kWh').
-	*  Each upstream `sensor.*` entity surfaces ONE device_class, so one
-	*  unit per slice is unambiguous. The UI prefers this over the role's
-	*  canonical unit so a 'kW' / 'Wh' feed renders verbatim. */
-	unit: zod.z.string().optional(),
-	/** Suggested decimal places for numeric display.
-	*  Populated live from the upstream source when provided (e.g. HA
-	*  `attributes.suggested_display_precision`). Falls back to
-	*  auto-formatting when absent. */
-	precision: zod.z.number().int().min(0).max(10).optional()
-});
-var powerMeterCapability = {
-	name: "power-meter",
-	scope: "device",
-	deviceNative: true,
-	mode: "singleton",
-	deviceTypes: [require_err_msg.DeviceType.Sensor],
-	methods: {},
-	status: {
-		schema: PowerMeterStatusSchema,
-		kind: "push"
-	},
-	runtimeState: PowerMeterStatusSchema,
-	/**
-	* Runtime-state durability: **restored** — as `numeric-sensor`; `kwhTotal` is an accumulator whose restored value is the baseline.
-	*
-	* See `RuntimeStateDurability`. Enforced by
-	* `scripts/check-runtime-state-durability.ts`.
-	*/
-	durability: "restored",
-	/**
-	* History (D850): recorded series. Gauges are floored at 30 s; `kwhTotal` is the one monotonic meter (counter).
-	*/
-	history: { fields: {
-		watts: {
-			kind: "gauge",
-			unit: "W",
-			deadband: 1,
-			minIntervalMs: 3e4
+//#region src/pipeline/auto-tune/detector-performance.ts
+var DETECTOR_PERF = {
+	"intel-core-ultra": {
+		"intel-npu": {
+			"yolov9t-320": {
+				p50Ms: 2.9,
+				fps: 383,
+				measured: true
+			},
+			"yolov9t-320-int8": {
+				p50Ms: 3.8,
+				fps: 333,
+				measured: true
+			},
+			"yolov9t-640": {
+				p50Ms: 7.4,
+				fps: 139,
+				measured: true
+			},
+			"yolov9t-640-int8": {
+				p50Ms: 7.5,
+				fps: 144,
+				measured: true
+			},
+			"yolov9s-320": {
+				p50Ms: 4.4,
+				fps: 241,
+				measured: true
+			},
+			"yolov9s-320-int8": {
+				p50Ms: 4.1,
+				fps: 264,
+				measured: true
+			},
+			"yolov9s-640": {
+				p50Ms: 12.7,
+				fps: 82,
+				measured: true
+			},
+			"yolov9s-640-int8": {
+				p50Ms: 10.7,
+				fps: 99,
+				measured: true
+			},
+			"yolov9m-320": {
+				p50Ms: 8.4,
+				fps: 123,
+				measured: true
+			},
+			"yolov9m-320-int8": {
+				p50Ms: 6.5,
+				fps: 165,
+				measured: true
+			},
+			"yolov9m-640": {
+				p50Ms: 29.5,
+				fps: 32,
+				measured: true
+			},
+			"yolov9m-640-int8": {
+				p50Ms: 19.5,
+				fps: 52,
+				measured: true
+			}
 		},
-		kwhTotal: {
-			kind: "counter",
-			unit: "kWh",
-			deadband: .01,
-			minIntervalMs: 6e4
+		"intel-igpu": {
+			"yolov9t-320": {
+				p50Ms: 2.6,
+				fps: 405,
+				measured: true
+			},
+			"yolov9t-320-int8": {
+				p50Ms: 2.8,
+				fps: 324,
+				measured: true
+			},
+			"yolov9t-640": {
+				p50Ms: 6.5,
+				fps: 157,
+				measured: true
+			},
+			"yolov9t-640-int8": {
+				p50Ms: 5.6,
+				fps: 185,
+				measured: true
+			},
+			"yolov9s-320": {
+				p50Ms: 4.6,
+				fps: 200,
+				measured: true
+			},
+			"yolov9s-320-int8": {
+				p50Ms: 4.1,
+				fps: 239,
+				measured: true
+			},
+			"yolov9s-640": {
+				p50Ms: 15.2,
+				fps: 69,
+				measured: true
+			},
+			"yolov9s-640-int8": {
+				p50Ms: 10.5,
+				fps: 99,
+				measured: true
+			},
+			"yolov9m-320": {
+				p50Ms: 11.4,
+				fps: 88,
+				measured: true
+			},
+			"yolov9m-320-int8": {
+				p50Ms: 7,
+				fps: 127,
+				measured: true
+			},
+			"yolov9m-640": {
+				p50Ms: 40,
+				fps: 25,
+				measured: true
+			},
+			"yolov9m-640-int8": {
+				p50Ms: 23.5,
+				fps: 44,
+				measured: true
+			}
 		},
-		volts: {
-			kind: "gauge",
-			unit: "V",
-			deadband: 1,
-			minIntervalMs: 3e4
+		"x86-cpu": {
+			"yolov9t-320": {
+				p50Ms: 6.9,
+				fps: 145,
+				measured: true
+			},
+			"yolov9t-320-int8": {
+				p50Ms: 2.7,
+				fps: 405,
+				measured: true
+			},
+			"yolov9t-640": {
+				p50Ms: 23,
+				fps: 44,
+				measured: true
+			},
+			"yolov9t-640-int8": {
+				p50Ms: 8.8,
+				fps: 124,
+				measured: true
+			},
+			"yolov9s-320": {
+				p50Ms: 15.8,
+				fps: 63,
+				measured: true
+			},
+			"yolov9s-320-int8": {
+				p50Ms: 6.5,
+				fps: 180,
+				measured: true
+			},
+			"yolov9s-640": {
+				p50Ms: 58.2,
+				fps: 17,
+				measured: true
+			},
+			"yolov9s-640-int8": {
+				p50Ms: 20.1,
+				fps: 52,
+				measured: true
+			},
+			"yolov9m-320": {
+				p50Ms: 40,
+				fps: 25,
+				measured: true
+			},
+			"yolov9m-320-int8": {
+				p50Ms: 14.2,
+				fps: 74,
+				measured: true
+			},
+			"yolov9m-640": {
+				p50Ms: 155.8,
+				fps: 6,
+				measured: true
+			},
+			"yolov9m-640-int8": {
+				p50Ms: 52.4,
+				fps: 19,
+				measured: true
+			}
 		},
-		amps: {
-			kind: "gauge",
-			unit: "A",
-			deadband: .05,
-			minIntervalMs: 3e4
+		coral: { "yolov9s-320-edgetpu": {
+			p50Ms: 32,
+			fps: 31,
+			measured: false
+		} }
+	},
+	"intel-n-series": {
+		"intel-igpu": {
+			"yolov9t-320": {
+				p50Ms: 15,
+				fps: 48,
+				measured: true
+			},
+			"yolov9t-320-int8": {
+				p50Ms: 14.1,
+				fps: 67,
+				measured: true
+			},
+			"yolov9t-640": {
+				p50Ms: 38.5,
+				fps: 26,
+				measured: true
+			},
+			"yolov9t-640-int8": {
+				p50Ms: 50,
+				fps: 20,
+				measured: true
+			},
+			"yolov9s-320": {
+				p50Ms: 41.4,
+				fps: 24,
+				measured: true
+			},
+			"yolov9s-320-int8": {
+				p50Ms: 23.3,
+				fps: 34,
+				measured: true
+			},
+			"yolov9s-640": {
+				p50Ms: 127.4,
+				fps: 8,
+				measured: true
+			},
+			"yolov9s-640-int8": {
+				p50Ms: 81,
+				fps: 12,
+				measured: true
+			},
+			"yolov9m-320": {
+				p50Ms: 63.5,
+				fps: 16,
+				measured: true
+			},
+			"yolov9m-320-int8": {
+				p50Ms: 66,
+				fps: 15,
+				measured: true
+			},
+			"yolov9m-640": {
+				p50Ms: 215.5,
+				fps: 5,
+				measured: true
+			},
+			"yolov9m-640-int8": {
+				p50Ms: 163,
+				fps: 6,
+				measured: true
+			}
 		},
-		va: {
-			kind: "gauge",
-			unit: "VA",
-			deadband: 1,
-			minIntervalMs: 3e4
+		"x86-cpu": {
+			"yolov9t-320": {
+				p50Ms: 86.2,
+				fps: 12,
+				measured: true
+			},
+			"yolov9t-320-int8": {
+				p50Ms: 52.7,
+				fps: 20,
+				measured: true
+			},
+			"yolov9t-640": {
+				p50Ms: 322.1,
+				fps: 3,
+				measured: true
+			},
+			"yolov9t-640-int8": {
+				p50Ms: 205.6,
+				fps: 5,
+				measured: true
+			},
+			"yolov9s-320": {
+				p50Ms: 164.4,
+				fps: 6,
+				measured: true
+			},
+			"yolov9s-320-int8": {
+				p50Ms: 86.9,
+				fps: 12,
+				measured: true
+			},
+			"yolov9s-640": {
+				p50Ms: 341.3,
+				fps: 3,
+				measured: true
+			},
+			"yolov9s-640-int8": {
+				p50Ms: 185.3,
+				fps: 5,
+				measured: true
+			},
+			"yolov9m-320": {
+				p50Ms: 166.8,
+				fps: 6,
+				measured: true
+			},
+			"yolov9m-320-int8": {
+				p50Ms: 226.3,
+				fps: 4,
+				measured: true
+			},
+			"yolov9m-640": {
+				p50Ms: 663.5,
+				fps: 2,
+				measured: true
+			},
+			"yolov9m-640-int8": {
+				p50Ms: 324.4,
+				fps: 3,
+				measured: true
+			}
 		},
-		powerFactor: {
-			kind: "gauge",
-			unit: "ratio",
-			deadband: .01,
-			minIntervalMs: 6e4
-		}
-	} },
-	/** Clock fields: written, but excluded from the compare that decides
-	*  whether persisting is worth a SQLite commit. */
-	volatileStateFields: ["lastFetchedAt"]
+		coral: { "yolov9s-320-edgetpu": {
+			p50Ms: 32,
+			fps: 31,
+			measured: false
+		} }
+	},
+	"amd-phoenix": {
+		"x86-cpu": {
+			"yolov9t-320": {
+				p50Ms: 24,
+				fps: 42,
+				measured: true
+			},
+			"yolov9t-320-int8": {
+				p50Ms: 12,
+				fps: 83,
+				measured: true
+			},
+			"yolov9t-640": {
+				p50Ms: 50,
+				fps: 20,
+				measured: true
+			},
+			"yolov9t-640-int8": {
+				p50Ms: 20,
+				fps: 50,
+				measured: true
+			},
+			"yolov9s-320": {
+				p50Ms: 30,
+				fps: 33,
+				measured: true
+			},
+			"yolov9s-320-int8": {
+				p50Ms: 15,
+				fps: 67,
+				measured: true
+			},
+			"yolov9s-640": {
+				p50Ms: 92,
+				fps: 11,
+				measured: true
+			},
+			"yolov9s-640-int8": {
+				p50Ms: 27,
+				fps: 37,
+				measured: true
+			},
+			"yolov9m-320": {
+				p50Ms: 67,
+				fps: 15,
+				measured: true
+			},
+			"yolov9m-320-int8": {
+				p50Ms: 21,
+				fps: 48,
+				measured: true
+			},
+			"yolov9m-640": {
+				p50Ms: 229,
+				fps: 4,
+				measured: true
+			},
+			"yolov9m-640-int8": {
+				p50Ms: 48,
+				fps: 21,
+				measured: true
+			}
+		},
+		"amd-igpu": {
+			"yolov9t-320": {
+				p50Ms: 40,
+				fps: 25,
+				measured: true
+			},
+			"yolov9t-640": {
+				p50Ms: 89,
+				fps: 11,
+				measured: true
+			},
+			"yolov9s-320": {
+				p50Ms: 65,
+				fps: 15,
+				measured: true
+			},
+			"yolov9s-640": {
+				p50Ms: 125,
+				fps: 8,
+				measured: true
+			},
+			"yolov9m-320": {
+				p50Ms: 85,
+				fps: 12,
+				measured: true
+			},
+			"yolov9m-640": {
+				p50Ms: 228,
+				fps: 4,
+				measured: true
+			}
+		},
+		coral: { "yolov9s-320-edgetpu": {
+			p50Ms: 32,
+			fps: 31,
+			measured: true
+		} }
+	},
+	"apple-m-pro": {
+		"apple-ane": {
+			"yolov9t-320": {
+				p50Ms: 1.1,
+				fps: 952,
+				measured: true
+			},
+			"yolov9t-640": {
+				p50Ms: 3,
+				fps: 333,
+				measured: true
+			},
+			"yolov9s-320": {
+				p50Ms: 1.5,
+				fps: 667,
+				measured: true
+			},
+			"yolov9s-640": {
+				p50Ms: 5.1,
+				fps: 196,
+				measured: true
+			},
+			"yolov9m-320": {
+				p50Ms: 3.2,
+				fps: 312,
+				measured: true
+			},
+			"yolov9m-640": {
+				p50Ms: 10.2,
+				fps: 98,
+				measured: true
+			}
+		},
+		coral: { "yolov9s-320-edgetpu": {
+			p50Ms: 32,
+			fps: 31,
+			measured: false
+		} }
+	},
+	"apple-m-base": {
+		"apple-ane": {
+			"yolov9t-320": {
+				p50Ms: 1.32,
+				fps: 758,
+				measured: false
+			},
+			"yolov9t-640": {
+				p50Ms: 3.45,
+				fps: 290,
+				measured: true
+			},
+			"yolov9s-320": {
+				p50Ms: 1.8,
+				fps: 556,
+				measured: false
+			},
+			"yolov9s-640": {
+				p50Ms: 5.46,
+				fps: 183,
+				measured: true
+			},
+			"yolov9m-320": {
+				p50Ms: 3.79,
+				fps: 264,
+				measured: true
+			},
+			"yolov9m-640": {
+				p50Ms: 10.34,
+				fps: 97,
+				measured: true
+			}
+		},
+		coral: { "yolov9s-320-edgetpu": {
+			p50Ms: 32,
+			fps: 31,
+			measured: false
+		} }
+	}
+};
+var DETECTOR_ACCURACY = {
+	"yolov9m-320": {
+		personPrecision: .979,
+		personRecall: .649
+	},
+	"yolov9m-320-int8": {
+		personPrecision: .974,
+		personRecall: .684
+	},
+	"yolov9m-640": {
+		personPrecision: .976,
+		personRecall: .854
+	},
+	"yolov9m-640-int8": {
+		personPrecision: .976,
+		personRecall: .847
+	},
+	"yolov9s-320": {
+		personPrecision: .958,
+		personRecall: .479
+	},
+	"yolov9s-320-int8": {
+		personPrecision: .969,
+		personRecall: .438
+	},
+	"yolov9s-640": {
+		personPrecision: .986,
+		personRecall: .753
+	},
+	"yolov9s-640-int8": {
+		personPrecision: .963,
+		personRecall: .823
+	},
+	"yolov9t-320": {
+		personPrecision: .946,
+		personRecall: .368
+	},
+	"yolov9t-320-int8": {
+		personPrecision: .943,
+		personRecall: .347
+	},
+	"yolov9t-640": {
+		personPrecision: .979,
+		personRecall: .646
+	},
+	"yolov9t-640-int8": {
+		personPrecision: .979,
+		personRecall: .646
+	}
 };
 //#endregion
-//#region src/capabilities/presence.cap.ts
+//#region src/pipeline/auto-tune/accelerator-compute.ts
+/**
+* Capacity of an accelerator we have not measured (D930).
+*
+* The latency table stays the measured columns. A device that reports compute
+* (OpenVINO GOPS, or execution units × clock, or compute units, or TOPS) is
+* estimated from the nearest measured column of the same accelerator kind,
+* scaled by the compute ratio and clamped. A node benchmark still replaces
+* the estimate. A device that reports neither compute nor a known class stays
+* `unknown`.
+*
+* A failed probe field is `null`, never `0` (D393): zero would be a compute
+* ratio of zero and would size the device as if it could not run.
+*/
+/**
+* An unmeasured device is never estimated outside this band of its reference.
+*
+* Peak GOPS and detector latency do not move together: a 640 model is memory
+* bound, a 320 model less so, and the N100→N305 public EU×clock ratio is
+* about 2.2×. 2× is the widest that spread justifies without a measurement
+* on the device; 0.5× is the symmetric floor so a tiny iGPU is not told it
+* is many times slower than the weakest column we measured. A node benchmark
+* replaces the estimate and is not clamped.
+*/
+var ESTIMATE_COMPUTE_RATIO_MIN = .5;
+var ESTIMATE_COMPUTE_RATIO_MAX = 2;
+/**
+* Within this of 1.0, a device whose class IS the reference is that measured
+* machine (a probe clock a few percent off the spec), not a different chip.
+* An unknown class is still estimated, so the plan says so.
+*/
+var REFERENCE_MATCH_FRACTION = .05;
+/** N100 iGPU: 24 execution units, 750 MHz graphics max (Intel specification). */
+var N100_IGPU_EU = 24;
+var N100_IGPU_CLOCK_MHZ = 750;
+/**
+* Core Ultra 7 265K iGPU: 4 Xe-cores. OpenVINO's execution-unit count for
+* Xe-LP is 16 per Xe-core, and the graphics max dynamic frequency is 2000 MHz.
+* Used only to choose the nearest column for a chip that is not itself a
+* Core Ultra — that class is the measurement and is never scaled.
+*/
+var CORE_ULTRA_265K_IGPU_EU = 64;
+var CORE_ULTRA_265K_IGPU_CLOCK_MHZ = 2e3;
+/** Phoenix / Hawk Point Radeon 780M: 12 compute units. */
+var PHOENIX_780M_CU = 12;
+var positiveOrNull = zod.z.number().nullable().transform((value) => value !== null && Number.isFinite(value) && value > 0 ? value : null);
+var textOrNull = zod.z.string().nullable().transform((value) => value !== null && value.trim() !== "" ? value : null);
+var PrecisionGopsSchema = zod.z.object({
+	int8: positiveOrNull,
+	fp16: positiveOrNull
+});
+/** What one accelerator device reported. Every failed query is null. */
+var AcceleratorComputeSchema = zod.z.object({
+	deviceKey: zod.z.string(),
+	fullDeviceName: textOrNull,
+	executionUnits: positiveOrNull,
+	clockMHz: positiveOrNull,
+	gops: PrecisionGopsSchema.nullable(),
+	architecture: textOrNull,
+	npuName: textOrNull,
+	tops: positiveOrNull,
+	vendor: textOrNull,
+	webgpuArchitecture: textOrNull,
+	webgpuDevice: textOrNull,
+	computeUnits: positiveOrNull
+});
+var AcceleratorFactsPayloadSchema = zod.z.object({ accelerators: zod.z.array(AcceleratorComputeSchema).nullable() });
+/**
+* Compute of the machines the latency columns were measured on.
+* GOPS is preferred when a column carries it; none of these do yet — the
+* boxes were measured before the probe reported `DEVICE_GOPS` — so the scale
+* uses execution units × clock (Intel) or compute units (AMD) until a
+* re-measure locks a GOPS figure on the column.
+*/
+var REFERENCE_COMPUTE = [
+	{
+		hardwareClass: "intel-n-series",
+		accelerator: "intel-igpu",
+		score: {
+			metric: "eu-mhz",
+			value: 24 * 750
+		}
+	},
+	{
+		hardwareClass: "intel-core-ultra",
+		accelerator: "intel-igpu",
+		score: {
+			metric: "eu-mhz",
+			value: 64 * CORE_ULTRA_265K_IGPU_CLOCK_MHZ
+		}
+	},
+	{
+		hardwareClass: "amd-phoenix",
+		accelerator: "amd-igpu",
+		score: {
+			metric: "cu",
+			value: 12
+		}
+	}
+];
+/** Parse a probe payload. `null` means the probe failed — not "no accelerators". */
+function parseAcceleratorFactsJson(raw) {
+	const parsed = AcceleratorFactsPayloadSchema.safeParse(raw);
+	if (!parsed.success || parsed.data.accelerators === null) return null;
+	return parsed.data.accelerators;
+}
+function positive$1(value) {
+	return value !== null && value > 0 ? value : null;
+}
+/** Scores in the order the estimate prefers. A non-positive field is absent. */
+function computeScores(report) {
+	const scores = [];
+	const int8 = positive$1(report.gops?.int8 ?? null);
+	if (int8 !== null) scores.push({
+		metric: "gops-int8",
+		value: int8
+	});
+	const fp16 = positive$1(report.gops?.fp16 ?? null);
+	if (fp16 !== null) scores.push({
+		metric: "gops-fp16",
+		value: fp16
+	});
+	const units = positive$1(report.executionUnits);
+	const clock = positive$1(report.clockMHz);
+	if (units !== null && clock !== null) scores.push({
+		metric: "eu-mhz",
+		value: units * clock
+	});
+	const computeUnits = positive$1(report.computeUnits);
+	if (computeUnits !== null) scores.push({
+		metric: "cu",
+		value: computeUnits
+	});
+	const tops = positive$1(report.tops);
+	if (tops !== null) scores.push({
+		metric: "tops",
+		value: tops
+	});
+	return scores;
+}
+function nearestReference(kind, score, references) {
+	const same = references.filter((ref) => ref.accelerator === kind && ref.score.metric === score.metric && ref.score.value > 0);
+	const first = same[0];
+	if (first === void 0) return null;
+	return same.reduce((best, ref) => {
+		return Math.abs(Math.log(score.value / ref.score.value)) < Math.abs(Math.log(score.value / best.score.value)) ? ref : best;
+	}, first);
+}
+function scoreAgainstReferences(report, kind, references) {
+	for (const score of computeScores(report)) if (nearestReference(kind, score, references) !== null) return score;
+	return null;
+}
+/** True when this report can scale a measured column of `kind`. */
+function reportIsScalable(report, kind, references = REFERENCE_COMPUTE) {
+	return scoreAgainstReferences(report, kind, references) !== null;
+}
+function classColumn(perf, hardwareClass, accelerator) {
+	if (hardwareClass === "unknown") return void 0;
+	return perf[hardwareClass]?.[accelerator];
+}
+function round1(value) {
+	return Math.round(value * 10) / 10;
+}
+function clampRatio(ratio) {
+	return Math.min(2, Math.max(ESTIMATE_COMPUTE_RATIO_MIN, ratio));
+}
+function scaleColumn(column, ratio, estimatedFrom) {
+	const out = {};
+	for (const [modelId, cell] of Object.entries(column)) out[modelId] = {
+		p50Ms: round1(cell.p50Ms / ratio),
+		fps: Math.max(1, Math.round(cell.fps * ratio)),
+		measured: false,
+		estimatedFrom
+	};
+	return out;
+}
 /**
-* Presence cap. Models HA `person.*` and `device_tracker.*` entities
-* on `DeviceType.Presence`. Read-only — no setters: presence is
-* derived from upstream signals (mobile-app location, router DHCP
-* lease, Bluetooth beacon, manual zone change) and pushed into the
-* slice.
-*
-* `state` follows HA's canonical values — `home` / `not_home` /
-* `<zone-name>` for any other named zone. The zone name is freeform
-* because users define arbitrary zones (`work`, `gym`, `school`).
-*
-* GPS coordinates are nullable — tracker types without location
-* (Bluetooth scanner, MQTT presence) omit them. The presence of
-* GPS data is signaled by `DeviceFeature.PresenceGps` for fast
-* UI map-pin rendering.
+* The latency column for one device. A measured class other than the N-series
+* spread is returned unchanged — one class there is one measured machine.
+* `intel-n-series` is the N100 column; a different reported compute scales it.
+* An unknown class scales from the nearest reference of the same kind.
 */
-var GpsLocationSchema = zod.z.object({
-	/** Latitude in decimal degrees, -90..90. */
-	latitude: zod.z.number().min(-90).max(90),
-	/** Longitude in decimal degrees, -180..180. */
-	longitude: zod.z.number().min(-180).max(180),
-	/** Reported accuracy in meters (lower = better). */
-	accuracyMeters: zod.z.number().nonnegative()
-});
-var PresenceStatusSchema = zod.z.object({
-	/** `home` / `not_home` / any user-defined zone name. */
-	state: zod.z.string(),
-	/** Optional textual location label (zone name, city, address). Null
-	*  when only the binary state is known. */
-	location: zod.z.string().nullable(),
-	/** GPS coordinates when available. Null otherwise. */
-	gps: GpsLocationSchema.nullable(),
-	/** Optional battery level of the tracking device (0..100). Null
-	*  when not reported. */
-	batteryPercent: zod.z.number().min(0).max(100).nullable(),
-	/** Ms epoch when the slice was last updated. */
+function resolveLatencyColumn(input) {
+	const perf = input.perf ?? DETECTOR_PERF;
+	const references = input.references ?? REFERENCE_COMPUTE;
+	const measured = classColumn(perf, input.hardwareClass, input.accelerator);
+	if (measured !== void 0 && input.hardwareClass !== "intel-n-series") return {
+		column: measured,
+		estimatedFrom: null
+	};
+	const score = input.report === null ? null : scoreAgainstReferences(input.report, input.accelerator, references);
+	if (score === null) return measured === void 0 ? null : {
+		column: measured,
+		estimatedFrom: null
+	};
+	const nearest = nearestReference(input.accelerator, score, references);
+	const base = nearest === null ? void 0 : classColumn(perf, nearest.hardwareClass, input.accelerator);
+	if (nearest === null || base === void 0) return measured === void 0 ? null : {
+		column: measured,
+		estimatedFrom: null
+	};
+	const rawRatio = score.value / nearest.score.value;
+	if (input.hardwareClass === nearest.hardwareClass && Math.abs(rawRatio - 1) <= .05) return {
+		column: base,
+		estimatedFrom: null
+	};
+	return {
+		column: scaleColumn(base, clampRatio(rawRatio), nearest.hardwareClass),
+		estimatedFrom: nearest.hardwareClass
+	};
+}
+//#endregion
+//#region src/capabilities/platform-probe.cap.ts
+var ModelFormatSchema = zod.z.enum(require_sleep.MODEL_FORMATS);
+var HwAccelBackendInputSchema = zod.z.enum([
+	"videotoolbox",
+	"cuda",
+	"nvdec",
+	"vaapi",
+	"qsv",
+	"d3d11va",
+	"dxva2",
+	"amf",
+	"vdpau",
+	"drm",
+	"coreml",
+	"tensorrt",
+	"openvino",
+	"directml",
+	"webgpu",
+	"none"
+]).nullable().optional();
+var HwAccelResolutionSchema = zod.z.object({
+	preferred: zod.z.array(zod.z.string()).readonly(),
+	rationale: zod.z.string()
+});
+var HardwareEncoderIdSchema = zod.z.enum([
+	"h264_videotoolbox",
+	"hevc_videotoolbox",
+	"h264_vaapi",
+	"hevc_vaapi",
+	"h264_nvenc",
+	"hevc_nvenc",
+	"h264_qsv",
+	"hevc_qsv",
+	"h264_amf",
+	"hevc_amf",
+	"libx264",
+	"libx265"
+]);
+var HardwareEncoderProbeSchema = zod.z.object({
+	encoder: HardwareEncoderIdSchema,
+	codec: zod.z.enum(["H264", "H265"]),
+	family: zod.z.enum([
+		"videotoolbox",
+		"vaapi",
+		"nvenc",
+		"qsv",
+		"amf",
+		"software"
+	]),
+	available: zod.z.boolean(),
+	reason: zod.z.string().optional()
+});
+zod.z.object({
+	encoders: zod.z.array(HardwareEncoderProbeSchema).readonly(),
+	defaultH264: HardwareEncoderIdSchema,
+	defaultH265: HardwareEncoderIdSchema,
+	probedAt: zod.z.number()
+});
+zod.z.object({
+	methods: zod.z.array(zod.z.string()).readonly(),
+	probedAt: zod.z.number()
+});
+var HardwarePlatformSchema = zod.z.enum([
+	"darwin",
+	"linux",
+	"win32"
+]);
+var HardwareArchSchema = zod.z.enum(["arm64", "x64"]);
+var GpuInfoSchema = zod.z.object({
+	type: zod.z.enum([
+		"nvidia",
+		"amd",
+		"intel",
+		"apple"
+	]),
+	name: zod.z.string(),
+	memoryMB: zod.z.number().optional()
+});
+var NpuInfoSchema = zod.z.object({
+	type: zod.z.enum([
+		"apple-ane",
+		"intel-npu",
+		"amd-xdna"
+	]),
+	name: zod.z.string().optional(),
+	generation: zod.z.enum(["xdna1", "xdna2"]).optional()
+});
+var CoralBusSchema = zod.z.enum(["usb", "pci"]);
+var CoralInfoSchema = zod.z.object({
+	type: zod.z.literal("coral-edgetpu"),
+	/** Legacy single-bus report (older nodes) — read via `coralUsableUnits`. */
+	bus: zod.z.string().optional(),
+	/** Legacy USB unit count (older nodes) — read via `coralUsableUnits`. */
+	count: zod.z.number().int().nonnegative().optional(),
+	/** Usable units per bus — each one is its own `edgetpu:<bus>[:N]` device. */
+	units: zod.z.array(zod.z.object({
+		bus: CoralBusSchema,
+		count: zod.z.number().int().nonnegative()
+	})).readonly().optional(),
+	/** Present-but-unusable units, each with its typed reason (never "absent"). */
+	unavailable: zod.z.array(zod.z.object({
+		bus: CoralBusSchema,
+		count: zod.z.number().int().nonnegative(),
+		reason: zod.z.enum(["driver-missing", "device-not-accessible"])
+	})).readonly().optional()
+});
+var HardwareInfoSchema = zod.z.object({
+	platform: HardwarePlatformSchema,
+	arch: HardwareArchSchema,
+	cpuModel: zod.z.string(),
+	cpuCores: zod.z.number(),
+	totalRAM_MB: zod.z.number(),
+	availableRAM_MB: zod.z.number(),
+	gpu: GpuInfoSchema.nullable(),
+	npu: NpuInfoSchema.nullable(),
+	coral: CoralInfoSchema.nullable().optional(),
+	/**
+	* Per-accelerator compute (D930). Omitted by a node that has not probed it.
+	* `null` fields inside an entry are a failed query, never a zero.
+	*/
+	accelerators: zod.z.array(AcceleratorComputeSchema).readonly().optional()
+});
+var PlatformScoreSchema = zod.z.object({
+	runtime: zod.z.literal("python"),
+	backend: zod.z.string(),
+	format: zod.z.enum([
+		"onnx",
+		"coreml",
+		"openvino",
+		"tflite"
+	]),
+	score: zod.z.number(),
+	reason: zod.z.string(),
+	available: zod.z.boolean()
+});
+var InferenceDeviceDescriptorSchema = zod.z.object({
+	key: zod.z.string(),
+	backend: zod.z.string(),
+	device: zod.z.string(),
+	format: ModelFormatSchema,
+	runtime: zod.z.literal("python"),
+	score: zod.z.number(),
+	available: zod.z.boolean()
+});
+var PlatformCapabilitiesSchema = zod.z.object({
+	hardware: HardwareInfoSchema,
+	scores: zod.z.array(PlatformScoreSchema).readonly(),
+	bestScore: PlatformScoreSchema,
+	pythonPath: zod.z.string().nullable(),
+	devices: zod.z.array(InferenceDeviceDescriptorSchema).readonly()
+});
+var ModelRequirementSchema = zod.z.object({
+	modelId: zod.z.string(),
+	name: zod.z.string(),
+	minRAM_MB: zod.z.number(),
+	accuracyScore: zod.z.number(),
+	formats: zod.z.array(zod.z.string()).readonly()
+});
+var ResolvedInferenceConfigSchema = zod.z.object({
+	modelId: zod.z.string(),
+	runtime: zod.z.literal("python"),
+	backend: zod.z.string(),
+	format: ModelFormatSchema,
+	reason: zod.z.string()
+});
+/**
+* The answer of an accelerator rescan (D919): the node's device list after
+* the re-probe, what changed, and the evidence that decided the Coral answer
+* (`usbBus` — could the USB bus be read at all; `decidedBy` — USB ids, the PCI
+* bus, the installed-delegate fallback, or nothing).
+*/
+var AcceleratorRescanSchema = zod.z.object({
+	devices: zod.z.array(InferenceDeviceDescriptorSchema).readonly(),
+	appeared: zod.z.array(zod.z.string()).readonly(),
+	disappeared: zod.z.array(zod.z.string()).readonly(),
+	usbBus: zod.z.enum(["observed", "unobservable"]),
+	decidedBy: zod.z.enum([
+		"usb-ids",
+		"pci",
+		"delegate-fallback",
+		"none"
+	])
+});
+var platformProbeCapability = {
+	name: "platform-probe",
+	scope: "system",
+	mode: "singleton",
+	methods: {
+		getCapabilities: require_sleep.method(zod.z.void(), PlatformCapabilitiesSchema),
+		getHardware: require_sleep.method(zod.z.void(), HardwareInfoSchema),
+		resolveInferenceConfig: require_sleep.method(zod.z.object({ requirements: zod.z.array(ModelRequirementSchema).readonly() }), ResolvedInferenceConfigSchema),
+		resolveHwAccel: require_sleep.method(zod.z.object({ prefer: HwAccelBackendInputSchema }), HwAccelResolutionSchema),
+		/**
+		* Re-probe this node's accelerators NOW (Coral USB ids + PCIe apex units;
+		* `/sys` and `/dev` reads, no model load) and rebuild the device list that
+		* `getCapabilities` serves. The same re-probe runs every 60 s on its own;
+		* this is the operator's "rescan inference devices". Target a node with the
+		* `{ nodeId }` routing input, like `getCapabilities`.
+		*/
+		rescanAccelerators: require_sleep.method(zod.z.void(), AcceleratorRescanSchema, {
+			kind: "mutation",
+			auth: "admin"
+		})
+	}
+};
+//#endregion
+//#region src/capabilities/power-meter.cap.ts
+/**
+* Multi-metric electrical meter. One slice can carry any combination
+* of instantaneous power (W), cumulative energy (kWh), voltage (V),
+* and current (A) — all fields optional so a single-metric source
+* (HA `sensor` with `device_class: power`) populates only what it
+* has and aggregators (energy dashboards, billing exports) compose
+* across providers without needing one cap per metric.
+*
+* Trade-off acknowledged: a HomeKit export that wants to surface
+* "power" and "energy" as separate services has to crack open the
+* slice and emit two characteristics from one cap. Worth it to avoid
+* exploding the cap catalog with `power-w` / `energy-kwh` /
+* `voltage-v` / `current-a` quartets that always travel together
+* in real-world devices.
+*/
+var PowerMeterStatusSchema = zod.z.object({
+	/** Instantaneous power draw in watts. */
+	watts: zod.z.number().optional(),
+	/** Cumulative energy in kilowatt-hours since the meter was reset. */
+	kwhTotal: zod.z.number().optional(),
+	/** Voltage in volts. */
+	volts: zod.z.number().optional(),
+	/** Current in amperes. */
+	amps: zod.z.number().optional(),
+	/** Apparent power in volt-amperes (W × power-factor reciprocal). */
+	va: zod.z.number().optional(),
+	/** Power factor (0..1) if reported. */
+	powerFactor: zod.z.number().min(0).max(1).optional(),
+	/** Ms epoch when the slice was last updated. */
+	lastFetchedAt: zod.z.number(),
+	/** Live display unit of the single metric this slice carries (e.g. HA
+	*  `attributes.unit_of_measurement` → 'V' / 'A' / 'W' / 'kW' / 'kWh').
+	*  Each upstream `sensor.*` entity surfaces ONE device_class, so one
+	*  unit per slice is unambiguous. The UI prefers this over the role's
+	*  canonical unit so a 'kW' / 'Wh' feed renders verbatim. */
+	unit: zod.z.string().optional(),
+	/** Suggested decimal places for numeric display.
+	*  Populated live from the upstream source when provided (e.g. HA
+	*  `attributes.suggested_display_precision`). Falls back to
+	*  auto-formatting when absent. */
+	precision: zod.z.number().int().min(0).max(10).optional()
+});
+var powerMeterCapability = {
+	name: "power-meter",
+	scope: "device",
+	deviceNative: true,
+	mode: "singleton",
+	deviceTypes: [require_err_msg.DeviceType.Sensor],
+	methods: {},
+	status: {
+		schema: PowerMeterStatusSchema,
+		kind: "push"
+	},
+	runtimeState: PowerMeterStatusSchema,
+	/**
+	* Runtime-state durability: **restored** — as `numeric-sensor`; `kwhTotal` is an accumulator whose restored value is the baseline.
+	*
+	* See `RuntimeStateDurability`. Enforced by
+	* `scripts/check-runtime-state-durability.ts`.
+	*/
+	durability: "restored",
+	/**
+	* History (D850): recorded series. Gauges are floored at 30 s; `kwhTotal` is the one monotonic meter (counter).
+	*/
+	history: { fields: {
+		watts: {
+			kind: "gauge",
+			unit: "W",
+			deadband: 1,
+			minIntervalMs: 3e4
+		},
+		kwhTotal: {
+			kind: "counter",
+			unit: "kWh",
+			deadband: .01,
+			minIntervalMs: 6e4
+		},
+		volts: {
+			kind: "gauge",
+			unit: "V",
+			deadband: 1,
+			minIntervalMs: 3e4
+		},
+		amps: {
+			kind: "gauge",
+			unit: "A",
+			deadband: .05,
+			minIntervalMs: 3e4
+		},
+		va: {
+			kind: "gauge",
+			unit: "VA",
+			deadband: 1,
+			minIntervalMs: 3e4
+		},
+		powerFactor: {
+			kind: "gauge",
+			unit: "ratio",
+			deadband: .01,
+			minIntervalMs: 6e4
+		}
+	} },
+	/** Clock fields: written, but excluded from the compare that decides
+	*  whether persisting is worth a SQLite commit. */
+	volatileStateFields: ["lastFetchedAt"]
+};
+//#endregion
+//#region src/capabilities/presence.cap.ts
+/**
+* Presence cap. Models HA `person.*` and `device_tracker.*` entities
+* on `DeviceType.Presence`. Read-only — no setters: presence is
+* derived from upstream signals (mobile-app location, router DHCP
+* lease, Bluetooth beacon, manual zone change) and pushed into the
+* slice.
+*
+* `state` follows HA's canonical values — `home` / `not_home` /
+* `<zone-name>` for any other named zone. The zone name is freeform
+* because users define arbitrary zones (`work`, `gym`, `school`).
+*
+* GPS coordinates are nullable — tracker types without location
+* (Bluetooth scanner, MQTT presence) omit them. The presence of
+* GPS data is signaled by `DeviceFeature.PresenceGps` for fast
+* UI map-pin rendering.
+*/
+var GpsLocationSchema = zod.z.object({
+	/** Latitude in decimal degrees, -90..90. */
+	latitude: zod.z.number().min(-90).max(90),
+	/** Longitude in decimal degrees, -180..180. */
+	longitude: zod.z.number().min(-180).max(180),
+	/** Reported accuracy in meters (lower = better). */
+	accuracyMeters: zod.z.number().nonnegative()
+});
+var PresenceStatusSchema = zod.z.object({
+	/** `home` / `not_home` / any user-defined zone name. */
+	state: zod.z.string(),
+	/** Optional textual location label (zone name, city, address). Null
+	*  when only the binary state is known. */
+	location: zod.z.string().nullable(),
+	/** GPS coordinates when available. Null otherwise. */
+	gps: GpsLocationSchema.nullable(),
+	/** Optional battery level of the tracking device (0..100). Null
+	*  when not reported. */
+	batteryPercent: zod.z.number().min(0).max(100).nullable(),
+	/** Ms epoch when the slice was last updated. */
 	lastChangedAt: zod.z.number()
 });
 var presenceCapability = {
@@ -71757,7 +72501,20 @@ var ZoneRuleSchema = zod.z.object({
 	* Defaults to `true` so operators creating a rule via the UI
 	* see it active immediately.
 	*/
-	enabled: zod.z.boolean().default(true)
+	enabled: zod.z.boolean().default(true),
+	/**
+	* Package stage only. When true, a package candidate may open from a
+	* scene difference in this rule's zone after a person leaves. The
+	* package model, when it boxes something overlapping, is extra evidence
+	* and is not the gate. Absent or false keeps today's model path.
+	*/
+	detectBySceneDifference: zod.z.boolean().optional(),
+	/**
+	* Package stage only. When true, a promoted package is shown to the
+	* `llm` cap before the delivery event is emitted. Absent or false emits
+	* as today. Usable with or without `detectBySceneDifference`.
+	*/
+	confirmWithLlm: zod.z.boolean().optional()
 });
 /**
 * Convenience array schema — used by addon device-settings
@@ -74721,7 +75478,7 @@ var trainingProviderCapability = {
 * - **Jobs.** A persisted state machine, a reconcile loop against the
 *   provider, a cost guard, a daily orphan sweep and the retention rules.
 * - **The return flow.** Verified artefacts → Model Studio
-*   (`custom-model-registry.importModelBundle`) → canary on cameras →
+*   (`custom-model-registry.importModelBundle`) → canary on accelerators →
 *   rollback. Nothing is ever registered automatically.
 *
 * Plan/start takes a live {@link TrainingCorpusSelection} (collections +
@@ -74858,20 +75615,24 @@ var TrainingProgressPointSchema = zod.z.object({
 	map50: zod.z.number().nullable(),
 	map50_95: zod.z.number().nullable()
 });
+/** One accelerator: a `(node, inference device)` that runs the root detector. */
+var TrainingAcceleratorRefSchema = zod.z.object({
+	nodeId: zod.z.string(),
+	deviceKey: zod.z.string()
+});
+/**
+* A canary pins the registered model on chosen ACCELERATORS — a model is
+* chosen by the accelerator that runs it (D927); every camera balanced onto
+* one runs it. `previous` is the root-detector pin each one had (`null` = it
+* ran its default), exactly, so rollback restores it.
+*/
 var TrainingCanarySchema = zod.z.object({
-	deviceIds: zod.z.array(zod.z.number().int()).readonly(),
+	accelerators: zod.z.array(TrainingAcceleratorRefSchema).readonly(),
 	since: zod.z.number(),
-	/** Every override the canary replaced, exactly, so rollback restores it. */
-	previous: zod.z.array(zod.z.object({
-		deviceId: zod.z.number().int(),
-		nodeId: zod.z.string(),
-		deviceKey: zod.z.string(),
-		patch: zod.z.object({
-			modelId: zod.z.string().optional(),
-			settings: zod.z.record(zod.z.string(), zod.z.unknown()).readonly().optional()
-		}).nullable()
-	})).readonly()
+	previous: zod.z.array(TrainingAcceleratorRefSchema.extend({ modelId: zod.z.string().nullable() })).readonly()
 });
+/** An accelerator a canary may pin: it runs the root detector, on this model now. */
+var TrainingCanaryTargetSchema = TrainingAcceleratorRefSchema.extend({ pinnedModelId: zod.z.string().nullable() });
 var TrainingJobSchema = zod.z.object({
 	id: zod.z.string(),
 	idempotencyKey: zod.z.string(),
@@ -75011,19 +75772,21 @@ var trainingCapability = {
 		}),
 		/** The verified `result.json` of a job in `ready` or later; null before. */
 		getJobResult: require_sleep.method(IdInput, TrainingResultSchema.nullable(), { auth: "admin" }),
+		/** The accelerators a canary may pin: every enabled one that runs the root detector. */
+		listCanaryTargets: require_sleep.method(zod.z.void(), zod.z.array(TrainingCanaryTargetSchema).readonly(), { auth: "admin" }),
 		/** Hand the verified bundle to Model Studio; optionally canary right after. */
-		registerResult: require_sleep.method(IdInput.extend({ canaryDeviceIds: zod.z.array(zod.z.number().int()).readonly() }), TrainingJobSchema, {
+		registerResult: require_sleep.method(IdInput.extend({ canaryAccelerators: zod.z.array(TrainingAcceleratorRefSchema).readonly() }), TrainingJobSchema, {
 			kind: "mutation",
 			auth: "admin",
 			timeoutMs: 30 * 6e4
 		}),
-		/** Pin the registered model on these cameras, remembering what it replaced. */
-		canaryResult: require_sleep.method(IdInput.extend({ deviceIds: zod.z.array(zod.z.number().int()).min(1).readonly() }), TrainingJobSchema, {
+		/** Pin the registered model on these accelerators, remembering what it replaced. */
+		canaryResult: require_sleep.method(IdInput.extend({ accelerators: zod.z.array(TrainingAcceleratorRefSchema).min(1).readonly() }), TrainingJobSchema, {
 			kind: "mutation",
 			auth: "admin",
 			timeoutMs: 12e4
 		}),
-		/** Put every canary camera back exactly as it was. */
+		/** Put every canary accelerator back exactly as it was. */
 		rollbackCanary: require_sleep.method(IdInput, TrainingJobSchema, {
 			kind: "mutation",
 			auth: "admin",
@@ -84623,20 +85386,6 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		access: "create",
 		role: "admin"
 	},
-	"pipelineExecutor.clearDeviceOverrides": {
-		capName: "pipeline-executor",
-		capScope: "system",
-		addonId: null,
-		access: "delete",
-		role: "admin"
-	},
-	"pipelineExecutor.clearModelBoundDeviceOverrides": {
-		capName: "pipeline-executor",
-		capScope: "system",
-		addonId: null,
-		access: "delete",
-		role: "admin"
-	},
 	"pipelineExecutor.deleteModel": {
 		capName: "pipeline-executor",
 		capScope: "system",
@@ -84679,13 +85428,6 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		access: "view",
 		role: "admin"
 	},
-	"pipelineExecutor.getDefaultSteps": {
-		capName: "pipeline-executor",
-		capScope: "system",
-		addonId: null,
-		access: "view",
-		role: "admin"
-	},
 	"pipelineExecutor.getDetectionConfigSchema": {
 		capName: "pipeline-executor",
 		capScope: "system",
@@ -84707,20 +85449,6 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		access: "view",
 		role: "admin"
 	},
-	"pipelineExecutor.getGlobalPipelineConfig": {
-		capName: "pipeline-executor",
-		capScope: "system",
-		addonId: null,
-		access: "view",
-		role: "admin"
-	},
-	"pipelineExecutor.getGlobalSteps": {
-		capName: "pipeline-executor",
-		capScope: "system",
-		addonId: null,
-		access: "view",
-		role: "admin"
-	},
 	"pipelineExecutor.getInferenceDeviceHealth": {
 		capName: "pipeline-executor",
 		capScope: "system",
@@ -84980,13 +85708,6 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		access: "view",
 		role: "admin"
 	},
-	"pipelineOrchestrator.getCameraStepOverrides": {
-		capName: "pipeline-orchestrator",
-		capScope: "system",
-		addonId: null,
-		access: "view",
-		role: "admin"
-	},
 	"pipelineOrchestrator.getCameraSwitches": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
@@ -85225,13 +85946,6 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		access: "create",
 		role: "admin"
 	},
-	"pipelineOrchestrator.setCameraPipelineForAgent": {
-		capName: "pipeline-orchestrator",
-		capScope: "system",
-		addonId: null,
-		access: "create",
-		role: "admin"
-	},
 	"pipelineOrchestrator.setCameraSensors": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
@@ -85239,42 +85953,42 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		access: "create",
 		role: "admin"
 	},
-	"pipelineOrchestrator.setCameraStepOverride": {
+	"pipelineOrchestrator.setCameraStepSettings": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
 		addonId: null,
 		access: "create",
 		role: "admin"
 	},
-	"pipelineOrchestrator.setCameraStepSettings": {
+	"pipelineOrchestrator.setCameraStepToggle": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
 		addonId: null,
 		access: "create",
 		role: "admin"
 	},
-	"pipelineOrchestrator.setCameraStepToggle": {
+	"pipelineOrchestrator.setCameraSwitch": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
 		addonId: null,
 		access: "create",
 		role: "admin"
 	},
-	"pipelineOrchestrator.setCameraSwitch": {
+	"pipelineOrchestrator.setCapabilityBinding": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
 		addonId: null,
 		access: "create",
 		role: "admin"
 	},
-	"pipelineOrchestrator.setCapabilityBinding": {
+	"pipelineOrchestrator.setLoadBalancingShares": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
 		addonId: null,
 		access: "create",
 		role: "admin"
 	},
-	"pipelineOrchestrator.setLoadBalancingShares": {
+	"pipelineOrchestrator.setNodeStepSettings": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
 		addonId: null,
@@ -87633,6 +88347,13 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		access: "view",
 		role: "admin"
 	},
+	"training.listCanaryTargets": {
+		capName: "training",
+		capScope: "system",
+		addonId: null,
+		access: "view",
+		role: "admin"
+	},
 	"training.listJobs": {
 		capName: "training",
 		capScope: "system",
@@ -97172,11 +97893,6 @@ var METHOD_DEVICE_SELECTORS = Object.freeze({
 		form: "single",
 		optional: false
 	}],
-	"pipelineExecutor.clearModelBoundDeviceOverrides": [{
-		name: "deviceIds",
-		form: "array",
-		optional: true
-	}],
 	"pipelineExecutor.runPipeline": [{
 		name: "deviceId",
 		form: "single",
@@ -97232,11 +97948,6 @@ var METHOD_DEVICE_SELECTORS = Object.freeze({
 		form: "array",
 		optional: true
 	}],
-	"pipelineOrchestrator.getCameraStepOverrides": [{
-		name: "deviceId",
-		form: "single",
-		optional: false
-	}],
 	"pipelineOrchestrator.getCameraSwitches": [{
 		name: "deviceId",
 		form: "single",
@@ -97277,21 +97988,11 @@ var METHOD_DEVICE_SELECTORS = Object.freeze({
 		form: "single",
 		optional: false
 	}],
-	"pipelineOrchestrator.setCameraPipelineForAgent": [{
-		name: "deviceId",
-		form: "single",
-		optional: false
-	}],
 	"pipelineOrchestrator.setCameraSensors": [{
 		name: "deviceId",
 		form: "single",
 		optional: false
 	}],
-	"pipelineOrchestrator.setCameraStepOverride": [{
-		name: "deviceId",
-		form: "single",
-		optional: false
-	}],
 	"pipelineOrchestrator.setCameraStepSettings": [{
 		name: "deviceId",
 		form: "single",
@@ -97969,11 +98670,6 @@ var METHOD_DEVICE_SELECTORS = Object.freeze({
 		form: "single",
 		optional: false
 	}],
-	"training.canaryResult": [{
-		name: "deviceIds",
-		form: "array",
-		optional: false
-	}],
 	"update.getStatus": [{
 		name: "deviceId",
 		form: "single",
@@ -98307,7 +99003,6 @@ var SYSTEM_SCOPE_DEVICE_METHODS = [
 	"osdManager.renderDevice",
 	"osdManager.setSlotBinding",
 	"osdManager.setSlotCameraEnabled",
-	"pipelineExecutor.clearModelBoundDeviceOverrides",
 	"pipelineExecutor.runPipeline",
 	"pipelineExecutor.runPipelineBatch",
 	"pipelineOrchestrator.applyDeviceSettingsPatch",
@@ -98319,7 +99014,6 @@ var SYSTEM_SCOPE_DEVICE_METHODS = [
 	"pipelineOrchestrator.getCameraSettings",
 	"pipelineOrchestrator.getCameraStatus",
 	"pipelineOrchestrator.getCameraStatuses",
-	"pipelineOrchestrator.getCameraStepOverrides",
 	"pipelineOrchestrator.getCameraSwitches",
 	"pipelineOrchestrator.getDeviceLiveContribution",
 	"pipelineOrchestrator.getDeviceSettingsContribution",
@@ -98328,9 +99022,7 @@ var SYSTEM_SCOPE_DEVICE_METHODS = [
 	"pipelineOrchestrator.requestOccupancyLook",
 	"pipelineOrchestrator.resolvePipeline",
 	"pipelineOrchestrator.setCameraDetectionSource",
-	"pipelineOrchestrator.setCameraPipelineForAgent",
 	"pipelineOrchestrator.setCameraSensors",
-	"pipelineOrchestrator.setCameraStepOverride",
 	"pipelineOrchestrator.setCameraStepSettings",
 	"pipelineOrchestrator.setCameraStepToggle",
 	"pipelineOrchestrator.setCameraSwitch",
@@ -98395,8 +99087,7 @@ var SYSTEM_SCOPE_DEVICE_METHODS = [
 	"streamBroker.restartProfile",
 	"streamBroker.retractCameraStream",
 	"streamBroker.setDeviceAudioMute",
-	"streamBroker.unassignProfile",
-	"training.canaryResult"
+	"streamBroker.unassignProfile"
 ];
 //#endregion
 //#region src/generated/provider-kind-map.ts
@@ -99863,17 +100554,12 @@ function createSystemProxy(api) {
 		pipelineExecutor: {
 			getAvailableEngines: (input) => dispatch("pipelineExecutor", "getAvailableEngines", "query", input),
 			getSelectedEngine: (input) => dispatch("pipelineExecutor", "getSelectedEngine", "query", input),
-			getDefaultSteps: (input) => dispatch("pipelineExecutor", "getDefaultSteps", "query", input),
 			getEngineProvisioning: (input) => dispatch("pipelineExecutor", "getEngineProvisioning", "query", input),
 			getVideoPipelineSteps: (input) => dispatch("pipelineExecutor", "getVideoPipelineSteps", "query", input),
 			setVideoPipelineSteps: (input) => dispatch("pipelineExecutor", "setVideoPipelineSteps", "mutation", input),
-			clearDeviceOverrides: (input) => dispatch("pipelineExecutor", "clearDeviceOverrides", "mutation", input),
-			clearModelBoundDeviceOverrides: (input) => dispatch("pipelineExecutor", "clearModelBoundDeviceOverrides", "mutation", input),
 			getInferenceDeviceHealth: (input) => dispatch("pipelineExecutor", "getInferenceDeviceHealth", "query", input),
 			rearmInferenceDevice: (input) => dispatch("pipelineExecutor", "rearmInferenceDevice", "mutation", input),
 			getSchema: (input) => dispatch("pipelineExecutor", "getSchema", "query", input),
-			getGlobalSteps: (input) => dispatch("pipelineExecutor", "getGlobalSteps", "query", input),
-			getGlobalPipelineConfig: (input) => dispatch("pipelineExecutor", "getGlobalPipelineConfig", "query", input),
 			getOrchestratorConfigSchema: (input) => dispatch("pipelineExecutor", "getOrchestratorConfigSchema", "query", input),
 			validatePipeline: (input) => dispatch("pipelineExecutor", "validatePipeline", "query", input),
 			getCapabilities: (input) => dispatch("pipelineExecutor", "getCapabilities", "query", input),
@@ -99917,6 +100603,7 @@ function createSystemProxy(api) {
 			setAgentDecodeLimits: (input) => dispatch("pipelineOrchestrator", "setAgentDecodeLimits", "mutation", input),
 			setAgentReachableHost: (input) => dispatch("pipelineOrchestrator", "setAgentReachableHost", "mutation", input),
 			setAgentInferenceDevices: (input) => dispatch("pipelineOrchestrator", "setAgentInferenceDevices", "mutation", input),
+			setNodeStepSettings: (input) => dispatch("pipelineOrchestrator", "setNodeStepSettings", "mutation", input),
 			getNodeInferenceDevices: (input) => dispatch("pipelineOrchestrator", "getNodeInferenceDevices", "query", input),
 			forgetInferenceDevice: (input) => dispatch("pipelineOrchestrator", "forgetInferenceDevice", "mutation", input),
 			resetNodePipelineDefaults: (input) => dispatch("pipelineOrchestrator", "resetNodePipelineDefaults", "mutation", input),
@@ -100137,6 +100824,7 @@ function createSystemProxy(api) {
 			getJob: (input) => dispatch("training", "getJob", "query", input),
 			cancelJob: (input) => dispatch("training", "cancelJob", "mutation", input),
 			getJobResult: (input) => dispatch("training", "getJobResult", "query", input),
+			listCanaryTargets: (input) => dispatch("training", "listCanaryTargets", "query", input),
 			registerResult: (input) => dispatch("training", "registerResult", "mutation", input),
 			canaryResult: (input) => dispatch("training", "canaryResult", "mutation", input),
 			rollbackCanary: (input) => dispatch("training", "rollbackCanary", "mutation", input),
@@ -105734,911 +106422,350 @@ function providerMotionEvent(source, data) {
 function hasBuild(model, format) {
 	return Boolean(model.formats[format]);
 }
-/**
-* Can a pool of `format` run a step whose catalog is `models`, given the model
-* the step names (`null`/absent = unpinned, the format default)?
-*/
-function stepModelRunsOnFormat(models, modelId, format) {
-	if (modelId !== void 0 && modelId !== null) {
-		const named = models.find((m) => m.id === modelId);
-		if (named !== void 0 && hasBuild(named, format)) return true;
-	}
-	return models.some((m) => m.legacy !== true && hasBuild(m, format));
-}
-//#endregion
-//#region src/pipeline/removed-model-ids.ts
-/**
-* Model ids DELETED from a step's catalog (D703, D710, D719), per step — and
-* the one question asked of them: is a stored pin to this id a pin to a model
-* that no longer exists? (D725)
-*
-* This is NOT a resolver input. `resolveModelForFormat` still returns an
-* unknown id unchanged (a custom model), and a bulk pass pinned to one still
-* refuses rather than substitutes (D54). The ONE reader is the orchestrator's
-* stored-pin reset (`removed-model-pin-reset.ts`), which clears such a pin from
-* the store so the step follows its default again — unless a registered custom
-* model carries the same id.
-*
-* `removed-model-ids.spec.ts` (addon-pipeline) pins that every id here is
-* really absent from its step's catalog. A model deleted from a catalog is
-* added here in the same change, or its stored pins stay behind as custom ids.
-*/
-/** `stepId → ids deleted from that step's catalog`. */
-var REMOVED_MODEL_IDS = {
-	"object-detection": ["efficientdet-lite0-edgetpu", "ssdlite-mobiledet-coco-edgetpu"],
-	"face-detection": [
-		"scrypted-yolov9t-face",
-		"scrfd-2.5g",
-		"ssd-mobilenet-v2-face-edgetpu"
-	],
-	"face-embedding": ["arcface-r100", "inception-resnet-v1"],
-	"plate-detection": ["yolov8n-plate"],
-	"plate-ocr": ["vgg-english-g2"],
-	"clip-embedding": [
-		"mobileclip-s0",
-		"mobileclip-s1",
-		"mobileclip-s2"
-	],
-	"package-detection": ["yolov8n-package"],
-	"bird-classifier": ["bird-classifier-aiy-edgetpu", "bird-nabirds-404"],
-	"animal-classifier": ["animals-10"],
-	"vehicle-classifier": ["vehicle-type-efficientnet"]
-};
-/** True when `modelId` was deleted from `stepId`'s catalog. */
-function isRemovedModelId(stepId, modelId) {
-	return REMOVED_MODEL_IDS[stepId]?.includes(modelId) ?? false;
-}
-//#endregion
-//#region src/pipeline/model-bound-settings.ts
-/** 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;
-}
-/** Store `value` for `key`, made for `modelId`. Returns a fresh object. */
-function writeModelBoundSetting(settings, key, value, modelId) {
-	return {
-		...settings,
-		[key]: value,
-		[modelBindingKey(key)]: modelId
-	};
-}
-/** Remove an override and its binding — "reset to the model default". */
-function clearModelBoundSetting(settings, key) {
-	const out = { ...settings };
-	delete out[key];
-	delete out[modelBindingKey(key)];
-	return out;
-}
-/** True when any of `boundKeys` has an override IN FORCE for `modelId`. */
-function hasModelBoundOverrides(settings, boundKeys, modelId) {
-	return boundKeys.some((key) => resolveModelBoundSetting(settings, key, modelId, void 0, void 0).source === "override");
-}
-/**
-* "Reset thresholds to model defaults": remove every override of `boundKeys`
-* that is in force for `modelId` (bound to it, or unbound), with its binding —
-* one result, so the editor writes it in one save. An override stored for
-* ANOTHER model is kept: it is not in force here, and it applies again when
-* that model runs.
-*/
-function clearModelBoundOverrides(settings, boundKeys, modelId) {
-	return boundKeys.reduce((acc, key) => resolveModelBoundSetting(acc, key, modelId, void 0, void 0).source === "override" ? clearModelBoundSetting(acc, key) : acc, { ...settings });
-}
-/**
-* The keys of every `bindsToModel` field of a step's config schema, groups
-* flattened (D738). One definition for the runner (which applies the binding)
-* and the orchestrator's Auto tune (which clears those overrides, D745).
-*/
-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] : [];
-	});
-}
-//#endregion
-//#region src/pipeline/step-settings-layers.ts
-/**
-* The layers of a detection step's settings, and the field-level edits on them
-* (D754).
-*
-* A step's settings reach a session through up to three stored layers, merged
-* key by key — a key in a higher layer wins:
-*
-*   node         the node's folded base (`inferenceDevices[node][*].steps`)
-*   camera       `cameraSettings[cam].stepSettings[step]` — every accelerator
-*   accelerator  `cameraSettings[cam].stepOverridesByDevice[node][key][step].settings`
-*
-* Below them sits the default: the running model's (D738) or the field's own.
-*
-* Every layer is SPARSE and FIELD-LEVEL. A key present in a layer is an
-* override; an absent key inherits. Two consequences that every editor must
-* respect, and why this module exists:
-*
-*   - A model-bound field (D738) occupies TWO keys, its value and
-*     `<key>ModelId`. They are written, compared and removed as one unit — a
-*     value without its binding over a lower layer's binding would be judged
-*     against the wrong model.
-*   - An editor writes a DIFF against the merged layers below, never a copy of
-*     them. A copy pins every field at the value it had that day, so later
-*     edits below never reach it (the full-copy "Override" this replaced).
-*/
-/** Top-down order of the stored layers. */
-var LAYER_ORDER = [
-	"accelerator",
-	"camera",
-	"node"
-];
-/**
-* The keys one field occupies in a bag: its own, plus its binding key when it
-* binds to a model. `boundKeys` = `collectModelBoundKeys(schema)`.
-*/
-function fieldUnitKeys(key, boundKeys) {
-	return boundKeys.includes(key) ? [key, modelBindingKey(key)] : [key];
-}
-/** The field a stored key belongs to (`minConfidencePersonModelId` → `minConfidencePerson`). */
-function unitOf(storedKey, boundKeys) {
-	return boundKeys.find((k) => modelBindingKey(k) === storedKey) ?? storedKey;
-}
-/** Structural equality for stored values (numbers, strings, booleans, arrays, plain objects). */
-function settingValuesEqual(a, b) {
-	if (Object.is(a, b)) return true;
-	if (Array.isArray(a) && Array.isArray(b)) return a.length === b.length && a.every((v, i) => settingValuesEqual(v, b[i]));
-	if (isPlainObject(a) && isPlainObject(b)) {
-		const ka = Object.keys(a);
-		const kb = Object.keys(b);
-		return ka.length === kb.length && ka.every((k) => settingValuesEqual(a[k], b[k]));
-	}
-	return false;
-}
-function isPlainObject(v) {
-	return typeof v === "object" && v !== null && !Array.isArray(v);
-}
-/** Merge bags bottom-up (later wins, per key). Fresh object. */
-function mergeSettingsBags(...bags) {
-	return bags.reduce((acc, bag) => ({
-		...acc,
-		...bag
-	}), {});
-}
-/** The merged value of the layers BELOW `layer` (what removing a key from `layer` falls back to). */
-function settingsBelow(layers, layer) {
-	return mergeSettingsBags(...LAYER_ORDER.slice(LAYER_ORDER.indexOf(layer) + 1).toReversed().map((id) => layers[id]));
-}
-/** The effective bag: every stored layer merged. */
-function effectiveStepSettings(layers) {
-	return mergeSettingsBags(layers.node, layers.camera, layers.accelerator);
-}
-/** The highest stored layer that holds any key of `key`'s unit, or `default`. */
-function stepSettingSource(layers, key, boundKeys) {
-	const unit = fieldUnitKeys(key, boundKeys);
-	for (const id of LAYER_ORDER) {
-		const bag = layers[id];
-		if (bag !== void 0 && unit.some((k) => bag[k] !== void 0)) return id;
-	}
-	return "default";
-}
-/**
-* `layer` with `key`'s unit set from `values` (a bag carrying the unit's new
-* value — e.g. the editor's whole next settings bag). A unit key that `values`
-* does not carry is removed from the layer. Fresh object.
-*/
-function withFieldFrom(layer, key, values, boundKeys) {
-	const out = { ...layer };
-	for (const k of fieldUnitKeys(key, boundKeys)) if (values[k] === void 0) delete out[k];
-	else out[k] = values[k];
-	return out;
-}
-/** `layer` without `key`'s unit — "reset to the next level". Fresh object. */
-function withoutField(layer, key, boundKeys) {
-	const out = { ...layer };
-	for (const k of fieldUnitKeys(key, boundKeys)) delete out[k];
-	return out;
-}
-/** Every field unit stored in `layer`, by its field key. */
-function unitsIn(layer, boundKeys) {
-	return [...new Set(Object.keys(layer).map((k) => unitOf(k, boundKeys)))];
-}
-/** True when every key of `key`'s unit has the same value in `layer` as in `below`. */
-function unitEqualsBelow(layer, below, key, boundKeys) {
-	return fieldUnitKeys(key, boundKeys).every((k) => settingValuesEqual(layer[k], below[k]));
-}
-/**
-* `layer` reduced to the fields that DIFFER from `below` — what an editor
-* stores. A unit is kept or dropped whole. `undefined` when nothing is left.
-*/
-function diffStepSettings(layer, below, boundKeys) {
-	if (layer === void 0) return void 0;
-	const out = {};
-	for (const unit of unitsIn(layer, boundKeys)) {
-		if (unitEqualsBelow(layer, below, unit, boundKeys)) continue;
-		for (const k of fieldUnitKeys(unit, boundKeys)) if (layer[k] !== void 0) out[k] = layer[k];
-	}
-	return Object.keys(out).length > 0 ? out : void 0;
-}
-/**
-* The fields `layer` stores at exactly the value of the layers below — a
-* legacy full copy's leftovers. They change nothing today and stop every
-* later edit below from reaching this layer. Sorted.
-*/
-function fieldsPinnedAtValueBelow(layer, below, boundKeys) {
-	if (layer === void 0) return [];
-	return unitsIn(layer, boundKeys).filter((unit) => unitEqualsBelow(layer, below, unit, boundKeys)).toSorted();
-}
-//#endregion
-//#region src/pipeline/auto-tune/hardware-class.ts
-var APPLE_CHIP = /^Apple M(\d+)(?:\s+(Pro|Max|Ultra))?\b/i;
-var INTEL_CORE_ULTRA = /Core\(TM\)\s+Ultra|Core Ultra/i;
-var INTEL_N_SERIES = /Intel\(R\)\s+N\d{2,3}\b|\bIntel\s+N\d{2,3}\b/i;
-/** Phoenix / Hawk Point mobile (7040/8040) and Ryzen 8000G desktop APUs. */
-var AMD_PHOENIX = /Ryzen \d+ (7[0-9]40|8[0-9]40|8[0-9]45)[HSU]|Ryzen \d+ 8[0-9]00G/i;
-function parseAppleChip(cpuModel) {
-	const match = APPLE_CHIP.exec(cpuModel.trim());
-	if (match === null) return null;
-	const generation = Number(match[1]);
-	const variantRaw = (match[2] ?? "base").toLowerCase();
-	return {
-		generation,
-		variant: variantRaw === "pro" || variantRaw === "max" || variantRaw === "ultra" ? variantRaw : "base"
-	};
-}
-/**
-* Classify a node. Apple base chips (M1–M4) map to the measured M2 column, the
-* Pro/Max/Ultra chips to the measured M3 Pro column — the M2 was measured at
-* 1.0–1.2× the M3 Pro on the Neural Engine, so the generation inside a variant
-* matters less than the column's own error.
-*/
-function classifyInferenceHardware(hw) {
-	const cpuModel = hw.cpuModel;
-	const apple = parseAppleChip(cpuModel);
-	if (apple !== null) return {
-		hardwareClass: apple.variant === "base" ? "apple-m-base" : "apple-m-pro",
-		cpuModel,
-		apple
-	};
-	if (INTEL_CORE_ULTRA.test(cpuModel)) return {
-		hardwareClass: "intel-core-ultra",
-		cpuModel
-	};
-	if (INTEL_N_SERIES.test(cpuModel)) return {
-		hardwareClass: "intel-n-series",
-		cpuModel
-	};
-	if (AMD_PHOENIX.test(cpuModel)) return {
-		hardwareClass: "amd-phoenix",
-		cpuModel
-	};
-	return {
-		hardwareClass: "unknown",
-		cpuModel
-	};
-}
-/**
-* The accelerator kind of one of a node's device keys (`openvino:npu`,
-* `openvino:gpu`, `coreml:all`, `edgetpu:usb`, `cpu`, `onnx:cpu`, …). `null`
-* for a key this table has no column for.
-*/
-function acceleratorKindOf(deviceKey, hw) {
-	const [backend = "", device = ""] = deviceKey.split(":");
-	if (backend === "edgetpu") return "coral";
-	if (backend === "coreml") return device === "cpu" ? "arm-cpu" : "apple-ane";
-	if (backend === "openvino" && device === "npu") return "intel-npu";
-	if (backend === "openvino" && device === "gpu") return "intel-igpu";
-	if (backend === "onnx" && device === "webgpu") return "amd-igpu";
-	if (backend === "vitisai" && device === "npu") return "amd-npu";
-	if (backend === "cpu" || device === "cpu") return hw.arch === "arm64" ? "arm-cpu" : "x86-cpu";
-	return null;
-}
-//#endregion
-//#region src/pipeline/auto-tune/detector-performance.ts
-var DETECTOR_PERF = {
-	"intel-core-ultra": {
-		"intel-npu": {
-			"yolov9t-320": {
-				p50Ms: 2.9,
-				fps: 383,
-				measured: true
-			},
-			"yolov9t-320-int8": {
-				p50Ms: 3.8,
-				fps: 333,
-				measured: true
-			},
-			"yolov9t-640": {
-				p50Ms: 7.4,
-				fps: 139,
-				measured: true
-			},
-			"yolov9t-640-int8": {
-				p50Ms: 7.5,
-				fps: 144,
-				measured: true
-			},
-			"yolov9s-320": {
-				p50Ms: 4.4,
-				fps: 241,
-				measured: true
-			},
-			"yolov9s-320-int8": {
-				p50Ms: 4.1,
-				fps: 264,
-				measured: true
-			},
-			"yolov9s-640": {
-				p50Ms: 12.7,
-				fps: 82,
-				measured: true
-			},
-			"yolov9s-640-int8": {
-				p50Ms: 10.7,
-				fps: 99,
-				measured: true
-			},
-			"yolov9m-320": {
-				p50Ms: 8.4,
-				fps: 123,
-				measured: true
-			},
-			"yolov9m-320-int8": {
-				p50Ms: 6.5,
-				fps: 165,
-				measured: true
-			},
-			"yolov9m-640": {
-				p50Ms: 29.5,
-				fps: 32,
-				measured: true
-			},
-			"yolov9m-640-int8": {
-				p50Ms: 19.5,
-				fps: 52,
-				measured: true
-			}
-		},
-		"intel-igpu": {
-			"yolov9t-320": {
-				p50Ms: 2.6,
-				fps: 405,
-				measured: true
-			},
-			"yolov9t-320-int8": {
-				p50Ms: 2.8,
-				fps: 324,
-				measured: true
-			},
-			"yolov9t-640": {
-				p50Ms: 6.5,
-				fps: 157,
-				measured: true
-			},
-			"yolov9t-640-int8": {
-				p50Ms: 5.6,
-				fps: 185,
-				measured: true
-			},
-			"yolov9s-320": {
-				p50Ms: 4.6,
-				fps: 200,
-				measured: true
-			},
-			"yolov9s-320-int8": {
-				p50Ms: 4.1,
-				fps: 239,
-				measured: true
-			},
-			"yolov9s-640": {
-				p50Ms: 15.2,
-				fps: 69,
-				measured: true
-			},
-			"yolov9s-640-int8": {
-				p50Ms: 10.5,
-				fps: 99,
-				measured: true
-			},
-			"yolov9m-320": {
-				p50Ms: 11.4,
-				fps: 88,
-				measured: true
-			},
-			"yolov9m-320-int8": {
-				p50Ms: 7,
-				fps: 127,
-				measured: true
-			},
-			"yolov9m-640": {
-				p50Ms: 40,
-				fps: 25,
-				measured: true
-			},
-			"yolov9m-640-int8": {
-				p50Ms: 23.5,
-				fps: 44,
-				measured: true
-			}
-		},
-		"x86-cpu": {
-			"yolov9t-320": {
-				p50Ms: 6.9,
-				fps: 145,
-				measured: true
-			},
-			"yolov9t-320-int8": {
-				p50Ms: 2.7,
-				fps: 405,
-				measured: true
-			},
-			"yolov9t-640": {
-				p50Ms: 23,
-				fps: 44,
-				measured: true
-			},
-			"yolov9t-640-int8": {
-				p50Ms: 8.8,
-				fps: 124,
-				measured: true
-			},
-			"yolov9s-320": {
-				p50Ms: 15.8,
-				fps: 63,
-				measured: true
-			},
-			"yolov9s-320-int8": {
-				p50Ms: 6.5,
-				fps: 180,
-				measured: true
-			},
-			"yolov9s-640": {
-				p50Ms: 58.2,
-				fps: 17,
-				measured: true
-			},
-			"yolov9s-640-int8": {
-				p50Ms: 20.1,
-				fps: 52,
-				measured: true
-			},
-			"yolov9m-320": {
-				p50Ms: 40,
-				fps: 25,
-				measured: true
-			},
-			"yolov9m-320-int8": {
-				p50Ms: 14.2,
-				fps: 74,
-				measured: true
-			},
-			"yolov9m-640": {
-				p50Ms: 155.8,
-				fps: 6,
-				measured: true
-			},
-			"yolov9m-640-int8": {
-				p50Ms: 52.4,
-				fps: 19,
-				measured: true
-			}
-		},
-		coral: { "yolov9s-320-edgetpu": {
-			p50Ms: 32,
-			fps: 31,
-			measured: false
-		} }
-	},
-	"intel-n-series": {
-		"intel-igpu": {
-			"yolov9t-320": {
-				p50Ms: 15,
-				fps: 48,
-				measured: true
-			},
-			"yolov9t-320-int8": {
-				p50Ms: 14.1,
-				fps: 67,
-				measured: true
-			},
-			"yolov9t-640": {
-				p50Ms: 38.5,
-				fps: 26,
-				measured: true
-			},
-			"yolov9t-640-int8": {
-				p50Ms: 33.1,
-				fps: 33,
-				measured: true
-			},
-			"yolov9s-320": {
-				p50Ms: 41.4,
-				fps: 24,
-				measured: true
-			},
-			"yolov9s-320-int8": {
-				p50Ms: 23.3,
-				fps: 34,
-				measured: true
-			},
-			"yolov9s-640": {
-				p50Ms: 127.4,
-				fps: 8,
-				measured: true
-			},
-			"yolov9s-640-int8": {
-				p50Ms: 92.9,
-				fps: 11,
-				measured: true
-			},
-			"yolov9m-320": {
-				p50Ms: 63.5,
-				fps: 16,
-				measured: true
-			},
-			"yolov9m-320-int8": {
-				p50Ms: 39.4,
-				fps: 26,
-				measured: true
-			},
-			"yolov9m-640": {
-				p50Ms: 215.5,
-				fps: 5,
-				measured: true
-			},
-			"yolov9m-640-int8": {
-				p50Ms: 139.1,
-				fps: 7,
-				measured: true
-			}
-		},
-		"x86-cpu": {
-			"yolov9t-320": {
-				p50Ms: 86.2,
-				fps: 12,
-				measured: true
-			},
-			"yolov9t-320-int8": {
-				p50Ms: 52.7,
-				fps: 20,
-				measured: true
-			},
-			"yolov9t-640": {
-				p50Ms: 322.1,
-				fps: 3,
-				measured: true
-			},
-			"yolov9t-640-int8": {
-				p50Ms: 205.6,
-				fps: 5,
-				measured: true
-			},
-			"yolov9s-320": {
-				p50Ms: 164.4,
-				fps: 6,
-				measured: true
-			},
-			"yolov9s-320-int8": {
-				p50Ms: 86.9,
-				fps: 12,
-				measured: true
-			},
-			"yolov9s-640": {
-				p50Ms: 341.3,
-				fps: 3,
-				measured: true
-			},
-			"yolov9s-640-int8": {
-				p50Ms: 185.3,
-				fps: 5,
-				measured: true
-			},
-			"yolov9m-320": {
-				p50Ms: 166.8,
-				fps: 6,
-				measured: true
-			},
-			"yolov9m-320-int8": {
-				p50Ms: 226.3,
-				fps: 4,
-				measured: true
-			},
-			"yolov9m-640": {
-				p50Ms: 663.5,
-				fps: 2,
-				measured: true
-			},
-			"yolov9m-640-int8": {
-				p50Ms: 324.4,
-				fps: 3,
-				measured: true
-			}
-		},
-		coral: { "yolov9s-320-edgetpu": {
-			p50Ms: 32,
-			fps: 31,
-			measured: false
-		} }
-	},
-	"amd-phoenix": {
-		"x86-cpu": {
-			"yolov9t-320": {
-				p50Ms: 24,
-				fps: 42,
-				measured: true
-			},
-			"yolov9t-320-int8": {
-				p50Ms: 12,
-				fps: 83,
-				measured: true
-			},
-			"yolov9t-640": {
-				p50Ms: 50,
-				fps: 20,
-				measured: true
-			},
-			"yolov9t-640-int8": {
-				p50Ms: 20,
-				fps: 50,
-				measured: true
-			},
-			"yolov9s-320": {
-				p50Ms: 30,
-				fps: 33,
-				measured: true
-			},
-			"yolov9s-320-int8": {
-				p50Ms: 15,
-				fps: 67,
-				measured: true
-			},
-			"yolov9s-640": {
-				p50Ms: 92,
-				fps: 11,
-				measured: true
-			},
-			"yolov9s-640-int8": {
-				p50Ms: 27,
-				fps: 37,
-				measured: true
-			},
-			"yolov9m-320": {
-				p50Ms: 67,
-				fps: 15,
-				measured: true
-			},
-			"yolov9m-320-int8": {
-				p50Ms: 21,
-				fps: 48,
-				measured: true
-			},
-			"yolov9m-640": {
-				p50Ms: 229,
-				fps: 4,
-				measured: true
-			},
-			"yolov9m-640-int8": {
-				p50Ms: 48,
-				fps: 21,
-				measured: true
-			}
-		},
-		"amd-igpu": {
-			"yolov9t-320": {
-				p50Ms: 40,
-				fps: 25,
-				measured: true
-			},
-			"yolov9t-640": {
-				p50Ms: 89,
-				fps: 11,
-				measured: true
-			},
-			"yolov9s-320": {
-				p50Ms: 65,
-				fps: 15,
-				measured: true
-			},
-			"yolov9s-640": {
-				p50Ms: 125,
-				fps: 8,
-				measured: true
-			},
-			"yolov9m-320": {
-				p50Ms: 85,
-				fps: 12,
-				measured: true
-			},
-			"yolov9m-640": {
-				p50Ms: 228,
-				fps: 4,
-				measured: true
-			}
-		},
-		coral: { "yolov9s-320-edgetpu": {
-			p50Ms: 32,
-			fps: 31,
-			measured: true
-		} }
-	},
-	"apple-m-pro": {
-		"apple-ane": {
-			"yolov9t-320": {
-				p50Ms: 1.1,
-				fps: 952,
-				measured: true
-			},
-			"yolov9t-640": {
-				p50Ms: 3,
-				fps: 333,
-				measured: true
-			},
-			"yolov9s-320": {
-				p50Ms: 1.5,
-				fps: 667,
-				measured: true
-			},
-			"yolov9s-640": {
-				p50Ms: 5.1,
-				fps: 196,
-				measured: true
-			},
-			"yolov9m-320": {
-				p50Ms: 3.2,
-				fps: 312,
-				measured: true
-			},
-			"yolov9m-640": {
-				p50Ms: 10.2,
-				fps: 98,
-				measured: true
-			}
-		},
-		coral: { "yolov9s-320-edgetpu": {
-			p50Ms: 32,
-			fps: 31,
-			measured: false
-		} }
-	},
-	"apple-m-base": {
-		"apple-ane": {
-			"yolov9t-320": {
-				p50Ms: 1.32,
-				fps: 758,
-				measured: false
-			},
-			"yolov9t-640": {
-				p50Ms: 3.45,
-				fps: 290,
-				measured: true
-			},
-			"yolov9s-320": {
-				p50Ms: 1.8,
-				fps: 556,
-				measured: false
-			},
-			"yolov9s-640": {
-				p50Ms: 5.46,
-				fps: 183,
-				measured: true
-			},
-			"yolov9m-320": {
-				p50Ms: 3.79,
-				fps: 264,
-				measured: true
-			},
-			"yolov9m-640": {
-				p50Ms: 10.34,
-				fps: 97,
-				measured: true
-			}
-		},
-		coral: { "yolov9s-320-edgetpu": {
-			p50Ms: 32,
-			fps: 31,
-			measured: false
-		} }
+/**
+* Can a pool of `format` run a step whose catalog is `models`, given the model
+* the step names (`null`/absent = unpinned, the format default)?
+*/
+function stepModelRunsOnFormat(models, modelId, format) {
+	if (modelId !== void 0 && modelId !== null) {
+		const named = models.find((m) => m.id === modelId);
+		if (named !== void 0 && hasBuild(named, format)) return true;
 	}
+	return models.some((m) => m.legacy !== true && hasBuild(m, format));
+}
+//#endregion
+//#region src/pipeline/removed-model-ids.ts
+/**
+* Model ids DELETED from a step's catalog (D703, D710, D719), per step — and
+* the one question asked of them: is a stored pin to this id a pin to a model
+* that no longer exists? (D725)
+*
+* This is NOT a resolver input. `resolveModelForFormat` still returns an
+* unknown id unchanged (a custom model), and a bulk pass pinned to one still
+* refuses rather than substitutes (D54). The ONE reader is the orchestrator's
+* stored-pin reset (`removed-model-pin-reset.ts`), which clears such a pin from
+* the store so the step follows its default again — unless a registered custom
+* model carries the same id.
+*
+* `removed-model-ids.spec.ts` (addon-pipeline) pins that every id here is
+* really absent from its step's catalog. A model deleted from a catalog is
+* added here in the same change, or its stored pins stay behind as custom ids.
+*/
+/** `stepId → ids deleted from that step's catalog`. */
+var REMOVED_MODEL_IDS = {
+	"object-detection": ["efficientdet-lite0-edgetpu", "ssdlite-mobiledet-coco-edgetpu"],
+	"face-detection": [
+		"scrypted-yolov9t-face",
+		"scrfd-2.5g",
+		"ssd-mobilenet-v2-face-edgetpu"
+	],
+	"face-embedding": ["arcface-r100", "inception-resnet-v1"],
+	"plate-detection": ["yolov8n-plate"],
+	"plate-ocr": ["vgg-english-g2"],
+	"clip-embedding": [
+		"mobileclip-s0",
+		"mobileclip-s1",
+		"mobileclip-s2"
+	],
+	"package-detection": ["yolov8n-package"],
+	"bird-classifier": ["bird-classifier-aiy-edgetpu", "bird-nabirds-404"],
+	"animal-classifier": ["animals-10"],
+	"vehicle-classifier": ["vehicle-type-efficientnet"]
 };
-var DETECTOR_ACCURACY = {
-	"yolov9m-320": {
-		personPrecision: .979,
-		personRecall: .649
-	},
-	"yolov9m-320-int8": {
-		personPrecision: .974,
-		personRecall: .684
-	},
-	"yolov9m-640": {
-		personPrecision: .976,
-		personRecall: .854
-	},
-	"yolov9m-640-int8": {
-		personPrecision: .976,
-		personRecall: .847
-	},
-	"yolov9s-320": {
-		personPrecision: .958,
-		personRecall: .479
-	},
-	"yolov9s-320-int8": {
-		personPrecision: .969,
-		personRecall: .438
-	},
-	"yolov9s-640": {
-		personPrecision: .986,
-		personRecall: .753
-	},
-	"yolov9s-640-int8": {
-		personPrecision: .963,
-		personRecall: .823
-	},
-	"yolov9t-320": {
-		personPrecision: .946,
-		personRecall: .368
-	},
-	"yolov9t-320-int8": {
-		personPrecision: .943,
-		personRecall: .347
-	},
-	"yolov9t-640": {
-		personPrecision: .979,
-		personRecall: .646
-	},
-	"yolov9t-640-int8": {
-		personPrecision: .979,
-		personRecall: .646
+/** True when `modelId` was deleted from `stepId`'s catalog. */
+function isRemovedModelId(stepId, modelId) {
+	return REMOVED_MODEL_IDS[stepId]?.includes(modelId) ?? false;
+}
+//#endregion
+//#region src/pipeline/model-bound-settings.ts
+/** 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;
+}
+/** Store `value` for `key`, made for `modelId`. Returns a fresh object. */
+function writeModelBoundSetting(settings, key, value, modelId) {
+	return {
+		...settings,
+		[key]: value,
+		[modelBindingKey(key)]: modelId
+	};
+}
+/** Remove an override and its binding — "reset to the model default". */
+function clearModelBoundSetting(settings, key) {
+	const out = { ...settings };
+	delete out[key];
+	delete out[modelBindingKey(key)];
+	return out;
+}
+/** True when any of `boundKeys` has an override IN FORCE for `modelId`. */
+function hasModelBoundOverrides(settings, boundKeys, modelId) {
+	return boundKeys.some((key) => resolveModelBoundSetting(settings, key, modelId, void 0, void 0).source === "override");
+}
+/**
+* "Reset thresholds to model defaults": remove every override of `boundKeys`
+* that is in force for `modelId` (bound to it, or unbound), with its binding —
+* one result, so the editor writes it in one save. An override stored for
+* ANOTHER model is kept: it is not in force here, and it applies again when
+* that model runs.
+*/
+function clearModelBoundOverrides(settings, boundKeys, modelId) {
+	return boundKeys.reduce((acc, key) => resolveModelBoundSetting(acc, key, modelId, void 0, void 0).source === "override" ? clearModelBoundSetting(acc, key) : acc, { ...settings });
+}
+/**
+* The keys of every `bindsToModel` field of a step's config schema, groups
+* flattened (D738). One definition for the runner (which applies the binding)
+* and the orchestrator's Auto tune (which clears those overrides, D745).
+*/
+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] : [];
+	});
+}
+//#endregion
+//#region src/pipeline/step-settings-layers.ts
+/**
+* The layers of a detection step's settings, and the field-level edits on them
+* (D754, D927).
+*
+* A step's settings reach a session through two stored layers, merged key by
+* key — a key in the higher layer wins:
+*
+*   node         the node's base for the accelerator that runs the step
+*   camera       `cameraSettings[cam].stepSettings[step]` — camera-semantic
+*                keys only, on every accelerator (never a model-bound field)
+*
+* Below them sits the default: the running model's (D738) or the field's own.
+*
+* Every layer is SPARSE and FIELD-LEVEL. A key present in a layer is an
+* override; an absent key inherits. Two consequences that every editor must
+* respect, and why this module exists:
+*
+*   - A model-bound field (D738) occupies TWO keys, its value and
+*     `<key>ModelId`. They are written, compared and removed as one unit — a
+*     value without its binding over a lower layer's binding would be judged
+*     against the wrong model.
+*   - An editor writes a DIFF against the merged layers below, never a copy of
+*     them. A copy pins every field at the value it had that day, so later
+*     edits below never reach it (the full-copy "Override" this replaced).
+*/
+/** Top-down order of the stored layers. */
+var LAYER_ORDER = ["camera", "node"];
+/**
+* The keys one field occupies in a bag: its own, plus its binding key when it
+* binds to a model. `boundKeys` = `collectModelBoundKeys(schema)`.
+*/
+function fieldUnitKeys(key, boundKeys) {
+	return boundKeys.includes(key) ? [key, modelBindingKey(key)] : [key];
+}
+/** The field a stored key belongs to (`minConfidencePersonModelId` → `minConfidencePerson`). */
+function unitOf(storedKey, boundKeys) {
+	return boundKeys.find((k) => modelBindingKey(k) === storedKey) ?? storedKey;
+}
+/** Structural equality for stored values (numbers, strings, booleans, arrays, plain objects). */
+function settingValuesEqual(a, b) {
+	if (Object.is(a, b)) return true;
+	if (Array.isArray(a) && Array.isArray(b)) return a.length === b.length && a.every((v, i) => settingValuesEqual(v, b[i]));
+	if (isPlainObject(a) && isPlainObject(b)) {
+		const ka = Object.keys(a);
+		const kb = Object.keys(b);
+		return ka.length === kb.length && ka.every((k) => settingValuesEqual(a[k], b[k]));
+	}
+	return false;
+}
+function isPlainObject(v) {
+	return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+/** Merge bags bottom-up (later wins, per key). Fresh object. */
+function mergeSettingsBags(...bags) {
+	return bags.reduce((acc, bag) => ({
+		...acc,
+		...bag
+	}), {});
+}
+/** The merged value of the layers BELOW `layer` (what removing a key from `layer` falls back to). */
+function settingsBelow(layers, layer) {
+	return mergeSettingsBags(...LAYER_ORDER.slice(LAYER_ORDER.indexOf(layer) + 1).toReversed().map((id) => layers[id]));
+}
+/** The effective bag: every stored layer merged. */
+function effectiveStepSettings(layers) {
+	return mergeSettingsBags(layers.node, layers.camera);
+}
+/** The highest stored layer that holds any key of `key`'s unit, or `default`. */
+function stepSettingSource(layers, key, boundKeys) {
+	const unit = fieldUnitKeys(key, boundKeys);
+	for (const id of LAYER_ORDER) {
+		const bag = layers[id];
+		if (bag !== void 0 && unit.some((k) => bag[k] !== void 0)) return id;
+	}
+	return "default";
+}
+/**
+* `layer` with `key`'s unit set from `values` (a bag carrying the unit's new
+* value — e.g. the editor's whole next settings bag). A unit key that `values`
+* does not carry is removed from the layer. Fresh object.
+*/
+function withFieldFrom(layer, key, values, boundKeys) {
+	const out = { ...layer };
+	for (const k of fieldUnitKeys(key, boundKeys)) if (values[k] === void 0) delete out[k];
+	else out[k] = values[k];
+	return out;
+}
+/** `layer` without `key`'s unit — "reset to the next level". Fresh object. */
+function withoutField(layer, key, boundKeys) {
+	const out = { ...layer };
+	for (const k of fieldUnitKeys(key, boundKeys)) delete out[k];
+	return out;
+}
+/** Every field unit stored in `layer`, by its field key. */
+function unitsIn(layer, boundKeys) {
+	return [...new Set(Object.keys(layer).map((k) => unitOf(k, boundKeys)))];
+}
+/** True when every key of `key`'s unit has the same value in `layer` as in `below`. */
+function unitEqualsBelow(layer, below, key, boundKeys) {
+	return fieldUnitKeys(key, boundKeys).every((k) => settingValuesEqual(layer[k], below[k]));
+}
+/**
+* `layer` reduced to the fields that DIFFER from `below` — what an editor
+* stores. A unit is kept or dropped whole. `undefined` when nothing is left.
+*/
+function diffStepSettings(layer, below, boundKeys) {
+	if (layer === void 0) return void 0;
+	const out = {};
+	for (const unit of unitsIn(layer, boundKeys)) {
+		if (unitEqualsBelow(layer, below, unit, boundKeys)) continue;
+		for (const k of fieldUnitKeys(unit, boundKeys)) if (layer[k] !== void 0) out[k] = layer[k];
+	}
+	return Object.keys(out).length > 0 ? out : void 0;
+}
+/**
+* The fields `layer` stores at exactly the value of the layers below — a
+* legacy full copy's leftovers. They change nothing today and stop every
+* later edit below from reaching this layer. Sorted.
+*/
+function fieldsPinnedAtValueBelow(layer, below, boundKeys) {
+	if (layer === void 0) return [];
+	return unitsIn(layer, boundKeys).filter((unit) => unitEqualsBelow(layer, below, unit, boundKeys)).toSorted();
+}
+//#endregion
+//#region src/pipeline/auto-tune/hardware-class.ts
+var APPLE_CHIP = /^Apple M(\d+)(?:\s+(Pro|Max|Ultra))?\b/i;
+var INTEL_CORE_ULTRA = /Core\(TM\)\s+Ultra|Core Ultra/i;
+var INTEL_N_SERIES = /Intel\(R\)\s+N\d{2,3}\b|\bIntel\s+N\d{2,3}\b/i;
+/** Phoenix / Hawk Point mobile (7040/8040) and Ryzen 8000G desktop APUs. */
+var AMD_PHOENIX = /Ryzen \d+ (7[0-9]40|8[0-9]40|8[0-9]45)[HSU]|Ryzen \d+ 8[0-9]00G/i;
+function parseAppleChip(cpuModel) {
+	const match = APPLE_CHIP.exec(cpuModel.trim());
+	if (match === null) return null;
+	const generation = Number(match[1]);
+	const variantRaw = (match[2] ?? "base").toLowerCase();
+	return {
+		generation,
+		variant: variantRaw === "pro" || variantRaw === "max" || variantRaw === "ultra" ? variantRaw : "base"
+	};
+}
+/**
+* Classify a node. Apple base chips (M1–M4) map to the measured M2 column, the
+* Pro/Max/Ultra chips to the measured M3 Pro column — the M2 was measured at
+* 1.0–1.2× the M3 Pro on the Neural Engine, so the generation inside a variant
+* matters less than the column's own error.
+*/
+function classifyInferenceHardware(hw) {
+	const cpuModel = hw.cpuModel;
+	const apple = parseAppleChip(cpuModel);
+	if (apple !== null) return {
+		hardwareClass: apple.variant === "base" ? "apple-m-base" : "apple-m-pro",
+		cpuModel,
+		apple
+	};
+	if (INTEL_CORE_ULTRA.test(cpuModel)) return {
+		hardwareClass: "intel-core-ultra",
+		cpuModel
+	};
+	if (INTEL_N_SERIES.test(cpuModel)) return {
+		hardwareClass: "intel-n-series",
+		cpuModel
+	};
+	if (AMD_PHOENIX.test(cpuModel)) return {
+		hardwareClass: "amd-phoenix",
+		cpuModel
+	};
+	return {
+		hardwareClass: "unknown",
+		cpuModel
+	};
+}
+/**
+* The accelerator kind of one of a node's device keys (`openvino:npu`,
+* `openvino:gpu`, `coreml:all`, `edgetpu:usb`, `cpu`, `onnx:cpu`, …). `null`
+* for a key this table has no column for.
+*/
+function acceleratorKindOf(deviceKey, hw) {
+	const [backend = "", device = ""] = deviceKey.split(":");
+	if (backend === "edgetpu") return "coral";
+	if (backend === "coreml") return device === "cpu" ? "arm-cpu" : "apple-ane";
+	if (backend === "openvino" && device === "npu") return "intel-npu";
+	if (backend === "openvino" && device === "gpu") return "intel-igpu";
+	if (backend === "onnx" && device === "webgpu") return "amd-igpu";
+	if (backend === "vitisai" && device === "npu") return "amd-npu";
+	if (backend === "cpu" || device === "cpu") return hw.arch === "arm64" ? "arm-cpu" : "x86-cpu";
+	return null;
+}
 //#endregion
 //#region src/pipeline/auto-tune/recommend.ts
 /** The family the cluster runs. */
@@ -106654,10 +106781,35 @@ var RECALL_TIE = .02;
 var DEFAULT_HEADROOM = .4;
 /** Detection rate a session is counted at when no camera says otherwise. */
 var DEFAULT_CAMERA_FPS = 10;
-/** Parallel sessions one device sustains at `fps` with `headroom` kept free. */
-function capacitySessionsOf(fps, headroom, cameraFps) {
-	if (!(fps > 0) || !(cameraFps > 0)) return 0;
-	return Math.max(0, Math.floor(fps * (1 - headroom) / cameraFps + 1e-9));
+/**
+* Camera rate at which serial `1000/p50` matched the cameras that held
+* (N100 iGPU, 2026-10-24). Below this the second InferRequest's overlap
+* becomes extra sessions; at and above it the serial ceiling is the count.
+*/
+var SERIAL_CAPACITY_CAMERA_FPS = 10;
+/**
+* Aggregate throughput ÷ serial throughput when the frame interval is wide
+* enough to hide the second request. intel-igpu is the N100 measurement
+* (~1.4× under LATENCY with 2 InferRequests). Every other kind stays 1
+* until it is measured the same way.
+*/
+var AGGREGATE_THROUGHPUT_BY_KIND = { "intel-igpu": 1.4 };
+/** The overlap factor for this kind at this camera rate. 1 at {@link SERIAL_CAPACITY_CAMERA_FPS} and above. */
+function aggregateThroughputFactor(kind, cameraFps) {
+	if (!(cameraFps > 0) || cameraFps >= 10) return 1;
+	return AGGREGATE_THROUGHPUT_BY_KIND[kind] ?? 1;
+}
+/**
+* Parallel sessions one device sustains at `fps` with `headroom` kept free.
+* `aggregateFactor` is the kind's overlap (1 unless the caller measured
+* extra throughput at this camera rate).
+*/
+function capacitySessionsOf(fps, headroom, cameraFps, aggregateFactor = 1) {
+	if (!(fps > 0) || !(cameraFps > 0) || !(aggregateFactor > 0)) return 0;
+	return Math.max(0, Math.floor(fps * aggregateFactor * (1 - headroom) / cameraFps + 1e-9));
+}
+function reportFor(hardware, deviceKey) {
+	return hardware.accelerators?.find((report) => report.deviceKey === deviceKey) ?? null;
 }
 /** The table column with the node's own measurements laid over it. */
 function overlayMeasured(table, measured) {
@@ -106679,11 +106831,12 @@ function round(value, digits = 3) {
 	const f = 10 ** digits;
 	return Math.round(value * f) / f;
 }
-function sessionsOn(cell, sizing) {
-	return cell === void 0 ? 0 : capacitySessionsOf(cell.fps, sizing.headroom, sizing.cameraFps);
+function sessionsOn(cell, sizing, kind) {
+	if (cell === void 0) return 0;
+	return capacitySessionsOf(cell.fps, sizing.headroom, sizing.cameraFps, aggregateThroughputFactor(kind, sizing.cameraFps));
 }
-function fitsOn(cell, sizing) {
-	return sessionsOn(cell, sizing) >= sizing.minSessions;
+function fitsOn(ctx, modelId, sizing) {
+	return sessionsOn(ctx.column[modelId], sizing, ctx.accelerator) >= sizing.minSessions;
 }
 function candidatesFor(contexts, formatsByModel) {
 	return Object.keys(DETECTOR_ACCURACY).filter((id) => id.startsWith(AUTO_TUNE_FAMILY)).filter((id) => contexts.every((c) => c.column[id] !== void 0 && (formatsByModel[id] ?? []).includes(c.device.format))).map((id) => ({
@@ -106696,13 +106849,13 @@ function totalLatency(contexts, modelId) {
 }
 /** The fewest sessions any device of the group sustains with this model. */
 function worstSessions(contexts, modelId, sizing) {
-	return contexts.reduce((worst, c) => Math.min(worst, sessionsOn(c.column[modelId], sizing)), Number.POSITIVE_INFINITY);
+	return contexts.reduce((worst, c) => Math.min(worst, sessionsOn(c.column[modelId], sizing, c.accelerator)), Number.POSITIVE_INFINITY);
 }
 /** One model for a group of devices that must agree (step 2–4 of the header). */
 function pickForGroup(contexts, formatsByModel, sizing) {
 	const candidates = candidatesFor(contexts, formatsByModel);
 	if (candidates.length === 0) return null;
-	const fitting = candidates.filter((c) => contexts.every((ctx) => fitsOn(ctx.column[c.modelId], sizing)));
+	const fitting = candidates.filter((c) => contexts.every((ctx) => fitsOn(ctx, c.modelId, sizing)));
 	if (fitting.length === 0) {
 		const lightest = candidates.toSorted((a, b) => worstSessions(contexts, b.modelId, sizing) - worstSessions(contexts, a.modelId, sizing) || totalLatency(contexts, a.modelId) - totalLatency(contexts, b.modelId))[0];
 		if (lightest === void 0) return null;
@@ -106721,7 +106874,7 @@ function pickForGroup(contexts, formatsByModel, sizing) {
 	const reasons = [];
 	const mostAccurate = candidates[0];
 	if (mostAccurate !== void 0 && mostAccurate.modelId !== best.modelId) {
-		const limitedBy = contexts.find((ctx) => !fitsOn(ctx.column[mostAccurate.modelId], sizing))?.device.key ?? "";
+		const limitedBy = contexts.find((ctx) => !fitsOn(ctx, mostAccurate.modelId, sizing))?.device.key ?? "";
 		reasons.push({
 			kind: "stepped-down",
 			from: mostAccurate.modelId,
@@ -106742,13 +106895,19 @@ function pickForGroup(contexts, formatsByModel, sizing) {
 function choiceOn(ctx, modelId, sizing) {
 	const cell = ctx.column[modelId];
 	if (cell === void 0) return null;
+	const estimatedFrom = cell.source?.kind === "node-benchmark" ? void 0 : cell.estimatedFrom;
+	const source = cell.source ?? (estimatedFrom !== void 0 ? {
+		kind: "estimated",
+		estimatedFrom
+	} : { kind: "table" });
 	return {
 		modelId,
 		p50Ms: cell.p50Ms,
 		fps: cell.fps,
 		measured: cell.measured,
-		source: cell.source ?? { kind: "table" },
-		capacitySessions: sessionsOn(cell, sizing),
+		source,
+		...estimatedFrom !== void 0 ? { estimatedFrom } : {},
+		capacitySessions: sessionsOn(cell, sizing, ctx.accelerator),
 		personRecall: DETECTOR_ACCURACY[modelId]?.personRecall ?? 0
 	};
 }
@@ -106799,7 +106958,11 @@ function recommendNode(input) {
 	const measured = input.measured ?? {};
 	const hasMeasured = Object.values(measured).some((m) => Object.keys(m).length > 0);
 	const knownTable = hardwareClass === "unknown" ? void 0 : perf[hardwareClass];
-	if (knownTable === void 0 && !hasMeasured) return skippedNode(node, {
+	const canEstimate = (hardware.accelerators ?? []).some((report) => {
+		const kind = acceleratorKindOf(report.deviceKey, hardware);
+		return kind !== null && reportIsScalable(report, kind);
+	});
+	if (knownTable === void 0 && !hasMeasured && !canEstimate) return skippedNode(node, {
 		kind: "no-measured-data",
 		hardwareClass
 	}, hardwareClass);
@@ -106835,7 +106998,12 @@ function recommendNode(input) {
 			});
 			continue;
 		}
-		const column = accelerator === null ? void 0 : overlayMeasured(classTable[accelerator], measured[device.key]);
+		const column = accelerator === null ? void 0 : overlayMeasured(resolveLatencyColumn({
+			hardwareClass,
+			accelerator,
+			report: reportFor(hardware, device.key),
+			perf
+		})?.column, measured[device.key]);
 		if (accelerator === null || column === void 0) {
 			early.set(device.key, [{
 				kind: "no-family-build",
@@ -107583,6 +107751,507 @@ function buildBenchStepTree(schema, rootModelId, enabledStepIds) {
 	}];
 }
 //#endregion
+//#region src/pipeline/second-pass/small-subject-recovery.ts
+/** The object-detection step id — the first-level detector both recipes run. */
+var OBJECT_DETECTION_STEP_ID = "object-detection";
+/**
+* Smallest crop side, native pixels. Below this the model no longer
+* magnifies enough to matter on a 4K frame, and on a 1080p frame 640 is
+* already a third of the picture. Measured: 480–800 px all recover the dog.
+*/
+var RECOVERY_CROP_MIN_SIDE_PX = 640;
+/**
+* Largest crop side. A 320 model on a 1024 px square is a 3.2× reduction and
+* scored the dog at 0.52–0.76; at 1280 px it was absent again. A region wider
+* than this is tiled, never zoomed out.
+*/
+var RECOVERY_CROP_MAX_SIDE_PX = 800;
+/** Context around the region before squaring, as a fraction of its larger side. */
+var RECOVERY_CROP_PADDING_RATIO = .25;
+/**
+* The view the crop is resolved at, compressed. Never larger than the crop
+* (the floor is {@link RECOVERY_CROP_MIN_SIDE_PX}), so it never upscales, and
+* the model letterboxes it to its own input from here as it does the frame.
+*/
+var RECOVERY_VIEW_PX = 640;
+/**
+* Crops per frame. Each is one more inference on the same pool (15–25 ms on
+* CoreML for a 640 view); two cover a person-and-dog blob and a second mover.
+*/
+var RECOVERY_MAX_CROPS_PER_FRAME = 2;
+/**
+* The pass runs at most this often per camera — at 10 fps that is one frame
+* in five. A subject the full pass misses is missed for seconds, not for one
+* frame, so the recovery does not need every frame to find it.
+*
+* The floor under this number is the tracker: a track coasts for
+* `maxMissedMs` (4 000 ms by default) before it is dropped, so 2 recoveries a
+* second keep a subject the full-frame pass has lost ALIVE with 8× margin,
+* and reach `minHits` (3) in 1.5 s. Raising it past ~1 300 ms would start to
+* lose tracks between passes.
+*/
+var RECOVERY_MIN_INTERVAL_MS = 500;
+/**
+* A region larger than this share of the frame is not a small subject: a
+* lighting change, a car filling the picture, a person at the lens. The
+* full-frame pass already sees those at scale.
+*/
+var RECOVERY_MAX_REGION_FRAME_FRACTION = .25;
+/**
+* How much of a region must lie OUTSIDE every full-frame detection for the
+* pass to run on it. A person's own blob (dilated, with shadow) is covered
+* 70–90% by the person box; a person-and-dog blob is covered ~55% by it.
+*/
+var RECOVERY_MIN_UNCOVERED_FRACTION = .35;
+/** Motion regions older than this describe a different frame. */
+var RECOVERY_MOTION_MAX_AGE_MS = 2e3;
+/** A recovered box overlapping a same-class full-frame box this much is the same subject. */
+var RECOVERY_FUSE_IOU = .5;
+/**
+* A recovered box CONTAINED this much in a same-class full-frame box is a part
+* of it — a torso the crop cut out of a person the full pass already has.
+*/
+var RECOVERY_FUSE_CONTAINMENT = .7;
+/** A box within this many crop-view pixels of the crop edge was clipped by it. */
+var RECOVERY_EDGE_MARGIN_PX = 2;
+/** Area of a normalised rectangle, never negative. Shared with the D396 recipe. */
+function normalizedArea(r) {
+	return Math.max(0, r.w) * Math.max(0, r.h);
+}
+var area = normalizedArea;
+function intersection(a, b) {
+	return Math.max(0, Math.min(a.x + a.w, b.x + b.w) - Math.max(a.x, b.x)) * Math.max(0, Math.min(a.y + a.h, b.y + b.h) - Math.max(a.y, b.y));
+}
+/**
+* Share of `region` not covered by any detection box. The sum of pairwise
+* intersections over-counts where detections overlap each other, which only
+* makes the pass MORE conservative; clipped at 1.
+*/
+function uncoveredFraction(region, detections) {
+	const regionArea = area(region);
+	if (regionArea <= 0) return 0;
+	let covered = 0;
+	for (const detection of detections) covered += intersection(region, detection);
+	return 1 - Math.min(1, covered / regionArea);
+}
+/**
+* THE square-placement rule of this pass — one owner, shared by both recipes.
+*
+* A crop is a square of `side` native pixels centred where it can be and slid
+* inside the frame where it cannot. Both region rules place their squares
+* through this function so a crop means the same rectangle whichever rule
+* chose the region.
+*/
+function squareAround(centreX, centreY, side, native) {
+	return {
+		left: Math.round(Math.max(0, Math.min(native.width - side, centreX - side / 2))),
+		top: Math.round(Math.max(0, Math.min(native.height - side, centreY - side / 2))),
+		side
+	};
+}
+function contains(crop, x, y) {
+	return x >= crop.left && x <= crop.left + crop.side && y >= crop.top && y <= crop.top + crop.side;
+}
+/**
+* Squares for one region: one when it fits the largest side, otherwise up to
+* two tiles along its longer axis (a person-sized blob with something small
+* at either end). The padded region decides the side, never the frame.
+*/
+function cropsForRegion(region, native) {
+	const widthPx = region.w * native.width;
+	const heightPx = region.h * native.height;
+	const longest = Math.max(widthPx, heightPx);
+	const padded = longest * 1.5;
+	const side = Math.round(Math.min(Math.max(padded, 640), 800));
+	const centreX = (region.x + region.w / 2) * native.width;
+	const centreY = (region.y + region.h / 2) * native.height;
+	if (padded <= 800) return [squareAround(centreX, centreY, side, native)];
+	const alongX = widthPx >= heightPx;
+	const quarter = longest / 4;
+	return [squareAround(alongX ? centreX - quarter : centreX, alongX ? centreY : centreY - quarter, side, native), squareAround(alongX ? centreX + quarter : centreX, alongX ? centreY : centreY + quarter, side, native)];
+}
+/**
+* The ONE place the two region gates are decided. `planRecoveryCrops` filters
+* on it and {@link countRecoverySkips} counts it, so the report can never
+* describe a gate the planner does not actually apply.
+*/
+function classifyRegion(region, uncovered) {
+	if (area(region) > .25) return "too-large";
+	if (uncovered < .35) return "covered";
+	return "eligible";
+}
+/**
+* WHY A FRAME PLANNED NO CROP, AS A NUMBER (D378).
+*
+* The pass report counts the passes that RAN, so "the second pass stops running
+* when a person is beside the dog" — a plausible reading of
+* {@link RECOVERY_MAX_REGION_FRAME_FRACTION} and
+* {@link RECOVERY_MIN_UNCOVERED_FRACTION}, and a live hypothesis on camera 615
+* — could not be confirmed or killed from the logs at all. This classifies the
+* regions a frame offered, against the same predicate the planner filters on.
+*/
+function countRecoverySkips(input) {
+	let tooLarge = 0;
+	let covered = 0;
+	let eligible = 0;
+	for (const region of input.regions) switch (classifyRegion(region, uncoveredFraction(region, input.detections))) {
+		case "too-large":
+			tooLarge += 1;
+			break;
+		case "covered":
+			covered += 1;
+			break;
+		case "eligible":
+			eligible += 1;
+			break;
+	}
+	return {
+		tooLarge,
+		covered,
+		eligible
+	};
+}
+function planRecoveryCrops(input) {
+	const { native } = input;
+	if (Math.min(native.width, native.height) < 640) return [];
+	const ranked = input.regions.map((region) => ({
+		region,
+		uncovered: uncoveredFraction(region, input.detections)
+	})).filter(({ region, uncovered }) => classifyRegion(region, uncovered) === "eligible").toSorted((a, b) => area(b.region) * b.uncovered - area(a.region) * a.uncovered);
+	const planned = [];
+	for (const { region } of ranked) for (const crop of cropsForRegion(region, native)) {
+		if (planned.length >= 2) return planned;
+		const centreX = crop.left + crop.side / 2;
+		const centreY = crop.top + crop.side / 2;
+		if (planned.some((existing) => contains(existing, centreX, centreY))) continue;
+		planned.push(crop);
+	}
+	return planned;
+}
+/**
+* Boxes the executor produced on the crop VIEW → the result's own space.
+*
+* Three spaces meet here: the view the model saw (`view`, ≤640 px), the native
+* square it was cut from (`crop`, native px) and the space the full-frame
+* result reports in (`result`, native px on the `frameRef` path, the inline
+* ≤640 view otherwise). A box touching the view edge was clipped by the crop
+* and is dropped: half a person is not a person, and the tracker would take
+* the half as the whole.
+*/
+function remapCropDetections(detections, crop, view, result, native) {
+	const viewToNative = crop.side / Math.max(1, view.width);
+	const nativeToResultX = result.width / Math.max(1, native.width);
+	const nativeToResultY = result.height / Math.max(1, native.height);
+	const out = [];
+	for (const detection of detections) {
+		const { x, y, width, height } = detection.bbox;
+		if (x <= 2 || y <= 2 || x + width >= view.width - 2 || y + height >= view.height - 2) continue;
+		out.push({
+			...detection,
+			nativeRecovery: {
+				score: detection.score,
+				cropSidePx: crop.side,
+				viewPx: view.width
+			},
+			bbox: {
+				x: (crop.left + x * viewToNative) * nativeToResultX,
+				y: (crop.top + y * viewToNative) * nativeToResultY,
+				width: width * viewToNative * nativeToResultX,
+				height: height * viewToNative * nativeToResultY
+			}
+		});
+	}
+	return out;
+}
+function boxIntersection(a, b) {
+	return Math.max(0, Math.min(a.x + a.width, b.x + b.width) - Math.max(a.x, b.x)) * Math.max(0, Math.min(a.y + a.height, b.y + b.height) - Math.max(a.y, b.y));
+}
+function sameSubject(recovered, existing) {
+	const inter = boxIntersection(recovered, existing);
+	if (inter <= 0) return false;
+	const areaR = recovered.width * recovered.height;
+	const union = areaR + existing.width * existing.height - inter;
+	if (union > 0 && inter / union >= .5) return true;
+	return areaR > 0 && inter / areaR >= .7;
+}
+/**
+* Class-aware NMS of the recovered boxes against the full-frame ones. Every
+* full-frame box is kept as it is — the second pass only ADDS. A recovered box
+* is added when no full-frame box of the same macro class is the same subject
+* (`RECOVERY_FUSE_IOU`) or contains it (`RECOVERY_FUSE_CONTAINMENT`). Ids are
+* re-minted so a crop's `d0` cannot collide with the frame's.
+*/
+function fuseRecoveredDetections(full, recovered) {
+	const accepted = [];
+	for (const [index, candidate] of recovered.entries()) {
+		if ([...full, ...accepted].some((existing) => existing.macroClass === candidate.macroClass && sameSubject(candidate.bbox, existing.bbox))) continue;
+		accepted.push({
+			...candidate,
+			id: `recovered-${index}-${candidate.id}`
+		});
+	}
+	return [...full, ...accepted];
+}
+/**
+* The step the second pass runs: the enabled first-level object detector of
+* the camera's own tree, with its own model and no children. Same model as
+* the full pass so a recovered box is comparable to a full-frame one.
+*/
+function selectRecoveryStep(steps) {
+	const detector = steps.find((step) => step.addonId === "object-detection" && step.enabled !== false);
+	if (!detector) return null;
+	return {
+		addonId: detector.addonId,
+		...detector.modelId !== void 0 ? { modelId: detector.modelId } : {},
+		enabled: true
+	};
+}
+//#endregion
+//#region src/pipeline/second-pass/motion-crop-plan.ts
+/**
+* Step-settings key of the opt-in, on the `object-detection` step — so it is
+* per camera through `pipelineOrchestrator.setCameraStepSettings` (a
+* camera-semantic key, D927), and it rides the same
+* `PipelineStepInputOutput.settings` the per-macro confidence floors ride.
+*/
+var MOTION_CROP_DISPATCH_KEY = "motionCropDispatch";
+/**
+* Read the opt-in. Anything that is not the boolean `true` is the shipped
+* rule: a stored string or a number is a mis-write (this repo has shipped a
+* setting written into the wrong sqlite table before), and a mis-write must
+* not silently change what a camera detects on.
+*/
+function readRecoveryRecipe(settings) {
+	return settings?.["motionCropDispatch"] === true ? "motion-crop" : "uncovered-region";
+}
+/**
+* The recipe this camera's resolved step tree selects.
+*
+* Reads the ENABLED first-level detector's own settings, which is where
+* `pipelineOrchestrator.setCameraStepSettings` writes a per-camera value. A
+* tree with no enabled detector runs no second pass at all, so the answer
+* there is the shipped rule and it is never used.
+*/
+function readRecoveryRecipeForSteps(steps) {
+	return readRecoveryRecipe(steps.find((step) => step.addonId === "object-detection" && step.enabled !== false)?.settings);
+}
+/**
+* A motion box is grown ×1.5 about its centre before anything else.
+*
+* The motion step's box is the CHANGED pixels, which on a moving animal is the
+* leading edge plus its shadow, not the animal. The detector needs the subject
+* and the context it was trained on.
+*/
+var MOTION_CROP_MOTION_PAD = 1.5;
+/**
+* An intersecting tracked box is grown ×1.25 — less, because it is already a
+* subject rectangle rather than a change mask.
+*/
+var MOTION_CROP_TRACKED_PAD = 1.25;
+/**
+* Regions per frame, largest area first.
+*
+* Measured as NON-BINDING: over the 156 frames of the recall harness the cap
+* bound on 0 of them. It is the bound on a storm, not a tuning knob, and the
+* runner reports when it binds so a camera on which it starts to is visible.
+*/
+var MOTION_CROP_MAX_REGIONS = 3;
+/**
+* The floor a `person` or `vehicle` box must clear when it came out of a CROP
+* rather than out of the full frame.
+*
+* Collected, not assumed: 3 085 quiet frames produced 27 motion-positive
+* frames and 28 crop invocations. The full-frame arm produced 0 boxes above
+* any gate; the crop arm produced 3, of which two are genuine false positives,
+* and both are night-IR corners upscaled into a 320 model — `vehicle 0.749`
+* and `person 0.701`. Zero false `animal` at any gate, which is why `animal`
+* is deliberately absent from this table: the class the pass exists to recover
+* is the class that never produced a false positive, and gating it would cost
+* the whole measured gain.
+*
+* This is a CROP-ONLY floor, applied on top of the per-macro floors the
+* executor already enforced. A full-frame `person` at 0.70 is untouched — the
+* full-frame arm is the one arm with ground truth behind its floor
+* (`minConfidencePerson` 0.65, raised on 2026-07-30 from a measured
+* distribution).
+*
+* The cost of this floor is stated rather than assumed away: it can also
+* remove a real distant person or vehicle recovered from a crop at 0.70–0.80.
+* Nothing in the quiet-footage sample measures that, so the floor is a
+* constant here rather than a slider, and the runner reports every drop it
+* makes per camera.
+*/
+var CROP_CLASS_FLOORS = Object.freeze({
+	person: .8,
+	vehicle: .8
+});
+/**
+* Apply the crop-only class floors, REPORTING every drop.
+*
+* A class with no entry in {@link CROP_CLASS_FLOORS} is kept: a floor this
+* table cannot express is not a floor of zero, and silently dropping a class
+* nobody measured is the exact shape of silent drop this repo has paid for
+* three separate times.
+*/
+function applyCropClassFloors(detections) {
+	const kept = [];
+	const dropped = [];
+	for (const detection of detections) {
+		const floor = CROP_CLASS_FLOORS[detection.macroClass];
+		if (floor !== void 0 && detection.score < floor) {
+			dropped.push({
+				macroClass: detection.macroClass,
+				score: detection.score,
+				floor
+			});
+			continue;
+		}
+		kept.push(detection);
+	}
+	return {
+		kept,
+		dropped
+	};
+}
+function scaleAbout(rect, factor) {
+	const w = rect.w * factor;
+	const h = rect.h * factor;
+	return {
+		x: rect.x + rect.w / 2 - w / 2,
+		y: rect.y + rect.h / 2 - h / 2,
+		w,
+		h
+	};
+}
+function overlaps(a, b) {
+	return Math.min(a.x + a.w, b.x + b.w) > Math.max(a.x, b.x) && Math.min(a.y + a.h, b.y + b.h) > Math.max(a.y, b.y);
+}
+function union(a, b) {
+	const x = Math.min(a.x, b.x);
+	const y = Math.min(a.y, b.y);
+	return {
+		x,
+		y,
+		w: Math.max(a.x + a.w, b.x + b.w) - x,
+		h: Math.max(a.y + a.h, b.y + b.h) - y
+	};
+}
+function clampToFrame(rect) {
+	const x = Math.max(0, rect.x);
+	const y = Math.max(0, rect.y);
+	return {
+		x,
+		y,
+		w: Math.min(1, rect.x + rect.w) - x,
+		h: Math.min(1, rect.y + rect.h) - y
+	};
+}
+/**
+* Merge transitively every seed whose padded box overlaps another, and answer
+* the union rectangles.
+*
+* Transitive on purpose: a person, the dog beside them and the dog's shadow
+* are three components of one subject, and cutting three crops for them spends
+* two inferences on pixels the first one already showed the detector.
+*/
+function mergeSeeds(seeds) {
+	const merged = [];
+	for (const seed of seeds) {
+		let current = seed;
+		let changed = true;
+		while (changed) {
+			changed = false;
+			for (let i = merged.length - 1; i >= 0; i -= 1) {
+				const other = merged[i];
+				if (other === void 0 || !overlaps(current, other)) continue;
+				current = union(current, other);
+				merged.splice(i, 1);
+				changed = true;
+			}
+		}
+		merged.push(current);
+	}
+	return merged;
+}
+/**
+* The regions the measured recipe judges this frame on.
+*
+* Motion boxes padded {@link MOTION_CROP_MOTION_PAD}; every full-frame box
+* that intersects a RAW motion box padded {@link MOTION_CROP_TRACKED_PAD} and
+* added as a seed of its own; everything that overlaps merged; the result
+* clamped to the frame, ordered largest first and capped at
+* {@link MOTION_CROP_MAX_REGIONS}.
+*
+* There is deliberately no coverage gate and no size gate here. Those belong
+* to the shipped rule, and they are what makes it a rule about a subject
+* BESIDE a detected one; the measurement says the pass is worth running on the
+* detected subject's own region too.
+*/
+function planMotionCropRegions(input) {
+	if (input.regions.length === 0) return [];
+	const seeds = input.regions.map((r) => scaleAbout(r, MOTION_CROP_MOTION_PAD));
+	for (const detection of input.detections) {
+		if (!input.regions.some((region) => overlaps(detection, region))) continue;
+		seeds.push(scaleAbout(detection, MOTION_CROP_TRACKED_PAD));
+	}
+	return mergeSeeds(seeds).map(clampToFrame).filter((r) => r.w > 0 && r.h > 0).toSorted((a, b) => normalizedArea(b) - normalizedArea(a)).slice(0, 3);
+}
+/**
+* The square the detector is fed for one measured region.
+*
+* "Grow to the detector's input aspect ratio without ever shrinking" is a
+* SQUARE here, and that is a fact about the production detector rather than a
+* simplification: `yolov9m-320-int8` takes 320×320, as does every hardware
+* default in the catalog.
+*
+* The side is the region's longer side, floored at
+* {@link RECOVERY_CROP_MIN_SIDE_PX} — the growth is what magnifies the subject
+* — and ceilinged at {@link RECOVERY_CROP_MAX_SIDE_PX}. The ceiling is NOT a
+* simplification either: at 1024 px the same 320 model scored the reference
+* dog 0.52–0.76, and at 1280 px lost it entirely
+* (`docs/benchmarks/pipeline-frame-model-eval.md`, case `miss-dog-615`). A
+* region longer than the ceiling is TILED along its longer axis, never zoomed
+* out.
+*/
+function motionCropsForRegion(region, native) {
+	const widthPx = region.w * native.width;
+	const heightPx = region.h * native.height;
+	const longest = Math.max(widthPx, heightPx);
+	const side = Math.round(Math.min(Math.max(longest, 640), 800));
+	const centreX = (region.x + region.w / 2) * native.width;
+	const centreY = (region.y + region.h / 2) * native.height;
+	if (longest <= 800) return [squareAround(centreX, centreY, side, native)];
+	const alongX = widthPx >= heightPx;
+	const quarter = longest / 4;
+	return [squareAround(alongX ? centreX - quarter : centreX, alongX ? centreY : centreY - quarter, side, native), squareAround(alongX ? centreX + quarter : centreX, alongX ? centreY : centreY + quarter, side, native)];
+}
+/** `true` when `inner` lies entirely inside `outer`. */
+function cropContains(outer, inner) {
+	return inner.left >= outer.left && inner.top >= outer.top && inner.left + inner.side <= outer.left + outer.side && inner.top + inner.side <= outer.top + outer.side;
+}
+/**
+* The crops the measured recipe runs on this frame.
+*
+* Dedupe is by CONTAINMENT only. Two squares that merely overlap both run: the
+* pixels the second adds are pixels no other crop shows the detector, and the
+* fusion step downstream already refuses a duplicate BOX. Dropping a crop
+* because it overlapped would drop the subject sitting at its edge, which is
+* the whole population this pass exists for.
+*
+* A frame that cannot hold the smallest crop yields nothing: it is already
+* seen at scale.
+*/
+function planMotionCrops(input) {
+	const { native } = input;
+	if (Math.min(native.width, native.height) < 640) return [];
+	const planned = [];
+	for (const region of planMotionCropRegions(input)) for (const crop of motionCropsForRegion(region, native)) {
+		if (planned.some((existing) => cropContains(existing, crop))) continue;
+		planned.push(crop);
+	}
+	return planned;
+}
+//#endregion
 //#region src/pipeline/root-face-crop.ts
 /** Side of the square, as a multiple of the face box's longer side. */
 var ROOT_FACE_REFINE_SCALE = 1.6;
@@ -109937,6 +110606,7 @@ exports.ADMIN_SCOPE = ADMIN_SCOPE;
 exports.AGENT_MDNS_QUERY_NAME = AGENT_MDNS_QUERY_NAME;
 exports.AGENT_MDNS_SERVICE_TYPE = AGENT_MDNS_SERVICE_TYPE;
 exports.AGENT_MDNS_TXT_KEYS = AGENT_MDNS_TXT_KEYS;
+exports.AGGREGATE_THROUGHPUT_BY_KIND = AGGREGATE_THROUGHPUT_BY_KIND;
 exports.ALEXA_EGRESS_PROFILE = ALEXA_EGRESS_PROFILE;
 exports.ALL_CAPABILITY_DEFINITIONS = ALL_CAPABILITY_DEFINITIONS;
 exports.ALL_METHOD_ACCESS = ALL_METHOD_ACCESS;
@@ -109964,6 +110634,7 @@ exports.AUDIO_SCALE_EPOCH_MS = AUDIO_SCALE_EPOCH_MS;
 exports.AUTOMATIC_HUB_ADDRESS_FLAGS = AUTOMATIC_HUB_ADDRESS_FLAGS;
 exports.AUTO_SHARE_HEADROOM = AUTO_SHARE_HEADROOM;
 exports.AUTO_TUNE_FAMILY = AUTO_TUNE_FAMILY;
+exports.AcceleratorComputeSchema = AcceleratorComputeSchema;
 exports.AcceleratorKindSchema = AcceleratorKindSchema;
 exports.AccessoriesStatusSchema = AccessoriesStatusSchema;
 exports.AccessoryKind = AccessoryKind;
@@ -110150,8 +110821,11 @@ exports.CONTAINER_CHILD_PRIORITY = CONTAINER_CHILD_PRIORITY;
 exports.CORAL_DEFAULT_MODEL_ID = CORAL_DEFAULT_MODEL_ID;
 exports.CORE_BLOCKS_ADDON_ID = CORE_BLOCKS_ADDON_ID;
 exports.CORE_BLOCK_ADDON_PREFIX = CORE_BLOCK_ADDON_PREFIX;
+exports.CORE_ULTRA_265K_IGPU_CLOCK_MHZ = CORE_ULTRA_265K_IGPU_CLOCK_MHZ;
+exports.CORE_ULTRA_265K_IGPU_EU = CORE_ULTRA_265K_IGPU_EU;
 exports.CREDENTIAL_TOKEN_AUDIENCE = CREDENTIAL_TOKEN_AUDIENCE;
 exports.CREDENTIAL_TOKEN_KIND = CREDENTIAL_TOKEN_KIND;
+exports.CROP_CLASS_FLOORS = CROP_CLASS_FLOORS;
 exports.CROP_SUPPLY_SOURCES = CROP_SUPPLY_SOURCES;
 exports.CROP_SUPPLY_STEP_IDS = CROP_SUPPLY_STEP_IDS;
 exports.CUSTOMIZATION_BLOCK_NAME_PREFIX = require_composition.CUSTOMIZATION_BLOCK_NAME_PREFIX;
@@ -110184,7 +110858,6 @@ exports.CameraMetricsSchema = CameraMetricsSchema;
 exports.CameraMetricsWithDeviceIdSchema = CameraMetricsWithDeviceIdSchema;
 exports.CameraMotionStatusSchema = CameraMotionStatusSchema;
 exports.CameraOccupancySnapshotForDeviceSchema = CameraOccupancySnapshotForDeviceSchema;
-exports.CameraOverrideClearSchema = CameraOverrideClearSchema;
 exports.CameraOwnMotionSchema = CameraOwnMotionSchema;
 exports.CameraRawLevelSchema = CameraRawLevelSchema;
 exports.CameraRecordingModeSchema = CameraRecordingModeSchema;
@@ -110437,7 +111110,6 @@ exports.DetailCropConventionSchema = DetailCropConventionSchema;
 exports.DetectionCatalogClassMapSchema = DetectionCatalogClassMapSchema;
 exports.DetectionSourceSchema = DetectionSourceSchema;
 exports.DetectionSourcesSchema = DetectionSourcesSchema;
-exports.DetectorStoreClearSchema = DetectorStoreClearSchema;
 exports.DeviceAdminLinkSchema = DeviceAdminLinkSchema;
 exports.DeviceCaStatusSchema = DeviceCaStatusSchema;
 exports.DeviceCertificateLoginMethodSchema = DeviceCertificateLoginMethodSchema;
@@ -110504,6 +111176,8 @@ exports.DoorbellStatusSchema = DoorbellStatusSchema;
 exports.EMBEDDING_MODEL_FAILED = EMBEDDING_MODEL_FAILED;
 exports.EMBEDDING_REQUIREMENTS_FAILED = EMBEDDING_REQUIREMENTS_FAILED;
 exports.EMBEDDING_REQUIREMENTS_UNAVAILABLE = EMBEDDING_REQUIREMENTS_UNAVAILABLE;
+exports.ESTIMATE_COMPUTE_RATIO_MAX = ESTIMATE_COMPUTE_RATIO_MAX;
+exports.ESTIMATE_COMPUTE_RATIO_MIN = ESTIMATE_COMPUTE_RATIO_MIN;
 exports.EVENTFUL_CAP_NAMES = EVENTFUL_CAP_NAMES;
 exports.EVENT_DENSITY_BATCH_MAX = EVENT_DENSITY_BATCH_MAX;
 exports.EVENT_KIND_BY_CAP = EVENT_KIND_BY_CAP;
@@ -110854,6 +111528,10 @@ exports.MODEL_FORMATS = require_sleep.MODEL_FORMATS;
 exports.MODEL_HOSTING = MODEL_HOSTING;
 exports.MODEL_PROVIDER_IDS = MODEL_PROVIDER_IDS;
 exports.MOTION_CLOSE_AFTER_MS = MOTION_CLOSE_AFTER_MS;
+exports.MOTION_CROP_DISPATCH_KEY = MOTION_CROP_DISPATCH_KEY;
+exports.MOTION_CROP_MAX_REGIONS = MOTION_CROP_MAX_REGIONS;
+exports.MOTION_CROP_MOTION_PAD = MOTION_CROP_MOTION_PAD;
+exports.MOTION_CROP_TRACKED_PAD = MOTION_CROP_TRACKED_PAD;
 exports.MOTION_SOURCE_LABELS = MOTION_SOURCE_LABELS;
 exports.MOTION_TRIGGER_FEATURE = MOTION_TRIGGER_FEATURE;
 exports.ManagedModelCatalogEntrySchema = ManagedModelCatalogEntrySchema;
@@ -110918,6 +111596,8 @@ exports.MotionZoneStatusSchema = MotionZoneStatusSchema;
 exports.MqttBrokerInfoSchema = BrokerInfoSchema$1;
 exports.MqttBrokerStatusSchema = StatusSchema;
 exports.MutationFilterSchema = MutationFilterSchema;
+exports.N100_IGPU_CLOCK_MHZ = N100_IGPU_CLOCK_MHZ;
+exports.N100_IGPU_EU = N100_IGPU_EU;
 exports.NATIVE_LEASE_ACTIVITY_FIELD = NATIVE_LEASE_ACTIVITY_FIELD;
 exports.NATIVE_LEASE_ACTIVITY_KEY = NATIVE_LEASE_ACTIVITY_KEY;
 exports.NATIVE_LEASE_ADMISSION_FIELD = NATIVE_LEASE_ADMISSION_FIELD;
@@ -111183,6 +111863,7 @@ exports.NotifierStatusSchema = NotifierStatusSchema;
 exports.NumericSensorStatusSchema = NumericSensorStatusSchema;
 exports.OAUTH_LANDING_PATH = OAUTH_LANDING_PATH;
 exports.OAUTH_LANDING_REASONS = OAUTH_LANDING_REASONS;
+exports.OBJECT_DETECTION_STEP_ID = OBJECT_DETECTION_STEP_ID;
 exports.OPERATOR_WRITTEN_STALE_MS = OPERATOR_WRITTEN_STALE_MS;
 exports.OPS_LOG_DEFAULT_LIMIT = OPS_LOG_DEFAULT_LIMIT;
 exports.OPS_LOG_RING_DEFAULT_MAX = OPS_LOG_RING_DEFAULT_MAX;
@@ -111233,6 +111914,7 @@ exports.PEER_BYTES_TICKET_TTL_MS = require_sleep.PEER_BYTES_TICKET_TTL_MS;
 exports.PENDING_BLOCK_ID = PENDING_BLOCK_ID;
 exports.PET_FEEDER_MANUAL_FEED_MAX = PET_FEEDER_MANUAL_FEED_MAX;
 exports.PET_FEEDER_MANUAL_FEED_MIN = PET_FEEDER_MANUAL_FEED_MIN;
+exports.PHOENIX_780M_CU = PHOENIX_780M_CU;
 exports.PIPELINE_ANALYTICS_CAP_NAME = PIPELINE_ANALYTICS_CAP_NAME;
 exports.PIPELINE_FLOW_CAPABILITY_NAMES = PIPELINE_FLOW_CAPABILITY_NAMES;
 exports.PIPELINE_OWNER_CAPABILITY_NAMES = PIPELINE_OWNER_CAPABILITY_NAMES;
@@ -111249,6 +111931,7 @@ exports.PUBLIC_ENDPOINT_HTTP_REASON = PUBLIC_ENDPOINT_HTTP_REASON;
 exports.PYTHON_SCRIPT = PYTHON_SCRIPT;
 exports.PackageInstallationSchema = PackageInstallationSchema;
 exports.PackageInstallationsSchema = PackageInstallationsSchema;
+exports.PackageLlmVerdictSchema = PackageLlmVerdictSchema;
 exports.PackageUpdateSchema = PackageUpdateSchema;
 exports.PackageVersionInfoSchema = PackageVersionInfoSchema;
 exports.ParkRefusalSchema = ParkRefusalSchema;
@@ -111281,6 +111964,7 @@ exports.PlaintextSecretError = require_sleep.PlaintextSecretError;
 exports.PolygonPointSchema = PolygonPointSchema;
 exports.PoolMemoryWatchdog = PoolMemoryWatchdog;
 exports.PowerMeterStatusSchema = PowerMeterStatusSchema;
+exports.PrecisionGopsSchema = PrecisionGopsSchema;
 exports.PreferenceDeviceIdSchema = PreferenceDeviceIdSchema;
 exports.PreferenceNamespaceSchema = PreferenceNamespaceSchema;
 exports.PreferenceRowSchema = PreferenceRowSchema;
@@ -111349,7 +112033,21 @@ exports.RECORD_QUERY_MAX = require_sleep.RECORD_QUERY_MAX;
 exports.RECORD_SECRET_COLLECTION_PREFIX = require_sleep.RECORD_SECRET_COLLECTION_PREFIX;
 exports.RECORD_SETTINGS_MAX_ROWS = require_sleep.RECORD_SETTINGS_MAX_ROWS;
 exports.RECORD_SWEEP_INTERVAL_MS = require_sleep.RECORD_SWEEP_INTERVAL_MS;
+exports.RECOVERY_CROP_MAX_SIDE_PX = RECOVERY_CROP_MAX_SIDE_PX;
+exports.RECOVERY_CROP_MIN_SIDE_PX = RECOVERY_CROP_MIN_SIDE_PX;
+exports.RECOVERY_CROP_PADDING_RATIO = RECOVERY_CROP_PADDING_RATIO;
+exports.RECOVERY_EDGE_MARGIN_PX = RECOVERY_EDGE_MARGIN_PX;
+exports.RECOVERY_FUSE_CONTAINMENT = RECOVERY_FUSE_CONTAINMENT;
+exports.RECOVERY_FUSE_IOU = RECOVERY_FUSE_IOU;
+exports.RECOVERY_MAX_CROPS_PER_FRAME = RECOVERY_MAX_CROPS_PER_FRAME;
+exports.RECOVERY_MAX_REGION_FRAME_FRACTION = RECOVERY_MAX_REGION_FRAME_FRACTION;
+exports.RECOVERY_MIN_INTERVAL_MS = RECOVERY_MIN_INTERVAL_MS;
+exports.RECOVERY_MIN_UNCOVERED_FRACTION = RECOVERY_MIN_UNCOVERED_FRACTION;
+exports.RECOVERY_MOTION_MAX_AGE_MS = RECOVERY_MOTION_MAX_AGE_MS;
+exports.RECOVERY_VIEW_PX = RECOVERY_VIEW_PX;
 exports.REDACTED_SECRET = require_sleep.REDACTED_SECRET;
+exports.REFERENCE_COMPUTE = REFERENCE_COMPUTE;
+exports.REFERENCE_MATCH_FRACTION = REFERENCE_MATCH_FRACTION;
 exports.REMOVAL_RECONCILE_INTERVAL_MS = REMOVAL_RECONCILE_INTERVAL_MS;
 exports.REMOVED_MODEL_IDS = REMOVED_MODEL_IDS;
 exports.REMOVE_LEAF = require_sleep.REMOVE_LEAF;
@@ -111536,6 +112234,7 @@ exports.SECRET_META = require_sleep.SECRET_META;
 exports.SECRET_REF_SCHEME = require_sleep.SECRET_REF_SCHEME;
 exports.SENSOR_FEATURES = SENSOR_FEATURES;
 exports.SENSOR_MAP = SENSOR_MAP;
+exports.SERIAL_CAPACITY_CAMERA_FPS = SERIAL_CAPACITY_CAMERA_FPS;
 exports.SERVER_NAME_MAX_LENGTH = SERVER_NAME_MAX_LENGTH;
 exports.SERVER_NAME_SETTING_KEY = SERVER_NAME_SETTING_KEY;
 exports.SESSION_PLACEMENT_SETTING_KEY = SESSION_PLACEMENT_SETTING_KEY;
@@ -111745,8 +112444,10 @@ exports.TrackStateSchema = TrackStateSchema;
 exports.TrackZoneFilterSchema = TrackZoneFilterSchema;
 exports.TrackedDetectionSchema = TrackedDetectionSchema;
 exports.TrainerSourceRefSchema = TrainerSourceRefSchema;
+exports.TrainingAcceleratorRefSchema = TrainingAcceleratorRefSchema;
 exports.TrainingBaseModelSchema = TrainingBaseModelSchema;
 exports.TrainingCanarySchema = TrainingCanarySchema;
+exports.TrainingCanaryTargetSchema = TrainingCanaryTargetSchema;
 exports.TrainingCatalogDraftSchema = TrainingCatalogDraftSchema;
 exports.TrainingCorpusSelectionSchema = TrainingCorpusSelectionSchema;
 exports.TrainingCredentialCheckSchema = TrainingCredentialCheckSchema;
@@ -111889,6 +112590,7 @@ exports.addonWidgetsSourceCapability = addonWidgetsSourceCapability;
 exports.addonsCapability = addonsCapability;
 exports.adminUiCapability = require_sleep.adminUiCapability;
 exports.advertisedHubOrigins = advertisedHubOrigins;
+exports.aggregateThroughputFactor = aggregateThroughputFactor;
 exports.airQualitySensorCapability = airQualitySensorCapability;
 exports.alarmDeviceBlocksArming = alarmDeviceBlocksArming;
 exports.alarmDeviceSecureOnArm = alarmDeviceSecureOnArm;
@@ -111906,6 +112608,7 @@ exports.ambientLightSensorCapability = ambientLightSensorCapability;
 exports.annotateClipsWithEventLabels = annotateClipsWithEventLabels;
 exports.appFlowLocation = appFlowLocation;
 exports.applyBlockingEdit = applyBlockingEdit;
+exports.applyCropClassFloors = applyCropClassFloors;
 exports.applyModeDelaysEdits = applyModeDelaysEdits;
 exports.applyModeDeviceListEdit = applyModeDeviceListEdit;
 exports.applyModelBoundSettings = applyModelBoundSettings;
@@ -111977,6 +112680,7 @@ exports.cameraCredentialsCapability = cameraCredentialsCapability;
 exports.cameraGridLayoutCapability = cameraGridLayoutCapability;
 exports.cameraOwnsMotionViaSensor = cameraOwnsMotionViaSensor;
 exports.cameraPipelineConfigCapability = cameraPipelineConfigCapability;
+exports.cameraScopedStepSettings = cameraScopedStepSettings;
 exports.cameraSensorRefKey = cameraSensorRefKey;
 exports.cameraStreamsCapability = cameraStreamsCapability;
 exports.canConvertUnit = canConvertUnit;
@@ -112040,6 +112744,7 @@ exports.compositionSliceKey = require_composition.compositionSliceKey;
 exports.compositionSourceKey = require_composition.compositionSourceKey;
 exports.compositionSourceRefs = compositionSourceRefs;
 exports.computeCapacityShares = computeCapacityShares;
+exports.computeScores = computeScores;
 exports.conditionDepth = conditionDepth;
 exports.conditionExclusionReason = conditionExclusionReason;
 exports.conditionVisibleForKind = conditionVisibleForKind;
@@ -112062,6 +112767,7 @@ exports.coreBlockSourceKind = coreBlockSourceKind;
 exports.coreBlocksCapability = coreBlocksCapability;
 exports.cosineSimilarity = cosineSimilarity;
 exports.countConditionLeaves = countConditionLeaves;
+exports.countRecoverySkips = countRecoverySkips;
 exports.coverCapability = coverCapability;
 exports.createAlarmProfile = createAlarmProfile;
 exports.createDeviceExtensionProvider = createDeviceExtensionProvider;
@@ -112232,6 +112938,7 @@ exports.formatSecretScope = require_sleep.formatSecretScope;
 exports.freshResults = freshResults;
 exports.frigateDefaultClassFloors = frigateDefaultClassFloors;
 exports.frigateLabelFields = frigateLabelFields;
+exports.fuseRecoveredDetections = fuseRecoveredDetections;
 exports.gasCapability = gasCapability;
 exports.gbToBytes = gbToBytes;
 exports.generateAutomationBlock = generateAutomationBlock;
@@ -112314,6 +113021,7 @@ exports.isKnownTemplateVar = isKnownTemplateVar;
 exports.isLabelSupplyStepId = isLabelSupplyStepId;
 exports.isLocationEnabled = isLocationEnabled;
 exports.isMediaOwnerType = isMediaOwnerType;
+exports.isModelScopedStepSettingKey = isModelScopedStepSettingKey;
 exports.isNode = isNode;
 exports.isOauthLandingReason = isOauthLandingReason;
 exports.isObjectInput = isObjectInput;
@@ -112413,6 +113121,7 @@ exports.modelBindingKey = modelBindingKey;
 exports.modelConvertCapability = modelConvertCapability;
 exports.modelDistributorCapability = modelDistributorCapability;
 exports.modelFormatForRuntime = modelFormatForRuntime;
+exports.modelScopedStepSettingKeys = modelScopedStepSettingKeys;
 exports.motionCapability = motionCapability;
 exports.motionDetectionCapability = motionDetectionCapability;
 exports.motionSourceLabel = motionSourceLabel;
@@ -112440,6 +113149,7 @@ exports.normalizeOrigin = normalizeOrigin;
 exports.normalizeSecretOwner = require_sleep.normalizeSecretOwner;
 exports.normalizeTokenScopes = normalizeTokenScopes;
 exports.normalizeUnit = normalizeUnit;
+exports.normalizedArea = normalizedArea;
 exports.notificationOutputCapability = notificationOutputCapability;
 exports.notificationRulesCapability = notificationRulesCapability;
 exports.notifierCapability = notifierCapability;
@@ -112457,6 +113167,7 @@ exports.osdCapability = osdCapability;
 exports.osdManagerCapability = osdManagerCapability;
 exports.overlayClusterStepSettings = overlayClusterStepSettings;
 exports.packagePickerItems = packagePickerItems;
+exports.parseAcceleratorFactsJson = parseAcceleratorFactsJson;
 exports.parseAdminBase = parseAdminBase;
 exports.parseAlertEpisodePayload = parseAlertEpisodePayload;
 exports.parseAppAuthCallback = parseAppAuthCallback;
@@ -112507,6 +113218,9 @@ exports.pipelineRunnerCapability = pipelineRunnerCapability;
 exports.planComposition = planComposition;
 exports.planCompositionEvents = planCompositionEvents;
 exports.planItems = planItems;
+exports.planMotionCropRegions = planMotionCropRegions;
+exports.planMotionCrops = planMotionCrops;
+exports.planRecoveryCrops = planRecoveryCrops;
 exports.plateGalleryCapability = plateGalleryCapability;
 exports.platformProbeCapability = platformProbeCapability;
 exports.poolMemoryThreshold = poolMemoryThreshold;
@@ -112535,6 +113249,8 @@ exports.readHubMotionStatus = readHubMotionStatus;
 exports.readMotionTriggeredBy = readMotionTriggeredBy;
 exports.readNativeLeaseOverride = readNativeLeaseOverride;
 exports.readNodePin = require_sleep.readNodePin;
+exports.readRecoveryRecipe = readRecoveryRecipe;
+exports.readRecoveryRecipeForSteps = readRecoveryRecipeForSteps;
 exports.readTimelapseGeneratedAt = readTimelapseGeneratedAt;
 exports.readUseRootModel = readUseRootModel;
 exports.readinessKey = require_sleep.readinessKey;
@@ -112556,9 +113272,11 @@ exports.recordsErrorFromMessage = require_sleep.recordsErrorFromMessage;
 exports.rectsToCells = rectsToCells;
 exports.reducePoints = reducePoints;
 exports.registerKnownSecret = require_sleep.registerKnownSecret;
+exports.remapCropDetections = remapCropDetections;
 exports.renameAlarmProfile = renameAlarmProfile;
 exports.renderVocabPhrase = renderVocabPhrase;
 exports.replacedFieldKeys = replacedFieldKeys;
+exports.reportIsScalable = reportIsScalable;
 exports.requestMountPrefix = requestMountPrefix;
 exports.requiredTopLevelKeys = requiredTopLevelKeys;
 exports.requiresPython = requiresPython;
@@ -112586,6 +113304,7 @@ exports.resolveHubAddressRoles = resolveHubAddressRoles;
 exports.resolveHydratedFieldValue = require_sleep.resolveHydratedFieldValue;
 exports.resolveIconKey = resolveIconKey;
 exports.resolveInternalAddress = resolveInternalAddress;
+exports.resolveLatencyColumn = resolveLatencyColumn;
 exports.resolveLocationMode = resolveLocationMode;
 exports.resolveMethodAuth = resolveMethodAuth;
 exports.resolveMethodRole = resolveMethodRole;
@@ -112652,6 +113371,7 @@ exports.secretTreeFromSchema = require_sleep.secretTreeFromSchema;
 exports.secureActuationFor = secureActuationFor;
 exports.selectAppConnectionEndpoints = selectAppConnectionEndpoints;
 exports.selectAssignedProfileSlots = require_sleep.selectAssignedProfileSlots;
+exports.selectRecoveryStep = selectRecoveryStep;
 exports.sendTimesForEditor = sendTimesForEditor;
 exports.sendTimesOfSchedule = sendTimesOfSchedule;
 exports.sensorRaisedOf = sensorRaisedOf;
@@ -112678,6 +113398,7 @@ exports.smokeCapability = smokeCapability;
 exports.smtpProviderCapability = smtpProviderCapability;
 exports.snapshotCapability = snapshotCapability;
 exports.splitTranslationRef = splitTranslationRef;
+exports.squareAround = squareAround;
 exports.ssoBridgeCapability = ssoBridgeCapability;
 exports.startMoverUnderClearance = startMoverUnderClearance;
 exports.startReachabilityPoll = startReachabilityPoll;