@camstack/types 1.2.404 → 1.2.405

package/dist/index.js

@@ -12883,7 +12883,7 @@ function kindOfValue(value) {
 function only(kind) {
 	return new Set([kind]);
 }
-function union(...sets) {
+function union$1(...sets) {
 	return new Set(sets.flatMap((s) => [...s]));
 }
 function withoutNull(set) {
@@ -12911,8 +12911,8 @@ function callKinds(callee, args) {
 	const rule = BUILTIN_RESULT_KINDS[callee];
 	if (rule === void 0) throw new KindInferenceError(`no result-kind rule for builtin '${callee}'`);
 	if (rule.kind === "fixed") return new Set(rule.result);
-	const nonNull = union(...args.map(withoutNull));
-	return args.every((a) => a.has("null")) ? union(nonNull, only("null")) : nonNull;
+	const nonNull = union$1(...args.map(withoutNull));
+	return args.every((a) => a.has("null")) ? union$1(nonNull, only("null")) : nonNull;
 }
 function kindsOf(node, bindings) {
 	switch (node.kind) {
@@ -12925,8 +12925,8 @@ function kindsOf(node, bindings) {
 		}
 		case "unary": return only(node.op === "!" ? "boolean" : "number");
 		case "binary": return binaryKinds(node.op, kindsOf(node.left, bindings), kindsOf(node.right, bindings));
-		case "logical": return union(kindsOf(node.left, bindings), kindsOf(node.right, bindings));
-		case "conditional": return union(kindsOf(node.consequent, bindings), kindsOf(node.alternate, bindings));
+		case "logical": return union$1(kindsOf(node.left, bindings), kindsOf(node.right, bindings));
+		case "conditional": return union$1(kindsOf(node.consequent, bindings), kindsOf(node.alternate, bindings));
 		case "call": return callKinds(node.callee, node.args.map((a) => kindsOf(a, bindings)));
 	}
 }
@@ -47289,6 +47289,20 @@ var CAMERA_SENSORS_NOT_LOADED = Object.freeze({
 	reason: "camera sensor mappings not loaded"
 });
 //#endregion
+//#region src/capabilities/schemas/package-llm-verdict.ts
+/**
+* What the vision model must answer before a package event is emitted
+* when a packages rule has "Confirm with the LLM" on.
+*
+* `package` is the verdict. `confidence` is 0..1. `reason` is the model's
+* one-line explanation, stored on the event so a drop is not silent.
+*/
+var PackageLlmVerdictSchema = zod.z.object({
+	package: zod.z.boolean(),
+	confidence: zod.z.number().min(0).max(1),
+	reason: zod.z.string().min(1)
+});
+//#endregion
 //#region src/pipeline/cluster-model-scope.ts
 /**
 * A model choice has a SCOPE, and a scope change has a workflow.
@@ -48407,6 +48421,21 @@ var ObjectEventSchema = zod.z.object({
 	* pick-up written before D684 — UNKNOWN, never 0 and never `timestamp`.
 	*/
 	observedAt: zod.z.number().optional(),
+	/**
+	* The delivery was emitted without a vision-model yes (D931).
+	*
+	* Set only when the packages rule asked for an LLM confirm and the model
+	* was unreachable, timed out, or answered something that did not parse.
+	* A notification reads it so it can say "possible" instead of a definite
+	* delivery. Absent on every other row, and on a confirm that said yes.
+	*/
+	packagePossible: zod.z.boolean().optional(),
+	/**
+	* The vision model's verdict, when a packages rule asked for one and the
+	* model answered the schema (D931). A "no" never becomes a row — the
+	* detector drops it and logs the reason. Present on a yes.
+	*/
+	packageLlmVerdict: PackageLlmVerdictSchema.optional(),
 	/** The parent track's key-event importance [0,1], propagated to every object
 	*  event of the track (so an event row can be sorted by importance without a
 	*  track join). Absent on legacy rows / before the track was scored. */
@@ -51632,11 +51661,18 @@ var KeptReasonSchema = zod.z.enum(["custom-pin"]);
 * Where a choice's latency came from (D791): this node's own benchmark
 * result, or the hardware-class table. Measured on the node beats the table.
 */
-var LatencySourceSchema = zod.z.discriminatedUnion("kind", [zod.z.object({ kind: zod.z.literal("table") }), zod.z.object({
-	kind: zod.z.literal("node-benchmark"),
-	resultId: zod.z.string(),
-	measuredAtMs: zod.z.number()
-})]);
+var LatencySourceSchema = zod.z.discriminatedUnion("kind", [
+	zod.z.object({ kind: zod.z.literal("table") }),
+	zod.z.object({
+		kind: zod.z.literal("node-benchmark"),
+		resultId: zod.z.string(),
+		measuredAtMs: zod.z.number()
+	}),
+	zod.z.object({
+		kind: zod.z.literal("estimated"),
+		estimatedFrom: HardwareClassIdSchema
+	})
+]);
 var DeviceModelChoiceSchema = zod.z.object({
 	modelId: zod.z.string(),
 	p50Ms: zod.z.number(),
@@ -51644,6 +51680,11 @@ var DeviceModelChoiceSchema = zod.z.object({
 	measured: zod.z.boolean(),
 	/** Absent on a plan from before D791 — read as the table. */
 	source: LatencySourceSchema.optional(),
+	/**
+	* The measured class this latency was scaled from (D930). Absent when the
+	* cell is the table or a node benchmark.
+	*/
+	estimatedFrom: HardwareClassIdSchema.optional(),
 	/** Parallel sessions at the camera rate with the headroom kept free: ⌊fps × (1 − headroom) / camera fps⌋. */
 	capacitySessions: zod.z.number(),
 	personRecall: zod.z.number()
@@ -67662,681 +67703,1455 @@ 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
-		},
-		volts: {
-			kind: "gauge",
-			unit: "V",
-			deadband: 1,
-			minIntervalMs: 3e4
+//#region src/pipeline/auto-tune/detector-performance.ts
+var DETECTOR_PERF = {
+	"intel-core-ultra": {
+		"intel-npu": {
+			"yolov9t-320": {
+				p50Ms: 2.9,
+				fps: 383,
+				measured: true
+			},
+			"yolov9t-320-int8": {
+				p50Ms: 3.8,
+				fps: 333,
+				measured: true
+			},
+			"yolov9t-640": {
+				p50Ms: 7.4,
+				fps: 139,
+				measured: true
+			},
+			"yolov9t-640-int8": {
+				p50Ms: 7.5,
+				fps: 144,
+				measured: true
+			},
+			"yolov9s-320": {
+				p50Ms: 4.4,
+				fps: 241,
+				measured: true
+			},
+			"yolov9s-320-int8": {
+				p50Ms: 4.1,
+				fps: 264,
+				measured: true
+			},
+			"yolov9s-640": {
+				p50Ms: 12.7,
+				fps: 82,
+				measured: true
+			},
+			"yolov9s-640-int8": {
+				p50Ms: 10.7,
+				fps: 99,
+				measured: true
+			},
+			"yolov9m-320": {
+				p50Ms: 8.4,
+				fps: 123,
+				measured: true
+			},
+			"yolov9m-320-int8": {
+				p50Ms: 6.5,
+				fps: 165,
+				measured: true
+			},
+			"yolov9m-640": {
+				p50Ms: 29.5,
+				fps: 32,
+				measured: true
+			},
+			"yolov9m-640-int8": {
+				p50Ms: 19.5,
+				fps: 52,
+				measured: true
+			}
 		},
-		amps: {
-			kind: "gauge",
-			unit: "A",
-			deadband: .05,
-			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
+			}
 		},
-		va: {
-			kind: "gauge",
-			unit: "VA",
-			deadband: 1,
-			minIntervalMs: 3e4
+		"x86-cpu": {
+			"yolov9t-320": {
+				p50Ms: 6.9,
+				fps: 145,
+				measured: true
+			},
+			"yolov9t-320-int8": {
+				p50Ms: 2.7,
+				fps: 405,
+				measured: true
+			},
+			"yolov9t-640": {
+				p50Ms: 23,
+				fps: 44,
+				measured: true
+			},
+			"yolov9t-640-int8": {
+				p50Ms: 8.8,
+				fps: 124,
+				measured: true
+			},
+			"yolov9s-320": {
+				p50Ms: 15.8,
+				fps: 63,
+				measured: true
+			},
+			"yolov9s-320-int8": {
+				p50Ms: 6.5,
+				fps: 180,
+				measured: true
+			},
+			"yolov9s-640": {
+				p50Ms: 58.2,
+				fps: 17,
+				measured: true
+			},
+			"yolov9s-640-int8": {
+				p50Ms: 20.1,
+				fps: 52,
+				measured: true
+			},
+			"yolov9m-320": {
+				p50Ms: 40,
+				fps: 25,
+				measured: true
+			},
+			"yolov9m-320-int8": {
+				p50Ms: 14.2,
+				fps: 74,
+				measured: true
+			},
+			"yolov9m-640": {
+				p50Ms: 155.8,
+				fps: 6,
+				measured: true
+			},
+			"yolov9m-640-int8": {
+				p50Ms: 52.4,
+				fps: 19,
+				measured: true
+			}
 		},
-		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"
+		coral: { "yolov9s-320-edgetpu": {
+			p50Ms: 32,
+			fps: 31,
+			measured: false
+		} }
 	},
-	/**
-	* 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"]
+	"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
+			}
+		},
+		"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/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"
+var DETECTOR_ACCURACY = {
+	"yolov9m-320": {
+		personPrecision: .979,
+		personRecall: .649
 	},
-	runtimeState: PressureSensorStatusSchema,
-	/**
-	* Runtime-state durability: **restored** — as `numeric-sensor`.
-	*
-	* See `RuntimeStateDurability`. Enforced by
-	* `scripts/check-runtime-state-durability.ts`.
-	*/
-	durability: "restored",
-	/**
-	* History (D850): recorded series.
-	*/
-	history: { fields: { hpa: {
-		kind: "gauge",
-		unit: "hPa",
-		deadband: .1
-	} } },
-	/** Clock fields: written, but excluded from the compare that decides
-	*  whether persisting is worth a SQLite commit. */
-	volatileStateFields: ["lastFetchedAt"]
+	"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/privacy-mask.cap.ts
-/**
-* PRIVACY — what the camera deliberately does not capture. Two planes:
-*
-*  - **video**: up to `maxRegions` SHAPES the camera blanks out (NOT a cell
-*    grid). Reolink `<shelterList>` zones are rectangles; Hikvision ISAPI
-*    `<RegionCoordinatesList>` zones are free polygons (this camera: exactly
-*    4 vertices, not necessarily axis-aligned). The cap composes the shared
-*    rect|polygon subset of the MaskShape vocabulary. All coords are
-*    normalized 0..1 (top-left origin).
-*  - **audio**: the camera's microphone. `setAudioEnabled(false)` stops the
-*    camera encoding an audio track at all, so EVERY consumer — live view,
-*    recording, the audio analyzer, an export — sees silent video. There is
-*    no server-side copy of this fact; the camera is the store and every read
-*    is a read-through, which is why a switch over it cannot drift
-*    ([D62](../../../../docs/decisions/adr-0062.md)).
-*
-* Both belong here for one reason: they are the two things an operator turns
-* off when the answer to "what is this camera allowed to record" changes, and
-* both are applied ON the device, before anything leaves it.
-*
-* **The audio flag has exactly one writer.** `stream-params` used to carry a
-* per-profile `audio` in its patch schema — reachable from no UI and honoured
-* by one provider — and it was removed when this landed. A second writer onto
-* one device register is the shape of every knob this repo has shipped that
-* disagreed with the one the reader read.
+//#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;
+}
+/**
+* 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.
 */
-/** A privacy-mask region's geometry — rectangle or free polygon. */
-var PrivacyMaskShapeSchema = zod.z.discriminatedUnion("kind", [MaskRectShapeSchema, MaskPolygonShapeSchema]);
-/** A single privacy-mask zone. */
-var PrivacyMaskRegionSchema = zod.z.object({
-	/** Slot id, 0-based. Stable across read/write. */
-	id: zod.z.number(),
-	/** Whether this zone is active (blanked out by the camera). */
-	enabled: zod.z.boolean(),
-	shape: PrivacyMaskShapeSchema
+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()
 });
-/** Current on-camera privacy state — mask master enable + zones + microphone. */
-var PrivacyMaskStatusSchema = zod.z.object({
-	enabled: zod.z.boolean(),
-	/**
-	* Active zones (normalized 0..1). Length ≤ maxRegions.
-	*
-	* `null` means "no answer" — the provider has never reached this camera
-	* (a cold `runtimeState` slice, a battery camera asleep) or the read
-	* failed. A consumer must render it as UNKNOWN and never as "this camera
-	* has no zones": those two look identical to an operator right up to the
-	* moment one of them is acted on, and acting on them differs completely.
-	* The switch group turned an unanswered read into *"nothing is set up for
-	* it to act on"* — an instruction to go and draw a zone that already
-	* exists — and this editor seeded an EMPTY canvas from it, one Save away
-	* from deleting the mask it could not read.
-	*
-	* Empty-and-answered is `[]` and stays a real answer: this camera genuinely
-	* has no zones. The distinction is the same one {@link
-	* PrivacyMaskStatusSchema.shape.audioEnabled} already draws for the
-	* microphone, on the very same payload — both planes come from ONE refresh,
-	* so it was never coherent for one of them to be able to say "unknown"
-	* while the other could not.
-	*/
-	regions: zod.z.array(PrivacyMaskRegionSchema).nullable(),
-	/**
-	* Is the camera capturing sound right now? Read from the camera, never from
-	* a server-side mirror.
-	*
-	* `null` means "no answer" — either this camera exposes no controllable
-	* microphone (`getOptions().supportsAudioMute === false`) or the read
-	* failed. A consumer must render `null` as UNKNOWN and never as `false`:
-	* "the microphone is off" and "we could not ask" look identical to an
-	* operator only until one of them is wrong.
-	*
-	* On a camera whose profiles carry the flag independently (Reolink writes
-	* it per stream), `true` means AT LEAST ONE profile still carries audio —
-	* privacy is only satisfied when every one of them is silent.
-	*/
-	audioEnabled: zod.z.boolean().nullable(),
-	lastFetchedAt: zod.z.number()
+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()
 });
-/** Per-camera availability. Probed, never assumed from the model name. */
-var PrivacyMaskOptionsSchema = zod.z.object({
-	/** Maximum number of supported zones. */
-	maxRegions: zod.z.number(),
-	/** Shape kinds this camera accepts — Reolink: ['rect']; Hikvision: ['rect','polygon']. */
-	supportedShapes: zod.z.array(MaskShapeKindSchema),
-	/** Polygon vertex bounds when 'polygon' is supported (Hikvision: {min:4,max:4}). */
-	polygonVertices: MaskPolygonVerticesSchema.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(),
 	/**
-	* Does this camera expose a microphone switch we can actually write?
-	*
-	* Camera-probed: `true` only when the firmware answered with an audio flag
-	* we know how to patch. A camera that never answered is `false` — a control
-	* the operator can press that changes nothing is worse than no control, and
-	* the switch group renders "not available" instead.
+	* 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.
 	*/
-	supportsAudioMute: zod.z.boolean()
+	accelerators: zod.z.array(AcceleratorComputeSchema).readonly().optional()
 });
-/** Partial change — every field optional. */
-var PrivacyMaskPatchSchema = zod.z.object({
-	enabled: zod.z.boolean().optional(),
-	regions: zod.z.array(PrivacyMaskRegionSchema).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 privacyMaskCapability = {
-	name: "privacy-mask",
-	scope: "device",
-	deviceNative: true,
+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",
-	deviceTypes: [require_err_msg.DeviceType.Camera],
-	deviceConfig: { ui: {
-		kind: "widget",
-		widgetId: "host/privacy-mask-grid",
-		tab: "image",
-		label: "Privacy Mask"
-	} },
 	methods: {
-		getOptions: require_sleep.method(zod.z.object({ deviceId: zod.z.number() }), PrivacyMaskOptionsSchema),
-		setMask: require_sleep.method(zod.z.object({
-			deviceId: zod.z.number(),
-			patch: PrivacyMaskPatchSchema
-		}), zod.z.void(), {
-			kind: "mutation",
-			auth: "admin"
-		}),
+		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),
 		/**
-		* Turn the camera's microphone on or off, at the camera.
-		*
-		* Deliberately its OWN mutation rather than a field on
-		* {@link PrivacyMaskPatchSchema}: `patch.enabled` already means "the video
-		* mask master switch", and overloading it would make one boolean mean two
-		* unrelated things on the same call. It is also the only method here whose
-		* write leaves the device in a state a later `getStatus` reads back
-		* verbatim, which is what makes it safe as a switch authority.
-		*
-		* A camera whose `getOptions().supportsAudioMute` is false must REJECT
-		* this rather than silently accept it — a write nothing applies is exactly
-		* what the switch group exists to remove.
+		* 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`.
 		*/
-		setAudioEnabled: require_sleep.method(zod.z.object({
-			deviceId: zod.z.number(),
-			enabled: zod.z.boolean()
-		}), zod.z.void(), {
+		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: PrivacyMaskStatusSchema,
-		kind: "poll"
+		schema: PowerMeterStatusSchema,
+		kind: "push"
 	},
-	runtimeState: PrivacyMaskStatusSchema,
+	runtimeState: PowerMeterStatusSchema,
 	/**
-	* Runtime-state durability: **restored** — operator-drawn regions, zero real churn — 22 writes in 25 minutes, every one of them the clock.
+	* 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): none — configuration.
+	* History (D850): recorded series. Gauges are floored at 30 s; `kwhTotal` is the one monotonic meter (counter).
 	*/
-	history: "none",
+	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"]
 };
-/**
-* Collapse a camera's PER-PROFILE audio flags into the one answer
-* {@link PrivacyMaskStatusSchema.shape.audioEnabled} promises.
-*
-* Both firmwares this cap talks to store the flag per stream profile, and
-* both let those profiles disagree. The rule is `some`, not `every`: privacy
-* is only satisfied when NOTHING is carrying sound, so a camera whose sub
-* stream is still audible must read as `true` and be switchable off — not as
-* `false` because the main stream happens to be muted already.
-*
-* An empty list is `null` ("this camera reported no audio flag at all"),
-* never `false`.
-*
-* Lives here rather than in each provider so the rule the schema documents
-* and the rule the providers apply cannot drift apart.
-*/
-function summarisePrivacyAudio(profiles) {
-	if (profiles.length === 0) return null;
-	return profiles.some((p) => p.audioEnabled);
-}
 //#endregion
-//#region src/capabilities/ptz.cap.ts
+//#region src/capabilities/presence.cap.ts
 /**
-* What a preset id DOES on this camera.
-*
-* On several PTZ firmwares the preset namespace is shared: low ids are stored
-* positions, a reserved band triggers camera FUNCTIONS. The dispensa camera
-* (Hikvision) returns its own reserved band in the preset list, named by the
-* firmware:
-*
-*   34 Back to origin · 39 Day mode · 40 Night mode · 46 Day/Night Auto Mode
-*   92 Set manual limits · 93 Save manual limits · 94 Remote reboot
-*   95 Call OSD menu
+* 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.
 *
-* We used to hand all of these to the UI as ordinary presets. Saving over one
-* is what produced `PUT /ISAPI/PTZCtrl/channels/1/presets/34 -> HTTP 500`: the
-* camera refusing to let "Back to origin" be overwritten, surfaced to the
-* operator as a transport failure.
+* `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`).
 *
-* A function preset stays fully usable as a DESTINATION -- `goToPreset('34')`
-* is the single most useful thing that camera can do. Only `savePreset` and
-* `deletePreset` are gated.
+* 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 PtzPresetFunctionSchema = zod.z.enum([
-	"home",
-	"day-mode",
-	"night-mode",
-	"day-night-auto",
-	"set-limits",
-	"save-limits",
-	"reboot",
-	"osd-menu"
-]);
-var PtzPresetSchema = zod.z.object({
-	id: zod.z.string(),
-	name: zod.z.string(),
-	/**
-	* The firmware function this id performs, when the provider KNOWS the id is
-	* reserved. `null` = an ordinary stored position, OR a reserved id this
-	* provider does not recognise -- the two are told apart by `writable`.
-	*/
-	fn: PtzPresetFunctionSchema.nullable(),
-	/**
-	* Whether `savePreset` / `deletePreset` may target this id. A provider sets
-	* it false only for a band it KNOWS is reserved; where the firmware is not
-	* documented it stays true and a refusal comes from the camera, named.
-	*/
-	writable: zod.z.boolean()
-});
+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`.
+	*
+	* See `RuntimeStateDurability`. Enforced by
+	* `scripts/check-runtime-state-durability.ts`.
+	*/
+	durability: "restored",
+	/**
+	* History (D850): recorded series.
+	*/
+	history: { fields: { hpa: {
+		kind: "gauge",
+		unit: "hPa",
+		deadband: .1
+	} } },
+	/** Clock fields: written, but excluded from the compare that decides
+	*  whether persisting is worth a SQLite commit. */
+	volatileStateFields: ["lastFetchedAt"]
+};
+//#endregion
+//#region src/capabilities/privacy-mask.cap.ts
+/**
+* PRIVACY — what the camera deliberately does not capture. Two planes:
+*
+*  - **video**: up to `maxRegions` SHAPES the camera blanks out (NOT a cell
+*    grid). Reolink `<shelterList>` zones are rectangles; Hikvision ISAPI
+*    `<RegionCoordinatesList>` zones are free polygons (this camera: exactly
+*    4 vertices, not necessarily axis-aligned). The cap composes the shared
+*    rect|polygon subset of the MaskShape vocabulary. All coords are
+*    normalized 0..1 (top-left origin).
+*  - **audio**: the camera's microphone. `setAudioEnabled(false)` stops the
+*    camera encoding an audio track at all, so EVERY consumer — live view,
+*    recording, the audio analyzer, an export — sees silent video. There is
+*    no server-side copy of this fact; the camera is the store and every read
+*    is a read-through, which is why a switch over it cannot drift
+*    ([D62](../../../../docs/decisions/adr-0062.md)).
+*
+* Both belong here for one reason: they are the two things an operator turns
+* off when the answer to "what is this camera allowed to record" changes, and
+* both are applied ON the device, before anything leaves it.
+*
+* **The audio flag has exactly one writer.** `stream-params` used to carry a
+* per-profile `audio` in its patch schema — reachable from no UI and honoured
+* by one provider — and it was removed when this landed. A second writer onto
+* one device register is the shape of every knob this repo has shipped that
+* disagreed with the one the reader read.
+*/
+/** A privacy-mask region's geometry — rectangle or free polygon. */
+var PrivacyMaskShapeSchema = zod.z.discriminatedUnion("kind", [MaskRectShapeSchema, MaskPolygonShapeSchema]);
+/** A single privacy-mask zone. */
+var PrivacyMaskRegionSchema = zod.z.object({
+	/** Slot id, 0-based. Stable across read/write. */
+	id: zod.z.number(),
+	/** Whether this zone is active (blanked out by the camera). */
+	enabled: zod.z.boolean(),
+	shape: PrivacyMaskShapeSchema
+});
+/** Current on-camera privacy state — mask master enable + zones + microphone. */
+var PrivacyMaskStatusSchema = zod.z.object({
+	enabled: zod.z.boolean(),
+	/**
+	* Active zones (normalized 0..1). Length ≤ maxRegions.
+	*
+	* `null` means "no answer" — the provider has never reached this camera
+	* (a cold `runtimeState` slice, a battery camera asleep) or the read
+	* failed. A consumer must render it as UNKNOWN and never as "this camera
+	* has no zones": those two look identical to an operator right up to the
+	* moment one of them is acted on, and acting on them differs completely.
+	* The switch group turned an unanswered read into *"nothing is set up for
+	* it to act on"* — an instruction to go and draw a zone that already
+	* exists — and this editor seeded an EMPTY canvas from it, one Save away
+	* from deleting the mask it could not read.
+	*
+	* Empty-and-answered is `[]` and stays a real answer: this camera genuinely
+	* has no zones. The distinction is the same one {@link
+	* PrivacyMaskStatusSchema.shape.audioEnabled} already draws for the
+	* microphone, on the very same payload — both planes come from ONE refresh,
+	* so it was never coherent for one of them to be able to say "unknown"
+	* while the other could not.
+	*/
+	regions: zod.z.array(PrivacyMaskRegionSchema).nullable(),
+	/**
+	* Is the camera capturing sound right now? Read from the camera, never from
+	* a server-side mirror.
+	*
+	* `null` means "no answer" — either this camera exposes no controllable
+	* microphone (`getOptions().supportsAudioMute === false`) or the read
+	* failed. A consumer must render `null` as UNKNOWN and never as `false`:
+	* "the microphone is off" and "we could not ask" look identical to an
+	* operator only until one of them is wrong.
+	*
+	* On a camera whose profiles carry the flag independently (Reolink writes
+	* it per stream), `true` means AT LEAST ONE profile still carries audio —
+	* privacy is only satisfied when every one of them is silent.
+	*/
+	audioEnabled: zod.z.boolean().nullable(),
+	lastFetchedAt: zod.z.number()
+});
+/** Per-camera availability. Probed, never assumed from the model name. */
+var PrivacyMaskOptionsSchema = zod.z.object({
+	/** Maximum number of supported zones. */
+	maxRegions: zod.z.number(),
+	/** Shape kinds this camera accepts — Reolink: ['rect']; Hikvision: ['rect','polygon']. */
+	supportedShapes: zod.z.array(MaskShapeKindSchema),
+	/** Polygon vertex bounds when 'polygon' is supported (Hikvision: {min:4,max:4}). */
+	polygonVertices: MaskPolygonVerticesSchema.optional(),
+	/**
+	* Does this camera expose a microphone switch we can actually write?
+	*
+	* Camera-probed: `true` only when the firmware answered with an audio flag
+	* we know how to patch. A camera that never answered is `false` — a control
+	* the operator can press that changes nothing is worse than no control, and
+	* the switch group renders "not available" instead.
+	*/
+	supportsAudioMute: zod.z.boolean()
+});
+/** Partial change — every field optional. */
+var PrivacyMaskPatchSchema = zod.z.object({
+	enabled: zod.z.boolean().optional(),
+	regions: zod.z.array(PrivacyMaskRegionSchema).optional()
+});
+var privacyMaskCapability = {
+	name: "privacy-mask",
+	scope: "device",
+	deviceNative: true,
+	mode: "singleton",
+	deviceTypes: [require_err_msg.DeviceType.Camera],
+	deviceConfig: { ui: {
+		kind: "widget",
+		widgetId: "host/privacy-mask-grid",
+		tab: "image",
+		label: "Privacy Mask"
+	} },
+	methods: {
+		getOptions: require_sleep.method(zod.z.object({ deviceId: zod.z.number() }), PrivacyMaskOptionsSchema),
+		setMask: require_sleep.method(zod.z.object({
+			deviceId: zod.z.number(),
+			patch: PrivacyMaskPatchSchema
+		}), zod.z.void(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		/**
+		* Turn the camera's microphone on or off, at the camera.
+		*
+		* Deliberately its OWN mutation rather than a field on
+		* {@link PrivacyMaskPatchSchema}: `patch.enabled` already means "the video
+		* mask master switch", and overloading it would make one boolean mean two
+		* unrelated things on the same call. It is also the only method here whose
+		* write leaves the device in a state a later `getStatus` reads back
+		* verbatim, which is what makes it safe as a switch authority.
+		*
+		* A camera whose `getOptions().supportsAudioMute` is false must REJECT
+		* this rather than silently accept it — a write nothing applies is exactly
+		* what the switch group exists to remove.
+		*/
+		setAudioEnabled: require_sleep.method(zod.z.object({
+			deviceId: zod.z.number(),
+			enabled: zod.z.boolean()
+		}), zod.z.void(), {
+			kind: "mutation",
+			auth: "admin"
+		})
+	},
+	status: {
+		schema: PrivacyMaskStatusSchema,
+		kind: "poll"
+	},
+	runtimeState: PrivacyMaskStatusSchema,
+	/**
+	* Runtime-state durability: **restored** — operator-drawn regions, zero real churn — 22 writes in 25 minutes, every one of them the clock.
+	*
+	* See `RuntimeStateDurability`. Enforced by
+	* `scripts/check-runtime-state-durability.ts`.
+	*/
+	durability: "restored",
+	/**
+	* History (D850): none — configuration.
+	*/
+	history: "none",
+	/** Clock fields: written, but excluded from the compare that decides
+	*  whether persisting is worth a SQLite commit. */
+	volatileStateFields: ["lastFetchedAt"]
+};
+/**
+* Collapse a camera's PER-PROFILE audio flags into the one answer
+* {@link PrivacyMaskStatusSchema.shape.audioEnabled} promises.
+*
+* Both firmwares this cap talks to store the flag per stream profile, and
+* both let those profiles disagree. The rule is `some`, not `every`: privacy
+* is only satisfied when NOTHING is carrying sound, so a camera whose sub
+* stream is still audible must read as `true` and be switchable off — not as
+* `false` because the main stream happens to be muted already.
+*
+* An empty list is `null` ("this camera reported no audio flag at all"),
+* never `false`.
+*
+* Lives here rather than in each provider so the rule the schema documents
+* and the rule the providers apply cannot drift apart.
+*/
+function summarisePrivacyAudio(profiles) {
+	if (profiles.length === 0) return null;
+	return profiles.some((p) => p.audioEnabled);
+}
+//#endregion
+//#region src/capabilities/ptz.cap.ts
+/**
+* What a preset id DOES on this camera.
+*
+* On several PTZ firmwares the preset namespace is shared: low ids are stored
+* positions, a reserved band triggers camera FUNCTIONS. The dispensa camera
+* (Hikvision) returns its own reserved band in the preset list, named by the
+* firmware:
+*
+*   34 Back to origin · 39 Day mode · 40 Night mode · 46 Day/Night Auto Mode
+*   92 Set manual limits · 93 Save manual limits · 94 Remote reboot
+*   95 Call OSD menu
+*
+* We used to hand all of these to the UI as ordinary presets. Saving over one
+* is what produced `PUT /ISAPI/PTZCtrl/channels/1/presets/34 -> HTTP 500`: the
+* camera refusing to let "Back to origin" be overwritten, surfaced to the
+* operator as a transport failure.
+*
+* A function preset stays fully usable as a DESTINATION -- `goToPreset('34')`
+* is the single most useful thing that camera can do. Only `savePreset` and
+* `deletePreset` are gated.
+*/
+var PtzPresetFunctionSchema = zod.z.enum([
+	"home",
+	"day-mode",
+	"night-mode",
+	"day-night-auto",
+	"set-limits",
+	"save-limits",
+	"reboot",
+	"osd-menu"
+]);
+var PtzPresetSchema = zod.z.object({
+	id: zod.z.string(),
+	name: zod.z.string(),
+	/**
+	* The firmware function this id performs, when the provider KNOWS the id is
+	* reserved. `null` = an ordinary stored position, OR a reserved id this
+	* provider does not recognise -- the two are told apart by `writable`.
+	*/
+	fn: PtzPresetFunctionSchema.nullable(),
+	/**
+	* Whether `savePreset` / `deletePreset` may target this id. A provider sets
+	* it false only for a band it KNOWS is reserved; where the firmware is not
+	* documented it stays true and a refusal comes from the camera, named.
+	*/
+	writable: zod.z.boolean()
+});
 /**
 * Where the head is pointing -- per axis, and `null` when the driver cannot
 * read it.
@@ -71686,7 +72501,20 @@ var ZoneRuleSchema = zod.z.object({
 	* Defaults to `true` so operators creating a rule via the UI
 	* see it active immediately.
 	*/
-	enabled: zod.z.boolean().default(true)
+	enabled: zod.z.boolean().default(true),
+	/**
+	* Package stage only. When true, a package candidate may open from a
+	* scene difference in this rule's zone after a person leaves. The
+	* package model, when it boxes something overlapping, is extra evidence
+	* and is not the gate. Absent or false keeps today's model path.
+	*/
+	detectBySceneDifference: zod.z.boolean().optional(),
+	/**
+	* Package stage only. When true, a promoted package is shown to the
+	* `llm` cap before the delivery event is emitted. Absent or false emits
+	* as today. Usable with or without `detectBySceneDifference`.
+	*/
+	confirmWithLlm: zod.z.boolean().optional()
 });
 /**
 * Convenience array schema — used by addon device-settings
@@ -105603,898 +106431,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 +106781,35 @@ var RECALL_TIE = .02;
 var DEFAULT_HEADROOM = .4;
 /** Detection rate a session is counted at when no camera says otherwise. */
 var DEFAULT_CAMERA_FPS = 10;
-/** Parallel sessions one device sustains at `fps` with `headroom` kept free. */
-function capacitySessionsOf(fps, headroom, cameraFps) {
-	if (!(fps > 0) || !(cameraFps > 0)) return 0;
-	return Math.max(0, Math.floor(fps * (1 - headroom) / cameraFps + 1e-9));
+/**
+* Camera rate at which serial `1000/p50` matched the cameras that held
+* (N100 iGPU, 2026-10-24). Below this the second InferRequest's overlap
+* becomes extra sessions; at and above it the serial ceiling is the count.
+*/
+var SERIAL_CAPACITY_CAMERA_FPS = 10;
+/**
+* Aggregate throughput ÷ serial throughput when the frame interval is wide
+* enough to hide the second request. intel-igpu is the N100 measurement
+* (~1.4× under LATENCY with 2 InferRequests). Every other kind stays 1
+* until it is measured the same way.
+*/
+var AGGREGATE_THROUGHPUT_BY_KIND = { "intel-igpu": 1.4 };
+/** The overlap factor for this kind at this camera rate. 1 at {@link SERIAL_CAPACITY_CAMERA_FPS} and above. */
+function aggregateThroughputFactor(kind, cameraFps) {
+	if (!(cameraFps > 0) || cameraFps >= 10) return 1;
+	return AGGREGATE_THROUGHPUT_BY_KIND[kind] ?? 1;
+}
+/**
+* Parallel sessions one device sustains at `fps` with `headroom` kept free.
+* `aggregateFactor` is the kind's overlap (1 unless the caller measured
+* extra throughput at this camera rate).
+*/
+function capacitySessionsOf(fps, headroom, cameraFps, aggregateFactor = 1) {
+	if (!(fps > 0) || !(cameraFps > 0) || !(aggregateFactor > 0)) return 0;
+	return Math.max(0, Math.floor(fps * aggregateFactor * (1 - headroom) / cameraFps + 1e-9));
+}
+function reportFor(hardware, deviceKey) {
+	return hardware.accelerators?.find((report) => report.deviceKey === deviceKey) ?? null;
 }
 /** The table column with the node's own measurements laid over it. */
 function overlayMeasured(table, measured) {
@@ -106535,11 +106831,12 @@ function round(value, digits = 3) {
 	const f = 10 ** digits;
 	return Math.round(value * f) / f;
 }
-function sessionsOn(cell, sizing) {
-	return cell === void 0 ? 0 : capacitySessionsOf(cell.fps, sizing.headroom, sizing.cameraFps);
+function sessionsOn(cell, sizing, kind) {
+	if (cell === void 0) return 0;
+	return capacitySessionsOf(cell.fps, sizing.headroom, sizing.cameraFps, aggregateThroughputFactor(kind, sizing.cameraFps));
 }
-function fitsOn(cell, sizing) {
-	return sessionsOn(cell, sizing) >= sizing.minSessions;
+function fitsOn(ctx, modelId, sizing) {
+	return sessionsOn(ctx.column[modelId], sizing, ctx.accelerator) >= sizing.minSessions;
 }
 function candidatesFor(contexts, formatsByModel) {
 	return Object.keys(DETECTOR_ACCURACY).filter((id) => id.startsWith(AUTO_TUNE_FAMILY)).filter((id) => contexts.every((c) => c.column[id] !== void 0 && (formatsByModel[id] ?? []).includes(c.device.format))).map((id) => ({
@@ -106552,13 +106849,13 @@ function totalLatency(contexts, modelId) {
 }
 /** The fewest sessions any device of the group sustains with this model. */
 function worstSessions(contexts, modelId, sizing) {
-	return contexts.reduce((worst, c) => Math.min(worst, sessionsOn(c.column[modelId], sizing)), Number.POSITIVE_INFINITY);
+	return contexts.reduce((worst, c) => Math.min(worst, sessionsOn(c.column[modelId], sizing, c.accelerator)), Number.POSITIVE_INFINITY);
 }
 /** One model for a group of devices that must agree (step 2–4 of the header). */
 function pickForGroup(contexts, formatsByModel, sizing) {
 	const candidates = candidatesFor(contexts, formatsByModel);
 	if (candidates.length === 0) return null;
-	const fitting = candidates.filter((c) => contexts.every((ctx) => fitsOn(ctx.column[c.modelId], sizing)));
+	const fitting = candidates.filter((c) => contexts.every((ctx) => fitsOn(ctx, c.modelId, sizing)));
 	if (fitting.length === 0) {
 		const lightest = candidates.toSorted((a, b) => worstSessions(contexts, b.modelId, sizing) - worstSessions(contexts, a.modelId, sizing) || totalLatency(contexts, a.modelId) - totalLatency(contexts, b.modelId))[0];
 		if (lightest === void 0) return null;
@@ -106577,7 +106874,7 @@ function pickForGroup(contexts, formatsByModel, sizing) {
 	const reasons = [];
 	const mostAccurate = candidates[0];
 	if (mostAccurate !== void 0 && mostAccurate.modelId !== best.modelId) {
-		const limitedBy = contexts.find((ctx) => !fitsOn(ctx.column[mostAccurate.modelId], sizing))?.device.key ?? "";
+		const limitedBy = contexts.find((ctx) => !fitsOn(ctx, mostAccurate.modelId, sizing))?.device.key ?? "";
 		reasons.push({
 			kind: "stepped-down",
 			from: mostAccurate.modelId,
@@ -106598,13 +106895,19 @@ function pickForGroup(contexts, formatsByModel, sizing) {
 function choiceOn(ctx, modelId, sizing) {
 	const cell = ctx.column[modelId];
 	if (cell === void 0) return null;
+	const estimatedFrom = cell.source?.kind === "node-benchmark" ? void 0 : cell.estimatedFrom;
+	const source = cell.source ?? (estimatedFrom !== void 0 ? {
+		kind: "estimated",
+		estimatedFrom
+	} : { kind: "table" });
 	return {
 		modelId,
 		p50Ms: cell.p50Ms,
 		fps: cell.fps,
 		measured: cell.measured,
-		source: cell.source ?? { kind: "table" },
-		capacitySessions: sessionsOn(cell, sizing),
+		source,
+		...estimatedFrom !== void 0 ? { estimatedFrom } : {},
+		capacitySessions: sessionsOn(cell, sizing, ctx.accelerator),
 		personRecall: DETECTOR_ACCURACY[modelId]?.personRecall ?? 0
 	};
 }
@@ -106655,7 +106958,11 @@ function recommendNode(input) {
 	const measured = input.measured ?? {};
 	const hasMeasured = Object.values(measured).some((m) => Object.keys(m).length > 0);
 	const knownTable = hardwareClass === "unknown" ? void 0 : perf[hardwareClass];
-	if (knownTable === void 0 && !hasMeasured) return skippedNode(node, {
+	const canEstimate = (hardware.accelerators ?? []).some((report) => {
+		const kind = acceleratorKindOf(report.deviceKey, hardware);
+		return kind !== null && reportIsScalable(report, kind);
+	});
+	if (knownTable === void 0 && !hasMeasured && !canEstimate) return skippedNode(node, {
 		kind: "no-measured-data",
 		hardwareClass
 	}, hardwareClass);
@@ -106691,7 +106998,12 @@ function recommendNode(input) {
 			});
 			continue;
 		}
-		const column = accelerator === null ? void 0 : overlayMeasured(classTable[accelerator], measured[device.key]);
+		const column = accelerator === null ? void 0 : overlayMeasured(resolveLatencyColumn({
+			hardwareClass,
+			accelerator,
+			report: reportFor(hardware, device.key),
+			perf
+		})?.column, measured[device.key]);
 		if (accelerator === null || column === void 0) {
 			early.set(device.key, [{
 				kind: "no-family-build",
@@ -107439,6 +107751,507 @@ function buildBenchStepTree(schema, rootModelId, enabledStepIds) {
 	}];
 }
 //#endregion
+//#region src/pipeline/second-pass/small-subject-recovery.ts
+/** The object-detection step id — the first-level detector both recipes run. */
+var OBJECT_DETECTION_STEP_ID = "object-detection";
+/**
+* Smallest crop side, native pixels. Below this the model no longer
+* magnifies enough to matter on a 4K frame, and on a 1080p frame 640 is
+* already a third of the picture. Measured: 480–800 px all recover the dog.
+*/
+var RECOVERY_CROP_MIN_SIDE_PX = 640;
+/**
+* Largest crop side. A 320 model on a 1024 px square is a 3.2× reduction and
+* scored the dog at 0.52–0.76; at 1280 px it was absent again. A region wider
+* than this is tiled, never zoomed out.
+*/
+var RECOVERY_CROP_MAX_SIDE_PX = 800;
+/** Context around the region before squaring, as a fraction of its larger side. */
+var RECOVERY_CROP_PADDING_RATIO = .25;
+/**
+* The view the crop is resolved at, compressed. Never larger than the crop
+* (the floor is {@link RECOVERY_CROP_MIN_SIDE_PX}), so it never upscales, and
+* the model letterboxes it to its own input from here as it does the frame.
+*/
+var RECOVERY_VIEW_PX = 640;
+/**
+* Crops per frame. Each is one more inference on the same pool (15–25 ms on
+* CoreML for a 640 view); two cover a person-and-dog blob and a second mover.
+*/
+var RECOVERY_MAX_CROPS_PER_FRAME = 2;
+/**
+* The pass runs at most this often per camera — at 10 fps that is one frame
+* in five. A subject the full pass misses is missed for seconds, not for one
+* frame, so the recovery does not need every frame to find it.
+*
+* The floor under this number is the tracker: a track coasts for
+* `maxMissedMs` (4 000 ms by default) before it is dropped, so 2 recoveries a
+* second keep a subject the full-frame pass has lost ALIVE with 8× margin,
+* and reach `minHits` (3) in 1.5 s. Raising it past ~1 300 ms would start to
+* lose tracks between passes.
+*/
+var RECOVERY_MIN_INTERVAL_MS = 500;
+/**
+* A region larger than this share of the frame is not a small subject: a
+* lighting change, a car filling the picture, a person at the lens. The
+* full-frame pass already sees those at scale.
+*/
+var RECOVERY_MAX_REGION_FRAME_FRACTION = .25;
+/**
+* How much of a region must lie OUTSIDE every full-frame detection for the
+* pass to run on it. A person's own blob (dilated, with shadow) is covered
+* 70–90% by the person box; a person-and-dog blob is covered ~55% by it.
+*/
+var RECOVERY_MIN_UNCOVERED_FRACTION = .35;
+/** Motion regions older than this describe a different frame. */
+var RECOVERY_MOTION_MAX_AGE_MS = 2e3;
+/** A recovered box overlapping a same-class full-frame box this much is the same subject. */
+var RECOVERY_FUSE_IOU = .5;
+/**
+* A recovered box CONTAINED this much in a same-class full-frame box is a part
+* of it — a torso the crop cut out of a person the full pass already has.
+*/
+var RECOVERY_FUSE_CONTAINMENT = .7;
+/** A box within this many crop-view pixels of the crop edge was clipped by it. */
+var RECOVERY_EDGE_MARGIN_PX = 2;
+/** Area of a normalised rectangle, never negative. Shared with the D396 recipe. */
+function normalizedArea(r) {
+	return Math.max(0, r.w) * Math.max(0, r.h);
+}
+var area = normalizedArea;
+function intersection(a, b) {
+	return Math.max(0, Math.min(a.x + a.w, b.x + b.w) - Math.max(a.x, b.x)) * Math.max(0, Math.min(a.y + a.h, b.y + b.h) - Math.max(a.y, b.y));
+}
+/**
+* Share of `region` not covered by any detection box. The sum of pairwise
+* intersections over-counts where detections overlap each other, which only
+* makes the pass MORE conservative; clipped at 1.
+*/
+function uncoveredFraction(region, detections) {
+	const regionArea = area(region);
+	if (regionArea <= 0) return 0;
+	let covered = 0;
+	for (const detection of detections) covered += intersection(region, detection);
+	return 1 - Math.min(1, covered / regionArea);
+}
+/**
+* THE square-placement rule of this pass — one owner, shared by both recipes.
+*
+* A crop is a square of `side` native pixels centred where it can be and slid
+* inside the frame where it cannot. Both region rules place their squares
+* through this function so a crop means the same rectangle whichever rule
+* chose the region.
+*/
+function squareAround(centreX, centreY, side, native) {
+	return {
+		left: Math.round(Math.max(0, Math.min(native.width - side, centreX - side / 2))),
+		top: Math.round(Math.max(0, Math.min(native.height - side, centreY - side / 2))),
+		side
+	};
+}
+function contains(crop, x, y) {
+	return x >= crop.left && x <= crop.left + crop.side && y >= crop.top && y <= crop.top + crop.side;
+}
+/**
+* Squares for one region: one when it fits the largest side, otherwise up to
+* two tiles along its longer axis (a person-sized blob with something small
+* at either end). The padded region decides the side, never the frame.
+*/
+function cropsForRegion(region, native) {
+	const widthPx = region.w * native.width;
+	const heightPx = region.h * native.height;
+	const longest = Math.max(widthPx, heightPx);
+	const padded = longest * 1.5;
+	const side = Math.round(Math.min(Math.max(padded, 640), 800));
+	const centreX = (region.x + region.w / 2) * native.width;
+	const centreY = (region.y + region.h / 2) * native.height;
+	if (padded <= 800) return [squareAround(centreX, centreY, side, native)];
+	const alongX = widthPx >= heightPx;
+	const quarter = longest / 4;
+	return [squareAround(alongX ? centreX - quarter : centreX, alongX ? centreY : centreY - quarter, side, native), squareAround(alongX ? centreX + quarter : centreX, alongX ? centreY : centreY + quarter, side, native)];
+}
+/**
+* The ONE place the two region gates are decided. `planRecoveryCrops` filters
+* on it and {@link countRecoverySkips} counts it, so the report can never
+* describe a gate the planner does not actually apply.
+*/
+function classifyRegion(region, uncovered) {
+	if (area(region) > .25) return "too-large";
+	if (uncovered < .35) return "covered";
+	return "eligible";
+}
+/**
+* WHY A FRAME PLANNED NO CROP, AS A NUMBER (D378).
+*
+* The pass report counts the passes that RAN, so "the second pass stops running
+* when a person is beside the dog" — a plausible reading of
+* {@link RECOVERY_MAX_REGION_FRAME_FRACTION} and
+* {@link RECOVERY_MIN_UNCOVERED_FRACTION}, and a live hypothesis on camera 615
+* — could not be confirmed or killed from the logs at all. This classifies the
+* regions a frame offered, against the same predicate the planner filters on.
+*/
+function countRecoverySkips(input) {
+	let tooLarge = 0;
+	let covered = 0;
+	let eligible = 0;
+	for (const region of input.regions) switch (classifyRegion(region, uncoveredFraction(region, input.detections))) {
+		case "too-large":
+			tooLarge += 1;
+			break;
+		case "covered":
+			covered += 1;
+			break;
+		case "eligible":
+			eligible += 1;
+			break;
+	}
+	return {
+		tooLarge,
+		covered,
+		eligible
+	};
+}
+function planRecoveryCrops(input) {
+	const { native } = input;
+	if (Math.min(native.width, native.height) < 640) return [];
+	const ranked = input.regions.map((region) => ({
+		region,
+		uncovered: uncoveredFraction(region, input.detections)
+	})).filter(({ region, uncovered }) => classifyRegion(region, uncovered) === "eligible").toSorted((a, b) => area(b.region) * b.uncovered - area(a.region) * a.uncovered);
+	const planned = [];
+	for (const { region } of ranked) for (const crop of cropsForRegion(region, native)) {
+		if (planned.length >= 2) return planned;
+		const centreX = crop.left + crop.side / 2;
+		const centreY = crop.top + crop.side / 2;
+		if (planned.some((existing) => contains(existing, centreX, centreY))) continue;
+		planned.push(crop);
+	}
+	return planned;
+}
+/**
+* Boxes the executor produced on the crop VIEW → the result's own space.
+*
+* Three spaces meet here: the view the model saw (`view`, ≤640 px), the native
+* square it was cut from (`crop`, native px) and the space the full-frame
+* result reports in (`result`, native px on the `frameRef` path, the inline
+* ≤640 view otherwise). A box touching the view edge was clipped by the crop
+* and is dropped: half a person is not a person, and the tracker would take
+* the half as the whole.
+*/
+function remapCropDetections(detections, crop, view, result, native) {
+	const viewToNative = crop.side / Math.max(1, view.width);
+	const nativeToResultX = result.width / Math.max(1, native.width);
+	const nativeToResultY = result.height / Math.max(1, native.height);
+	const out = [];
+	for (const detection of detections) {
+		const { x, y, width, height } = detection.bbox;
+		if (x <= 2 || y <= 2 || x + width >= view.width - 2 || y + height >= view.height - 2) continue;
+		out.push({
+			...detection,
+			nativeRecovery: {
+				score: detection.score,
+				cropSidePx: crop.side,
+				viewPx: view.width
+			},
+			bbox: {
+				x: (crop.left + x * viewToNative) * nativeToResultX,
+				y: (crop.top + y * viewToNative) * nativeToResultY,
+				width: width * viewToNative * nativeToResultX,
+				height: height * viewToNative * nativeToResultY
+			}
+		});
+	}
+	return out;
+}
+function boxIntersection(a, b) {
+	return Math.max(0, Math.min(a.x + a.width, b.x + b.width) - Math.max(a.x, b.x)) * Math.max(0, Math.min(a.y + a.height, b.y + b.height) - Math.max(a.y, b.y));
+}
+function sameSubject(recovered, existing) {
+	const inter = boxIntersection(recovered, existing);
+	if (inter <= 0) return false;
+	const areaR = recovered.width * recovered.height;
+	const union = areaR + existing.width * existing.height - inter;
+	if (union > 0 && inter / union >= .5) return true;
+	return areaR > 0 && inter / areaR >= .7;
+}
+/**
+* Class-aware NMS of the recovered boxes against the full-frame ones. Every
+* full-frame box is kept as it is — the second pass only ADDS. A recovered box
+* is added when no full-frame box of the same macro class is the same subject
+* (`RECOVERY_FUSE_IOU`) or contains it (`RECOVERY_FUSE_CONTAINMENT`). Ids are
+* re-minted so a crop's `d0` cannot collide with the frame's.
+*/
+function fuseRecoveredDetections(full, recovered) {
+	const accepted = [];
+	for (const [index, candidate] of recovered.entries()) {
+		if ([...full, ...accepted].some((existing) => existing.macroClass === candidate.macroClass && sameSubject(candidate.bbox, existing.bbox))) continue;
+		accepted.push({
+			...candidate,
+			id: `recovered-${index}-${candidate.id}`
+		});
+	}
+	return [...full, ...accepted];
+}
+/**
+* The step the second pass runs: the enabled first-level object detector of
+* the camera's own tree, with its own model and no children. Same model as
+* the full pass so a recovered box is comparable to a full-frame one.
+*/
+function selectRecoveryStep(steps) {
+	const detector = steps.find((step) => step.addonId === "object-detection" && step.enabled !== false);
+	if (!detector) return null;
+	return {
+		addonId: detector.addonId,
+		...detector.modelId !== void 0 ? { modelId: detector.modelId } : {},
+		enabled: true
+	};
+}
+//#endregion
+//#region src/pipeline/second-pass/motion-crop-plan.ts
+/**
+* Step-settings key of the opt-in, on the `object-detection` step — so it is
+* per camera through `pipelineOrchestrator.setCameraStepSettings` (a
+* camera-semantic key, D927), and it rides the same
+* `PipelineStepInputOutput.settings` the per-macro confidence floors ride.
+*/
+var MOTION_CROP_DISPATCH_KEY = "motionCropDispatch";
+/**
+* Read the opt-in. Anything that is not the boolean `true` is the shipped
+* rule: a stored string or a number is a mis-write (this repo has shipped a
+* setting written into the wrong sqlite table before), and a mis-write must
+* not silently change what a camera detects on.
+*/
+function readRecoveryRecipe(settings) {
+	return settings?.["motionCropDispatch"] === true ? "motion-crop" : "uncovered-region";
+}
+/**
+* The recipe this camera's resolved step tree selects.
+*
+* Reads the ENABLED first-level detector's own settings, which is where
+* `pipelineOrchestrator.setCameraStepSettings` writes a per-camera value. A
+* tree with no enabled detector runs no second pass at all, so the answer
+* there is the shipped rule and it is never used.
+*/
+function readRecoveryRecipeForSteps(steps) {
+	return readRecoveryRecipe(steps.find((step) => step.addonId === "object-detection" && step.enabled !== false)?.settings);
+}
+/**
+* A motion box is grown ×1.5 about its centre before anything else.
+*
+* The motion step's box is the CHANGED pixels, which on a moving animal is the
+* leading edge plus its shadow, not the animal. The detector needs the subject
+* and the context it was trained on.
+*/
+var MOTION_CROP_MOTION_PAD = 1.5;
+/**
+* An intersecting tracked box is grown ×1.25 — less, because it is already a
+* subject rectangle rather than a change mask.
+*/
+var MOTION_CROP_TRACKED_PAD = 1.25;
+/**
+* Regions per frame, largest area first.
+*
+* Measured as NON-BINDING: over the 156 frames of the recall harness the cap
+* bound on 0 of them. It is the bound on a storm, not a tuning knob, and the
+* runner reports when it binds so a camera on which it starts to is visible.
+*/
+var MOTION_CROP_MAX_REGIONS = 3;
+/**
+* The floor a `person` or `vehicle` box must clear when it came out of a CROP
+* rather than out of the full frame.
+*
+* Collected, not assumed: 3 085 quiet frames produced 27 motion-positive
+* frames and 28 crop invocations. The full-frame arm produced 0 boxes above
+* any gate; the crop arm produced 3, of which two are genuine false positives,
+* and both are night-IR corners upscaled into a 320 model — `vehicle 0.749`
+* and `person 0.701`. Zero false `animal` at any gate, which is why `animal`
+* is deliberately absent from this table: the class the pass exists to recover
+* is the class that never produced a false positive, and gating it would cost
+* the whole measured gain.
+*
+* This is a CROP-ONLY floor, applied on top of the per-macro floors the
+* executor already enforced. A full-frame `person` at 0.70 is untouched — the
+* full-frame arm is the one arm with ground truth behind its floor
+* (`minConfidencePerson` 0.65, raised on 2026-07-30 from a measured
+* distribution).
+*
+* The cost of this floor is stated rather than assumed away: it can also
+* remove a real distant person or vehicle recovered from a crop at 0.70–0.80.
+* Nothing in the quiet-footage sample measures that, so the floor is a
+* constant here rather than a slider, and the runner reports every drop it
+* makes per camera.
+*/
+var CROP_CLASS_FLOORS = Object.freeze({
+	person: .8,
+	vehicle: .8
+});
+/**
+* Apply the crop-only class floors, REPORTING every drop.
+*
+* A class with no entry in {@link CROP_CLASS_FLOORS} is kept: a floor this
+* table cannot express is not a floor of zero, and silently dropping a class
+* nobody measured is the exact shape of silent drop this repo has paid for
+* three separate times.
+*/
+function applyCropClassFloors(detections) {
+	const kept = [];
+	const dropped = [];
+	for (const detection of detections) {
+		const floor = CROP_CLASS_FLOORS[detection.macroClass];
+		if (floor !== void 0 && detection.score < floor) {
+			dropped.push({
+				macroClass: detection.macroClass,
+				score: detection.score,
+				floor
+			});
+			continue;
+		}
+		kept.push(detection);
+	}
+	return {
+		kept,
+		dropped
+	};
+}
+function scaleAbout(rect, factor) {
+	const w = rect.w * factor;
+	const h = rect.h * factor;
+	return {
+		x: rect.x + rect.w / 2 - w / 2,
+		y: rect.y + rect.h / 2 - h / 2,
+		w,
+		h
+	};
+}
+function overlaps(a, b) {
+	return Math.min(a.x + a.w, b.x + b.w) > Math.max(a.x, b.x) && Math.min(a.y + a.h, b.y + b.h) > Math.max(a.y, b.y);
+}
+function union(a, b) {
+	const x = Math.min(a.x, b.x);
+	const y = Math.min(a.y, b.y);
+	return {
+		x,
+		y,
+		w: Math.max(a.x + a.w, b.x + b.w) - x,
+		h: Math.max(a.y + a.h, b.y + b.h) - y
+	};
+}
+function clampToFrame(rect) {
+	const x = Math.max(0, rect.x);
+	const y = Math.max(0, rect.y);
+	return {
+		x,
+		y,
+		w: Math.min(1, rect.x + rect.w) - x,
+		h: Math.min(1, rect.y + rect.h) - y
+	};
+}
+/**
+* Merge transitively every seed whose padded box overlaps another, and answer
+* the union rectangles.
+*
+* Transitive on purpose: a person, the dog beside them and the dog's shadow
+* are three components of one subject, and cutting three crops for them spends
+* two inferences on pixels the first one already showed the detector.
+*/
+function mergeSeeds(seeds) {
+	const merged = [];
+	for (const seed of seeds) {
+		let current = seed;
+		let changed = true;
+		while (changed) {
+			changed = false;
+			for (let i = merged.length - 1; i >= 0; i -= 1) {
+				const other = merged[i];
+				if (other === void 0 || !overlaps(current, other)) continue;
+				current = union(current, other);
+				merged.splice(i, 1);
+				changed = true;
+			}
+		}
+		merged.push(current);
+	}
+	return merged;
+}
+/**
+* The regions the measured recipe judges this frame on.
+*
+* Motion boxes padded {@link MOTION_CROP_MOTION_PAD}; every full-frame box
+* that intersects a RAW motion box padded {@link MOTION_CROP_TRACKED_PAD} and
+* added as a seed of its own; everything that overlaps merged; the result
+* clamped to the frame, ordered largest first and capped at
+* {@link MOTION_CROP_MAX_REGIONS}.
+*
+* There is deliberately no coverage gate and no size gate here. Those belong
+* to the shipped rule, and they are what makes it a rule about a subject
+* BESIDE a detected one; the measurement says the pass is worth running on the
+* detected subject's own region too.
+*/
+function planMotionCropRegions(input) {
+	if (input.regions.length === 0) return [];
+	const seeds = input.regions.map((r) => scaleAbout(r, MOTION_CROP_MOTION_PAD));
+	for (const detection of input.detections) {
+		if (!input.regions.some((region) => overlaps(detection, region))) continue;
+		seeds.push(scaleAbout(detection, MOTION_CROP_TRACKED_PAD));
+	}
+	return mergeSeeds(seeds).map(clampToFrame).filter((r) => r.w > 0 && r.h > 0).toSorted((a, b) => normalizedArea(b) - normalizedArea(a)).slice(0, 3);
+}
+/**
+* The square the detector is fed for one measured region.
+*
+* "Grow to the detector's input aspect ratio without ever shrinking" is a
+* SQUARE here, and that is a fact about the production detector rather than a
+* simplification: `yolov9m-320-int8` takes 320×320, as does every hardware
+* default in the catalog.
+*
+* The side is the region's longer side, floored at
+* {@link RECOVERY_CROP_MIN_SIDE_PX} — the growth is what magnifies the subject
+* — and ceilinged at {@link RECOVERY_CROP_MAX_SIDE_PX}. The ceiling is NOT a
+* simplification either: at 1024 px the same 320 model scored the reference
+* dog 0.52–0.76, and at 1280 px lost it entirely
+* (`docs/benchmarks/pipeline-frame-model-eval.md`, case `miss-dog-615`). A
+* region longer than the ceiling is TILED along its longer axis, never zoomed
+* out.
+*/
+function motionCropsForRegion(region, native) {
+	const widthPx = region.w * native.width;
+	const heightPx = region.h * native.height;
+	const longest = Math.max(widthPx, heightPx);
+	const side = Math.round(Math.min(Math.max(longest, 640), 800));
+	const centreX = (region.x + region.w / 2) * native.width;
+	const centreY = (region.y + region.h / 2) * native.height;
+	if (longest <= 800) return [squareAround(centreX, centreY, side, native)];
+	const alongX = widthPx >= heightPx;
+	const quarter = longest / 4;
+	return [squareAround(alongX ? centreX - quarter : centreX, alongX ? centreY : centreY - quarter, side, native), squareAround(alongX ? centreX + quarter : centreX, alongX ? centreY : centreY + quarter, side, native)];
+}
+/** `true` when `inner` lies entirely inside `outer`. */
+function cropContains(outer, inner) {
+	return inner.left >= outer.left && inner.top >= outer.top && inner.left + inner.side <= outer.left + outer.side && inner.top + inner.side <= outer.top + outer.side;
+}
+/**
+* The crops the measured recipe runs on this frame.
+*
+* Dedupe is by CONTAINMENT only. Two squares that merely overlap both run: the
+* pixels the second adds are pixels no other crop shows the detector, and the
+* fusion step downstream already refuses a duplicate BOX. Dropping a crop
+* because it overlapped would drop the subject sitting at its edge, which is
+* the whole population this pass exists for.
+*
+* A frame that cannot hold the smallest crop yields nothing: it is already
+* seen at scale.
+*/
+function planMotionCrops(input) {
+	const { native } = input;
+	if (Math.min(native.width, native.height) < 640) return [];
+	const planned = [];
+	for (const region of planMotionCropRegions(input)) for (const crop of motionCropsForRegion(region, native)) {
+		if (planned.some((existing) => cropContains(existing, crop))) continue;
+		planned.push(crop);
+	}
+	return planned;
+}
+//#endregion
 //#region src/pipeline/root-face-crop.ts
 /** Side of the square, as a multiple of the face box's longer side. */
 var ROOT_FACE_REFINE_SCALE = 1.6;
@@ -109793,6 +110606,7 @@ exports.ADMIN_SCOPE = ADMIN_SCOPE;
 exports.AGENT_MDNS_QUERY_NAME = AGENT_MDNS_QUERY_NAME;
 exports.AGENT_MDNS_SERVICE_TYPE = AGENT_MDNS_SERVICE_TYPE;
 exports.AGENT_MDNS_TXT_KEYS = AGENT_MDNS_TXT_KEYS;
+exports.AGGREGATE_THROUGHPUT_BY_KIND = AGGREGATE_THROUGHPUT_BY_KIND;
 exports.ALEXA_EGRESS_PROFILE = ALEXA_EGRESS_PROFILE;
 exports.ALL_CAPABILITY_DEFINITIONS = ALL_CAPABILITY_DEFINITIONS;
 exports.ALL_METHOD_ACCESS = ALL_METHOD_ACCESS;
@@ -109820,6 +110634,7 @@ exports.AUDIO_SCALE_EPOCH_MS = AUDIO_SCALE_EPOCH_MS;
 exports.AUTOMATIC_HUB_ADDRESS_FLAGS = AUTOMATIC_HUB_ADDRESS_FLAGS;
 exports.AUTO_SHARE_HEADROOM = AUTO_SHARE_HEADROOM;
 exports.AUTO_TUNE_FAMILY = AUTO_TUNE_FAMILY;
+exports.AcceleratorComputeSchema = AcceleratorComputeSchema;
 exports.AcceleratorKindSchema = AcceleratorKindSchema;
 exports.AccessoriesStatusSchema = AccessoriesStatusSchema;
 exports.AccessoryKind = AccessoryKind;
@@ -110006,8 +110821,11 @@ exports.CONTAINER_CHILD_PRIORITY = CONTAINER_CHILD_PRIORITY;
 exports.CORAL_DEFAULT_MODEL_ID = CORAL_DEFAULT_MODEL_ID;
 exports.CORE_BLOCKS_ADDON_ID = CORE_BLOCKS_ADDON_ID;
 exports.CORE_BLOCK_ADDON_PREFIX = CORE_BLOCK_ADDON_PREFIX;
+exports.CORE_ULTRA_265K_IGPU_CLOCK_MHZ = CORE_ULTRA_265K_IGPU_CLOCK_MHZ;
+exports.CORE_ULTRA_265K_IGPU_EU = CORE_ULTRA_265K_IGPU_EU;
 exports.CREDENTIAL_TOKEN_AUDIENCE = CREDENTIAL_TOKEN_AUDIENCE;
 exports.CREDENTIAL_TOKEN_KIND = CREDENTIAL_TOKEN_KIND;
+exports.CROP_CLASS_FLOORS = CROP_CLASS_FLOORS;
 exports.CROP_SUPPLY_SOURCES = CROP_SUPPLY_SOURCES;
 exports.CROP_SUPPLY_STEP_IDS = CROP_SUPPLY_STEP_IDS;
 exports.CUSTOMIZATION_BLOCK_NAME_PREFIX = require_composition.CUSTOMIZATION_BLOCK_NAME_PREFIX;
@@ -110358,6 +111176,8 @@ exports.DoorbellStatusSchema = DoorbellStatusSchema;
 exports.EMBEDDING_MODEL_FAILED = EMBEDDING_MODEL_FAILED;
 exports.EMBEDDING_REQUIREMENTS_FAILED = EMBEDDING_REQUIREMENTS_FAILED;
 exports.EMBEDDING_REQUIREMENTS_UNAVAILABLE = EMBEDDING_REQUIREMENTS_UNAVAILABLE;
+exports.ESTIMATE_COMPUTE_RATIO_MAX = ESTIMATE_COMPUTE_RATIO_MAX;
+exports.ESTIMATE_COMPUTE_RATIO_MIN = ESTIMATE_COMPUTE_RATIO_MIN;
 exports.EVENTFUL_CAP_NAMES = EVENTFUL_CAP_NAMES;
 exports.EVENT_DENSITY_BATCH_MAX = EVENT_DENSITY_BATCH_MAX;
 exports.EVENT_KIND_BY_CAP = EVENT_KIND_BY_CAP;
@@ -110708,6 +111528,10 @@ exports.MODEL_FORMATS = require_sleep.MODEL_FORMATS;
 exports.MODEL_HOSTING = MODEL_HOSTING;
 exports.MODEL_PROVIDER_IDS = MODEL_PROVIDER_IDS;
 exports.MOTION_CLOSE_AFTER_MS = MOTION_CLOSE_AFTER_MS;
+exports.MOTION_CROP_DISPATCH_KEY = MOTION_CROP_DISPATCH_KEY;
+exports.MOTION_CROP_MAX_REGIONS = MOTION_CROP_MAX_REGIONS;
+exports.MOTION_CROP_MOTION_PAD = MOTION_CROP_MOTION_PAD;
+exports.MOTION_CROP_TRACKED_PAD = MOTION_CROP_TRACKED_PAD;
 exports.MOTION_SOURCE_LABELS = MOTION_SOURCE_LABELS;
 exports.MOTION_TRIGGER_FEATURE = MOTION_TRIGGER_FEATURE;
 exports.ManagedModelCatalogEntrySchema = ManagedModelCatalogEntrySchema;
@@ -110772,6 +111596,8 @@ exports.MotionZoneStatusSchema = MotionZoneStatusSchema;
 exports.MqttBrokerInfoSchema = BrokerInfoSchema$1;
 exports.MqttBrokerStatusSchema = StatusSchema;
 exports.MutationFilterSchema = MutationFilterSchema;
+exports.N100_IGPU_CLOCK_MHZ = N100_IGPU_CLOCK_MHZ;
+exports.N100_IGPU_EU = N100_IGPU_EU;
 exports.NATIVE_LEASE_ACTIVITY_FIELD = NATIVE_LEASE_ACTIVITY_FIELD;
 exports.NATIVE_LEASE_ACTIVITY_KEY = NATIVE_LEASE_ACTIVITY_KEY;
 exports.NATIVE_LEASE_ADMISSION_FIELD = NATIVE_LEASE_ADMISSION_FIELD;
@@ -111037,6 +111863,7 @@ exports.NotifierStatusSchema = NotifierStatusSchema;
 exports.NumericSensorStatusSchema = NumericSensorStatusSchema;
 exports.OAUTH_LANDING_PATH = OAUTH_LANDING_PATH;
 exports.OAUTH_LANDING_REASONS = OAUTH_LANDING_REASONS;
+exports.OBJECT_DETECTION_STEP_ID = OBJECT_DETECTION_STEP_ID;
 exports.OPERATOR_WRITTEN_STALE_MS = OPERATOR_WRITTEN_STALE_MS;
 exports.OPS_LOG_DEFAULT_LIMIT = OPS_LOG_DEFAULT_LIMIT;
 exports.OPS_LOG_RING_DEFAULT_MAX = OPS_LOG_RING_DEFAULT_MAX;
@@ -111087,6 +111914,7 @@ exports.PEER_BYTES_TICKET_TTL_MS = require_sleep.PEER_BYTES_TICKET_TTL_MS;
 exports.PENDING_BLOCK_ID = PENDING_BLOCK_ID;
 exports.PET_FEEDER_MANUAL_FEED_MAX = PET_FEEDER_MANUAL_FEED_MAX;
 exports.PET_FEEDER_MANUAL_FEED_MIN = PET_FEEDER_MANUAL_FEED_MIN;
+exports.PHOENIX_780M_CU = PHOENIX_780M_CU;
 exports.PIPELINE_ANALYTICS_CAP_NAME = PIPELINE_ANALYTICS_CAP_NAME;
 exports.PIPELINE_FLOW_CAPABILITY_NAMES = PIPELINE_FLOW_CAPABILITY_NAMES;
 exports.PIPELINE_OWNER_CAPABILITY_NAMES = PIPELINE_OWNER_CAPABILITY_NAMES;
@@ -111103,6 +111931,7 @@ exports.PUBLIC_ENDPOINT_HTTP_REASON = PUBLIC_ENDPOINT_HTTP_REASON;
 exports.PYTHON_SCRIPT = PYTHON_SCRIPT;
 exports.PackageInstallationSchema = PackageInstallationSchema;
 exports.PackageInstallationsSchema = PackageInstallationsSchema;
+exports.PackageLlmVerdictSchema = PackageLlmVerdictSchema;
 exports.PackageUpdateSchema = PackageUpdateSchema;
 exports.PackageVersionInfoSchema = PackageVersionInfoSchema;
 exports.ParkRefusalSchema = ParkRefusalSchema;
@@ -111135,6 +111964,7 @@ exports.PlaintextSecretError = require_sleep.PlaintextSecretError;
 exports.PolygonPointSchema = PolygonPointSchema;
 exports.PoolMemoryWatchdog = PoolMemoryWatchdog;
 exports.PowerMeterStatusSchema = PowerMeterStatusSchema;
+exports.PrecisionGopsSchema = PrecisionGopsSchema;
 exports.PreferenceDeviceIdSchema = PreferenceDeviceIdSchema;
 exports.PreferenceNamespaceSchema = PreferenceNamespaceSchema;
 exports.PreferenceRowSchema = PreferenceRowSchema;
@@ -111203,7 +112033,21 @@ exports.RECORD_QUERY_MAX = require_sleep.RECORD_QUERY_MAX;
 exports.RECORD_SECRET_COLLECTION_PREFIX = require_sleep.RECORD_SECRET_COLLECTION_PREFIX;
 exports.RECORD_SETTINGS_MAX_ROWS = require_sleep.RECORD_SETTINGS_MAX_ROWS;
 exports.RECORD_SWEEP_INTERVAL_MS = require_sleep.RECORD_SWEEP_INTERVAL_MS;
+exports.RECOVERY_CROP_MAX_SIDE_PX = RECOVERY_CROP_MAX_SIDE_PX;
+exports.RECOVERY_CROP_MIN_SIDE_PX = RECOVERY_CROP_MIN_SIDE_PX;
+exports.RECOVERY_CROP_PADDING_RATIO = RECOVERY_CROP_PADDING_RATIO;
+exports.RECOVERY_EDGE_MARGIN_PX = RECOVERY_EDGE_MARGIN_PX;
+exports.RECOVERY_FUSE_CONTAINMENT = RECOVERY_FUSE_CONTAINMENT;
+exports.RECOVERY_FUSE_IOU = RECOVERY_FUSE_IOU;
+exports.RECOVERY_MAX_CROPS_PER_FRAME = RECOVERY_MAX_CROPS_PER_FRAME;
+exports.RECOVERY_MAX_REGION_FRAME_FRACTION = RECOVERY_MAX_REGION_FRAME_FRACTION;
+exports.RECOVERY_MIN_INTERVAL_MS = RECOVERY_MIN_INTERVAL_MS;
+exports.RECOVERY_MIN_UNCOVERED_FRACTION = RECOVERY_MIN_UNCOVERED_FRACTION;
+exports.RECOVERY_MOTION_MAX_AGE_MS = RECOVERY_MOTION_MAX_AGE_MS;
+exports.RECOVERY_VIEW_PX = RECOVERY_VIEW_PX;
 exports.REDACTED_SECRET = require_sleep.REDACTED_SECRET;
+exports.REFERENCE_COMPUTE = REFERENCE_COMPUTE;
+exports.REFERENCE_MATCH_FRACTION = REFERENCE_MATCH_FRACTION;
 exports.REMOVAL_RECONCILE_INTERVAL_MS = REMOVAL_RECONCILE_INTERVAL_MS;
 exports.REMOVED_MODEL_IDS = REMOVED_MODEL_IDS;
 exports.REMOVE_LEAF = require_sleep.REMOVE_LEAF;
@@ -111390,6 +112234,7 @@ exports.SECRET_META = require_sleep.SECRET_META;
 exports.SECRET_REF_SCHEME = require_sleep.SECRET_REF_SCHEME;
 exports.SENSOR_FEATURES = SENSOR_FEATURES;
 exports.SENSOR_MAP = SENSOR_MAP;
+exports.SERIAL_CAPACITY_CAMERA_FPS = SERIAL_CAPACITY_CAMERA_FPS;
 exports.SERVER_NAME_MAX_LENGTH = SERVER_NAME_MAX_LENGTH;
 exports.SERVER_NAME_SETTING_KEY = SERVER_NAME_SETTING_KEY;
 exports.SESSION_PLACEMENT_SETTING_KEY = SESSION_PLACEMENT_SETTING_KEY;
@@ -111745,6 +112590,7 @@ exports.addonWidgetsSourceCapability = addonWidgetsSourceCapability;
 exports.addonsCapability = addonsCapability;
 exports.adminUiCapability = require_sleep.adminUiCapability;
 exports.advertisedHubOrigins = advertisedHubOrigins;
+exports.aggregateThroughputFactor = aggregateThroughputFactor;
 exports.airQualitySensorCapability = airQualitySensorCapability;
 exports.alarmDeviceBlocksArming = alarmDeviceBlocksArming;
 exports.alarmDeviceSecureOnArm = alarmDeviceSecureOnArm;
@@ -111762,6 +112608,7 @@ exports.ambientLightSensorCapability = ambientLightSensorCapability;
 exports.annotateClipsWithEventLabels = annotateClipsWithEventLabels;
 exports.appFlowLocation = appFlowLocation;
 exports.applyBlockingEdit = applyBlockingEdit;
+exports.applyCropClassFloors = applyCropClassFloors;
 exports.applyModeDelaysEdits = applyModeDelaysEdits;
 exports.applyModeDeviceListEdit = applyModeDeviceListEdit;
 exports.applyModelBoundSettings = applyModelBoundSettings;
@@ -111897,6 +112744,7 @@ exports.compositionSliceKey = require_composition.compositionSliceKey;
 exports.compositionSourceKey = require_composition.compositionSourceKey;
 exports.compositionSourceRefs = compositionSourceRefs;
 exports.computeCapacityShares = computeCapacityShares;
+exports.computeScores = computeScores;
 exports.conditionDepth = conditionDepth;
 exports.conditionExclusionReason = conditionExclusionReason;
 exports.conditionVisibleForKind = conditionVisibleForKind;
@@ -111919,6 +112767,7 @@ exports.coreBlockSourceKind = coreBlockSourceKind;
 exports.coreBlocksCapability = coreBlocksCapability;
 exports.cosineSimilarity = cosineSimilarity;
 exports.countConditionLeaves = countConditionLeaves;
+exports.countRecoverySkips = countRecoverySkips;
 exports.coverCapability = coverCapability;
 exports.createAlarmProfile = createAlarmProfile;
 exports.createDeviceExtensionProvider = createDeviceExtensionProvider;
@@ -112089,6 +112938,7 @@ exports.formatSecretScope = require_sleep.formatSecretScope;
 exports.freshResults = freshResults;
 exports.frigateDefaultClassFloors = frigateDefaultClassFloors;
 exports.frigateLabelFields = frigateLabelFields;
+exports.fuseRecoveredDetections = fuseRecoveredDetections;
 exports.gasCapability = gasCapability;
 exports.gbToBytes = gbToBytes;
 exports.generateAutomationBlock = generateAutomationBlock;
@@ -112299,6 +113149,7 @@ exports.normalizeOrigin = normalizeOrigin;
 exports.normalizeSecretOwner = require_sleep.normalizeSecretOwner;
 exports.normalizeTokenScopes = normalizeTokenScopes;
 exports.normalizeUnit = normalizeUnit;
+exports.normalizedArea = normalizedArea;
 exports.notificationOutputCapability = notificationOutputCapability;
 exports.notificationRulesCapability = notificationRulesCapability;
 exports.notifierCapability = notifierCapability;
@@ -112316,6 +113167,7 @@ exports.osdCapability = osdCapability;
 exports.osdManagerCapability = osdManagerCapability;
 exports.overlayClusterStepSettings = overlayClusterStepSettings;
 exports.packagePickerItems = packagePickerItems;
+exports.parseAcceleratorFactsJson = parseAcceleratorFactsJson;
 exports.parseAdminBase = parseAdminBase;
 exports.parseAlertEpisodePayload = parseAlertEpisodePayload;
 exports.parseAppAuthCallback = parseAppAuthCallback;
@@ -112366,6 +113218,9 @@ exports.pipelineRunnerCapability = pipelineRunnerCapability;
 exports.planComposition = planComposition;
 exports.planCompositionEvents = planCompositionEvents;
 exports.planItems = planItems;
+exports.planMotionCropRegions = planMotionCropRegions;
+exports.planMotionCrops = planMotionCrops;
+exports.planRecoveryCrops = planRecoveryCrops;
 exports.plateGalleryCapability = plateGalleryCapability;
 exports.platformProbeCapability = platformProbeCapability;
 exports.poolMemoryThreshold = poolMemoryThreshold;
@@ -112394,6 +113249,8 @@ exports.readHubMotionStatus = readHubMotionStatus;
 exports.readMotionTriggeredBy = readMotionTriggeredBy;
 exports.readNativeLeaseOverride = readNativeLeaseOverride;
 exports.readNodePin = require_sleep.readNodePin;
+exports.readRecoveryRecipe = readRecoveryRecipe;
+exports.readRecoveryRecipeForSteps = readRecoveryRecipeForSteps;
 exports.readTimelapseGeneratedAt = readTimelapseGeneratedAt;
 exports.readUseRootModel = readUseRootModel;
 exports.readinessKey = require_sleep.readinessKey;
@@ -112415,9 +113272,11 @@ exports.recordsErrorFromMessage = require_sleep.recordsErrorFromMessage;
 exports.rectsToCells = rectsToCells;
 exports.reducePoints = reducePoints;
 exports.registerKnownSecret = require_sleep.registerKnownSecret;
+exports.remapCropDetections = remapCropDetections;
 exports.renameAlarmProfile = renameAlarmProfile;
 exports.renderVocabPhrase = renderVocabPhrase;
 exports.replacedFieldKeys = replacedFieldKeys;
+exports.reportIsScalable = reportIsScalable;
 exports.requestMountPrefix = requestMountPrefix;
 exports.requiredTopLevelKeys = requiredTopLevelKeys;
 exports.requiresPython = requiresPython;
@@ -112445,6 +113304,7 @@ exports.resolveHubAddressRoles = resolveHubAddressRoles;
 exports.resolveHydratedFieldValue = require_sleep.resolveHydratedFieldValue;
 exports.resolveIconKey = resolveIconKey;
 exports.resolveInternalAddress = resolveInternalAddress;
+exports.resolveLatencyColumn = resolveLatencyColumn;
 exports.resolveLocationMode = resolveLocationMode;
 exports.resolveMethodAuth = resolveMethodAuth;
 exports.resolveMethodRole = resolveMethodRole;
@@ -112511,6 +113371,7 @@ exports.secretTreeFromSchema = require_sleep.secretTreeFromSchema;
 exports.secureActuationFor = secureActuationFor;
 exports.selectAppConnectionEndpoints = selectAppConnectionEndpoints;
 exports.selectAssignedProfileSlots = require_sleep.selectAssignedProfileSlots;
+exports.selectRecoveryStep = selectRecoveryStep;
 exports.sendTimesForEditor = sendTimesForEditor;
 exports.sendTimesOfSchedule = sendTimesOfSchedule;
 exports.sensorRaisedOf = sensorRaisedOf;
@@ -112537,6 +113398,7 @@ exports.smokeCapability = smokeCapability;
 exports.smtpProviderCapability = smtpProviderCapability;
 exports.snapshotCapability = snapshotCapability;
 exports.splitTranslationRef = splitTranslationRef;
+exports.squareAround = squareAround;
 exports.ssoBridgeCapability = ssoBridgeCapability;
 exports.startMoverUnderClearance = startMoverUnderClearance;
 exports.startReachabilityPoll = startReachabilityPoll;