@camstack/types 1.2.404 → 1.2.406

package/dist/index.js

@@ -1,7 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-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_sleep = require("./sleep-UP964hNP.js");
+const require_event_category = require("./event-category-DG6Vir8Z.js");
+const require_composition = require("./composition-RmnnN39T.js");
 const require_node_color = require("./node-color.js");
 const require_err_msg = require("./err-msg-BhVbr0NX.js");
 const require_enums = require("./enums.js");
@@ -12871,7 +12871,15 @@ var BUILTIN_RESULT_KINDS = Object.freeze({
 		kind: "fixed",
 		result: ["number", "null"]
 	},
-	count: NUMBER
+	count: NUMBER,
+	dwell: {
+		kind: "fixed",
+		result: ["boolean", "null"]
+	},
+	latchedAt: {
+		kind: "fixed",
+		result: ["number", "null"]
+	}
 });
 var KindInferenceError = class extends Error {};
 function kindOfValue(value) {
@@ -12883,7 +12891,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) {
@@ -12911,8 +12919,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) {
@@ -12925,8 +12933,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)));
 	}
 }
@@ -43726,9 +43734,6 @@ var NcSystemEventKindSchema = zod.z.enum([
 	"device-battery-normal",
 	"device-consumable-low",
 	"device-consumable-normal",
-	"device-tank-low",
-	"device-tank-full",
-	"device-tank-normal",
 	"stream-online",
 	"stream-offline",
 	"node-online",
@@ -43775,18 +43780,19 @@ var NcSystemEventKindSchema = zod.z.enum([
 	"camera-enabled"
 ]);
 /** The legacy tail of {@link NcSystemEventKindSchema} — see its docblock. */
-var NC_LEGACY_SYSTEM_EVENT_KINDS = new Set([
+var NC_LEGACY_SYSTEM_EVENT_KINDS = [
 	"camera-online",
 	"camera-offline",
 	"camera-disabled",
 	"camera-enabled"
-]);
+];
+var NC_LEGACY_SYSTEM_EVENT_KIND_SET = new Set(NC_LEGACY_SYSTEM_EVENT_KINDS);
 /**
 * The kinds a rule may be AUTHORED with — every schema member except the
 * legacy tail. Editors render THIS list; the schema still parses the tail so a
 * durable row (and an unmigrated rule) survives being read.
 */
-var NC_AUTHORABLE_SYSTEM_EVENT_KINDS = NcSystemEventKindSchema.options.filter((kind) => !NC_LEGACY_SYSTEM_EVENT_KINDS.has(kind));
+var NC_AUTHORABLE_SYSTEM_EVENT_KINDS = NcSystemEventKindSchema.options.filter((kind) => !NC_LEGACY_SYSTEM_EVENT_KIND_SET.has(kind));
 /**
 * The panel's transitions, as ONE list.
 *
@@ -43831,12 +43837,6 @@ var NC_BATTERY_CONSUMABLE_SYSTEM_EVENT_KINDS = [
 * and both editors read it.
 */
 var NC_CONSUMABLE_SYSTEM_EVENT_KINDS = ["device-consumable-low", "device-consumable-normal"];
-/** A vacuum's tank alerts (D642) — raised on the provider's own verdict. */
-var NC_TANK_SYSTEM_EVENT_KINDS = [
-	"device-tank-low",
-	"device-tank-full",
-	"device-tank-normal"
-];
 /**
 * The consumable threshold a rule that does not state one judges at (D642).
 * The operator's number ("default 15 %, configurable on the rule"), and the
@@ -45072,18 +45072,18 @@ var NcRuleSchema = NcRuleInputSchema.extend({
 * `addon-updates` the addons that are behind (D708 split them). `backups-exports` and `alarm` are not sections — a completed
 * job is not an open state, and the alarm stays instant.
 */
-var NcStateSummarySectionIdSchema = zod.z.enum([
+var NC_STATE_SUMMARY_SECTION_IDS = [
 	"device-state",
 	"streams",
 	"battery",
 	"consumables",
-	"tanks",
 	"detection-blind",
 	"nodes",
 	"addons",
 	"addon-updates",
 	"updates"
-]);
+];
+var NcStateSummarySectionIdSchema = zod.z.enum(NC_STATE_SUMMARY_SECTION_IDS);
 /** One section of a previewed state summary. `unavailable` = its state could not be read. */
 var NcStateSummaryPreviewSectionSchema = zod.z.object({
 	id: NcStateSummarySectionIdSchema,
@@ -45460,18 +45460,6 @@ var NC_CONDITION_CATALOG = [
 				value: "device-consumable-normal",
 				label: "Consumable replaced"
 			},
-			{
-				value: "device-tank-low",
-				label: "Tank low (water, detergent)"
-			},
-			{
-				value: "device-tank-full",
-				label: "Tank full (dirty water, dust)"
-			},
-			{
-				value: "device-tank-normal",
-				label: "Tank back to normal"
-			},
 			{
 				value: "export-completed",
 				label: "Export completed"
@@ -47289,6 +47277,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.
@@ -48407,6 +48409,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. */
@@ -51632,11 +51649,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(),
@@ -51644,6 +51668,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()
@@ -67662,427 +67691,1201 @@ 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
-		},
-		kwhTotal: {
-			kind: "counter",
-			unit: "kWh",
-			deadband: .01,
-			minIntervalMs: 6e4
+//#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
+			}
 		},
-		volts: {
-			kind: "gauge",
-			unit: "V",
-			deadband: 1,
-			minIntervalMs: 3e4
+		"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
+			}
 		},
-		amps: {
-			kind: "gauge",
-			unit: "A",
-			deadband: .05,
-			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
+			}
 		},
-		va: {
-			kind: "gauge",
-			unit: "VA",
-			deadband: 1,
-			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
+			}
 		},
