@camstack/types 1.2.316 → 1.2.318

package/dist/index.js

@@ -5731,6 +5731,40 @@ var ModelFormatEntrySchema = zod.z.object({
 	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}`.
 */
@@ -26545,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",
@@ -26563,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()
 });
 /**
@@ -26621,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(),
@@ -26839,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).
 		*
@@ -26933,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
@@ -27185,6 +27242,319 @@ var pipelineExecutorCapability = {
 	}
 };
 //#endregion
+//#region src/pipeline/load-balancing/schemas.ts
+/**
+* Wire shapes of the Load balancing surface (D748): the session placement
+* policy, the atomic share write, the observed placement statistics, the
+* hardware share suggestion and the stale device pins.
+*/
+/**
+* How a new detection session picks its node and device.
+*  - `least-loaded` — the historical rule: lowest `attached / weight`, a
+*    constant node order at a tie (D37). An idle node always ties at 0, so a
+*    weight only bites once a node already holds a session.
+*  - `share` — the share of PARALLEL sessions is held to the weights, and a
+*    full or drowning node yields to a free one (D748).
+*/
+var SessionPlacementPolicySchema = zod.z.enum(["least-loaded", "share"]);
+var DEFAULT_SESSION_PLACEMENT_POLICY = "least-loaded";
+/** The global-settings key the policy is stored under (orchestrator `load` section). */
+var SESSION_PLACEMENT_SETTING_KEY = "sessionPlacement";
+/** Parse a stored value; anything unknown is the default (nothing changes on deploy). */
+function parseSessionPlacementPolicy(value) {
+	const parsed = SessionPlacementPolicySchema.safeParse(value);
+	return parsed.success ? parsed.data : DEFAULT_SESSION_PLACEMENT_POLICY;
+}
+var LoadBalancingSharesInputSchema = zod.z.object({
+	/** nodeId → share (> 0). A node left out keeps its weight. */
+	nodes: zod.z.record(zod.z.string(), zod.z.number().positive()).default({}),
+	/** nodeId → deviceKey → share (> 0). A device left out keeps its weight. */
+	devices: zod.z.record(zod.z.string(), zod.z.record(zod.z.string(), zod.z.number().positive())).default({})
+});
+var PlacementStatsInputSchema = zod.z.object({ 
+/** Window the observed shares are averaged over (default 1 h, max 24 h). */
+windowMs: zod.z.number().int().min(6e4).max(1440 * 60 * 1e3).default(3600 * 1e3) });
+var PlacementDeviceStatsSchema = zod.z.object({
+	deviceKey: zod.z.string(),
+	/** Sessions running on this device now. */
+	sessionsNow: zod.z.number(),
+	/** Sessions started on this device inside the window. */
+	sessionsStarted: zod.z.number(),
+	/** Time-weighted share of the node's parallel sessions over the window (0–1); null = no session ran. */
+	observedShare: zod.z.number().nullable()
+});
+var PlacementNodeStatsSchema = zod.z.object({
+	nodeId: zod.z.string(),
+	sessionsNow: zod.z.number(),
+	sessionsStarted: zod.z.number(),
+	/** Time-weighted share of the cluster's parallel sessions over the window (0–1); null = none ran. */
+	observedShare: zod.z.number().nullable(),
+	/** Most sessions this node ran at once inside the window. */
+	peakSessions: zod.z.number(),
+	/** Sessions a share election handed elsewhere because this node was full or drowning. */
+	yieldsAway: zod.z.number(),
+	devices: zod.z.array(PlacementDeviceStatsSchema).readonly()
+});
+/** A camera's device pin that the session path cannot honour. */
+var StaleDevicePinSchema = zod.z.object({
+	deviceId: zod.z.number(),
+	deviceKey: zod.z.string(),
+	/** `disabled` — the key exists on some node but is not enabled anywhere; `absent` — no node has it. */
+	reason: zod.z.enum(["disabled", "absent"])
+});
+var PlacementStatsSchema = zod.z.object({
+	policy: SessionPlacementPolicySchema,
+	windowMs: zod.z.number(),
+	/** How much of the window was actually observed (the hub keeps it in memory). */
+	observedForMs: zod.z.number(),
+	sessionsNow: zod.z.number(),
+	/** Most parallel sessions across the cluster inside the window. */
+	clusterPeakSessions: zod.z.number(),
+	nodes: zod.z.array(PlacementNodeStatsSchema).readonly(),
+	stalePins: zod.z.array(StaleDevicePinSchema).readonly()
+});
+var SuggestSharesInputSchema = zod.z.object({ headroom: zod.z.number().min(.3).max(.5).default(.4) });
+var SuggestedDeviceShareSchema = zod.z.object({
+	deviceKey: zod.z.string(),
+	/** Share of the node (0–100, rounded). */
+	share: zod.z.number(),
+	modelId: zod.z.string().nullable(),
+	/** Inferences per second at that model, from the measured table. */
+	fps: zod.z.number().nullable(),
+	measured: zod.z.boolean(),
+	/** Advisory session cap: ⌊fps × (1 − headroom) / camera fps⌋. Never enforced. */
+	suggestedMaxSessions: zod.z.number().nullable()
+});
+var SuggestedNodeShareSchema = zod.z.object({
+	nodeId: zod.z.string(),
+	/** Share of the cluster (0–100, rounded); null = node skipped (offline, unknown hardware). */
+	share: zod.z.number().nullable(),
+	/** Parallel sessions the node sustains at the suggested models with the headroom kept free. */
+	capacitySessions: zod.z.number(),
+	devices: zod.z.array(SuggestedDeviceShareSchema).readonly(),
+	skippedReason: zod.z.string().nullable()
+});
+var SuggestSharesResultSchema = zod.z.object({
+	headroom: zod.z.number(),
+	/** Camera detection rate the capacity is counted in (the fastest camera's fps). */
+	cameraFps: zod.z.number(),
+	/** How many share → model → capacity rounds ran before the shares stopped moving (≤ 3). */
+	iterations: zod.z.number(),
+	nodes: zod.z.array(SuggestedNodeShareSchema).readonly()
+});
+//#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(),
+	/** How on-motion sessions were charged: per-device observation, or split by share (D748). */
+	placement: SessionPlacementPolicySchema
+});
+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),
+	/**
+	* What-if shares (D748): plan as if these node/device shares were stored
+	* and the policy were `share`. Absent = the stored shares under the stored
+	* policy. A what-if plan is for display; apply always re-plans from what
+	* is stored.
+	*/
+	shares: LoadBalancingSharesInputSchema.optional()
+});
+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(),
+	/** Planned under what-if shares (D748): for display — apply refuses it as stale. */
+	whatIf: zod.z.boolean(),
+	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({
@@ -28798,7 +29168,6 @@ var CameraStepOverridePatchSchema = zod.z.object({
 	settings: zod.z.record(zod.z.string(), zod.z.unknown()).readonly().optional()
 });
 var CameraPipelineSettingsSchema = zod.z.object({
-	pinnedAgentNodeId: zod.z.string().optional(),
 	stepToggles: zod.z.record(zod.z.string(), zod.z.boolean()).optional(),
 	stepOverridesByDevice: zod.z.record(zod.z.string(), zod.z.record(zod.z.string(), zod.z.record(zod.z.string(), CameraStepOverridePatchSchema))).optional(),
 	pipelineByAgent: zod.z.record(zod.z.string(), CameraPipelineForAgentSchema).optional()
@@ -29492,18 +29861,6 @@ var pipelineOrchestratorCapability = {
 			auth: "admin"
 		}),
 		/**
-		* Set a node's detection WEIGHT (relative share for the quota balancer).
-		* `null` clears it (back to the implicit weight 1). Unpinned cameras
-		* distribute proportionally to weight; `maxCameras` still clamps on top.
-		*/
-		setAgentDetectWeight: require_sleep.method(zod.z.object({
-			agentNodeId: zod.z.string(),
-			detectWeight: zod.z.number().positive().nullable()
-		}), zod.z.object({ success: zod.z.literal(true) }), {
-			kind: "mutation",
-			auth: "admin"
-		}),
-		/**
 		* Set one node's placement CAPABILITIES — the per-node record that
 		* replaced the four flat orchestrator lists (`enabledNodes`,
 		* `enabledDecoderNodes`, `enabledAudioNodes`, `remoteSourcingNodes`).
@@ -29622,6 +29979,54 @@ 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"
+		}),
+		/**
+		* Load balancing (D748) — write node shares (`detectWeight`) and per-node
+		* device shares (inference-device `weight`) in ONE atomic read-modify-write
+		* of the agent settings — the only writer of node shares (the per-node
+		* `setAgentDetectWeight` it replaced raced its siblings, one RMW each).
+		* A node or device left out keeps its weight. Never changes the
+		* `sessionPlacement` policy.
+		*/
+		setLoadBalancingShares: require_sleep.method(LoadBalancingSharesInputSchema, zod.z.object({ success: zod.z.literal(true) }), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		/**
+		* Load balancing (D748) — what placement actually did: per node and
+		* device, sessions now, sessions started and the time-weighted share of
+		* PARALLEL sessions over `windowMs`; the cluster's parallel peak; yields
+		* a share election made; and every device pin the session path cannot
+		* honour. In memory on the hub — a restart starts a new window.
+		*/
+		getPlacementStats: require_sleep.method(PlacementStatsInputSchema, PlacementStatsSchema, { auth: "admin" }),
+		/**
+		* Load balancing (D748) — shares proportional to each node's measured
+		* capacity at the models Best settings would pick, iterated (≤ 3 rounds)
+		* until the shares stop moving; per device, an ADVISORY session cap.
+		* Writes nothing.
+		*/
+		suggestShares: require_sleep.method(SuggestSharesInputSchema, SuggestSharesResultSchema, { 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. */
@@ -55704,6 +56109,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",
@@ -55920,6 +56331,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",
@@ -56070,6 +56487,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"pipelineOrchestrator.getPlacementStats": {
+		capName: "pipeline-orchestrator",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"pipelineOrchestrator.getReconcileFromDiskStatus": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
@@ -56094,6 +56517,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",
@@ -56154,12 +56583,6 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "create"
 	},
-	"pipelineOrchestrator.setAgentDetectWeight": {
-		capName: "pipeline-orchestrator",
-		capScope: "system",
-		addonId: null,
-		access: "create"
-	},
 	"pipelineOrchestrator.setAgentInferenceDevices": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
@@ -56214,12 +56637,24 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"pipelineOrchestrator.setLoadBalancingShares": {
+		capName: "pipeline-orchestrator",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"pipelineOrchestrator.setPipelineDevicePin": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
 		addonId: null,
 		access: "create"
 	},
+	"pipelineOrchestrator.suggestShares": {
+		capName: "pipeline-orchestrator",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"pipelineOrchestrator.unassignAudio": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
@@ -64868,6 +65303,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",
@@ -65935,6 +66375,7 @@ var SYSTEM_SCOPE_DEVICE_METHODS = [
 	"osdManager.previewSlot",
 	"osdManager.renderDevice",
 	"osdManager.setSlotBinding",
+	"pipelineExecutor.clearModelBoundDeviceOverrides",
 	"pipelineExecutor.runPipeline",
 	"pipelineExecutor.runPipelineBatch",
 	"pipelineOrchestrator.applyDeviceSettingsPatch",
@@ -66919,6 +67360,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),
@@ -66967,13 +67409,17 @@ function createSystemProxy(api) {
 			listAgentSettings: (input) => dispatch("pipelineOrchestrator", "listAgentSettings", "query", input),
 			removeAgentSettings: (input) => dispatch("pipelineOrchestrator", "removeAgentSettings", "mutation", input),
 			setAgentMaxCameras: (input) => dispatch("pipelineOrchestrator", "setAgentMaxCameras", "mutation", input),
-			setAgentDetectWeight: (input) => dispatch("pipelineOrchestrator", "setAgentDetectWeight", "mutation", input),
 			setAgentCapabilities: (input) => dispatch("pipelineOrchestrator", "setAgentCapabilities", "mutation", input),
 			setAgentDecodeLimits: (input) => dispatch("pipelineOrchestrator", "setAgentDecodeLimits", "mutation", input),
 			setAgentReachableHost: (input) => dispatch("pipelineOrchestrator", "setAgentReachableHost", "mutation", input),
 			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),
+			setLoadBalancingShares: (input) => dispatch("pipelineOrchestrator", "setLoadBalancingShares", "mutation", input),
+			getPlacementStats: (input) => dispatch("pipelineOrchestrator", "getPlacementStats", "query", input),
+			suggestShares: (input) => dispatch("pipelineOrchestrator", "suggestShares", "query", input),
 			getCameraStatuses: (input) => dispatch("pipelineOrchestrator", "getCameraStatuses", "query", input),
 			setCameraSensors: (input) => dispatch("pipelineOrchestrator", "setCameraSensors", "mutation", input),
 			reconcileFromDisk: (input) => dispatch("pipelineOrchestrator", "reconcileFromDisk", "mutation", input),
@@ -71846,41 +72292,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`. */
@@ -71969,6 +72380,901 @@ 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 placement = input.shares ? "share" : "least-loaded";
+	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));
+	};
+	const pinNodeOf = (pin) => {
+		if (pin.nodeId !== null) return pin.nodeId;
+		const holders = input.eligible.filter((d) => d.deviceKey === pin.deviceKey);
+		return holders.length === 1 ? holders[0].nodeId : null;
+	};
+	let alwaysOnTotal = 0;
+	for (const cam of input.cameras) {
+		if (!charges(cam)) continue;
+		const pinNode = cam.devicePin !== null ? pinNodeOf(cam.devicePin) : null;
+		if (cam.devicePin !== null && pinNode !== null) {
+			const key = deviceId(pinNode, cam.devicePin.deviceKey);
+			if (!eligibleById.has(key)) continue;
+			bump(pinnedFps, key, cam.fps);
+			noteMax(key, cam.fps);
+			continue;
+		}
+		const standing = cam.mode === "always-on" && cam.standingNodeId !== null ? cam.standingNodeId : cam.nodePinId;
+		if (standing !== null) {
+			if (cam.mode === "always-on") alwaysOnTotal += 1;
+			const nodeWeight = weightByNode.get(standing) ?? 0;
+			for (const d of input.eligible) {
+				if (d.nodeId !== standing || 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);
+	const clusterPeak = input.shares?.clusterPeak ?? null;
+	const clusterObserved = clusterPeak !== null && clusterPeak.observedForMs >= 864e5;
+	const clusterSessions = clusterObserved ? Math.max(0, clusterPeak.peakSessions - alwaysOnTotal) : estimatedTotal;
+	const shareSum = [...weightByNode.keys()].reduce((sum, nodeId) => sum + Math.max(input.shares?.nodes[nodeId] ?? 0, 0), 0);
+	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 && input.shares !== void 0) {
+			const nodeWeight = weightByNode.get(d.nodeId) ?? 0;
+			const nodeShare = shareSum > 0 ? Math.max(input.shares.nodes[d.nodeId] ?? 0, 0) / shareSum : 0;
+			const deviceShare = nodeWeight > 0 ? Math.max(d.weight, 0) / nodeWeight : 0;
+			onMotionSessions = Math.max(0, Math.ceil(clusterSessions * nodeShare * deviceShare - 1e-9));
+			onMotionSource = clusterObserved ? "observed-24h" : "estimate";
+		} else 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: input.shares !== void 0 ? clusterPeak?.observedForMs ?? null : peak?.observedForMs ?? null,
+			placement
+		};
+	}).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/load-balancing/share-election.ts
+/** Deficits equal up to float noise (0.7 × 2 − 1 is 0.3999…, not 0.4). */
+var DEFICIT_EPSILON = 1e-9;
+function byDeficit(a, b) {
+	const diff = b.deficit - a.deficit;
+	return (Math.abs(diff) < DEFICIT_EPSILON ? 0 : diff) || b.candidate.share - a.candidate.share || a.candidate.key.localeCompare(b.candidate.key);
+}
+function spareOf(c) {
+	return c.spare ?? Number.POSITIVE_INFINITY;
+}
+function electByShare(candidates) {
+	if (candidates.length === 0) return { kind: "none" };
+	const shareSum = candidates.reduce((s, c) => s + Math.max(c.share, 0), 0);
+	const running = candidates.reduce((s, c) => s + Math.max(c.running, 0), 0);
+	const scored = candidates.map((candidate) => ({
+		candidate,
+		deficit: (shareSum > 0 ? Math.max(candidate.share, 0) / shareSum : 1 / candidates.length) * (running + 1) - candidate.running
+	})).toSorted(byDeficit);
+	const turn = scored[0].candidate;
+	if (!turn.capped && !turn.saturated) return {
+		kind: "elected",
+		key: turn.key,
+		reason: "share"
+	};
+	const free = scored.filter((s) => !s.candidate.capped && !s.candidate.saturated).toSorted((a, b) => spareOf(b.candidate) - spareOf(a.candidate) || byDeficit(a, b));
+	const yieldReason = turn.capped ? "at-cap" : "saturated";
+	if (free.length > 0) return {
+		kind: "elected",
+		key: free[0].candidate.key,
+		reason: "yield",
+		turnKey: turn.key,
+		yieldReason
+	};
+	const uncapped = scored.find((s) => !s.candidate.capped);
+	if (uncapped === void 0) return { kind: "none" };
+	return {
+		kind: "elected",
+		key: uncapped.candidate.key,
+		reason: "share"
+	};
+}
 //#endregion
 //#region src/pipeline/root-face-crop.ts
 /** Side of the square, as a multiple of the face box's longer side. */
