@camstack/types 1.2.315 → 1.2.317

package/dist/index.js

@@ -5718,16 +5718,53 @@ var ModelFormatEntrySchema = zod.z.object({
 	/** Runtime(s) that can use this format. If omitted, inferred from ModelFormat key */
 	runtimes: zod.z.array(zod.z.enum(["python"])).readonly().optional(),
 	/**
-	* Content revision of the hosted artefact. Set it, or change it, whenever
-	* the bytes at `url` are replaced in place (same path, new content). A node
-	* records the revision it downloaded next to the file
+	* Content revision of the artefact, for one hosted OFF the CamStack mirror.
+	* A format on the mirror leaves it unset: its revision (the sha256 of its
+	* weight file) comes from the downloader's generated table, kept in step
+	* with the mirror by `scripts/check-hosted-model-revisions.ts` (D744). A
+	* node records the revision it downloaded next to the file
 	* (`<file>.revision`); a copy with no record or a different one is stale
-	* and is downloaded again, the old copy serving until the new one is
-	* complete. Omitted ⇒ a file on disk is current, whatever it holds (D743).
+	* unless its weight file hashes to the revision, and a stale copy is
+	* downloaded again, the old one serving until the new one is complete. No
+	* revision at all ⇒ a file on disk is current, whatever it holds (D743).
 	*/
 	revision: zod.z.string().min(1).optional()
 });
 /**
+* What a node holds for one (model, format) (D746). `current` is a complete
+* copy at its catalog revision — exactly what `downloaded: true` means.
+* `stale` is bytes on disk that are not (yet) proven current under D743/D744:
+* no or a different revision record, or a missing sibling. `missing` is no
+* copy. `downloaded` alone folds `stale` into "not downloaded", which hid
+* reclaimable bytes and a copy about to be replaced.
+*/
+var ModelOnDiskStateSchema = zod.z.enum([
+	"current",
+	"stale",
+	"missing"
+]);
+/**
+* The numeric precision of one format's BUILD (D746) — reported only when the
+* build states it (file-name token, an INT8 variant, an EdgeTPU compile, a
+* CamStack Core ML export). Absent means "not stated", never "fp32".
+*/
+var ModelFormatPrecisionSchema = zod.z.enum([
+	"fp32",
+	"fp16",
+	"int8"
+]);
+/**
+* One format of one model as a node's `pipelineExecutor.getSchema` reports it.
+* `onDisk` / `precision` are optional for version skew: a runner that predates
+* them omits them, and a reader falls back to `downloaded`.
+*/
+var PipelineModelFormatStatusSchema = zod.z.object({
+	downloaded: zod.z.boolean(),
+	sizeMB: zod.z.number(),
+	onDisk: ModelOnDiskStateSchema.optional(),
+	precision: ModelFormatPrecisionSchema.optional()
+});
+/**
 * Extra file that must be downloaded alongside the model (e.g., labels JSON, dict.txt).
 * The downloader fetches from `url` and saves to `{modelsDir}/{filename}`.
 */
@@ -26542,7 +26579,7 @@ var FrameRefSchema = zod.z.object({
 	timestamp: zod.z.number(),
 	capturedAt: zod.z.number().optional()
 });