-		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"]
+		"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
+		} }
+	}
 };
-//#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 = {
-	name: "presence",
-	scope: "device",
-	deviceNative: true,
-	mode: "singleton",
-	deviceTypes: [require_err_msg.DeviceType.Presence],
-	methods: {},
-	status: {
-		schema: PresenceStatusSchema,
-		kind: "push"
+var DETECTOR_ACCURACY = {
+	"yolov9m-320": {
+		personPrecision: .979,
+		personRecall: .649
 	},
-	/**
-	* Runtime-state slice — mirrored by the kernel. UI presence card
-	* reads `state` + `location` for the text label; iff `gps !== null`
-	* the map pin is rendered (use `DeviceFeature.PresenceGps` for the
-	* pre-fetch fast-path check).
-	*/
-	runtimeState: PresenceStatusSchema,
-	/**
-	* Runtime-state durability: **restored** — occupancy-relevant: the restored state is what an occupancy rule compares the first post-restart observation against.
-	*
-	* See `RuntimeStateDurability`. Enforced by
-	* `scripts/check-runtime-state-durability.ts`.
-	*/
-	durability: "restored",
-	/**
-	* History (D850): recorded series.
-	*/
-	history: { fields: { batteryPercent: {
-		kind: "gauge",
-		unit: "%",
-		deadband: 1
-	} } },
-	/** Clock fields: written, but excluded from the compare that decides
-	*  whether persisting is worth a SQLite commit. */
-	volatileStateFields: ["lastChangedAt"]
+	"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/pressure-sensor.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;
+}
 /**
-* Atmospheric pressure reading in hectopascals. Drives Home Assistant
-* `sensor` entries with `device_class: pressure`.
-*
-* Unit normalisation: hPa. The canonical display unit (`hPa`) is a
-* descriptor constant in the UI (ROLE_DESCRIPTOR), not stored in
-* `sourceInfo`.
+* 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 PressureSensorStatusSchema = zod.z.object({
-	/** Current pressure in hPa. */
-	hpa: zod.z.number(),
-	/** Ms epoch when the slice was last updated. */
-	lastFetchedAt: zod.z.number(),
-	/** Live display unit from the upstream source (e.g. HA
-	*  `attributes.unit_of_measurement`). The UI prefers this over the
-	*  role's canonical unit. Absent → fall back to the canonical unit. */
-	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 pressureSensorCapability = {
-	name: "pressure-sensor",
-	scope: "device",
-	deviceNative: true,
-	mode: "singleton",
-	deviceTypes: [require_err_msg.DeviceType.Sensor],
-	methods: {},
-	status: {
-		schema: PressureSensorStatusSchema,
-		kind: "push"
-	},
+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 = {
+	name: "presence",
+	scope: "device",
+	deviceNative: true,
+	mode: "singleton",
+	deviceTypes: [require_err_msg.DeviceType.Presence],
+	methods: {},
+	status: {
+		schema: PresenceStatusSchema,
+		kind: "push"
+	},
+	/**
+	* Runtime-state slice — mirrored by the kernel. UI presence card
+	* reads `state` + `location` for the text label; iff `gps !== null`
+	* the map pin is rendered (use `DeviceFeature.PresenceGps` for the
+	* pre-fetch fast-path check).
+	*/
+	runtimeState: PresenceStatusSchema,
+	/**
+	* Runtime-state durability: **restored** — occupancy-relevant: the restored state is what an occupancy rule compares the first post-restart observation against.
+	*
+	* See `RuntimeStateDurability`. Enforced by
+	* `scripts/check-runtime-state-durability.ts`.
+	*/
+	durability: "restored",
+	/**
+	* History (D850): recorded series.
+	*/
+	history: { fields: { batteryPercent: {
+		kind: "gauge",
+		unit: "%",
+		deadband: 1
+	} } },
+	/** Clock fields: written, but excluded from the compare that decides
+	*  whether persisting is worth a SQLite commit. */
+	volatileStateFields: ["lastChangedAt"]
+};
+//#endregion
+//#region src/capabilities/pressure-sensor.cap.ts
+/**
+* Atmospheric pressure reading in hectopascals. Drives Home Assistant
+* `sensor` entries with `device_class: pressure`.
+*
+* Unit normalisation: hPa. The canonical display unit (`hPa`) is a
+* descriptor constant in the UI (ROLE_DESCRIPTOR), not stored in
+* `sourceInfo`.
+*/
+var PressureSensorStatusSchema = zod.z.object({
+	/** Current pressure in hPa. */
+	hpa: zod.z.number(),
+	/** Ms epoch when the slice was last updated. */
+	lastFetchedAt: zod.z.number(),
+	/** Live display unit from the upstream source (e.g. HA
+	*  `attributes.unit_of_measurement`). The UI prefers this over the
+	*  role's canonical unit. Absent → fall back to the canonical unit. */
+	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 pressureSensorCapability = {
+	name: "pressure-sensor",
+	scope: "device",
+	deviceNative: true,
+	mode: "singleton",
+	deviceTypes: [require_err_msg.DeviceType.Sensor],
+	methods: {},
+	status: {
+		schema: PressureSensorStatusSchema,
+		kind: "push"
+	},
 	runtimeState: PressureSensorStatusSchema,
 	/**
 	* Runtime-state durability: **restored** — as `numeric-sensor`.
@@ -68786,6 +69589,43 @@ var ptzAutotrackCapability = {
 	history: "none"
 };
 //#endregion
+//#region src/capabilities/running-state.cap.ts
+var RunningStateSourceSchema = zod.z.enum(["native", "assigned"]);
+var RunningStateStatusSchema = zod.z.object({
+	/** null = unknown — never coerced to false (D393). */
+	running: zod.z.boolean().nullable(),
+	/** Epoch ms the current boolean began; null while `running` is null. */
+	since: zod.z.number().nullable(),
+	source: RunningStateSourceSchema,
+	phase: zod.z.string().nullable(),
+	lastFetchedAt: zod.z.number()
+});
+var RunningFlipEventDataSchema = zod.z.object({
+	deviceId: zod.z.number(),
+	since: zod.z.number().nullable(),
+	phase: zod.z.string().nullable()
+});
+var runningStateCapability = {
+	name: "running-state",
+	scope: "device",
+	deviceNative: true,
+	mode: "singleton",
+	deviceTypes: Object.values(require_err_msg.DeviceType),
+	methods: {},
+	events: {
+		onStarted: { data: RunningFlipEventDataSchema },
+		onFinished: { data: RunningFlipEventDataSchema }
+	},
+	status: {
+		schema: RunningStateStatusSchema,
+		kind: "push"
+	},
+	runtimeState: RunningStateStatusSchema,
+	durability: "restored",
+	history: { fields: { running: { kind: "boolean" } } },
+	volatileStateFields: ["lastFetchedAt"]
+};
+//#endregion
 //#region src/capabilities/reboot.cap.ts
 /**
 * reboot — device-scoped capability for "soft" device reboots (firmware
@@ -71686,7 +72526,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
@@ -74999,6 +75852,215 @@ var PIPELINE_OWNER_CAPABILITY_NAMES = [
 	"pipeline-runner"
 ];
 //#endregion
+//#region src/running-state/assignment.ts
+function constant(literal) {
+	return {
+		kind: "expression",
+		expr: literal,
+		bindings: {}
+	};
+}
+function fromRead(source, cap, fieldPath) {
+	return {
+		kind: "from",
+		source,
+		cap,
+		fieldPath
+	};
+}
+function sortKeys(value) {
+	if (Array.isArray(value)) return value.map(sortKeys);
+	if (typeof value !== "object" || value === null) return value;
+	return Object.fromEntries(Object.entries(value).toSorted(([a], [b]) => a.localeCompare(b)).map(([key, inner]) => [key, sortKeys(inner)]));
+}
+function sameFeature(a, b) {
+	return JSON.stringify(sortKeys(a)) === JSON.stringify(sortKeys(b));
+}
+function booleanRunningField(input) {
+	if (input.source.kind !== "boolean") return null;
+	const read = fromRead(input.source.source, input.source.cap, input.source.fieldPath);
+	if (!input.invert) return read;
+	return {
+		kind: "expression",
+		expr: "!x",
+		bindings: { x: read }
+	};
+}
+function sinceField(input) {
+	if (input.source.kind === "boolean" && input.changedAtField !== null) return fromRead(input.source.source, input.source.cap, input.changedAtField);
+	return {
+		kind: "expression",
+		expr: "latchedAt(running)",
+		bindings: { running: fromRead(input.target, "running-state", "running") }
+	};
+}
+function powerRunningField(input) {
+	if (input.source.kind !== "number") return null;
+	if (!Number.isFinite(input.thresholdWatts) || !Number.isFinite(input.startDelayMs) || !Number.isFinite(input.stopDelayMs) || input.thresholdWatts < 0 || input.startDelayMs < 0 || input.stopDelayMs < 0) return null;
+	const read = fromRead(input.source.source, input.source.cap, input.source.fieldPath);
+	return {
+		kind: "expression",
+		expr: `dwell(x >= ${input.thresholdWatts}, ${input.startDelayMs}, ${input.stopDelayMs})`,
+		bindings: { x: read }
+	};
+}
+function runningAssignmentFeature(input) {
+	const running = input.source.kind === "number" ? powerRunningField(input) : booleanRunningField(input);
+	if (running === null) return null;
+	return {
+		kind: "fields",
+		cap: "running-state",
+		fields: {
+			source: constant("\"assigned\""),
+			phase: constant("null"),
+			lastFetchedAt: constant("now"),
+			running,
+			since: sinceField(input)
+		}
+	};
+}
+function booleanSourceFromRunningField(source) {
+	if (source === void 0) return null;
+	if (source.kind === "from") return {
+		source: source.source,
+		cap: source.cap,
+		fieldPath: source.fieldPath,
+		kind: "boolean"
+	};
+	if (source.kind !== "expression" || source.expr !== "!x") return null;
+	const x = source.bindings["x"];
+	if (x === void 0 || x.kind !== "from") return null;
+	return {
+		source: x.source,
+		cap: x.cap,
+		fieldPath: x.fieldPath,
+		kind: "boolean"
+	};
+}
+function recoverPowerRunning(running) {
+	if (running === void 0 || running.kind !== "expression") return null;
+	const match = /^dwell\(x >= ([\d.]+), (\d+), (\d+)\)$/.exec(running.expr);
+	if (match === null) return null;
+	const x = running.bindings["x"];
+	if (x === void 0 || x.kind !== "from") return null;
+	const thresholdWatts = Number(match[1]);
+	const startDelayMs = Number(match[2]);
+	const stopDelayMs = Number(match[3]);
+	if (!Number.isFinite(thresholdWatts) || !Number.isFinite(startDelayMs) || !Number.isFinite(stopDelayMs)) return null;
+	return {
+		source: {
+			...x,
+			kind: "number"
+		},
+		invert: false,
+		thresholdWatts,
+		startDelayMs,
+		stopDelayMs
+	};
+}
+/** Recover what {@link runningAssignmentFeature} wrote, else null. */
+function runningAssignmentRecovered(stored, target) {
+	if (stored.cap !== "running-state" || stored.kind !== "fields") return null;
+	const power = recoverPowerRunning(stored.fields["running"]);
+	if (power !== null) return power;
+	const booleanSource = booleanSourceFromRunningField(stored.fields["running"]);
+	if (booleanSource === null) return null;
+	const since = stored.fields["since"];
+	let changedAtField = null;
+	if (since?.kind === "from" && since.cap === booleanSource.cap && since.source.addonId === booleanSource.source.addonId && since.source.stableId === booleanSource.source.stableId) changedAtField = since.fieldPath;
+	const rebuilt = runningAssignmentFeature({
+		mode: "replace",
+		target,
+		source: booleanSource,
+		changedAtField,
+		invert: stored.fields["running"]?.kind === "expression" && stored.fields["running"].expr === "!x",
+		thresholdWatts: 0,
+		startDelayMs: 0,
+		stopDelayMs: 0
+	});
+	if (rebuilt === null) return null;
+	const { enabled: _e, ...rest } = stored;
+	if (!sameFeature(rest, rebuilt)) return null;
+	return {
+		source: booleanSource,
+		invert: stored.fields["running"]?.kind === "expression" && stored.fields["running"].expr === "!x",
+		thresholdWatts: 0,
+		startDelayMs: 0,
+		stopDelayMs: 0
+	};
+}
+function isRunningAssignmentFeature(stored, mode, target) {
+	const recovered = runningAssignmentRecovered(stored, target);
+	if (recovered === null) return false;
+	const rebuilt = recovered.source.kind === "number" ? runningAssignmentFeature({
+		mode,
+		target,
+		source: recovered.source,
+		changedAtField: null,
+		invert: false,
+		thresholdWatts: recovered.thresholdWatts,
+		startDelayMs: recovered.startDelayMs,
+		stopDelayMs: recovered.stopDelayMs
+	}) : runningAssignmentFeature({
+		mode,
+		target,
+		source: recovered.source,
+		changedAtField: stored.fields["since"]?.kind === "from" ? stored.fields["since"].fieldPath : null,
+		invert: recovered.invert,
+		thresholdWatts: 0,
+		startDelayMs: 0,
+		stopDelayMs: 0
+	});
+	if (rebuilt === null) return false;
+	const { enabled: _enabled, ...rest } = stored;
+	return sameFeature(rest, rebuilt);
+}
+//#endregion
+//#region src/running-state/defaults.ts
+var RUNNING_POWER_THRESHOLD_WATTS = 5;
+var RUNNING_POWER_START_DELAY_MS = 3e4;
+var RUNNING_POWER_STOP_DELAY_MS = 18e4;
+//#endregion
+//#region src/running-state/from-operation.ts
+function resolveSince(running, previous, sinceMs) {
+	if (running === null) return null;
+	if ((previous?.running ?? null) !== running) return sinceMs;
+	return previous?.since ?? sinceMs;
+}
+function nativeSlice(running, phase, previous, sinceMs, now) {
+	return {
+		running,
+		since: resolveSince(running, previous, sinceMs),
+		source: "native",
+		phase: running === null ? null : phase,
+		lastFetchedAt: now
+	};
+}
+function runningFromDishwasherOperation(operation, program, previous, now) {
+	if (operation === null) return nativeSlice(null, null, previous, now, now);
+	if (operation === "Run" || operation === "Aborting") return nativeSlice(true, program ?? operation, previous, now, now);
+	if (operation === "Pause") return nativeSlice(false, "Pause", previous, now, now);
+	return nativeSlice(false, operation, previous, now, now);
+}
+function runningFromVacuumState(state, previous, now) {
+	if (state === null) return nativeSlice(null, null, previous, now, now);
+	if (state === "cleaning" || state === "returning" || state === "drying") return nativeSlice(true, state, previous, now, now);
+	if (state === "paused") return nativeSlice(false, "paused", previous, now, now);
+	return nativeSlice(false, state, previous, now, now);
+}
+function runningFromLawnMower(activity, previous, now) {
+	if (activity === null) return nativeSlice(null, null, previous, now, now);
+	if (activity === "mowing") return nativeSlice(true, activity, previous, now, now);
+	if (activity === "paused") return nativeSlice(false, "paused", previous, now, now);
+	return nativeSlice(false, activity, previous, now, now);
+}
+function runningFromMediaPlayer(state, previous, now) {
+	if (state === null) return nativeSlice(null, null, previous, now, now);
+	if (state === "playing" || state === "buffering") return nativeSlice(true, state, previous, now, now);
+	if (state === "paused") return nativeSlice(false, "paused", previous, now, now);
+	return nativeSlice(false, state, previous, now, now);
+}
+//#endregion
 //#region src/clips/clip-event-labels.ts
 /**
 * Which of OUR object detections a clip window holds — the ONE overlap rule
@@ -75642,11 +76704,12 @@ function expressionOutcome(source, read, now, stateful) {
 		return unavailable;
 	}
 	const deadlines = [];
+	const hooks = {
+		noteDeadline: (at) => deadlines.push(at),
+		convert: (value, from, to) => tryConvertUnit(value, normalizeUnit(from) ?? from, normalizeUnit(to) ?? to) ?? null
+	};
 	const result = require_composition.evaluateExpressionSource(source.expr, values, now, {
-		hooks: {
-			noteDeadline: (at) => deadlines.push(at),
-			convert: (value, from, to) => tryConvertUnit(value, normalizeUnit(from) ?? from, normalizeUnit(to) ?? to) ?? null
-		},
+		hooks,
 		...stateful === void 0 ? {} : { invokeStateful: (invocation) => require_composition.evaluateStatefulExpressionCall(stateful.callPathPrefix === void 0 ? invocation : {
 			...invocation,
 			path: `${stateful.callPathPrefix}@${invocation.path}`
@@ -75654,7 +76717,7 @@ function expressionOutcome(source, read, now, stateful) {
 			currentOutput: stateful.currentOutput,
 			startedAtMs: stateful.startedAtMs,
 			nowMs: now
-		}) }
+		}, hooks) }
 	});
 	if (!result.ok) return {
 		state: "unavailable",
@@ -76606,6 +77669,7 @@ var DEVICE_LOCAL_STATE_CAPS = {
 	ptzAutotrack: ptzAutotrackCapability,
 	recordingOnboard: recordingOnboardCapability,
 	recordingSignal: recordingSignalCapability,
+	runningState: runningStateCapability,
 	sceneMonitor: sceneMonitorCapability,
 	scriptRunner: scriptRunnerCapability,
 	smoke: smokeCapability,
@@ -86189,6 +87253,13 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		access: "create",
 		role: "admin"
 	},
+	"runningState.getStatus": {
+		capName: "running-state",
+		capScope: "device",
+		addonId: null,
+		access: "view",
+		role: "viewer"
+	},
 	"sceneMonitor.captureReference": {
 		capName: "scene-monitor",
 		capScope: "device",
@@ -88478,6 +89549,7 @@ var KNOWN_CAP_NAMES = [
 	"recording-onboard",
 	"recording-signal",
 	"records",
+	"running-state",
 	"scene-monitor",
 	"script-runner",
 	"server-management",
@@ -88592,6 +89664,7 @@ var DEVICE_CAP_NAMES = [
 	"recording",
 	"recording-onboard",
 	"recording-signal",
+	"running-state",
 	"scene-monitor",
 	"script-runner",
 	"smoke",
@@ -91276,6 +92349,32 @@ var APPLIANCE_CAP_VOCABULARY = {
 		}],
 		events: { onSent: { notOperatorFacing: "a delivery receipt of a send this system made — not a fact about the world" } }
 	},
+	"running-state": {
+		scope: "device",
+		noun: t("Running", "In funzione"),
+		state: [{
+			kind: "boolean",
+			field: "running",
+			label: t("Running", "In funzione"),
+			whenTrue: t("When {device} starts", "Quando {device} inizia"),
+			whenFalse: t("When {device} finishes", "Quando {device} finisce"),
+			icon: "play"
+		}],
+		events: {
+			onStarted: {
+				category: require_event_category.EventCategory.RunningStarted,
+				label: t("Started running", "Ha iniziato a funzionare"),
+				phrase: t("When {device} starts running", "Quando {device} inizia a funzionare"),
+				icon: "play"
+			},
+			onFinished: {
+				category: require_event_category.EventCategory.RunningFinished,
+				label: t("Finished", "Ha finito"),
+				phrase: t("When {device} finishes", "Quando {device} finisce"),
+				icon: "square"
+			}
+		}
+	},
 	update: {
 		scope: "device",
 		noun: t("Firmware update", "Aggiornamento firmware"),
@@ -94216,6 +95315,7 @@ var CAP_NAMES_WITH_STATUS = [
 	"recording-archive",
 	"recording-onboard",
 	"recording-signal",
+	"running-state",
 	"scene-monitor",
 	"script-runner",
 	"smoke",
@@ -94371,6 +95471,7 @@ var CAPABILITY_NAMES = {
 	recordingOnboard: "recording-onboard",
 	recordingSignal: "recording-signal",
 	records: "records",
+	runningState: "running-state",
 	sceneMonitor: "scene-monitor",
 	scriptRunner: "script-runner",
 	serverManagement: "server-management",
@@ -94964,6 +96065,10 @@ var CAPABILITY_ROUTER_KEYS = [
 		key: "records",
 		name: "records"
 	},
+	{
+		key: "runningState",
+		name: "running-state"
+	},
 	{
 		key: "sceneMonitor",
 		name: "scene-monitor"
@@ -95280,6 +96385,7 @@ var ALL_CAPABILITY_DEFINITIONS = [
 	recordingOnboardCapability,
 	recordingSignalCapability,
 	recordsCapability,
+	runningStateCapability,
 	sceneMonitorCapability,
 	scriptRunnerCapability,
 	serverManagementCapability,
@@ -97596,6 +98702,11 @@ var METHOD_DEVICE_SELECTORS = Object.freeze({
 		form: "single",
 		optional: true
 	}],
+	"runningState.getStatus": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"sceneMonitor.captureReference": [{
 		name: "deviceId",
 		form: "single",
@@ -98297,7 +99408,7 @@ function getCapsByProviderKind(kind) {
 //#region src/generated/runtime-state-durability.ts
 /**
 * Per-cap runtime-state policy, projected from every `*.cap.ts` that declares
-* `runtimeState`. 71 caps: 37 `restored`, 34 `session`.
+* `runtimeState`. 72 caps: 38 `restored`, 34 `session`.
 *
 * A cap absent from this map has no runtime-state slice at all. A cap PRESENT
 * with `durability: 'session'` has one and has decided not to keep it.
@@ -98515,6 +99626,10 @@ var RUNTIME_STATE_POLICY = {
 		durability: "session",
 		volatileFields: []
 	},
+	"running-state": {
+		durability: "restored",
+		volatileFields: ["lastFetchedAt"]
+	},
 	"scene-monitor": {
 		durability: "session",
 		volatileFields: []
@@ -98637,6 +99752,7 @@ var RESTORED_CAP_NAMES = [
 	"pressure-sensor",
 	"privacy-mask",
 	"recording-onboard",
+	"running-state",
 	"smoke",
 	"stream-catalog",
 	"stream-params",
@@ -98752,7 +99868,7 @@ var BucketAccumulator = class {
 //#region src/generated/history-catalog.ts
 /**
 * Cap history catalog, projected from every `*.cap.ts` `history` block.
-* 40 caps with series (73 series), 30 caps answered `'none'`.
+* 41 caps with series (74 series), 30 caps answered `'none'`.
 * Field keys are `runtimeState` paths (`a.b` into fixed objects only).
 */
 var HISTORY_CATALOG = {
@@ -99029,6 +100145,7 @@ var HISTORY_CATALOG = {
 		unit: "hPa",
 		deadband: .1
 	} },
+	"running-state": { "running": { kind: "boolean" } },
 	"smoke": { "detected": { kind: "boolean" } },
 	"stream-params": {
 		"main.bitrate": {
@@ -100832,6 +101949,7 @@ function prepareNotification(caps, n) {
 * narrows, and still fails CLOSED on a subject that cannot produce the identity
 * it tests (a device the mirror cannot name is not evidence of a camera).
 */
+var LEGACY_KINDS_WITHOUT_FILTERS = new Set(NC_LEGACY_SYSTEM_EVENT_KINDS);
 /**
 * Every filter, for the callers that must cover all of them (guards, tests).
 *
@@ -100855,6 +101973,7 @@ var NC_SYSTEM_EVENT_FILTER_KEYS = [
 * ignores it and an editor hides its input. It never means "excluded".
 */
 function systemEventFilterApplies(kind, filter) {
+	if (LEGACY_KINDS_WITHOUT_FILTERS.has(kind)) return false;
 	switch (filter) {
 		case "deviceIds": return kind.startsWith("device-") || kind.startsWith("stream-") || kind === "detection-blind" || kind.startsWith("motion-") || kind.startsWith("recording-") || kind === "alarm-triggered";
 		case "deviceTypes": return kind.startsWith("device-") || kind === "detection-blind" || kind.startsWith("motion-");
@@ -100909,9 +102028,6 @@ var NC_SYSTEM_EVENT_FAMILY = {
 	"device-battery-normal": "device-events",
 	"device-consumable-low": "device-events",
 	"device-consumable-normal": "device-events",
-	"device-tank-low": "device-events",
-	"device-tank-full": "device-events",
-	"device-tank-normal": "device-events",
 	"stream-online": "device-events",
 	"stream-offline": "device-events",
 	"detection-blind": "device-events",
@@ -101006,16 +102122,6 @@ var NC_SYSTEM_EVENT_KIND_GROUP_SPECS = [
 		label: "Consumables",
 		kinds: ["device-consumable-low", "device-consumable-normal"]
 	},
-	{
-		id: "tanks",
-		family: "device-events",
-		label: "Tanks",
-		kinds: [
-			"device-tank-low",
-			"device-tank-full",
-			"device-tank-normal"
-		]
-	},
 	{
 		id: "detection-blind",
 		family: "device-events",
@@ -102912,11 +104018,6 @@ var RULE_BODY_ONLY = ["body"];
 var RULE_TEXT = ["title", "body"];
 var BATTERY = ["device-battery-low", "device-battery-normal"];
 var CONSUMABLE = ["device-consumable-low", "device-consumable-normal"];
-var TANK = [
-	"device-tank-low",
-	"device-tank-full",
-	"device-tank-normal"
-];
 var ALERT_EPISODE = [
 	"alert-critical",
 	"alert-error",
@@ -102948,7 +104049,6 @@ var DEVICE_EVENTS = [
 	"device-enabled",
 	...BATTERY,
 	...CONSUMABLE,
-	...TANK,
 	"stream-online",
 	"stream-offline",
 	"detection-blind",
@@ -102994,12 +104094,6 @@ var STATE_SUMMARY_SECTION_VARS = [
 		example: "Robot — filter 10 %",
 		kinds: CONSUMABLE
 	},
-	{
-		name: "summaryTanks",
-		label: "Summary: tanks",
-		example: "Robot — clean water low",
-		kinds: TANK
-	},
 	{
 		name: "summaryDetection",
 		label: "Summary: cameras detecting nothing",
@@ -103408,18 +104502,7 @@ var NC_TEMPLATE_VARS = [
 		families: ["rule"],
 		fields: [...RULE_TEXT],
 		kinds: ["system"],
-		systemEventKinds: [...CONSUMABLE, ...TANK]
-	},
-	{
-		name: "tank",
-		label: "Tank",
-		description: "Which tank, as a stable token: cleanWater, dirtyWater, detergent, dustBin, or the device key of any other supply (salt, rinse aid).",
-		example: "clean water",
-		group: "system",
-		families: ["rule"],
-		fields: [...RULE_TEXT],
-		kinds: ["system"],
-		systemEventKinds: [...TANK]
+		systemEventKinds: [...CONSUMABLE]
 	},
 	{
 		name: "profile",
@@ -104070,9 +105153,6 @@ var NC_TEMPLATE_VARS = [
 * delete it from here then, and the served catalog names it again.
 */
 var NC_TEMPLATE_HELD_BACK_SYSTEM_EVENT_KINDS = [
-	"device-tank-low",
-	"device-tank-full",
-	"device-tank-normal",
 	"node-restarting",
 	"node-updating",
 	"alert-critical",
@@ -104234,15 +105314,6 @@ var NC_SYSTEM_EVENT_CLASS_SPECS = [
 		snapshotLabel: "Consumables low now",
 		snapshotSection: "consumables"
 	},
-	{
-		id: "tanks",
-		family: "device-events",
-		label: "Tanks (low or full / back to normal)",
-		bad: ["device-tank-low", "device-tank-full"],
-		recovery: ["device-tank-normal"],
-		snapshotLabel: "Tanks low or full now",
-		snapshotSection: "tanks"
-	},
 	{
 		id: "motion-noise",
 		family: "device-events",
@@ -105603,898 +106674,341 @@ function stepModelRunsOnFormat(models, modelId, format) {
 		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, 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/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
-		} }
-	}
+	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. */
@@ -106510,10 +107024,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) {
@@ -106535,11 +107074,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) => ({
@@ -106552,13 +107092,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;
@@ -106577,7 +107117,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,
@@ -106598,13 +107138,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
 	};
 }
@@ -106655,7 +107201,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);
@@ -106691,7 +107241,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",
@@ -107439,6 +107994,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;
@@ -109793,6 +110849,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;
@@ -109820,6 +110877,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;
@@ -110006,8 +111064,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;
@@ -110358,6 +111419,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;
@@ -110708,6 +111771,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;
@@ -110772,6 +111839,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;
@@ -110839,6 +111908,7 @@ exports.NC_GROUPING_MAX_SEC = NC_GROUPING_MAX_SEC;
 exports.NC_GROUPING_MIN_SEC = NC_GROUPING_MIN_SEC;
 exports.NC_HISTORY_LIMIT_DEFAULT = NC_HISTORY_LIMIT_DEFAULT;
 exports.NC_HISTORY_LIMIT_MAX = NC_HISTORY_LIMIT_MAX;
+exports.NC_LEGACY_SYSTEM_EVENT_KINDS = NC_LEGACY_SYSTEM_EVENT_KINDS;
 exports.NC_MAX_PER_TRACK_IMMEDIATE = NC_MAX_PER_TRACK_IMMEDIATE;
 exports.NC_MEDIA_IMAGE_MODES = NC_MEDIA_IMAGE_MODES;
 exports.NC_OCCUPANCY_DEFAULTS = NC_OCCUPANCY_DEFAULTS;
@@ -110853,6 +111923,7 @@ exports.NC_SENSOR_TRANSITION_NEVER_FIRES_WARNING = NC_SENSOR_TRANSITION_NEVER_FI
 exports.NC_SENSOR_TRANSITION_UNSUPPORTED_REASON = NC_SENSOR_TRANSITION_UNSUPPORTED_REASON;
 exports.NC_SERVER_PACKAGE_NAME = NC_SERVER_PACKAGE_NAME;
 exports.NC_SNOOZE_MAX_MINUTES = NC_SNOOZE_MAX_MINUTES;
+exports.NC_STATE_SUMMARY_SECTION_IDS = NC_STATE_SUMMARY_SECTION_IDS;
 exports.NC_SYSTEM_DELIVERY = NC_SYSTEM_DELIVERY;
 exports.NC_SYSTEM_EVENT_CLASS_SPECS = NC_SYSTEM_EVENT_CLASS_SPECS;
 exports.NC_SYSTEM_EVENT_CONDITION_FILTER_KEYS = NC_SYSTEM_EVENT_CONDITION_FILTER_KEYS;
@@ -110863,7 +111934,6 @@ exports.NC_SYSTEM_EVENT_FILTER_KEYS = NC_SYSTEM_EVENT_FILTER_KEYS;
 exports.NC_SYSTEM_EVENT_KIND_GROUP_SPECS = NC_SYSTEM_EVENT_KIND_GROUP_SPECS;
 exports.NC_SYSTEM_EVENT_SUMMARY_FAMILIES = NC_SYSTEM_EVENT_SUMMARY_FAMILIES;
 exports.NC_SYSTEM_RULE_KINDS = NC_SYSTEM_RULE_KINDS;
-exports.NC_TANK_SYSTEM_EVENT_KINDS = NC_TANK_SYSTEM_EVENT_KINDS;
 exports.NC_TAXONOMY = NC_TAXONOMY;
 exports.NC_TEMPLATE_HELD_BACK_SYSTEM_EVENT_KINDS = NC_TEMPLATE_HELD_BACK_SYSTEM_EVENT_KINDS;
 exports.NC_TEMPLATE_VARS = NC_TEMPLATE_VARS;
@@ -111037,6 +112107,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;
@@ -111087,6 +112158,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;
@@ -111103,6 +112175,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;
@@ -111135,6 +112208,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;
@@ -111203,7 +112277,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;
@@ -111223,6 +112311,9 @@ exports.ROOT_CHILD_CONTAINMENT_MIN = ROOT_CHILD_CONTAINMENT_MIN;
 exports.ROOT_FACE_REFINE_INPUT_PX = ROOT_FACE_REFINE_INPUT_PX;
 exports.ROOT_FACE_REFINE_SCALE = ROOT_FACE_REFINE_SCALE;
 exports.ROOT_SUPPLIABLE_STEP_IDS = ROOT_SUPPLIABLE_STEP_IDS;
+exports.RUNNING_POWER_START_DELAY_MS = RUNNING_POWER_START_DELAY_MS;
+exports.RUNNING_POWER_STOP_DELAY_MS = RUNNING_POWER_STOP_DELAY_MS;
+exports.RUNNING_POWER_THRESHOLD_WATTS = RUNNING_POWER_THRESHOLD_WATTS;
 exports.RUNTIME_DEFAULTS = require_sleep.RUNTIME_DEFAULTS;
 exports.RUNTIME_STATE_POLICY = RUNTIME_STATE_POLICY;
 exports.RUNTIME_STATE_REFRESH_MISS_COOLDOWN_MS = RUNTIME_STATE_REFRESH_MISS_COOLDOWN_MS;
@@ -111374,6 +112465,8 @@ exports.RunnerJumpStepProvisioningSchema = RunnerJumpStepProvisioningSchema;
 exports.RunnerLocalLoadSchema = RunnerLocalLoadSchema;
 exports.RunnerLocalMetricsSchema = RunnerLocalMetricsSchema;
 exports.RunnerRefusalSchema = RunnerRefusalSchema;
+exports.RunningStateSourceSchema = RunningStateSourceSchema;
+exports.RunningStateStatusSchema = RunningStateStatusSchema;
 exports.SCENE_CONDITIONS = SCENE_CONDITIONS;
 exports.SCENE_CONFIRM_DEFAULT_MAX_IMAGE_PX = SCENE_CONFIRM_DEFAULT_MAX_IMAGE_PX;
 exports.SCENE_CONFIRM_DEFAULT_TIMEOUT_MS = SCENE_CONFIRM_DEFAULT_TIMEOUT_MS;
@@ -111390,6 +112483,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,6 +112839,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;
@@ -111762,6 +112857,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;
@@ -111897,6 +112993,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;
@@ -111919,6 +113016,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;
@@ -112089,6 +113187,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;
@@ -112181,6 +113280,7 @@ exports.isRemovedModelId = isRemovedModelId;
 exports.isRestoredCap = isRestoredCap;
 exports.isRetiredClearKey = isRetiredClearKey;
 exports.isRootSuppliableStepId = isRootSuppliableStepId;
+exports.isRunningAssignmentFeature = isRunningAssignmentFeature;
 exports.isSameAddonId = isSameAddonId;
 exports.isScheduleActive = isScheduleActive;
 exports.isSecretClear = require_sleep.isSecretClear;
@@ -112299,6 +113399,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;
@@ -112316,6 +113417,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;
@@ -112366,6 +113468,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;
@@ -112394,6 +113499,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;
@@ -112415,9 +113522,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;
@@ -112445,6 +113554,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;
@@ -112488,6 +113598,13 @@ exports.ruleSectionOf = ruleSectionOf;
 exports.ruleSeedForSection = ruleSeedForSection;
 exports.ruleTriggerZoneIds = ruleTriggerZoneIds;
 exports.runInferenceStep = runInferenceStep;
+exports.runningAssignmentFeature = runningAssignmentFeature;
+exports.runningAssignmentRecovered = runningAssignmentRecovered;
+exports.runningFromDishwasherOperation = runningFromDishwasherOperation;
+exports.runningFromLawnMower = runningFromLawnMower;
+exports.runningFromMediaPlayer = runningFromMediaPlayer;
+exports.runningFromVacuumState = runningFromVacuumState;
+exports.runningStateCapability = runningStateCapability;
 exports.runtimeDevices = runtimeDevices;
 exports.runtimeStatePolicyFor = runtimeStatePolicyFor;
 exports.sameDoFamily = sameDoFamily;
@@ -112511,6 +113628,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;
@@ -112537,6 +113655,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;