@@ -74114,6 +75420,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;
@@ -74192,6 +75499,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;
@@ -74207,6 +75515,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;
@@ -74309,6 +75623,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;
@@ -74466,11 +75781,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;
@@ -74478,6 +75795,7 @@ exports.DEFAULT_POOL_MEMORY_POLICY = DEFAULT_POOL_MEMORY_POLICY;
 exports.DEFAULT_RECORDING_PROFILES = DEFAULT_RECORDING_PROFILES;
 exports.DEFAULT_RETENTION = DEFAULT_RETENTION;
 exports.DEFAULT_RUNTIME_STATE_DURABILITY = require_sleep.DEFAULT_RUNTIME_STATE_DURABILITY;
+exports.DEFAULT_SESSION_PLACEMENT_POLICY = DEFAULT_SESSION_PLACEMENT_POLICY;
 exports.DEFAULT_TIMELAPSE_PREVIEW_TEXT = DEFAULT_TIMELAPSE_PREVIEW_TEXT;
 exports.DEFAULT_TOKEN_EXPIRY = DEFAULT_TOKEN_EXPIRY;
 exports.DERIVED_CAMERA_SILENCED_CAP_NAMES = DERIVED_CAMERA_SILENCED_CAP_NAMES;
@@ -74487,6 +75805,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;
@@ -74524,16 +75844,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;
@@ -74686,6 +76010,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;
@@ -74767,6 +76092,7 @@ exports.LlmRuntimeStatusSchema = LlmRuntimeStatusSchema;
 exports.LlmTimeoutDefaults = LlmTimeoutDefaults;
 exports.LlmUsageRollupSchema = LlmUsageRollupSchema;
 exports.LlmUsageSchema = LlmUsageSchema;