-var ModelFormatSchema$1 = zod.z.enum([
+var ModelFormatSchema$2 = zod.z.enum([
 	"onnx",
 	"coreml",
 	"openvino",
@@ -26560,7 +26597,7 @@ var PipelineSlotSchema = zod.z.enum([
 var PipelineEngineChoiceSchema = zod.z.object({
 	runtime: zod.z.literal("python"),
 	backend: zod.z.string(),
-	format: ModelFormatSchema$1,
+	format: ModelFormatSchema$2,
 	device: zod.z.string().optional()
 });
 /**
@@ -26618,10 +26655,7 @@ var PipelineTemplateSchema$1 = zod.z.object({
 var PipelineModelOptionSchema = zod.z.object({
 	id: zod.z.string(),
 	name: zod.z.string(),
-	formats: zod.z.record(zod.z.string(), zod.z.object({
-		downloaded: zod.z.boolean(),
-		sizeMB: zod.z.number()
-	})),
+	formats: zod.z.record(zod.z.string(), PipelineModelFormatStatusSchema),
 	group: ModelVariantGroupSchema.optional(),
 	legacy: zod.z.boolean().optional(),
 	provider: ModelProviderIdSchema.optional(),
@@ -26836,6 +26870,32 @@ var pipelineExecutorCapability = {
 			auth: "admin"
 		}),
 		/**
+		* Best settings (D745): the MODEL-BOUND thresholds (`bindsToModel` keys of
+		* the object-detection root, and their binding keys) stored in THIS node's
+		* per-camera detector settings — and, unless `dryRun`, remove them so the
+		* running model's own defaults apply. Every other key of a camera's store
+		* is kept. `nodeId` is the ROUTING key. `deviceIds` absent ⇒ every camera
+		* with a store. A camera whose store could not be read is `refused`, never
+		* reported as clean.
+		*/
+		clearModelBoundDeviceOverrides: require_sleep.method(zod.z.object({
+			nodeId: zod.z.string(),
+			deviceIds: zod.z.array(zod.z.number()).readonly().optional(),
+			dryRun: zod.z.boolean()
+		}), zod.z.object({
+			entries: zod.z.array(zod.z.object({
+				deviceId: zod.z.number(),
+				keys: zod.z.array(zod.z.string()).readonly()
+			})).readonly(),
+			refused: zod.z.array(zod.z.object({
+				deviceId: zod.z.number(),
+				reason: zod.z.string()
+			})).readonly()
+		}), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		/**
 		* Which of THIS node's inference devices the executor currently refuses,
 		* and why. `nodeId` is the ROUTING key (stripped by the generated router).
 		*
@@ -26930,12 +26990,12 @@ var pipelineExecutorCapability = {
 		downloadModel: require_sleep.method(zod.z.object({
 			addonId: zod.z.string(),
 			modelId: zod.z.string(),
-			format: ModelFormatSchema$1
+			format: ModelFormatSchema$2
 		}), DownloadModelResultSchema, { kind: "mutation" }),
 		deleteModel: require_sleep.method(zod.z.object({
 			addonId: zod.z.string(),
 			modelId: zod.z.string(),
-			format: ModelFormatSchema$1
+			format: ModelFormatSchema$2
 		}), zod.z.object({ success: zod.z.literal(true) }), { kind: "mutation" }),
 		/**
 		* Stateless single-frame execution. Callers (runner, benchmark) pass
@@ -27182,6 +27242,206 @@ var pipelineExecutorCapability = {
 	}
 };
 //#endregion
+//#region src/pipeline/best-settings/plan-schemas.ts
+/**
+* The wire shapes of the Best settings plan and apply (D745), used by the
+* `pipeline-orchestrator` cap. The recommender's own types
+* (`recommend.ts`, `demand.ts`) are the TS face of the same data; these
+* schemas are what crosses the cap boundary.
+*/
+var ModelFormatSchema$1 = zod.z.enum(MODEL_FORMATS);
+var HardwareClassIdSchema = zod.z.enum([
+	"intel-core-ultra",
+	"intel-n-series",
+	"apple-m-base",
+	"apple-m-pro",
+	"unknown"
+]);
+var AcceleratorKindSchema = zod.z.enum([
+	"intel-npu",
+	"intel-igpu",
+	"x86-cpu",
+	"arm-cpu",
+	"apple-ane",
+	"coral"
+]);
+var RecommendationReasonSchema = zod.z.discriminatedUnion("kind", [
+	zod.z.object({
+		kind: zod.z.literal("fits"),
+		utilisation: zod.z.number()
+	}),
+	zod.z.object({
+		kind: zod.z.literal("tie-faster"),
+		over: zod.z.string(),
+		recallDelta: zod.z.number()
+	}),
+	zod.z.object({
+		kind: zod.z.literal("stepped-down"),
+		from: zod.z.string(),
+		to: zod.z.string(),
+		limitedBy: zod.z.string()
+	}),
+	zod.z.object({
+		kind: zod.z.literal("no-fit-lightest"),
+		utilisation: zod.z.number()
+	}),
+	zod.z.object({
+		kind: zod.z.literal("derived-latency"),
+		modelId: zod.z.string()
+	}),
+	zod.z.object({
+		kind: zod.z.literal("estimated-load"),
+		observedForMs: zod.z.number().nullable()
+	}),
+	zod.z.object({ kind: zod.z.literal("cpu-device") }),
+	zod.z.object({ kind: zod.z.literal("coral-untouched") }),
+	zod.z.object({ kind: zod.z.literal("device-disabled") }),
+	zod.z.object({ kind: zod.z.literal("device-unavailable") }),
+	zod.z.object({ kind: zod.z.literal("node-offline") }),
+	zod.z.object({ kind: zod.z.literal("no-hardware-facts") }),
+	zod.z.object({
+		kind: zod.z.literal("no-measured-data"),
+		hardwareClass: HardwareClassIdSchema
+	}),
+	zod.z.object({
+		kind: zod.z.literal("no-family-build"),
+		format: ModelFormatSchema$1
+	})
+]);
+var DeviceDemandSchema = zod.z.object({
+	nodeId: zod.z.string(),
+	deviceKey: zod.z.string(),
+	demandFps: zod.z.number(),
+	maxCameraFps: zod.z.number(),
+	alwaysOnCameras: zod.z.number(),
+	onMotionSessions: zod.z.number(),
+	onMotionSource: zod.z.enum([
+		"observed-24h",
+		"estimate",
+		"none"
+	]),
+	observedForMs: zod.z.number().nullable()
+});
+var DeviceModelChoiceSchema = zod.z.object({
+	modelId: zod.z.string(),
+	p50Ms: zod.z.number(),
+	fps: zod.z.number(),
+	measured: zod.z.boolean(),
+	utilisation: zod.z.number(),
+	personRecall: zod.z.number()
+});
+var DeviceRecommendationSchema = zod.z.object({
+	deviceKey: zod.z.string(),
+	accelerator: AcceleratorKindSchema.nullable(),
+	enabled: zod.z.boolean(),
+	available: zod.z.boolean(),
+	demand: DeviceDemandSchema.nullable(),
+	chosen: DeviceModelChoiceSchema.nullable(),
+	reasons: zod.z.array(RecommendationReasonSchema).readonly()
+});
+var NodeRecommendationSchema = zod.z.object({
+	nodeId: zod.z.string(),
+	reachable: zod.z.boolean(),
+	hardwareClass: HardwareClassIdSchema.nullable(),
+	cpuModel: zod.z.string().nullable(),
+	skipped: zod.z.boolean(),
+	acceleratorModelId: zod.z.string().nullable(),
+	devices: zod.z.array(DeviceRecommendationSchema).readonly(),
+	reasons: zod.z.array(RecommendationReasonSchema).readonly()
+});
+var ModelPinChangeSchema = zod.z.object({
+	stepId: zod.z.string(),
+	before: zod.z.string().nullable(),
+	after: zod.z.string().nullable()
+});
+var NodeDeviceChangeSchema = zod.z.object({
+	nodeId: zod.z.string(),
+	deviceKey: zod.z.string(),
+	madeExplicit: zod.z.boolean(),
+	modelPins: zod.z.array(ModelPinChangeSchema).readonly(),
+	thresholds: zod.z.array(zod.z.object({
+		stepId: zod.z.string(),
+		keys: zod.z.array(zod.z.string()).readonly()
+	})).readonly()
+});
+var CameraOverrideClearSchema = zod.z.object({
+	deviceId: zod.z.number(),
+	source: zod.z.enum(["step-override", "wholesale"]),
+	nodeId: zod.z.string(),
+	deviceKey: zod.z.string().nullable(),
+	stepId: zod.z.string(),
+	modelIdBefore: zod.z.string().nullable(),
+	keys: zod.z.array(zod.z.string()).readonly()
+});
+var DetectorStoreClearSchema = zod.z.object({
+	deviceId: zod.z.number(),
+	keys: zod.z.array(zod.z.string()).readonly()
+});
+var BestSettingsWarningSchema = zod.z.discriminatedUnion("kind", [
+	zod.z.object({
+		kind: zod.z.literal("detector-store-cluster-wide"),
+		skippedNodes: zod.z.array(zod.z.string()).readonly()
+	}),
+	zod.z.object({
+		kind: zod.z.literal("detector-store-unreadable"),
+		error: zod.z.string()
+	}),
+	zod.z.object({
+		kind: zod.z.literal("coral-enabled"),
+		nodeId: zod.z.string(),
+		deviceKey: zod.z.string()
+	})
+]);
+var BestSettingsOptionsSchema = zod.z.object({ 
+/** Share of each accelerator's throughput kept free (0.3–0.5). */
+headroom: zod.z.number().min(.3).max(.5).default(.4) });
+var BestSettingsPlanSchema = zod.z.object({
+	/** Hash of everything the apply will write — the apply refuses a different one. */
+	planHash: zod.z.string(),
+	family: zod.z.literal("yolov9"),
+	headroom: zod.z.number(),
+	generatedAt: zod.z.number(),
+	nodes: zod.z.array(NodeRecommendationSchema).readonly(),
+	nodeChanges: zod.z.array(NodeDeviceChangeSchema).readonly(),
+	cameraClears: zod.z.array(CameraOverrideClearSchema).readonly(),
+	detectorStoreClears: zod.z.array(DetectorStoreClearSchema).readonly(),
+	warnings: zod.z.array(BestSettingsWarningSchema).readonly()
+});
+var BestSettingsApplyInputSchema = zod.z.object({
+	planHash: zod.z.string(),
+	headroom: zod.z.number().min(.3).max(.5).default(.4)
+});
+var BestSettingsPhaseResultSchema = zod.z.object({
+	phase: zod.z.enum([
+		"download",
+		"camera-overrides",
+		"detector-thresholds",
+		"node-models",
+		"redispatch"
+	]),
+	ok: zod.z.boolean(),
+	detail: zod.z.string()
+});
+var BestSettingsApplyResultSchema = zod.z.discriminatedUnion("kind", [
+	zod.z.object({
+		kind: zod.z.literal("applied"),
+		planHash: zod.z.string(),
+		phases: zod.z.array(BestSettingsPhaseResultSchema).readonly()
+	}),
+	zod.z.object({
+		kind: zod.z.literal("aborted"),
+		phases: zod.z.array(BestSettingsPhaseResultSchema).readonly()
+	}),
+	zod.z.object({
+		kind: zod.z.literal("stale"),
+		plan: BestSettingsPlanSchema
+	}),
+	zod.z.object({
+		kind: zod.z.literal("refused"),
+		reason: zod.z.enum(["apply-in-progress"])
+	})
+]);
+//#endregion
 //#region src/capabilities/schemas/orchestrator-metrics.ts
 /** Shared Zod schemas for the runtime pipeline orchestrator metrics. */
 var OrchestratorMetricsSchema = zod.z.object({
@@ -29619,6 +29879,27 @@ var pipelineOrchestratorCapability = {
 			kind: "mutation",
 			auth: "admin"
 		}),
+		/**
+		* Best settings (D745) — DRY RUN. Recommends ONE detector family (YOLOv9)
+		* for the whole cluster from each node's static hardware class, the
+		* measured latency table and the detection demand, and lists every write
+		* the apply would make: the node model pins set, the enrichment pins and
+		* model-bound thresholds removed (node level and per camera), and the
+		* per-camera detector thresholds cleared. Writes nothing. Step
+		* enablement, device enablement, pins, recording, notifications, zones and
+		* rules are never part of it. `planHash` names exactly this diff.
+		*/
+		planBestSettings: require_sleep.method(BestSettingsOptionsSchema, BestSettingsPlanSchema, { auth: "admin" }),
+		/**
+		* Best settings (D745) — APPLY the plan the operator confirmed. Recomputes
+		* the plan and refuses (`stale`, with the fresh plan) when its hash is not
+		* `planHash`, so what is written is exactly the confirmed diff. Offline
+		* nodes are skipped; there is no undo.
+		*/
+		applyBestSettings: require_sleep.method(BestSettingsApplyInputSchema, BestSettingsApplyResultSchema, {
+			kind: "mutation",
+			auth: "admin"
+		}),
 		/** Read one camera's settings. Null when never touched (inherits agent defaults fully). */
 		getCameraSettings: require_sleep.method(zod.z.object({ deviceId: zod.z.number() }), CameraPipelineSettingsSchema.nullable()),
 		/** Set or clear the 3-state toggle for one (camera, addonId). Pass `enabled: null` to clear and revert to agent default. */
@@ -55701,6 +55982,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "delete"
 	},
+	"pipelineExecutor.clearModelBoundDeviceOverrides": {
+		capName: "pipeline-executor",
+		capScope: "system",
+		addonId: null,
+		access: "delete"
+	},
 	"pipelineExecutor.deleteModel": {
 		capName: "pipeline-executor",
 		capScope: "system",
@@ -55917,6 +56204,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"pipelineOrchestrator.applyBestSettings": {
+		capName: "pipeline-orchestrator",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"pipelineOrchestrator.applyDeviceSettingsPatch": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
@@ -56091,6 +56384,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"pipelineOrchestrator.planBestSettings": {
+		capName: "pipeline-orchestrator",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"pipelineOrchestrator.rebalance": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
@@ -64865,6 +65164,11 @@ var METHOD_DEVICE_SELECTORS = Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"pipelineExecutor.clearModelBoundDeviceOverrides": [{
+		name: "deviceIds",
+		form: "array",
+		optional: true
+	}],
 	"pipelineExecutor.runPipeline": [{
 		name: "deviceId",
 		form: "single",
@@ -65932,6 +66236,7 @@ var SYSTEM_SCOPE_DEVICE_METHODS = [
 	"osdManager.previewSlot",
 	"osdManager.renderDevice",
 	"osdManager.setSlotBinding",
+	"pipelineExecutor.clearModelBoundDeviceOverrides",
 	"pipelineExecutor.runPipeline",
 	"pipelineExecutor.runPipelineBatch",
 	"pipelineOrchestrator.applyDeviceSettingsPatch",
@@ -66916,6 +67221,7 @@ function createSystemProxy(api) {
 			getVideoPipelineSteps: (input) => dispatch("pipelineExecutor", "getVideoPipelineSteps", "query", input),
 			setVideoPipelineSteps: (input) => dispatch("pipelineExecutor", "setVideoPipelineSteps", "mutation", input),
 			clearDeviceOverrides: (input) => dispatch("pipelineExecutor", "clearDeviceOverrides", "mutation", input),
+			clearModelBoundDeviceOverrides: (input) => dispatch("pipelineExecutor", "clearModelBoundDeviceOverrides", "mutation", input),
 			getInferenceDeviceHealth: (input) => dispatch("pipelineExecutor", "getInferenceDeviceHealth", "query", input),
 			rearmInferenceDevice: (input) => dispatch("pipelineExecutor", "rearmInferenceDevice", "mutation", input),
 			getSchema: (input) => dispatch("pipelineExecutor", "getSchema", "query", input),
@@ -66971,6 +67277,8 @@ function createSystemProxy(api) {
 			setAgentInferenceDevices: (input) => dispatch("pipelineOrchestrator", "setAgentInferenceDevices", "mutation", input),
 			getNodeInferenceDevices: (input) => dispatch("pipelineOrchestrator", "getNodeInferenceDevices", "query", input),
 			resetNodePipelineDefaults: (input) => dispatch("pipelineOrchestrator", "resetNodePipelineDefaults", "mutation", input),
+			planBestSettings: (input) => dispatch("pipelineOrchestrator", "planBestSettings", "query", input),
+			applyBestSettings: (input) => dispatch("pipelineOrchestrator", "applyBestSettings", "mutation", input),
 			getCameraStatuses: (input) => dispatch("pipelineOrchestrator", "getCameraStatuses", "query", input),
 			setCameraSensors: (input) => dispatch("pipelineOrchestrator", "setCameraSensors", "mutation", input),
 			reconcileFromDisk: (input) => dispatch("pipelineOrchestrator", "reconcileFromDisk", "mutation", input),
@@ -71843,41 +72151,6 @@ function isRemovedModelId(stepId, modelId) {
 }
 //#endregion
 //#region src/pipeline/model-bound-settings.ts
-/**
-* Model-bound step settings (D738): an operator value that is only meaningful
-* for ONE model, stored together with that model's id.
-*
-* The per-class confidence floors are the case it exists for. A score is a
-* property of one detector's output scale — on this hub the median score of a
-* correct person was 0.78 on `yolov9m-320-int8`, 0.68 on `yolo26s-320-int8`,
-* 0.40 on `yolo26n-320-int8` and 0.89 on `yolo26s` (640) — so a floor tuned on
-* one model is wrong on the next. The DEFAULT of such a field belongs to the
-* model (the catalog entry); an operator OVERRIDE belongs to the model it was
-* made for.
-*
-* The binding is checked at READ time against the model that RUNS, never
-* enforced by a write on the model-change path: a model can change without any
-* operator write at all (an unpinned root follows the elected device's
-* hardware-aware default, D736), and an event-driven reset could be dropped
-* (events are telemetry, D8/D11). So:
-*
-*   effective = override   when the stored binding names the running model
-*             | override   when no binding is stored (a legacy / programmatic
-*                          value — it applies to whatever runs, as before D738)
-*             | the running model's default, when it declares one
-*             | the field's global default.
-*
-* Storage shape: the value stays a plain number under its own key (every
-* reader of the raw settings bag keeps working), and the binding is a SIBLING
-* key, {@link modelBindingKey}. Both are flat so the shallow per-key merges of
-* the settings layers (node fold, camera override) carry a value and its
-* binding together whenever one layer writes both — which every writer here
-* does.
-*
-* Lives in the bare `@camstack/types` entry, which every addon bundles, so the
-* runner (`addon-pipeline`) and the editors (`ui-library`, `addon-admin-ui`)
-* apply the same rule.
-*/
 /** Suffix of the sibling key that names the model a stored value was made for. */
 var MODEL_BINDING_SUFFIX = "ModelId";
 /** `minConfidencePerson` → `minConfidencePersonModelId`. */
@@ -71966,6 +72239,838 @@ function hasModelBoundOverrides(settings, boundKeys, modelId) {
 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 Best settings (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/best-settings/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;
+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
+	};
+	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 === "cpu" || device === "cpu") return hw.arch === "arm64" ? "arm-cpu" : "x86-cpu";
+	return null;
+}
+//#endregion
+//#region src/pipeline/best-settings/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
+			}
+		}
+	},
+	"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
+			}
+		}
+	},
+	"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
+		}
+	} },
+	"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
+		}
+	} }
+};
+var DETECTOR_ACCURACY = {
+	"yolov9m-320": {
+		personPrecision: .979,
+		personRecall: .649
+	},
+	"yolov9m-320-int8": {
+		personPrecision: .974,
+		personRecall: .684
+	},
+	"yolov9m-640": {
+		personPrecision: .976,
+		personRecall: .854
+	},
+	"yolov9m-640-int8": {
+		personPrecision: .976,
+		personRecall: .847
+	},
+	"yolov9s-320": {
+		personPrecision: .958,
+		personRecall: .479
+	},
+	"yolov9s-320-int8": {
+		personPrecision: .969,
+		personRecall: .438
+	},
+	"yolov9s-640": {
+		personPrecision: .986,
+		personRecall: .753
+	},
+	"yolov9s-640-int8": {
+		personPrecision: .963,
+		personRecall: .823
+	},
+	"yolov9t-320": {
+		personPrecision: .946,
+		personRecall: .368
+	},
+	"yolov9t-320-int8": {
+		personPrecision: .943,
+		personRecall: .347
+	},
+	"yolov9t-640": {
+		personPrecision: .979,
+		personRecall: .646
+	},
+	"yolov9t-640-int8": {
+		personPrecision: .979,
+		personRecall: .646
+	}
+};
+//#endregion
+//#region src/pipeline/best-settings/demand.ts
+var DEFAULT_DEMAND_OPTIONS = {
+	onMotionConcurrency: .25,
+	onMotionMinConcurrent: 2
+};
+/** A full observation window. */
+var OBSERVATION_WINDOW_MS = 1440 * 60 * 1e3;
+function deviceId(nodeId, deviceKey) {
+	return `${nodeId}\u0000${deviceKey}`;
+}
+function charges(load) {
+	return load.mode !== "disabled" && load.runsPipelineRoot && load.fps > 0;
+}
+/** The highest `count` rates, summed. */
+function topRatesSum(rates, count) {
+	return rates.toSorted((a, b) => b - a).slice(0, Math.max(0, count)).reduce((sum, r) => sum + r, 0);
+}
+/** Concurrent on-motion sessions assumed cluster-wide without an observation. */
+function estimatedConcurrentSessions(cameraCount, options) {
+	if (cameraCount <= 0) return 0;
+	const share = Math.ceil(options.onMotionConcurrency * cameraCount);
+	return Math.min(cameraCount, Math.max(share, Math.min(cameraCount, options.onMotionMinConcurrent)));
+}
+/**
+* Demand on every eligible device of the cluster.
+*/
+function estimateDeviceDemand(input) {
+	const options = input.options ?? DEFAULT_DEMAND_OPTIONS;
+	const eligibleById = new Map(input.eligible.map((d) => [deviceId(d.nodeId, d.deviceKey), d]));
+	const peakById = new Map(input.peaks.map((p) => [deviceId(p.nodeId, p.deviceKey), p]));
+	const weightByNode = /* @__PURE__ */ new Map();
+	const eligibleCountByNode = /* @__PURE__ */ new Map();
+	for (const d of input.eligible) {
+		weightByNode.set(d.nodeId, (weightByNode.get(d.nodeId) ?? 0) + Math.max(d.weight, 0));
+		eligibleCountByNode.set(d.nodeId, (eligibleCountByNode.get(d.nodeId) ?? 0) + 1);
+	}
+	const pinnedFps = /* @__PURE__ */ new Map();
+	const alwaysOnFps = /* @__PURE__ */ new Map();
+	const alwaysOnCount = /* @__PURE__ */ new Map();
+	const maxFps = /* @__PURE__ */ new Map();
+	const onMotionRates = [];
+	const bump = (map, key, by) => {
+		map.set(key, (map.get(key) ?? 0) + by);
+	};
+	const noteMax = (key, fps) => {
+		maxFps.set(key, Math.max(maxFps.get(key) ?? 0, fps));
+	};
+	for (const cam of input.cameras) {
+		if (!charges(cam)) continue;
+		if (cam.devicePin !== null) {
+			const key = deviceId(cam.devicePin.nodeId, cam.devicePin.deviceKey);
+			if (!eligibleById.has(key)) continue;
+			bump(pinnedFps, key, cam.fps);
+			noteMax(key, cam.fps);
+			continue;
+		}
+		if (cam.mode === "always-on" && cam.standingNodeId !== null) {
+			const nodeWeight = weightByNode.get(cam.standingNodeId) ?? 0;
+			for (const d of input.eligible) {
+				if (d.nodeId !== cam.standingNodeId || nodeWeight <= 0) continue;
+				const key = deviceId(d.nodeId, d.deviceKey);
+				const share = Math.max(d.weight, 0) / nodeWeight;
+				bump(alwaysOnFps, key, cam.fps * share);
+				bump(alwaysOnCount, key, share);
+				noteMax(key, cam.fps);
+			}
+			continue;
+		}
+		onMotionRates.push(cam.fps);
+	}
+	const fastestOnMotion = onMotionRates.reduce((m, r) => Math.max(m, r), 0);
+	const nodeCount = weightByNode.size;
+	const estimatedTotal = estimatedConcurrentSessions(onMotionRates.length, options);
+	return input.eligible.map((d) => {
+		const key = deviceId(d.nodeId, d.deviceKey);
+		const peak = peakById.get(key) ?? (eligibleCountByNode.get(d.nodeId) === 1 ? peakById.get(deviceId(d.nodeId, "")) : void 0);
+		const alwaysOn = alwaysOnCount.get(key) ?? 0;
+		let onMotionSessions = 0;
+		let onMotionSource = "none";
+		if (onMotionRates.length > 0) if (peak !== void 0 && peak.observedForMs >= 864e5) {
+			onMotionSessions = Math.max(0, Math.round(peak.peakSessions - alwaysOn));
+			onMotionSource = "observed-24h";
+		} else {
+			const nodeWeight = weightByNode.get(d.nodeId) ?? 0;
+			const share = nodeCount > 0 && nodeWeight > 0 ? Math.max(d.weight, 0) / nodeWeight / nodeCount : 0;
+			onMotionSessions = Math.ceil(estimatedTotal * share);
+			onMotionSource = "estimate";
+		}
+		const demandFps = (pinnedFps.get(key) ?? 0) + (alwaysOnFps.get(key) ?? 0) + topRatesSum(onMotionRates, onMotionSessions);
+		return {
+			nodeId: d.nodeId,
+			deviceKey: d.deviceKey,
+			demandFps: Math.round(demandFps * 100) / 100,
+			maxCameraFps: Math.max(maxFps.get(key) ?? 0, fastestOnMotion),
+			alwaysOnCameras: Math.round(alwaysOn * 100) / 100,
+			onMotionSessions,
+			onMotionSource,
+			observedForMs: peak?.observedForMs ?? null
+		};
+	}).toSorted((a, b) => a.nodeId === b.nodeId ? a.deviceKey.localeCompare(b.deviceKey) : a.nodeId.localeCompare(b.nodeId));
+}
+//#endregion
+//#region src/pipeline/best-settings/recommend.ts
+/** The family the cluster runs. */
+var BEST_SETTINGS_FAMILY = "yolov9";
+/** Recall within this of the best counts as a tie — the faster one wins. */
+var RECALL_TIE = .02;
+/** Default share of an accelerator's throughput kept free. */
+var DEFAULT_HEADROOM = .4;
+function round(value, digits = 3) {
+	const f = 10 ** digits;
+	return Math.round(value * f) / f;
+}
+function utilisationOf(cell, demand) {
+	return cell.fps > 0 ? round((demand?.demandFps ?? 0) / cell.fps) : Number.POSITIVE_INFINITY;
+}
+function fitsOn(cell, demand, headroom) {
+	const budget = cell.fps * (1 - headroom);
+	return budget >= (demand?.demandFps ?? 0) && budget >= (demand?.maxCameraFps ?? 0);
+}
+function candidatesFor(contexts, formatsByModel) {
+	return Object.keys(DETECTOR_ACCURACY).filter((id) => id.startsWith(BEST_SETTINGS_FAMILY)).filter((id) => contexts.every((c) => c.column[id] !== void 0 && (formatsByModel[id] ?? []).includes(c.device.format))).map((id) => ({
+		modelId: id,
+		personRecall: DETECTOR_ACCURACY[id]?.personRecall ?? 0
+	})).toSorted((a, b) => b.personRecall - a.personRecall || a.modelId.localeCompare(b.modelId));
+}
+function totalLatency(contexts, modelId) {
+	return contexts.reduce((sum, c) => sum + (c.column[modelId]?.p50Ms ?? Number.POSITIVE_INFINITY), 0);
+}
+function worstUtilisation(contexts, modelId) {
+	return contexts.reduce((worst, c) => {
+		const cell = c.column[modelId];
+		return Math.max(worst, cell ? utilisationOf(cell, c.demand) : Number.POSITIVE_INFINITY);
+	}, 0);
+}
+/** One model for a group of devices that must agree (step 2–4 of the header). */
+function pickForGroup(contexts, formatsByModel, headroom) {
+	const candidates = candidatesFor(contexts, formatsByModel);
+	if (candidates.length === 0) return null;
+	const fitting = candidates.filter((c) => contexts.every((ctx) => {
+		const cell = ctx.column[c.modelId];
+		return cell !== void 0 && fitsOn(cell, ctx.demand, headroom);
+	}));
+	if (fitting.length === 0) {
+		const lightest = candidates.toSorted((a, b) => worstUtilisation(contexts, a.modelId) - worstUtilisation(contexts, b.modelId))[0];
+		if (lightest === void 0) return null;
+		return {
+			modelId: lightest.modelId,
+			reasons: [{
+				kind: "no-fit-lightest",
+				utilisation: worstUtilisation(contexts, lightest.modelId)
+			}]
+		};
+	}
+	const best = fitting[0];
+	if (best === void 0) return null;
+	const chosen = fitting.filter((c) => best.personRecall - c.personRecall <= .02).toSorted((a, b) => totalLatency(contexts, a.modelId) - totalLatency(contexts, b.modelId) || b.personRecall - a.personRecall)[0] ?? best;
+	const reasons = [];
+	const mostAccurate = candidates[0];
+	if (mostAccurate !== void 0 && mostAccurate.modelId !== best.modelId) {
+		const limitedBy = contexts.find((ctx) => {
+			const cell = ctx.column[mostAccurate.modelId];
+			return cell === void 0 || !fitsOn(cell, ctx.demand, headroom);
+		})?.device.key ?? "";
+		reasons.push({
+			kind: "stepped-down",
+			from: mostAccurate.modelId,
+			to: best.modelId,
+			limitedBy
+		});
+	}
+	if (chosen.modelId !== best.modelId) reasons.push({
+		kind: "tie-faster",
+		over: best.modelId,
+		recallDelta: round(best.personRecall - chosen.personRecall)
+	});
+	return {
+		modelId: chosen.modelId,
+		reasons
+	};
+}
+function choiceOn(ctx, modelId) {
+	const cell = ctx.column[modelId];
+	if (cell === void 0) return null;
+	return {
+		modelId,
+		p50Ms: cell.p50Ms,
+		fps: cell.fps,
+		measured: cell.measured,
+		utilisation: utilisationOf(cell, ctx.demand),
+		personRecall: DETECTOR_ACCURACY[modelId]?.personRecall ?? 0
+	};
+}
+function deviceReasonsFor(ctx, choice) {
+	const out = [{
+		kind: "fits",
+		utilisation: choice.utilisation
+	}];
+	if (!choice.measured) out.push({
+		kind: "derived-latency",
+		modelId: choice.modelId
+	});
+	if (ctx.demand?.onMotionSource === "estimate") out.push({
+		kind: "estimated-load",
+		observedForMs: ctx.demand.observedForMs
+	});
+	return out;
+}
+function skippedNode(node, reason, hardwareClass) {
+	return {
+		nodeId: node.nodeId,
+		reachable: node.reachable,
+		hardwareClass,
+		cpuModel: node.hardware?.cpuModel ?? null,
+		skipped: true,
+		acceleratorModelId: null,
+		devices: node.devices.map((d) => ({
+			deviceKey: d.key,
+			accelerator: node.hardware ? acceleratorKindOf(d.key, node.hardware) : null,
+			enabled: d.enabled,
+			available: d.available,
+			demand: null,
+			chosen: null,
+			reasons: []
+		})),
+		reasons: [reason]
+	};
+}
+/** Recommend one node. See the module header. */
+function recommendNode(input) {
+	const { node } = input;
+	const headroom = input.headroom ?? .4;
+	const perf = input.perf ?? DETECTOR_PERF;
+	if (!node.reachable) return skippedNode(node, { kind: "node-offline" }, null);
+	if (node.hardware === null) return skippedNode(node, { kind: "no-hardware-facts" }, null);
+	const hardware = node.hardware;
+	const { hardwareClass, cpuModel } = classifyInferenceHardware(hardware);
+	const classTable = perf[hardwareClass];
+	if (hardwareClass === "unknown" || classTable === void 0) return skippedNode(node, {
+		kind: "no-measured-data",
+		hardwareClass
+	}, hardwareClass);
+	const demandByKey = new Map(input.demand.filter((d) => d.nodeId === node.nodeId).map((d) => [d.deviceKey, d]));
+	const devices = node.devices.toSorted((a, b) => a.key.localeCompare(b.key));
+	const contexts = /* @__PURE__ */ new Map();
+	const early = /* @__PURE__ */ new Map();
+	for (const device of devices) {
+		const accelerator = acceleratorKindOf(device.key, hardware);
+		if (accelerator === "coral") {
+			early.set(device.key, device.enabled ? [{ kind: "coral-untouched" }] : []);
+			continue;
+		}
+		if (!device.enabled) {
+			early.set(device.key, [{ kind: "device-disabled" }]);
+			continue;
+		}
+		if (!device.available) {
+			early.set(device.key, [{ kind: "device-unavailable" }]);
+			continue;
+		}
+		const column = accelerator === null ? void 0 : classTable[accelerator];
+		if (accelerator === null || column === void 0) {
+			early.set(device.key, [{
+				kind: "no-family-build",
+				format: device.format
+			}]);
+			continue;
+		}
+		contexts.set(device.key, {
+			device,
+			accelerator,
+			column,
+			demand: demandByKey.get(device.key) ?? null
+		});
+	}
+	const isCpu = (a) => a === "x86-cpu" || a === "arm-cpu";
+	const accelerators = [...contexts.values()].filter((c) => !isCpu(c.accelerator));
+	const cpus = [...contexts.values()].filter((c) => isCpu(c.accelerator));
+	const chosenByKey = /* @__PURE__ */ new Map();
+	const reasonsByKey = /* @__PURE__ */ new Map();
+	const nodeReasons = [];
+	let acceleratorModelId = null;
+	const groupPick = accelerators.length > 0 ? pickForGroup(accelerators, node.formatsByModel, headroom) : null;
+	if (groupPick !== null) {
+		acceleratorModelId = groupPick.modelId;
+		nodeReasons.push(...groupPick.reasons);
+		for (const ctx of accelerators) {
+			const choice = choiceOn(ctx, groupPick.modelId);
+			if (choice === null) continue;
+			chosenByKey.set(ctx.device.key, choice);
+			reasonsByKey.set(ctx.device.key, deviceReasonsFor(ctx, choice));
+		}
+	} else for (const ctx of accelerators) reasonsByKey.set(ctx.device.key, [{
+		kind: "no-family-build",
+		format: ctx.device.format
+	}]);
+	for (const ctx of cpus) {
+		const pick = pickForGroup([ctx], node.formatsByModel, headroom);
+		const choice = pick === null ? null : choiceOn(ctx, pick.modelId);
+		if (pick === null || choice === null) {
+			reasonsByKey.set(ctx.device.key, [{
+				kind: "no-family-build",
+				format: ctx.device.format
+			}]);
+			continue;
+		}
+		chosenByKey.set(ctx.device.key, choice);
+		reasonsByKey.set(ctx.device.key, [
+			{ kind: "cpu-device" },
+			...pick.reasons,
+			...deviceReasonsFor(ctx, choice)
+		]);
+	}
+	return {
+		nodeId: node.nodeId,
+		reachable: true,
+		hardwareClass,
+		cpuModel,
+		skipped: chosenByKey.size === 0,
+		acceleratorModelId,
+		devices: devices.map((device) => ({
+			deviceKey: device.key,
+			accelerator: acceleratorKindOf(device.key, hardware),
+			enabled: device.enabled,
+			available: device.available,
+			demand: demandByKey.get(device.key) ?? null,
+			chosen: chosenByKey.get(device.key) ?? null,
+			reasons: early.get(device.key) ?? reasonsByKey.get(device.key) ?? []
+		})),
+		reasons: nodeReasons
+	};
+}
 //#endregion
 //#region src/pipeline/root-face-crop.ts
 /** Side of the square, as a multiple of the face box's longer side. */
@@ -74111,6 +75216,7 @@ exports.AUDIO_PRESETS = require_composition.AUDIO_PRESETS;
 exports.AUDIO_SCALE_EPOCH_ISO = AUDIO_SCALE_EPOCH_ISO;
 exports.AUDIO_SCALE_EPOCH_MS = AUDIO_SCALE_EPOCH_MS;
 exports.AUTOMATIC_HUB_ADDRESS_FLAGS = AUTOMATIC_HUB_ADDRESS_FLAGS;
+exports.AcceleratorKindSchema = AcceleratorKindSchema;
 exports.AccessoriesStatusSchema = AccessoriesStatusSchema;
 exports.AccessoryKind = AccessoryKind;
 exports.AddBrokerInputSchema = AddBrokerInputSchema;
@@ -74189,6 +75295,7 @@ exports.BASE_DEVICE_CAPS = BASE_DEVICE_CAPS;
 exports.BASE_LIVE_EGRESS_PROFILE = BASE_LIVE_EGRESS_PROFILE;
 exports.BATTERY_DEVICE_PROFILE = BATTERY_DEVICE_PROFILE;
 exports.BATTERY_UNREACHABLE_AFTER_MS = BATTERY_UNREACHABLE_AFTER_MS;
+exports.BEST_SETTINGS_FAMILY = BEST_SETTINGS_FAMILY;
 exports.BIRTH_DECISION_DEFAULT_LIMIT = BIRTH_DECISION_DEFAULT_LIMIT;
 exports.BOOT_RECOVERY_BACKOFF_MS = require_sleep.BOOT_RECOVERY_BACKOFF_MS;
 exports.BUILTIN_RESULT_KINDS = BUILTIN_RESULT_KINDS;
@@ -74204,6 +75311,12 @@ exports.BaseAddon = require_sleep.BaseAddon;
 exports.BaseDevice = BaseDevice;
 exports.BaseDeviceProvider = BaseDeviceProvider;
 exports.BatteryStatusSchema = BatteryStatusSchema;
+exports.BestSettingsApplyInputSchema = BestSettingsApplyInputSchema;
+exports.BestSettingsApplyResultSchema = BestSettingsApplyResultSchema;
+exports.BestSettingsOptionsSchema = BestSettingsOptionsSchema;
+exports.BestSettingsPhaseResultSchema = BestSettingsPhaseResultSchema;
+exports.BestSettingsPlanSchema = BestSettingsPlanSchema;
+exports.BestSettingsWarningSchema = BestSettingsWarningSchema;
 exports.BinaryStatusSchema = BinaryStatusSchema;
 exports.BirthDecisionQueryInputSchema = BirthDecisionQueryInputSchema;
 exports.BirthDecisionRecordSchema = BirthDecisionRecordSchema;
@@ -74306,6 +75419,7 @@ exports.CameraMetricsSchema = CameraMetricsSchema;
 exports.CameraMetricsWithDeviceIdSchema = CameraMetricsWithDeviceIdSchema;
 exports.CameraMotionStatusSchema = CameraMotionStatusSchema;
 exports.CameraOccupancySnapshotForDeviceSchema = CameraOccupancySnapshotForDeviceSchema;
+exports.CameraOverrideClearSchema = CameraOverrideClearSchema;
 exports.CameraOwnMotionSchema = CameraOwnMotionSchema;
 exports.CameraRawLevelSchema = CameraRawLevelSchema;
 exports.CameraRecordingModeSchema = CameraRecordingModeSchema;
@@ -74463,11 +75577,13 @@ exports.DEFAULT_CLUSTER_STEP_MODELS = DEFAULT_CLUSTER_STEP_MODELS;
 exports.DEFAULT_CLUSTER_STEP_SETTINGS = DEFAULT_CLUSTER_STEP_SETTINGS;
 exports.DEFAULT_CORE_BLOCK_ENTRY = DEFAULT_CORE_BLOCK_ENTRY;
 exports.DEFAULT_DECODER_HWACCEL_CONFIG = DEFAULT_DECODER_HWACCEL_CONFIG;
+exports.DEFAULT_DEMAND_OPTIONS = DEFAULT_DEMAND_OPTIONS;
 exports.DEFAULT_DETAIL_CROP_CONVENTION = DEFAULT_DETAIL_CROP_CONVENTION;
 exports.DEFAULT_EVENTS_BAND_BUFFER_SEC = DEFAULT_EVENTS_BAND_BUFFER_SEC;
 exports.DEFAULT_EVENT_COLOR = DEFAULT_EVENT_COLOR;
 exports.DEFAULT_FEATURES = DEFAULT_FEATURES;
 exports.DEFAULT_FIRST_SIGHTING_FRESHNESS_MS = require_composition.DEFAULT_FIRST_SIGHTING_FRESHNESS_MS;
+exports.DEFAULT_HEADROOM = DEFAULT_HEADROOM;
 exports.DEFAULT_MIN_LANDMARK_FACE_SIZE_PX = DEFAULT_MIN_LANDMARK_FACE_SIZE_PX;
 exports.DEFAULT_NATIVE_LEASE_SETTINGS = DEFAULT_NATIVE_LEASE_SETTINGS;
 exports.DEFAULT_OVERLAY_LAYERS = DEFAULT_OVERLAY_LAYERS;
@@ -74484,6 +75600,8 @@ exports.DETAIL_CROP_SECTION_ID = DETAIL_CROP_SECTION_ID;
 exports.DETAIL_CROP_SQUARE_KEY = DETAIL_CROP_SQUARE_KEY;
 exports.DETECTION_MACRO_CLASSES = DETECTION_MACRO_CLASSES;
 exports.DETECTION_PIPELINE_CAP_NAME = DETECTION_PIPELINE_CAP_NAME;
+exports.DETECTOR_ACCURACY = DETECTOR_ACCURACY;
+exports.DETECTOR_PERF = DETECTOR_PERF;
 exports.DEVICE_BACKEND_TO_FORMAT = DEVICE_BACKEND_TO_FORMAT;
 exports.DEVICE_CAP_NAMES = DEVICE_CAP_NAMES;
 exports.DEVICE_CHILDREN_BATCH_MAX = require_sleep.DEVICE_CHILDREN_BATCH_MAX;
@@ -74521,16 +75639,20 @@ exports.DetailCropConventionSchema = DetailCropConventionSchema;
 exports.DetectionCatalogClassMapSchema = DetectionCatalogClassMapSchema;
 exports.DetectionSourceSchema = DetectionSourceSchema;
 exports.DetectionSourcesSchema = DetectionSourcesSchema;
+exports.DetectorStoreClearSchema = DetectorStoreClearSchema;
 exports.DeviceAdminLinkSchema = DeviceAdminLinkSchema;
 exports.DeviceCodeSeveritySchema = DeviceCodeSeveritySchema;
 exports.DeviceConfig = DeviceConfig;
+exports.DeviceDemandSchema = DeviceDemandSchema;
 exports.DeviceDiscoveryStatusSchema = DeviceDiscoveryStatusSchema;
 exports.DeviceExportExposeInputSchema = ExposeInputSchema;
 exports.DeviceExportStatusSchema = DeviceExportStatusSchema;
 exports.DeviceExportUnexposeInputSchema = UnexposeInputSchema;
 exports.DeviceFeature = require_err_msg.DeviceFeature;
 exports.DeviceInfoSchema = DeviceInfoSchema;
+exports.DeviceModelChoiceSchema = DeviceModelChoiceSchema;
 exports.DeviceNetworkStatsSchema = DeviceNetworkStatsSchema;
+exports.DeviceRecommendationSchema = DeviceRecommendationSchema;
 exports.DeviceRestoreRetryScheduler = DeviceRestoreRetryScheduler;
 exports.DeviceRole = require_err_msg.DeviceRole;
 exports.DeviceRuntimeState = DeviceRuntimeState;
@@ -74683,6 +75805,7 @@ exports.HOURS_PER_DAY = HOURS_PER_DAY;
 exports.HUB_ADDRESS_ROLES = HUB_ADDRESS_ROLES;
 exports.HUB_VIEWER_MOUNT = HUB_VIEWER_MOUNT;
 exports.HWACCEL_OPTIONS = HWACCEL_OPTIONS;
+exports.HardwareClassIdSchema = HardwareClassIdSchema;
 exports.HealthStatusSchema = HealthStatusSchema;
 exports.HfModelResolutionSchema = HfModelResolutionSchema;
 exports.HistoryPointSchema = HistoryPointSchema;
@@ -74865,8 +75988,11 @@ exports.ModelDistributeInputSchema = ModelDistributeInputSchema;
 exports.ModelDistributeResultSchema = ModelDistributeResultSchema;
 exports.ModelExtraFileSchema = ModelExtraFileSchema;
 exports.ModelFormatEntrySchema = ModelFormatEntrySchema;
+exports.ModelFormatPrecisionSchema = ModelFormatPrecisionSchema;
 exports.ModelFormatsSchema = ModelFormatsSchema;
 exports.ModelLicenseSchema = ModelLicenseSchema;
+exports.ModelOnDiskStateSchema = ModelOnDiskStateSchema;
+exports.ModelPinChangeSchema = ModelPinChangeSchema;
 exports.ModelProviderIdSchema = ModelProviderIdSchema;
 exports.ModelSubstitutionSchema = ModelSubstitutionSchema;
 exports.ModelVariantGroupSchema = ModelVariantGroupSchema;
@@ -75103,14 +76229,17 @@ exports.NetworkAccessStatusSchema = NetworkAccessStatusSchema;
 exports.NetworkAddressSchema = NetworkAddressSchema;
 exports.NetworkEndpointSchema = NetworkEndpointSchema;
 exports.NetworkLinkStatusSchema = NetworkLinkStatusSchema;
+exports.NodeDeviceChangeSchema = NodeDeviceChangeSchema;
 exports.NodeDirectoryEntrySchema = NodeDirectoryEntrySchema;
 exports.NodeDirectorySchema = NodeDirectorySchema;
+exports.NodeRecommendationSchema = NodeRecommendationSchema;
 exports.NotificationActionIconSchema = NotificationActionIconSchema;
 exports.NotificationActionSchema = NotificationActionSchema;
 exports.NotificationFormatSchema = NotificationFormatSchema;
 exports.NotificationSchema = NotificationSchema;
 exports.NotifierStatusSchema = NotifierStatusSchema;
 exports.NumericSensorStatusSchema = NumericSensorStatusSchema;
+exports.OBSERVATION_WINDOW_MS = OBSERVATION_WINDOW_MS;
 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;
@@ -75184,6 +76313,7 @@ exports.PickedCamStreamSchema = PickedCamStreamSchema;
 exports.PipelineAssignmentSchema = PipelineAssignmentSchema;
 exports.PipelineDefaultStepSchema = PipelineDefaultStepSchema;
 exports.PipelineEngineChoiceSchema = PipelineEngineChoiceSchema;
+exports.PipelineModelFormatStatusSchema = PipelineModelFormatStatusSchema;
 exports.PipelineRunResultBridge = PipelineRunResultBridge;
 exports.PipelineStepInputSchema = PipelineStepInputSchema;
 exports.PipelineValidationIssueSchema = PipelineValidationIssueSchema;
@@ -75223,6 +76353,7 @@ exports.RATE_CONTROL_TIGHT = RATE_CONTROL_TIGHT;
 exports.REACHABILITY_FAILURES_TO_OFFLINE = REACHABILITY_FAILURES_TO_OFFLINE;
 exports.REACHABILITY_POLL_INTERVAL_MS = REACHABILITY_POLL_INTERVAL_MS;
 exports.REACHABILITY_PROBE_TIMEOUT_MS = REACHABILITY_PROBE_TIMEOUT_MS;
+exports.RECALL_TIE = RECALL_TIE;
 exports.RECOGNITION_TYPES = RECOGNITION_TYPES;
 exports.RECORDING_AUDIO_TRIGGER_OFFERED_DBFS = RECORDING_AUDIO_TRIGGER_OFFERED_DBFS;
 exports.RECORDING_EXPORT_MAX_READ_BYTES = RECORDING_EXPORT_MAX_READ_BYTES;
@@ -75255,6 +76386,7 @@ exports.ReadinessTimeoutError = require_sleep.ReadinessTimeoutError;
 exports.RebuildObjectEmbeddingsRefusalSchema = RebuildObjectEmbeddingsRefusalSchema;
 exports.RecentTracksPageSchema = RecentTracksPageSchema;
 exports.RecentTracksQueryInput = RecentTracksQueryInput;
+exports.RecommendationReasonSchema = RecommendationReasonSchema;
 exports.RecordTriggerSchema = RecordTriggerSchema;
 exports.RecordWindowSchema = RecordWindowSchema;
 exports.RecordingAvailabilityForDeviceSchema = RecordingAvailabilityForDeviceSchema;
@@ -75610,6 +76742,7 @@ exports.ZoneRulesArraySchema = ZoneRulesArraySchema;
 exports.ZoneSchema = ZoneSchema;
 exports.ZoneScopeBreakdownSchema = ZoneScopeBreakdownSchema;
 exports.__resetLogChannelRegistryForTests = __resetLogChannelRegistryForTests;
+exports.acceleratorKindOf = acceleratorKindOf;
 exports.accessoriesCapability = accessoriesCapability;
 exports.accessoryStableId = accessoryStableId;
 exports.actionsForBoundCaps = actionsForBoundCaps;
@@ -75701,6 +76834,7 @@ exports.carbonMonoxideCapability = carbonMonoxideCapability;
 exports.cellsToRects = cellsToRects;
 exports.checkRoleAddress = checkRoleAddress;
 exports.classifyBearerPrincipal = classifyBearerPrincipal;
+exports.classifyInferenceHardware = classifyInferenceHardware;
 exports.classifyStream = classifyStream;
 exports.classifyStreams = classifyStreams;
 exports.clearModelBoundOverrides = clearModelBoundOverrides;
@@ -75717,6 +76851,7 @@ exports.clusterStepSettingKey = clusterStepSettingKey;
 exports.codecIsAccepted = codecIsAccepted;
 exports.collectHydratedFieldEntries = require_sleep.collectHydratedFieldEntries;
 exports.collectHydratedFieldValues = require_sleep.collectHydratedFieldValues;
+exports.collectModelBoundKeys = collectModelBoundKeys;
 exports.collectSecretConfigKeys = collectSecretConfigKeys;
 exports.colorCapability = colorCapability;
 exports.colorForKind = colorForKind;
@@ -75848,6 +76983,8 @@ exports.enumerateInferenceDevices = enumerateInferenceDevices;
 exports.enumerateItemArrayFields = enumerateItemArrayFields;
 exports.enumerateSchemaFields = enumerateSchemaFields;
 exports.errMsg = require_err_msg.errMsg;
+exports.estimateDeviceDemand = estimateDeviceDemand;
+exports.estimatedConcurrentSessions = estimatedConcurrentSessions;
 exports.evaluateAst = require_composition.evaluateAst;
 exports.evaluateCompositionField = evaluateCompositionField;
 exports.evaluateCount = require_composition.evaluateCount;
@@ -76130,6 +77267,7 @@ exports.readTimelapseGeneratedAt = readTimelapseGeneratedAt;
 exports.readUseRootModel = readUseRootModel;
 exports.readinessKey = require_sleep.readinessKey;
 exports.rebootCapability = rebootCapability;
+exports.recommendNode = recommendNode;
 exports.reconcileBlockDevices = reconcileBlockDevices;
 exports.recordingArchiveCapability = recordingArchiveCapability;
 exports.recordingCapability = recordingCapability;