+exports.LoadBalancingSharesInputSchema = LoadBalancingSharesInputSchema;
 exports.LoadContributionSchema = LoadContributionSchema;
 exports.LocateSegmentResultSchema = LocateSegmentResultSchema;
 exports.LocationDescriptionAssignmentSchema = LocationDescriptionAssignmentSchema;
@@ -74868,8 +76194,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;
@@ -75106,14 +76435,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;
@@ -75187,11 +76519,16 @@ exports.PickedCamStreamSchema = PickedCamStreamSchema;
 exports.PipelineAssignmentSchema = PipelineAssignmentSchema;
 exports.PipelineDefaultStepSchema = PipelineDefaultStepSchema;
 exports.PipelineEngineChoiceSchema = PipelineEngineChoiceSchema;
+exports.PipelineModelFormatStatusSchema = PipelineModelFormatStatusSchema;
 exports.PipelineRunResultBridge = PipelineRunResultBridge;
 exports.PipelineStepInputSchema = PipelineStepInputSchema;
 exports.PipelineValidationIssueSchema = PipelineValidationIssueSchema;
 exports.PipelineValidationResultSchema = PipelineValidationResultSchema;
 exports.PlaceholderReasonSchema = PlaceholderReasonSchema;
+exports.PlacementDeviceStatsSchema = PlacementDeviceStatsSchema;
+exports.PlacementNodeStatsSchema = PlacementNodeStatsSchema;
+exports.PlacementStatsInputSchema = PlacementStatsInputSchema;
+exports.PlacementStatsSchema = PlacementStatsSchema;
 exports.PolygonPointSchema = PolygonPointSchema;
 exports.PoolMemoryWatchdog = PoolMemoryWatchdog;
 exports.PowerMeterStatusSchema = PowerMeterStatusSchema;
@@ -75226,6 +76563,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;
@@ -75258,6 +76596,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;
@@ -75352,6 +76691,7 @@ exports.SCENE_RESET_RECAPTURES = SCENE_RESET_RECAPTURES;
 exports.SCOPE_PRESETS = SCOPE_PRESETS;
 exports.SENSOR_FEATURES = SENSOR_FEATURES;
 exports.SENSOR_MAP = SENSOR_MAP;
+exports.SESSION_PLACEMENT_SETTING_KEY = SESSION_PLACEMENT_SETTING_KEY;
 exports.SHARE_VIEW_KINDS = require_sleep.SHARE_VIEW_KINDS;
 exports.SINGLE_HUB_ADDRESS_ROLES = SINGLE_HUB_ADDRESS_ROLES;
 exports.SOURCE_CAPS = require_composition.SOURCE_CAPS;
@@ -75397,6 +76737,7 @@ exports.ServerUpdateActionResultSchema = ServerUpdateActionResultSchema;
 exports.ServerUpdateCheckResultSchema = ServerUpdateCheckResultSchema;
 exports.ServerUpdateOutcomeSchema = ServerUpdateOutcomeSchema;
 exports.ServerUpdateStateSchema = ServerUpdateStateSchema;
+exports.SessionPlacementPolicySchema = SessionPlacementPolicySchema;
 exports.SessionTriggerSchema = SessionTriggerSchema;
 exports.SetCameraSensorsInputSchema = SetCameraSensorsInputSchema;
 exports.SetLoggingSettingsInputSchema = SetLoggingSettingsInputSchema;
@@ -75419,6 +76760,7 @@ exports.SnapshotImageSchema = SnapshotImageSchema;
 exports.SourceInfoSchema = SourceInfoSchema;
 exports.SpatialDetectionSchema = SpatialDetectionSchema;
 exports.SsoBridgeClaimsSchema = SsoBridgeClaimsSchema;
+exports.StaleDevicePinSchema = StaleDevicePinSchema;
 exports.StartEmbeddedInputSchema = StartEmbeddedInputSchema;
 exports.StationaryObjectSchema = StationaryObjectSchema;
 exports.StorageAbortUploadInputSchema = AbortUploadInputSchema;
@@ -75482,6 +76824,10 @@ exports.SubscribeAudioChunksInputSchema = require_sleep.SubscribeAudioChunksInpu
 exports.SubscribeAudioChunksResultSchema = require_sleep.SubscribeAudioChunksResultSchema;
 exports.SubscribeFramesInputSchema = require_sleep.SubscribeFramesInputSchema;
 exports.SubscribeFramesResultSchema = require_sleep.SubscribeFramesResultSchema;
+exports.SuggestSharesInputSchema = SuggestSharesInputSchema;
+exports.SuggestSharesResultSchema = SuggestSharesResultSchema;
+exports.SuggestedDeviceShareSchema = SuggestedDeviceShareSchema;
+exports.SuggestedNodeShareSchema = SuggestedNodeShareSchema;
 exports.SuppliedRootOutputSchema = SuppliedRootOutputSchema;
 exports.SwitchStatusSchema = SwitchStatusSchema;
 exports.SystemMetricsSchema = SystemMetricsSchema;
@@ -75613,6 +76959,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;
@@ -75704,6 +77051,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;
@@ -75720,6 +77068,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;
@@ -75834,6 +77183,7 @@ exports.doorbellFeatureSources = doorbellFeatureSources;
 exports.droppedConditionsForKind = droppedConditionsForKind;
 exports.egressTranscodeSharingKey = egressTranscodeSharingKey;
 exports.egressTransportFromRequest = egressTransportFromRequest;
+exports.electByShare = electByShare;
 exports.embeddingEncoderCapability = embeddingEncoderCapability;
 exports.embeddingModelFailedError = embeddingModelFailedError;
 exports.embeddingModelFailedOf = embeddingModelFailedOf;
@@ -75851,6 +77201,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;
@@ -76082,6 +77434,7 @@ exports.parseOccupancyScope = parseOccupancyScope;
 exports.parseProcStatus = parseProcStatus;
 exports.parseProfileBrokerId = require_sleep.parseProfileBrokerId;
 exports.parseRuleSection = parseRuleSection;
+exports.parseSessionPlacementPolicy = parseSessionPlacementPolicy;
 exports.parseStreamParamsFormPatch = parseStreamParamsFormPatch;
 exports.patchAudio = patchAudio;
 exports.petFeederCapability = petFeederCapability;
@@ -76133,6 +77486,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;