@camstack/addon-pipeline-orchestrator 1.2.289 → 1.2.291

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { randomUUID } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
@@ -8048,7 +8048,7 @@ import { errMsg } from '@camstack/types'
 * Extract a human-readable message from an unknown error value.
 * Replaces the ubiquitous `errMsg(err)` pattern.
 */
-function errMsg$1(err) {
+function errMsg$2(err) {
 	if (err instanceof Error) return err.message;
 	if (typeof err === "string") return err;
 	return String(err);
@@ -11551,7 +11551,53 @@ var ModelFormatEntrySchema = object({
 	/** Multi-file payload (directory members or sibling files). */
 	files: array(string()).readonly().optional(),
 	/** Runtime(s) that can use this format. If omitted, inferred from ModelFormat key */
-	runtimes: array(_enum(["python"])).readonly().optional()
+	runtimes: array(_enum(["python"])).readonly().optional(),
+	/**
+	* 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
+	* 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: 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 = _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 = _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 = object({
+	downloaded: boolean(),
+	sizeMB: number(),
+	onDisk: ModelOnDiskStateSchema.optional(),
+	precision: ModelFormatPrecisionSchema.optional()
 });
 /**
 * Extra file that must be downloaded alongside the model (e.g., labels JSON, dict.txt).
@@ -24297,7 +24343,7 @@ var FrameRefSchema = object({
 	timestamp: number(),
 	capturedAt: number().optional()
 });
-var ModelFormatSchema$1 = _enum([
+var ModelFormatSchema$2 = _enum([
 	"onnx",
 	"coreml",
 	"openvino",
@@ -24315,7 +24361,7 @@ var PipelineSlotSchema = _enum([
 var PipelineEngineChoiceSchema = object({
 	runtime: literal("python"),
 	backend: string(),
-	format: ModelFormatSchema$1,
+	format: ModelFormatSchema$2,
 	device: string().optional()
 });
 /**
@@ -24372,10 +24418,7 @@ var PipelineTemplateSchema$1 = object({
 var PipelineModelOptionSchema = object({
 	id: string(),
 	name: string(),
-	formats: record(string(), object({
-		downloaded: boolean(),
-		sizeMB: number()
-	})),
+	formats: record(string(), PipelineModelFormatStatusSchema),
 	group: ModelVariantGroupSchema.optional(),
 	legacy: boolean().optional(),
 	provider: ModelProviderIdSchema.optional(),
@@ -24590,6 +24633,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: method(object({
+			nodeId: string(),
+			deviceIds: array(number()).readonly().optional(),
+			dryRun: boolean()
+		}), object({
+			entries: array(object({
+				deviceId: number(),
+				keys: array(string()).readonly()
+			})).readonly(),
+			refused: array(object({
+				deviceId: number(),
+				reason: 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).
 		*
@@ -24684,12 +24753,12 @@ var pipelineExecutorCapability = {
 		downloadModel: method(object({
 			addonId: string(),
 			modelId: string(),
-			format: ModelFormatSchema$1
+			format: ModelFormatSchema$2
 		}), DownloadModelResultSchema, { kind: "mutation" }),
 		deleteModel: method(object({
 			addonId: string(),
 			modelId: string(),
-			format: ModelFormatSchema$1
+			format: ModelFormatSchema$2
 		}), object({ success: literal(true) }), { kind: "mutation" }),
 		/**
 		* Stateless single-frame execution. Callers (runner, benchmark) pass
@@ -24935,6 +25004,315 @@ var pipelineExecutorCapability = {
 		getDetectionConfigSchema: method(_void(), ConfigUISchemaNullableBridge)
 	}
 };
+/**
+* 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 = _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 = object({
+	/** nodeId → share (> 0). A node left out keeps its weight. */
+	nodes: record(string(), number().positive()).default({}),
+	/** nodeId → deviceKey → share (> 0). A device left out keeps its weight. */
+	devices: record(string(), record(string(), number().positive())).default({})
+});
+var PlacementStatsInputSchema = object({ 
+/** Window the observed shares are averaged over (default 1 h, max 24 h). */
+windowMs: number().int().min(6e4).max(1440 * 60 * 1e3).default(3600 * 1e3) });
+var PlacementDeviceStatsSchema = object({
+	deviceKey: string(),
+	/** Sessions running on this device now. */
+	sessionsNow: number(),
+	/** Sessions started on this device inside the window. */
+	sessionsStarted: number(),
+	/** Time-weighted share of the node's parallel sessions over the window (0–1); null = no session ran. */
+	observedShare: number().nullable()
+});
+var PlacementNodeStatsSchema = object({
+	nodeId: string(),
+	sessionsNow: number(),
+	sessionsStarted: number(),
+	/** Time-weighted share of the cluster's parallel sessions over the window (0–1); null = none ran. */
+	observedShare: number().nullable(),
+	/** Most sessions this node ran at once inside the window. */
+	peakSessions: number(),
+	/** Sessions a share election handed elsewhere because this node was full or drowning. */
+	yieldsAway: number(),
+	devices: array(PlacementDeviceStatsSchema).readonly()
+});
+/** A camera's device pin that the session path cannot honour. */
+var StaleDevicePinSchema = object({
+	deviceId: number(),
+	deviceKey: string(),
+	/** `disabled` — the key exists on some node but is not enabled anywhere; `absent` — no node has it. */
+	reason: _enum(["disabled", "absent"])
+});
+var PlacementStatsSchema = object({
+	policy: SessionPlacementPolicySchema,
+	windowMs: number(),
+	/** How much of the window was actually observed (the hub keeps it in memory). */
+	observedForMs: number(),
+	sessionsNow: number(),
+	/** Most parallel sessions across the cluster inside the window. */
+	clusterPeakSessions: number(),
+	nodes: array(PlacementNodeStatsSchema).readonly(),
+	stalePins: array(StaleDevicePinSchema).readonly()
+});
+var SuggestSharesInputSchema = object({ headroom: number().min(.3).max(.5).default(.4) });
+var SuggestedDeviceShareSchema = object({
+	deviceKey: string(),
+	/** Share of the node (0–100, rounded). */
+	share: number(),
+	modelId: string().nullable(),
+	/** Inferences per second at that model, from the measured table. */
+	fps: number().nullable(),
+	measured: boolean(),
+	/** Advisory session cap: ⌊fps × (1 − headroom) / camera fps⌋. Never enforced. */
+	suggestedMaxSessions: number().nullable()
+});
+var SuggestedNodeShareSchema = object({
+	nodeId: string(),
+	/** Share of the cluster (0–100, rounded); null = node skipped (offline, unknown hardware). */
+	share: number().nullable(),
+	/** Parallel sessions the node sustains at the suggested models with the headroom kept free. */
+	capacitySessions: number(),
+	devices: array(SuggestedDeviceShareSchema).readonly(),
+	skippedReason: string().nullable()
+});
+var SuggestSharesResultSchema = object({
+	headroom: number(),
+	/** Camera detection rate the capacity is counted in (the fastest camera's fps). */
+	cameraFps: number(),
+	/** How many share → model → capacity rounds ran before the shares stopped moving (≤ 3). */
+	iterations: number(),
+	nodes: array(SuggestedNodeShareSchema).readonly()
+});
+/**
+* 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 = _enum(MODEL_FORMATS);
+var HardwareClassIdSchema = _enum([
+	"intel-core-ultra",
+	"intel-n-series",
+	"apple-m-base",
+	"apple-m-pro",
+	"unknown"
+]);
+var AcceleratorKindSchema = _enum([
+	"intel-npu",
+	"intel-igpu",
+	"x86-cpu",
+	"arm-cpu",
+	"apple-ane",
+	"coral"
+]);
+var RecommendationReasonSchema = discriminatedUnion("kind", [
+	object({
+		kind: literal("fits"),
+		utilisation: number()
+	}),
+	object({
+		kind: literal("tie-faster"),
+		over: string(),
+		recallDelta: number()
+	}),
+	object({
+		kind: literal("stepped-down"),
+		from: string(),
+		to: string(),
+		limitedBy: string()
+	}),
+	object({
+		kind: literal("no-fit-lightest"),
+		utilisation: number()
+	}),
+	object({
+		kind: literal("derived-latency"),
+		modelId: string()
+	}),
+	object({
+		kind: literal("estimated-load"),
+		observedForMs: number().nullable()
+	}),
+	object({ kind: literal("cpu-device") }),
+	object({ kind: literal("coral-untouched") }),
+	object({ kind: literal("device-disabled") }),
+	object({ kind: literal("device-unavailable") }),
+	object({ kind: literal("node-offline") }),
+	object({ kind: literal("no-hardware-facts") }),
+	object({
+		kind: literal("no-measured-data"),
+		hardwareClass: HardwareClassIdSchema
+	}),
+	object({
+		kind: literal("no-family-build"),
+		format: ModelFormatSchema$1
+	})
+]);
+var DeviceDemandSchema = object({
+	nodeId: string(),
+	deviceKey: string(),
+	demandFps: number(),
+	maxCameraFps: number(),
+	alwaysOnCameras: number(),
+	onMotionSessions: number(),
+	onMotionSource: _enum([
+		"observed-24h",
+		"estimate",
+		"none"
+	]),
+	observedForMs: number().nullable(),
+	/** How on-motion sessions were charged: per-device observation, or split by share (D748). */
+	placement: SessionPlacementPolicySchema
+});
+var DeviceModelChoiceSchema = object({
+	modelId: string(),
+	p50Ms: number(),
+	fps: number(),
+	measured: boolean(),
+	utilisation: number(),
+	personRecall: number()
+});
+var DeviceRecommendationSchema = object({
+	deviceKey: string(),
+	accelerator: AcceleratorKindSchema.nullable(),
+	enabled: boolean(),
+	available: boolean(),
+	demand: DeviceDemandSchema.nullable(),
+	chosen: DeviceModelChoiceSchema.nullable(),
+	reasons: array(RecommendationReasonSchema).readonly()
+});
+var NodeRecommendationSchema = object({
+	nodeId: string(),
+	reachable: boolean(),
+	hardwareClass: HardwareClassIdSchema.nullable(),
+	cpuModel: string().nullable(),
+	skipped: boolean(),
+	acceleratorModelId: string().nullable(),
+	devices: array(DeviceRecommendationSchema).readonly(),
+	reasons: array(RecommendationReasonSchema).readonly()
+});
+var ModelPinChangeSchema = object({
+	stepId: string(),
+	before: string().nullable(),
+	after: string().nullable()
+});
+var NodeDeviceChangeSchema = object({
+	nodeId: string(),
+	deviceKey: string(),
+	madeExplicit: boolean(),
+	modelPins: array(ModelPinChangeSchema).readonly(),
+	thresholds: array(object({
+		stepId: string(),
+		keys: array(string()).readonly()
+	})).readonly()
+});
+var CameraOverrideClearSchema = object({
+	deviceId: number(),
+	source: _enum(["step-override", "wholesale"]),
+	nodeId: string(),
+	deviceKey: string().nullable(),
+	stepId: string(),
+	modelIdBefore: string().nullable(),
+	keys: array(string()).readonly()
+});
+var DetectorStoreClearSchema = object({
+	deviceId: number(),
+	keys: array(string()).readonly()
+});
+var BestSettingsWarningSchema = discriminatedUnion("kind", [
+	object({
+		kind: literal("detector-store-cluster-wide"),
+		skippedNodes: array(string()).readonly()
+	}),
+	object({
+		kind: literal("detector-store-unreadable"),
+		error: string()
+	}),
+	object({
+		kind: literal("coral-enabled"),
+		nodeId: string(),
+		deviceKey: string()
+	})
+]);
+var BestSettingsOptionsSchema = object({
+	/** Share of each accelerator's throughput kept free (0.3–0.5). */
+	headroom: 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 = object({
+	/** Hash of everything the apply will write — the apply refuses a different one. */
+	planHash: string(),
+	family: literal("yolov9"),
+	headroom: number(),
+	/** Planned under what-if shares (D748): for display — apply refuses it as stale. */
+	whatIf: boolean(),
+	generatedAt: number(),
+	nodes: array(NodeRecommendationSchema).readonly(),
+	nodeChanges: array(NodeDeviceChangeSchema).readonly(),
+	cameraClears: array(CameraOverrideClearSchema).readonly(),
+	detectorStoreClears: array(DetectorStoreClearSchema).readonly(),
+	warnings: array(BestSettingsWarningSchema).readonly()
+});
+var BestSettingsApplyInputSchema = object({
+	planHash: string(),
+	headroom: number().min(.3).max(.5).default(.4)
+});
+var BestSettingsPhaseResultSchema = object({
+	phase: _enum([
+		"download",
+		"camera-overrides",
+		"detector-thresholds",
+		"node-models",
+		"redispatch"
+	]),
+	ok: boolean(),
+	detail: string()
+});
+var BestSettingsApplyResultSchema = discriminatedUnion("kind", [
+	object({
+		kind: literal("applied"),
+		planHash: string(),
+		phases: array(BestSettingsPhaseResultSchema).readonly()
+	}),
+	object({
+		kind: literal("aborted"),
+		phases: array(BestSettingsPhaseResultSchema).readonly()
+	}),
+	object({
+		kind: literal("stale"),
+		plan: BestSettingsPlanSchema
+	}),
+	object({
+		kind: literal("refused"),
+		reason: _enum(["apply-in-progress"])
+	})
+]);
 object({
 	activeCameras: number(),
 	throttledCameras: number(),
@@ -26343,7 +26721,6 @@ var CameraStepOverridePatchSchema = object({
 	settings: record(string(), unknown()).readonly().optional()
 });
 var CameraPipelineSettingsSchema = object({
-	pinnedAgentNodeId: string().optional(),
 	stepToggles: record(string(), boolean()).optional(),
 	stepOverridesByDevice: record(string(), record(string(), record(string(), CameraStepOverridePatchSchema))).optional(),
 	pipelineByAgent: record(string(), CameraPipelineForAgentSchema).optional()
@@ -26991,18 +27368,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: method(object({
-			agentNodeId: string(),
-			detectWeight: number().positive().nullable()
-		}), object({ success: 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`).
@@ -27121,6 +27486,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: 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: 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: method(LoadBalancingSharesInputSchema, object({ success: 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: 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: method(SuggestSharesInputSchema, SuggestSharesResultSchema, { auth: "admin" }),
 		/** Read one camera's settings. Null when never touched (inherits agent defaults fully). */
 		getCameraSettings: method(object({ deviceId: number() }), CameraPipelineSettingsSchema.nullable()),
 		/** Set or clear the 3-state toggle for one (camera, addonId). Pass `enabled: null` to clear and revert to agent default. */
@@ -42922,6 +43335,12 @@ Object.freeze({
 		addonId: null,
 		access: "delete"
 	},
+	"pipelineExecutor.clearModelBoundDeviceOverrides": {
+		capName: "pipeline-executor",
+		capScope: "system",
+		addonId: null,
+		access: "delete"
+	},
 	"pipelineExecutor.deleteModel": {
 		capName: "pipeline-executor",
 		capScope: "system",
@@ -43138,6 +43557,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"pipelineOrchestrator.applyBestSettings": {
+		capName: "pipeline-orchestrator",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"pipelineOrchestrator.applyDeviceSettingsPatch": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
@@ -43288,6 +43713,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"pipelineOrchestrator.getPlacementStats": {
+		capName: "pipeline-orchestrator",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"pipelineOrchestrator.getReconcileFromDiskStatus": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
@@ -43312,6 +43743,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"pipelineOrchestrator.planBestSettings": {
+		capName: "pipeline-orchestrator",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"pipelineOrchestrator.rebalance": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
@@ -43372,12 +43809,6 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
-	"pipelineOrchestrator.setAgentDetectWeight": {
-		capName: "pipeline-orchestrator",
-		capScope: "system",
-		addonId: null,
-		access: "create"
-	},
 	"pipelineOrchestrator.setAgentInferenceDevices": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
@@ -43432,12 +43863,24 @@ 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",
@@ -48762,6 +49205,11 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"pipelineExecutor.clearModelBoundDeviceOverrides": [{
+		name: "deviceIds",
+		form: "array",
+		optional: true
+	}],
 	"pipelineExecutor.runPipeline": [{
 		name: "deviceId",
 		form: "single",
@@ -50656,6 +51104,891 @@ var REMOVED_MODEL_IDS = {
 function isRemovedModelId(stepId, modelId) {
 	return REMOVED_MODEL_IDS[stepId]?.includes(modelId) ?? false;
 }
+/** Suffix of the sibling key that names the model a stored value was made for. */
+var MODEL_BINDING_SUFFIX = "ModelId";
+/** `minConfidencePerson` → `minConfidencePersonModelId`. */
+function modelBindingKey(key) {
+	return `${key}${MODEL_BINDING_SUFFIX}`;
+}
+/**
+* The 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] : [];
+	});
+}
+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;
+}
+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
+	}
+};
+var DEFAULT_DEMAND_OPTIONS = {
+	onMotionConcurrency: .25,
+	onMotionMinConcurrent: 2
+};
+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));
+}
+/** The family the cluster runs. */
+var BEST_SETTINGS_FAMILY = "yolov9";
+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
+	};
+}
+/** 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"
+	};
+}
 /**
 * THE detail-crop convention — the single derivation of the rectangle a
 * detail/enrichment step (clip-embedding, face-detection, plate-detection…)
@@ -51430,7 +52763,7 @@ var AudioSubscriptionController = class {
 		} catch (err) {
 			this.deps.logger.error("audio re-attach failed", {
 				tags: { deviceId },
-				meta: { error: errMsg$1(err) }
+				meta: { error: errMsg$2(err) }
 			});
 		}
 	}
@@ -51541,7 +52874,7 @@ var AudioSubscriptionController = class {
 			this.closeMotionAudioWindow(deviceId, "motion-cooldown-elapsed").catch((err) => {
 				this.deps.logger.warn("lazy audio: cooldown teardown failed", {
 					tags: { deviceId },
-					meta: { error: errMsg$1(err) }
+					meta: { error: errMsg$2(err) }
 				});
 			});
 		}, cooldownMs);
@@ -51560,7 +52893,7 @@ var AudioSubscriptionController = class {
 			this.closeMotionAudioWindow(deviceId, "quiet-window-elapsed").catch((err) => {
 				this.deps.logger.warn("lazy audio: quiet-window teardown failed", {
 					tags: { deviceId },
-					meta: { error: errMsg$1(err) }
+					meta: { error: errMsg$2(err) }
 				});
 			});
 		}, windowMs);
@@ -51762,7 +53095,7 @@ var AudioSubscriptionController = class {
 					meta: {
 						audioNodeId,
 						brokerId: audioBrokerId,
-						error: errMsg$1(err)
+						error: errMsg$2(err)
 					}
 				});
 			});
@@ -51837,7 +53170,7 @@ async function readOrRefuse(deps, deviceId) {
 	try {
 		device = await deps.readDevice(deviceId);
 	} catch (err) {
-		return refuse(deps, deviceId, `could not read device ${deviceId}: ${errMsg$1(err)}`);
+		return refuse(deps, deviceId, `could not read device ${deviceId}: ${errMsg$2(err)}`);
 	}
 	if (device === null) return refuse(deps, deviceId, `no device ${deviceId}`);
 	return device;
@@ -53167,7 +54500,7 @@ var LoadShedController = class LoadShedController {
 		if (await this.tryClusterRelocate(deviceId).catch((err) => {
 			this.deps.logger.warn("Load management: cluster relocate failed", {
 				tags: { deviceId },
-				meta: { error: errMsg$1(err) }
+				meta: { error: errMsg$2(err) }
 			});
 			return false;
 		})) {
@@ -53181,7 +54514,7 @@ var LoadShedController = class LoadShedController {
 		this.deps.api()?.pipelineRunner.detachCamera.mutate({ deviceId }).catch((err) => {
 			this.deps.logger.warn("Load management: detachCamera failed", {
 				tags: { deviceId },
-				meta: { error: errMsg$1(err) }
+				meta: { error: errMsg$2(err) }
 			});
 		});
 		this.ensureLoadShedResumeTimer();
@@ -53213,7 +54546,7 @@ var LoadShedController = class LoadShedController {
 				tags: { deviceId },
 				meta: {
 					from: currentNode,
-					error: errMsg$1(err)
+					error: errMsg$2(err)
 				}
 			});
 		});
@@ -53256,7 +54589,7 @@ var LoadShedController = class LoadShedController {
 			this.deps.redispatchSingleCamera(deviceId).catch((err) => {
 				this.deps.logger.warn("Load management: auto-resume dispatch failed", {
 					tags: { deviceId },
-					meta: { error: errMsg$1(err) }
+					meta: { error: errMsg$2(err) }
 				});
 			});
 		}
@@ -53421,7 +54754,7 @@ var AgentLoadService = class AgentLoadService {
 			ms,
 			outcome: "failed",
 			load: null,
-			error: errMsg$1(outcome.error)
+			error: errMsg$2(outcome.error)
 		};
 		return {
 			nodeId,
@@ -53888,7 +55221,7 @@ function buildCameraSensorsPorts(api, logger) {
 		} catch (err) {
 			return {
 				ok: false,
-				error: errMsg$1(err)
+				error: errMsg$2(err)
 			};
 		}
 	};
@@ -54152,7 +55485,7 @@ var CameraSensorsController = class {
 	async #readFleet() {
 		const read = await this.#deps.listCameraIds().catch((err) => ({
 			kind: "unreadable",
-			error: errMsg$1(err)
+			error: errMsg$2(err)
 		}));
 		if (read.kind === "unreadable") {
 			this.#deps.logger.warn("camera-sensors: camera list unreadable — mappings stay unloaded", { meta: { error: read.error } });
@@ -54179,7 +55512,7 @@ var CameraSensorsController = class {
 		} catch (err) {
 			this.#deps.logger.error("camera-sensors: refresh failed — nothing applied", {
 				tags: { deviceId: cameraId },
-				meta: { error: errMsg$1(err) }
+				meta: { error: errMsg$2(err) }
 			});
 		}
 	}
@@ -54272,7 +55605,7 @@ async function readCameraSensorsSetting(read) {
 	} catch (err) {
 		return {
 			state: "unreadable",
-			reason: `settings read failed — ${errMsg$1(err)}`
+			reason: `settings read failed — ${errMsg$2(err)}`
 		};
 	}
 }
@@ -54582,7 +55915,7 @@ var CameraMotionSlice = class {
 		st.chain = st.chain.then(job).catch((err) => {
 			this.#deps.logger.error("camera motion slice: write job failed", {
 				tags: { deviceId },
-				meta: { error: errMsg$1(err) }
+				meta: { error: errMsg$2(err) }
 			});
 		});
 	}
@@ -54646,7 +55979,7 @@ var CameraMotionSlice = class {
 				meta: {
 					detected: slice.detected,
 					reason,
-					error: errMsg$1(err)
+					error: errMsg$2(err)
 				}
 			});
 			return;
@@ -54676,7 +56009,7 @@ var CameraMotionSlice = class {
 	async #republishAll() {
 		const listed = await this.#deps.listCameraIds().catch((err) => ({
 			kind: "unreadable",
-			error: errMsg$1(err)
+			error: errMsg$2(err)
 		}));
 		if (!this.#open || this.#stopped) return;
 		if (listed.kind === "unreadable") this.#deps.logger.warn("camera motion slice: camera list unreadable — only cameras with motion since boot are re-published", { meta: { error: listed.error } });
@@ -54798,7 +56131,7 @@ function hubMotionSliceStore(api) {
 			} catch (err) {
 				return {
 					kind: "unreadable",
-					error: errMsg$1(err)
+					error: errMsg$2(err)
 				};
 			}
 		}
@@ -56670,7 +58003,7 @@ function warnSampled(deps, deviceId, source, message, meta) {
 function warnUnreachable(deps, deviceId, source, err) {
 	warnSampled(deps, deviceId, source, UNREACHABLE_MESSAGE, {
 		source,
-		error: errMsg$1(err)
+		error: errMsg$2(err)
 	});
 }
 /**
@@ -57944,7 +59277,7 @@ var ONBOARD_DETECTION_SOURCE = "onboard";
 * configs, and it reads them the same way the runner does.
 */
 var DETECTION_SOURCES_WHEN_ABSENT = ["pipeline"];
-function errMsg(err) {
+function errMsg$1(err) {
 	return err instanceof Error ? err.message : String(err);
 }
 /**
@@ -57963,7 +59296,7 @@ async function reconcileOnboardForwarding(input, deps) {
 		log.warn("onboard forwarding not reconciled — could not tell whether the camera has the cap", { meta: {
 			wantsOnboard,
 			detectionSources: [...detectionSources],
-			error: errMsg(err)
+			error: errMsg$1(err)
 		} });
 		return {
 			kind: "read-failed",
@@ -57981,7 +59314,7 @@ async function reconcileOnboardForwarding(input, deps) {
 		log.warn("onboard forwarding not reconciled — the vendor flag could not be read", { meta: {
 			wantsOnboard,
 			detectionSources: [...detectionSources],
-			error: errMsg(err)
+			error: errMsg$1(err)
 		} });
 		return {
 			kind: "read-failed",
@@ -57999,7 +59332,7 @@ async function reconcileOnboardForwarding(input, deps) {
 			was: current,
 			wanted: wantsOnboard,
 			detectionSources: [...detectionSources],
-			error: errMsg(err)
+			error: errMsg$1(err)
 		} });
 		return {
 			kind: "write-failed",
@@ -58195,7 +59528,7 @@ var DetectionWiringController = class {
 		try {
 			raw = await this.deps.ctx().settings.readDeviceStore(deviceId);
 		} catch (err) {
-			const msg = errMsg$1(err);
+			const msg = errMsg$2(err);
 			this.deps.logger.error("resolveDeviceDetectionSettings failed", {
 				tags: { deviceId },
 				meta: { error: msg }
@@ -58226,7 +59559,7 @@ var DetectionWiringController = class {
 				motionDetectionEnabled
 			});
 		} catch (err) {
-			const msg = errMsg$1(err);
+			const msg = errMsg$2(err);
 			this.deps.logger.error("resolveDeviceDetectionSettings narrowing failed", {
 				tags: { deviceId },
 				meta: { error: msg }
@@ -58261,7 +59594,7 @@ var DetectionWiringController = class {
 		} catch (err) {
 			this.deps.logger.debug("fetchAssignedProfiles: slot read failed (transient) — treating as unknown", {
 				tags: { deviceId },
-				meta: { error: errMsg$1(err) }
+				meta: { error: errMsg$2(err) }
 			});
 			return null;
 		}
@@ -58337,7 +59670,7 @@ var DetectionWiringController = class {
 			if (config.motionSources.includes("analyzer")) try {
 				await this.deps.session.ensureMotionWatch(deviceId, config);
 			} catch (err) {
-				log.error("ensureMotionWatch failed", { meta: { error: errMsg$1(err) } });
+				log.error("ensureMotionWatch failed", { meta: { error: errMsg$2(err) } });
 			}
 			log.info("detection armed (session-time) — watching for motion", { meta: { motion: config.motionSources.join("+") } });
 		} else {
@@ -58358,14 +59691,14 @@ var DetectionWiringController = class {
 			try {
 				await this.deps.placement.dispatchCamera(runnerConfig);
 			} catch (err) {
-				const msg = errMsg$1(err);
+				const msg = errMsg$2(err);
 				log.error("dispatchCamera failed", { meta: { error: msg } });
 			}
 		}
 		try {
 			await this.deps.audio.resubscribe(deviceId, config);
 		} catch (err) {
-			const msg = errMsg$1(err);
+			const msg = errMsg$2(err);
 			log.error("subscribeAudioStream failed", { meta: { error: msg } });
 		}
 		if (config.detectionMode !== "on-motion") log.info("Detection dispatched", { meta: {
@@ -58381,7 +59714,7 @@ var DetectionWiringController = class {
 		try {
 			await this.deps.placement.releaseCamera({ deviceId });
 		} catch (err) {
-			const msg = errMsg$1(err);
+			const msg = errMsg$2(err);
 			this.deps.logger.error("releaseCamera failed", {
 				tags: { deviceId },
 				meta: { error: msg }
@@ -58407,7 +59740,7 @@ var DetectionWiringController = class {
 		} catch (err) {
 			this.deps.logger.warn("failed to clear per-device orchestrator settings on removal", {
 				tags: { deviceId },
-				meta: { error: errMsg$1(err) }
+				meta: { error: errMsg$2(err) }
 			});
 		}
 		this.deps.logger.info("Purged pipeline config for removed device", { tags: { deviceId } });
@@ -58431,7 +59764,7 @@ var DetectionWiringController = class {
 		} catch (err) {
 			this.deps.logger.debug("device existence check failed — proceeding as before", {
 				tags: { deviceId },
-				meta: { error: errMsg$1(err) }
+				meta: { error: errMsg$2(err) }
 			});
 			return false;
 		}
@@ -58548,7 +59881,7 @@ var DetectionWiringController = class {
 			await this.deps.attachOn(assignment.agentNodeId, nextConfig);
 			log.info("pipeline.camera-updated: hot-reloaded", { tags: { nodeId: assignment.agentNodeId } });
 		} catch (err) {
-			const msg = errMsg$1(err);
+			const msg = errMsg$2(err);
 			log.error("pipeline.camera-updated: attachOn failed", {
 				tags: { nodeId: assignment.agentNodeId },
 				meta: { error: msg }
@@ -58624,7 +59957,7 @@ var DetectionWiringController = class {
 			this.deps.audio.resubscribe(deviceId, audioCfg).catch((err) => {
 				this.deps.logger.warn("watchdog audio re-subscribe failed", {
 					tags: { deviceId },
-					meta: { error: errMsg$1(err) }
+					meta: { error: errMsg$2(err) }
 				});
 			});
 		}
@@ -58718,6 +60051,35 @@ function pickInferenceDevice(input) {
 	const loadByKey = new Map((input.loads ?? []).map((l) => [l.deviceKey, l]));
 	const healthyKeys = eligibleKeys.filter((k) => !isDeviceSaturated(loadByKey.get(k)));
 	const consideredKeys = pin !== null || healthyKeys.length === 0 || healthyKeys.length === eligibleKeys.length ? eligibleKeys : healthyKeys;
+	if (input.policy === "share" && pin === null) {
+		const election = electByShare(eligibleKeys.map((key) => {
+			const load = loadByKey.get(key);
+			const attached = load?.attachedCameras ?? 0;
+			const cap = input.caps?.[key];
+			const hasCap = cap !== null && cap !== void 0 && cap > 0;
+			return {
+				key,
+				share: input.eligible[key] ?? 1,
+				running: attached,
+				capped: hasCap && attached >= cap,
+				saturated: isDeviceSaturated(load),
+				...hasCap ? { spare: Math.max(0, cap - attached) } : {}
+			};
+		}));
+		if (election.kind === "none") return {
+			kind: "default-pool",
+			reason: "all-devices-at-cap",
+			eligibleKeys
+		};
+		return {
+			kind: "selected",
+			deviceKey: election.key,
+			reason: "share",
+			tieBreak: null,
+			eligibleKeys,
+			tiedKeys: [election.key]
+		};
+	}
 	const balancerInput = {
 		nodes: consideredKeys.map((k) => deviceAsLoad(k, loadByKey.get(k))),
 		preferredAgent: pin,
@@ -58823,7 +60185,7 @@ var DeviceConfigContributions = class {
 				issue: configIssue
 			} });
 			this.deps.topology.refreshNodeCapabilities().then(() => this.deps.redispatchAllActiveCameras("ingest-owner-changed")).catch((err) => {
-				this.deps.ctx().logger.warn("ingest-owner-changed re-dispatch failed", { meta: { error: errMsg$1(err) } });
+				this.deps.ctx().logger.warn("ingest-owner-changed re-dispatch failed", { meta: { error: errMsg$2(err) } });
 			});
 		}
 		this.deps.clearOnSettingsChange();
@@ -59277,10 +60639,25 @@ function rootRefusal(input, droppedRoots) {
 		droppedRoots
 	};
 }
+/**
+* Whose provisioning an attach applies. The elected device when there is one.
+* With NO elected device the runner's default pool serves the camera; when the
+* node has exactly one eligible device the balancer returns
+* `single-eligible-device` and that default pool IS that device (a Mac's
+* `coreml:all`, an N100 with only its iGPU on), so its model pin and the
+* camera's override stored under its key apply (D745 — before, the empty key
+* was read, which no store writes, and the pin was silently never run).
+* Otherwise `''`: the node's folded settings with no hardware fields.
+*/
+function provisioningKeyFor(input) {
+	if (input.deviceKey !== void 0) return input.deviceKey;
+	const eligibleKeys = Object.keys(input.eligible);
+	return eligibleKeys.length === 1 ? eligibleKeys[0] ?? "" : "";
+}
 /** Steps 3 of the module header: provision the resolved structure. */
 async function provisionAttachPipeline(input, roster, resolved, store) {
 	const { deviceId, nodeId, deviceKey } = input;
-	const electedKey = deviceKey ?? "";
+	const electedKey = provisioningKeyFor(input);
 	const rosterKeys = (roster ?? []).map((d) => d.deviceKey);
 	const sources = await store.readDeviceProvisioning(deviceId, nodeId, [...new Set([electedKey, ...rosterKeys])]);
 	const elected = sources.get(electedKey);
@@ -59888,7 +61265,7 @@ var PlacementService = class {
 	async releaseCamera(input) {
 		const current = this.deps.ledger.getAssignment(input.deviceId);
 		if (current) await this.detachOn(current.agentNodeId, input.deviceId).catch((err) => {
-			const msg = errMsg$1(err);
+			const msg = errMsg$2(err);
 			this.deps.ctx().logger.debug("releaseCamera detach failed", {
 				tags: { deviceId: input.deviceId },
 				meta: { error: msg }
@@ -59916,7 +61293,7 @@ var PlacementService = class {
 			pipelineNodeId: input.agentNodeId,
 			[PREFERRED_AGENT_SETTING]: null
 		}).catch((err) => {
-			const msg = errMsg$1(err);
+			const msg = errMsg$2(err);
 			ctx.logger.warn("assignPipeline: failed to persist pin", {
 				tags: { deviceId: input.deviceId },
 				meta: { error: msg }
@@ -59948,7 +61325,7 @@ var PlacementService = class {
 		}
 		const current = this.deps.ledger.getAssignment(input.deviceId);
 		if (current && current.agentNodeId !== input.agentNodeId) await this.detachOn(current.agentNodeId, input.deviceId).catch((err) => {
-			const msg = errMsg$1(err);
+			const msg = errMsg$2(err);
 			ctx.logger.debug("assignPipeline detach-old failed", {
 				tags: { deviceId: input.deviceId },
 				meta: { error: msg }
@@ -59973,7 +61350,7 @@ var PlacementService = class {
 		await ctx.settings?.writeDeviceStore(input.deviceId, { pipelineDeviceKey: clearing ? "auto" : input.deviceKey }).catch((err) => {
 			ctx.logger.warn("setPipelineDevicePin: failed to persist device pin", {
 				tags: { deviceId: input.deviceId },
-				meta: { error: errMsg$1(err) }
+				meta: { error: errMsg$2(err) }
 			});
 		});
 		const sessionNode = this.deps.activeSessionNode(input.deviceId);
@@ -59996,7 +61373,7 @@ var PlacementService = class {
 			[PREFERRED_AGENT_SETTING]: null,
 			pipelineNodeId: "auto"
 		}).catch((err) => {
-			const msg = errMsg$1(err);
+			const msg = errMsg$2(err);
 			ctx.logger.warn("unassignPipeline: failed to clear pin", {
 				tags: { deviceId: input.deviceId },
 				meta: { error: msg }
@@ -60017,7 +61394,7 @@ var PlacementService = class {
 			else {
 				const targetNodeId = decision.agentNodeId;
 				if (current && current.agentNodeId !== targetNodeId) await this.detachOn(current.agentNodeId, input.deviceId).catch((err) => {
-					const msg = errMsg$1(err);
+					const msg = errMsg$2(err);
 					ctx.logger.debug("unassignPipeline detach-old failed", {
 						tags: { deviceId: input.deviceId },
 						meta: { error: msg }
@@ -60037,7 +61414,7 @@ var PlacementService = class {
 			}
 		}
 		if (current) await this.detachOn(current.agentNodeId, input.deviceId).catch((err) => {
-			const msg = errMsg$1(err);
+			const msg = errMsg$2(err);
 			ctx.logger.debug("unassignPipeline detach failed", {
 				tags: { deviceId: input.deviceId },
 				meta: { error: msg }
@@ -60056,7 +61433,7 @@ var PlacementService = class {
 	async runAutoRebalance() {
 		if (!this.deps.ctxIfReady()) return;
 		await this.deps.reconcilePlacementFromRunners().catch((err) => {
-			this.deps.ctx().logger.debug("auto-rebalance: attachment reconcile failed", { meta: { error: errMsg$1(err) } });
+			this.deps.ctx().logger.debug("auto-rebalance: attachment reconcile failed", { meta: { error: errMsg$2(err) } });
 		});
 		if (this.autoRebalanceInFlight) return;
 		if (this.deps.topology.enabledNodes.length < 2) return;
@@ -60065,7 +61442,7 @@ var PlacementService = class {
 			const { migrated } = await this.rebalance({ minImprovement: AUTO_REBALANCE_MIN_IMPROVEMENT });
 			if (migrated > 0) this.deps.ctx().logger.info("auto-rebalance: corrected placement drift", { meta: { migrated } });
 		} catch (err) {
-			this.deps.ctx().logger.debug("auto-rebalance pass failed", { meta: { error: errMsg$1(err) } });
+			this.deps.ctx().logger.debug("auto-rebalance pass failed", { meta: { error: errMsg$2(err) } });
 		} finally {
 			this.autoRebalanceInFlight = false;
 		}
@@ -60137,7 +61514,7 @@ var PlacementService = class {
 			const targetConfig = withAttachPipeline(config, placement.pipeline);
 			if (current) {
 				await this.detachOn(current.agentNodeId, deviceId).catch((err) => {
-					const msg = errMsg$1(err);
+					const msg = errMsg$2(err);
 					ctx.logger.debug("rebalance detach-old failed", {
 						tags: { deviceId },
 						meta: { error: msg }
@@ -60542,7 +61919,7 @@ var NodeLifecycleHandler = class {
 					nodeId: decision.agentNodeId
 				} });
 			} catch (err) {
-				const msg = errMsg$1(err);
+				const msg = errMsg$2(err);
 				this.deps.logger.error("Failover: attach failed", {
 					tags: {
 						deviceId,
@@ -60572,7 +61949,7 @@ var NodeLifecycleHandler = class {
 		this.deps.schedulePendingRetry();
 		if (failoverPolicy.onReconnect === "rebalance") {
 			await this.deps.rebalance().catch((err) => {
-				const msg = errMsg$1(err);
+				const msg = errMsg$2(err);
 				this.deps.logger.error("rebalance after reconnect failed", { meta: { error: msg } });
 			});
 			return;
@@ -60598,7 +61975,7 @@ var NodeLifecycleHandler = class {
 				this.deps.ledger.recordAssignment(deviceId, nodeId, "failover", false);
 				restored++;
 			} catch (err) {
-				const msg = errMsg$1(err);
+				const msg = errMsg$2(err);
 				this.deps.logger.error("restore attach failed", {
 					tags: {
 						deviceId,
@@ -60692,7 +62069,7 @@ var NodeLifecycleHandler = class {
 						deviceId,
 						nodeId
 					},
-					meta: { error: errMsg$1(err) }
+					meta: { error: errMsg$2(err) }
 				});
 			}
 			this.deps.logger.info("readiness: detection-pipeline reseeded agent defaults + redispatched cameras", {
@@ -60706,7 +62083,7 @@ var NodeLifecycleHandler = class {
 				this.reattachStaleEmpties(nodeId).catch((err) => {
 					this.deps.logger.debug("readiness deferred sweep failed", {
 						tags: { nodeId },
-						meta: { error: errMsg$1(err) }
+						meta: { error: errMsg$2(err) }
 					});
 				});
 			}, 3e3);
@@ -60717,7 +62094,7 @@ var NodeLifecycleHandler = class {
 				tags: { nodeId },
 				meta: {
 					epoch: t.epoch,
-					error: errMsg$1(err)
+					error: errMsg$2(err)
 				}
 			});
 		}
@@ -60796,7 +62173,7 @@ var NodeLifecycleHandler = class {
 						deviceId,
 						nodeId
 					},
-					meta: { error: errMsg$1(err) }
+					meta: { error: errMsg$2(err) }
 				});
 			}
 		}
@@ -61118,7 +62495,7 @@ var NodeStressController = class NodeStressController {
 		if (this.timer) return;
 		this.timer = setInterval(() => {
 			this.sweep().catch((err) => {
-				this.deps.logger.warn("node-stress sweep failed", { meta: { error: errMsg$1(err) } });
+				this.deps.logger.warn("node-stress sweep failed", { meta: { error: errMsg$2(err) } });
 			});
 		}, NodeStressController.SWEEP_INTERVAL_MS);
 	}
@@ -61291,7 +62668,7 @@ var NodeStressController = class NodeStressController {
 				meta: {
 					from: plan.fromNodeId,
 					to: plan.toNodeId,
-					error: errMsg$1(err)
+					error: errMsg$2(err)
 				}
 			});
 		} finally {
@@ -61988,7 +63365,7 @@ var NodeTopologyService = class {
 		try {
 			blob = await this.deps.readAgentSettingsMap();
 		} catch (err) {
-			this.deps.logger.warn("refreshNodeCapabilities: agent settings read failed", { meta: { error: errMsg$1(err) } });
+			this.deps.logger.warn("refreshNodeCapabilities: agent settings read failed", { meta: { error: errMsg$2(err) } });
 		}
 		const nodeIds = new Set(["hub"]);
 		for (const nodeId of Object.keys(blob)) if (typeof nodeId === "string" && nodeId.length > 0 && !nodeId.includes("/")) nodeIds.add(nodeId);
@@ -62162,7 +63539,7 @@ function wireOrchestratorSubscriptions(deps) {
 	const unsubInferenceResult = deps.eventBus.subscribe({ category: EventCategory.PipelineInferenceResult }, (event) => {
 		if (!isEvent(event, EventCategory.PipelineInferenceResult)) return;
 		deps.handleInferenceResult(event.data).catch((err) => {
-			const msg = errMsg$1(err);
+			const msg = errMsg$2(err);
 			deps.logger.error("PipelineInferenceResult post-processing failed", {
 				tags: { deviceId: event.data.deviceId },
 				meta: { error: msg }
@@ -62181,7 +63558,7 @@ function wireOrchestratorSubscriptions(deps) {
 			deps.logger.info("received onProfileSlotsChanged", { tags: { deviceId } });
 			deps.handleDeviceRegistered(deviceId).catch((err) => {
 				if (isTornDown) return;
-				const msg = errMsg$1(err);
+				const msg = errMsg$2(err);
 				deps.logger.error("handleDeviceRegistered failed", {
 					tags: { deviceId },
 					meta: { error: msg }
@@ -62193,7 +63570,7 @@ function wireOrchestratorSubscriptions(deps) {
 	const unsubDeviceUnregistered = deps.eventBus.subscribe({ category: EventCategory.DeviceUnregistered }, (event) => {
 		const { deviceId } = event.data;
 		deps.handleDeviceUnregistered(deviceId).catch((err) => {
-			const msg = errMsg$1(err);
+			const msg = errMsg$2(err);
 			deps.logger.error("handleDeviceUnregistered failed", {
 				tags: { deviceId },
 				meta: { error: msg }
@@ -62206,7 +63583,7 @@ function wireOrchestratorSubscriptions(deps) {
 		deps.cameraSensors.requestCamera(deviceId, "settings-updated");
 		deps.handleSettingsChanged(deviceId).catch((err) => {
 			if (isTornDown) return;
-			const msg = errMsg$1(err);
+			const msg = errMsg$2(err);
 			deps.logger.error("handleSettingsChanged failed", {
 				tags: { deviceId },
 				meta: { error: msg }
@@ -62216,7 +63593,7 @@ function wireOrchestratorSubscriptions(deps) {
 	const unsubCameraUpdated = deps.eventBus.subscribe({ category: EventCategory.PipelineCameraUpdated }, (event) => {
 		if (!isEvent(event, EventCategory.PipelineCameraUpdated)) return;
 		deps.handlePipelineCameraUpdated(event.data.deviceId, event.data.config).catch((err) => {
-			const msg = errMsg$1(err);
+			const msg = errMsg$2(err);
 			deps.logger.error("handlePipelineCameraUpdated failed", {
 				tags: { deviceId: event.data.deviceId },
 				meta: { error: msg }
@@ -62229,7 +63606,7 @@ function wireOrchestratorSubscriptions(deps) {
 		if (!(reason === "wrapper-activated" || reason === "wrapper-deactivated") || !(capName === "detection-pipeline" || capName === "audio-analysis" || capName === "motion-detection")) return;
 		deps.handleSettingsChanged(deviceId).catch((err) => {
 			if (isTornDown) return;
-			const msg = errMsg$1(err);
+			const msg = errMsg$2(err);
 			deps.logger.error("binding-changed re-dispatch failed", {
 				tags: { deviceId },
 				meta: {
@@ -62257,7 +63634,7 @@ function wireOrchestratorSubscriptions(deps) {
 				tags: { deviceId },
 				meta: {
 					detected,
-					error: errMsg$1(err)
+					error: errMsg$2(err)
 				}
 			});
 		});
@@ -62304,7 +63681,7 @@ function wireOrchestratorSubscriptions(deps) {
 				tags: { deviceId },
 				meta: {
 					detected,
-					error: errMsg$1(err)
+					error: errMsg$2(err)
 				}
 			});
 		});
@@ -62570,7 +63947,7 @@ async function reattachAfterPackageZoneChange(deps, deviceId) {
 				deviceId,
 				nodeId
 			},
-			meta: { error: errMsg$1(err) }
+			meta: { error: errMsg$2(err) }
 		});
 	}
 }
@@ -62851,7 +64228,7 @@ async function resetRemovedModelPins(deps, trigger) {
 	} catch (err) {
 		deps.logger.warn("removed-model pin reset skipped — custom model registry unreadable", { meta: {
 			trigger,
-			error: errMsg$1(err)
+			error: errMsg$2(err)
 		} });
 		return [];
 	}
@@ -62870,7 +64247,7 @@ async function resetRemovedModelPins(deps, trigger) {
 	} catch (err) {
 		deps.logger.warn("removed-model pin reset failed", { meta: {
 			trigger,
-			error: errMsg$1(err)
+			error: errMsg$2(err)
 		} });
 		return [];
 	}
@@ -63026,7 +64403,6 @@ var StoredCameraPipelineForAgentSchema = object({
 	}).nullable()
 });
 var StoredCameraPipelineSettingsSchema = object({
-	pinnedAgentNodeId: string().optional(),
 	stepToggles: record(string(), boolean()).optional(),
 	stepOverridesByDevice: record(string(), record(string(), record(string(), StoredCameraStepOverridePatchSchema))).optional(),
 	stepOverridesByAgent: record(string(), record(string(), LegacyCameraStepOverridePatchSchema)).optional(),
@@ -63229,6 +64605,21 @@ var PipelineSettingsStore = class PipelineSettingsStore {
 		});
 	}
 	/**
+	* Rewrite the whole agent-settings map in ONE read-modify-write under
+	* {@link blobWriteLock} — atomic across every node of the blob (Best
+	* settings, D745, writes several nodes' devices at once). `transform` must
+	* be pure: it may run on a fresh read.
+	*/
+	async rewriteAgentSettingsMap(transform) {
+		await this.blobWriteLock.run(PipelineSettingsStore.AGENT_SETTINGS_LOCK_KEY, async () => {
+			await this.agentSettingsState.set(transform(await this.readAgentSettingsMap()));
+		});
+	}
+	/** Rewrite the whole camera-settings map in one durable `update()` (D745). */
+	async rewriteCameraSettingsMap(transform) {
+		await this.cameraSettingsState.update(transform);
+	}
+	/**
 	* Drop one agent's persisted settings entry. Returns whether an entry
 	* existed (`false` also when the store is already disposed — the locked
 	* section becomes a no-op then). Serialized via {@link blobWriteLock} for
@@ -63485,6 +64876,10 @@ var PipelineSettingsStore = class PipelineSettingsStore {
 	* epochs and operator resets — a bound, not a budget.
 	*/
 	static CATALOG_FENCE_REREADS = 3;
+	/** The node's catalog, read through the cache (awaits the node when cold). */
+	async readCatalogForNode(nodeId) {
+		return this.getCatalogForAgent(nodeId);
+	}
 	async getCatalogForAgent(nodeId) {
 		const api = this.deps.api();
 		if (!api) return null;
@@ -63502,7 +64897,7 @@ var PipelineSettingsStore = class PipelineSettingsStore {
 					this.catalogReadFailing.add(nodeId);
 					this.deps.logger.warn("node catalog read failed — placements on it wait or stay pending", {
 						tags: { nodeId },
-						meta: { error: errMsg$1(err) }
+						meta: { error: errMsg$2(err) }
 					});
 				}
 				return null;
@@ -63589,7 +64984,7 @@ var PipelineSettingsStore = class PipelineSettingsStore {
 				tags: { deviceId },
 				meta: {
 					capName: "detection-pipeline",
-					error: errMsg$1(err)
+					error: errMsg$2(err)
 				}
 			});
 			return true;
@@ -64422,7 +65817,7 @@ var ReconcileController = class ReconcileController {
 			try {
 				slots = await api.streamBroker.listAllProfileSlots.query();
 			} catch (err) {
-				this.deps.logger.debug("dispatch reconcile skipped — stream-broker not ready", { meta: { error: errMsg$1(err) } });
+				this.deps.logger.debug("dispatch reconcile skipped — stream-broker not ready", { meta: { error: errMsg$2(err) } });
 				return;
 			}
 			const desired = desiredDeviceIdsFromSlots(slots);
@@ -64449,7 +65844,7 @@ var ReconcileController = class ReconcileController {
 			} catch (err) {
 				this.deps.logger.warn("dispatch reconcile: handleDeviceRegistered failed", {
 					tags: { deviceId },
-					meta: { error: errMsg$1(err) }
+					meta: { error: errMsg$2(err) }
 				});
 			}
 			await this.reconcilePlacementFromRunners();
@@ -64477,7 +65872,7 @@ var ReconcileController = class ReconcileController {
 			const devices = await api.deviceManager.listAll.query({ projection: "slim" });
 			return new Set(devices.map((device) => device.id));
 		} catch (err) {
-			this.deps.logger.debug("dispatch reconcile: deviceManager.listAll failed", { meta: { error: errMsg$1(err) } });
+			this.deps.logger.debug("dispatch reconcile: deviceManager.listAll failed", { meta: { error: errMsg$2(err) } });
 			return null;
 		}
 	}
@@ -64503,7 +65898,7 @@ var ReconcileController = class ReconcileController {
 			} catch (err) {
 				this.deps.logger.warn("dispatch reconcile: teardown of vanished device failed", {
 					tags: { deviceId },
-					meta: { error: errMsg$1(err) }
+					meta: { error: errMsg$2(err) }
 				});
 			}
 		}
@@ -64560,7 +65955,7 @@ var ReconcileController = class ReconcileController {
 			this.deps.logger.debug("placement reconcile skipped node — getLocalCameras failed", {
 				tags: { nodeId },
 				meta: {
-					error: outcome.kind === "rejected" ? errMsg$1(outcome.error) : "budget exceeded",
+					error: outcome.kind === "rejected" ? errMsg$2(outcome.error) : "budget exceeded",
 					ms
 				}
 			});
@@ -64590,7 +65985,7 @@ var ReconcileController = class ReconcileController {
 						nodeId,
 						deviceId
 					},
-					meta: { error: errMsg$1(err) }
+					meta: { error: errMsg$2(err) }
 				});
 			})));
 		}
@@ -64632,7 +66027,7 @@ var ReconcileController = class ReconcileController {
 			this.deps.handleDeviceRegistered(deviceId).catch((err) => {
 				this.deps.logger.debug("slot-read retry: handleDeviceRegistered failed", {
 					tags: { deviceId },
-					meta: { error: errMsg$1(err) }
+					meta: { error: errMsg$2(err) }
 				});
 			});
 		}, delay);
@@ -64710,7 +66105,7 @@ var ReconcileController = class ReconcileController {
 					} catch (err) {
 						this.deps.logger.warn("pending retry: dispatchCamera failed", {
 							tags: { deviceId },
-							meta: { error: errMsg$1(err) }
+							meta: { error: errMsg$2(err) }
 						});
 						stillPending++;
 					}
@@ -64788,7 +66183,7 @@ var ReconcileController = class ReconcileController {
 			await this.deps.detachOn(assignment.agentNodeId, deviceId).catch((err) => {
 				this.deps.logger.debug("remote-health exhausted-detach failed", {
 					tags: { deviceId },
-					meta: { error: errMsg$1(err) }
+					meta: { error: errMsg$2(err) }
 				});
 			});
 			return;
@@ -64811,14 +66206,14 @@ var ReconcileController = class ReconcileController {
 		await this.deps.detachOn(assignment.agentNodeId, deviceId).catch((err) => {
 			this.deps.logger.warn("remote-health detach failed", {
 				tags: { deviceId },
-				meta: { error: errMsg$1(err) }
+				meta: { error: errMsg$2(err) }
 			});
 		});
 		this.deps.ledger.dropAssignment(deviceId, "silent");
 		await this.deps.redispatchCamera(cfg).catch((err) => {
 			this.deps.logger.warn("remote-health re-dispatch failed", {
 				tags: { deviceId },
-				meta: { error: errMsg$1(err) }
+				meta: { error: errMsg$2(err) }
 			});
 		});
 	}
@@ -64993,7 +66388,7 @@ var OccupancyRecheckController = class {
 					tags: { deviceId },
 					meta: {
 						deviceId,
-						error: errMsg$1(err)
+						error: errMsg$2(err)
 					}
 				});
 			});
@@ -65127,7 +66522,7 @@ var OccupancyRecheckController = class {
 					tags: { deviceId },
 					meta: {
 						deviceId,
-						error: errMsg$1(err)
+						error: errMsg$2(err)
 					}
 				});
 			});
@@ -65182,7 +66577,7 @@ var OccupancyRecheckController = class {
 				meta: {
 					deviceId,
 					nodeId,
-					error: errMsg$1(err),
+					error: errMsg$2(err),
 					kind
 				}
 			});
@@ -65191,7 +66586,7 @@ var OccupancyRecheckController = class {
 		}
 		const answer = await this.deps.requestBurstOn(nodeId, deviceId, frames, reasonTag).catch((err) => ({
 			started: false,
-			error: errMsg$1(err)
+			error: errMsg$2(err)
 		}));
 		if (!answer.started) {
 			const refusedBecause = "refusedBecause" in answer ? answer.refusedBecause : void 0;
@@ -65239,7 +66634,7 @@ var OccupancyRecheckController = class {
 					meta: {
 						deviceId,
 						nodeId,
-						error: errMsg$1(err)
+						error: errMsg$2(err)
 					}
 				});
 			});
@@ -65296,7 +66691,7 @@ var OccupancyRecheckController = class {
 				meta: {
 					deviceId,
 					nodeId: burst.nodeId,
-					error: errMsg$1(err)
+					error: errMsg$2(err)
 				}
 			});
 		});
@@ -65511,7 +66906,15 @@ var TtlMemo = class {
 //#endregion
 //#region src/detection-session-registry.ts
 var DetectionSessionRegistry = class {
+	onChange;
 	sessions = /* @__PURE__ */ new Map();
+	/**
+	* @param onChange called after every register / deregister / clear with the
+	*   running set — feeds the placement statistics (D748). Never on a no-op.
+	*/
+	constructor(onChange = () => {}) {
+		this.onChange = onChange;
+	}
 	register(deviceId, nodeId, startedAt, triggeredBy, deviceKey) {
 		const existing = this.sessions.get(deviceId);
 		if (existing?.teardownTimer) clearTimeout(existing.teardownTimer);
@@ -65524,6 +66927,7 @@ var DetectionSessionRegistry = class {
 			...deviceKey ? { deviceKey } : {}
 		};
 		this.sessions.set(deviceId, session);
+		this.onChange(this.list());
 		return session;
 	}
 	get(deviceId) {
@@ -65537,6 +66941,7 @@ var DetectionSessionRegistry = class {
 		if (!session) return void 0;
 		if (session.teardownTimer) clearTimeout(session.teardownTimer);
 		this.sessions.delete(deviceId);
+		this.onChange(this.list());
 		return session;
 	}
 	setTeardownTimer(deviceId, timer) {
@@ -65559,9 +66964,39 @@ var DetectionSessionRegistry = class {
 	}
 	clear() {
 		for (const session of this.sessions.values()) if (session.teardownTimer) clearTimeout(session.teardownTimer);
+		const hadSessions = this.sessions.size > 0;
 		this.sessions.clear();
+		if (hadSessions) this.onChange([]);
 	}
 };
+//#endregion
+//#region src/session-share-placement.ts
+function nodeSaturated(load) {
+	return load.devices.length > 0 && load.devices.every((d) => isDeviceSaturated(d));
+}
+function electNodeByShare(input) {
+	return electByShare(input.loads.filter((l) => l.nodeId.length > 0 && input.eligible.includes(l.nodeId)).map((load) => {
+		const cap = input.caps[load.nodeId];
+		const hasCap = cap !== null && cap !== void 0 && cap > 0;
+		const weight = input.weights[load.nodeId];
+		return {
+			key: load.nodeId,
+			share: weight !== void 0 && weight > 0 ? weight : 1,
+			running: input.runningByNode.get(load.nodeId) ?? 0,
+			capped: hasCap && load.attachedCameras >= cap,
+			saturated: nodeSaturated(load),
+			...hasCap ? { spare: Math.max(0, cap - load.attachedCameras) } : {}
+		};
+	}));
+}
+/** Parallel sessions per node: sessions and standing cameras, each camera once. */
+function countRunningByNode(placements) {
+	const seen = /* @__PURE__ */ new Map();
+	for (const p of placements) if (!seen.has(p.deviceId)) seen.set(p.deviceId, p.nodeId);
+	const out = /* @__PURE__ */ new Map();
+	for (const nodeId of seen.values()) out.set(nodeId, (out.get(nodeId) ?? 0) + 1);
+	return out;
+}
 /**
 * Minimum time a detection session stays open, whatever closes it.
 *
@@ -65674,7 +67109,15 @@ var SessionDispatchController = class {
 	* (not `private`) — see the class doc for the two production/test reasons
 	* `index.ts` reaches through it directly.
 	*/
-	sessionRegistry = new DetectionSessionRegistry();
+	sessionRegistry = new DetectionSessionRegistry((sessions) => this.deps.placementStats?.noteSessions(sessions.map((s) => ({
+		nodeId: s.nodeId,
+		deviceKey: s.deviceKey ?? ""
+	}))));
+	/**
+	* `deviceId|deviceKey` of device pins the session path has already said it
+	* ignored — one line per stale pin, not one per session (D748).
+	*/
+	reportedStalePins = /* @__PURE__ */ new Set();
 	/**
 	* Per-device async mutex for session dispatch/teardown critical sections —
 	* backed by the generic `KeyedAsyncLock` (mirrors the audio controller's
@@ -65953,7 +67396,7 @@ var SessionDispatchController = class {
 						deviceId,
 						nodeId: session.nodeId
 					},
-					meta: { error: errMsg$1(err) }
+					meta: { error: errMsg$2(err) }
 				});
 			});
 			this.deps.dropAssignment(deviceId, "silent");
@@ -66135,6 +67578,76 @@ var SessionDispatchController = class {
 		});
 	}
 	/**
+	* The session's node. `least-loaded` (and any node pin, under either
+	* policy) is `balance()` exactly as before. `share` holds the node shares
+	* of PARALLEL sessions (D748): sessions now running and standing cameras
+	* count toward their node, and a node at its cap or drowning yields —
+	* logged with the reason, and counted against the node in the stats.
+	*/
+	electSessionNode(input) {
+		const balanced = () => balance({
+			nodes: input.loads,
+			preferredAgent: input.preferredAgent,
+			nodeCaps: input.nodeCaps,
+			weights: input.weights,
+			eligibleNodes: input.eligible
+		});
+		if (input.policy !== "share" || input.preferredAgent) return balanced();
+		const running = countRunningByNode([...this.sessionRegistry.list().map((s) => ({
+			deviceId: s.deviceId,
+			nodeId: s.nodeId
+		})), ...this.deps.ledger.listAssignments().map((a) => ({
+			deviceId: a.deviceId,
+			nodeId: a.agentNodeId
+		}))]);
+		const election = electNodeByShare({
+			loads: input.loads,
+			eligible: input.eligible,
+			weights: input.weights,
+			caps: input.nodeCaps,
+			runningByNode: running
+		});
+		if (election.kind === "none") return balanced();
+		if (election.reason === "yield") {
+			this.deps.placementStats?.noteYield(election.turnKey);
+			this.deps.logger.info("detection session: share turn yielded — the node had no room", {
+				tags: {
+					deviceId: input.deviceId,
+					nodeId: election.key
+				},
+				meta: {
+					turnNodeId: election.turnKey,
+					reason: election.yieldReason
+				}
+			});
+		}
+		const load = input.loads.find((l) => l.nodeId === election.key);
+		return {
+			kind: "assigned",
+			agentNodeId: election.key,
+			reason: "capacity",
+			score: load ? load.attachedCameras + load.queueDepthTotal : 0
+		};
+	}
+	/**
+	* Say ONCE that a camera's device pin names a device this node does not
+	* offer (disabled, absent): the session path ignores it, and the Load
+	* balancing tab offers to clear it. Never cleared here (D748).
+	*/
+	noteStalePin(deviceId, pinnedDeviceKey, enabledDevices) {
+		if (pinnedDeviceKey === null || pinnedDeviceKey in enabledDevices) return;
+		const key = `${deviceId}|${pinnedDeviceKey}`;
+		if (this.reportedStalePins.has(key)) return;
+		this.reportedStalePins.add(key);
+		this.deps.logger.warn("device pin ignored — the pinned device is not enabled on the elected node", {
+			tags: { deviceId },
+			meta: {
+				pin: pinnedDeviceKey,
+				enabled: Object.keys(enabledDevices).join(",")
+			}
+		});
+	}
+	/**
 	* Dispatch a session-time detection attach for an on-motion camera whose
 	* `decideSessionAction` returned `'dispatch'`. Builds a session
 	* `RunnerCameraConfig` the same way `startDetection` does, but forces
@@ -66170,7 +67683,7 @@ var SessionDispatchController = class {
 		};
 		if (reconcileBudgetExceeded) log.warn("detection session: placement census overran its budget — placing without it", { meta: { budgetMs: 500 } });
 		else if (censusOutcome.kind === "rejected") log.warn("detection session: placement census failed — placing on the ledger as it is", { meta: {
-			error: errMsg$1(censusOutcome.error),
+			error: errMsg$2(censusOutcome.error),
 			reconcileMs
 		} });
 		const balanceStartedAt = Date.now();
@@ -66185,12 +67698,17 @@ var SessionDispatchController = class {
 		const usableEligible = allEligible.filter((n) => this.deps.isNodeInferenceUsable(n));
 		const eligible = usableEligible.length > 0 ? usableEligible : allEligible;
 		if (usableEligible.length > 0 && usableEligible.length < allEligible.length) log.info("nodes dropped from session placement — no usable inference device", { meta: { dropped: allEligible.filter((n) => !usableEligible.includes(n)) } });
-		const decision = balance({
-			nodes: loads,
+		const nodeCaps = await this.nodeCaps.get(CLUSTER_KEY);
+		const weights = await this.nodeWeights.get(CLUSTER_KEY);
+		const policy = this.deps.sessionPlacement?.() ?? "least-loaded";
+		const decision = this.electSessionNode({
+			deviceId,
+			policy,
+			loads,
 			preferredAgent,
-			nodeCaps: await this.nodeCaps.get(CLUSTER_KEY),
-			weights: await this.nodeWeights.get(CLUSTER_KEY),
-			eligibleNodes: eligible
+			nodeCaps,
+			weights,
+			eligible
 		});
 		if (!decision || decision.kind !== "assigned") {
 			log.warn("detection session: no eligible node — will retry on next motion", { meta: { reason: decision?.kind === "pending" ? decision.reason : "no-runners-online" } });
@@ -66203,12 +67721,14 @@ var SessionDispatchController = class {
 		const targetLoad = loads.find((n) => n.nodeId === targetNodeId);
 		const deviceCaps = await this.inferenceDeviceCaps.get(targetNodeId);
 		const pinnedDeviceKey = await this.deps.readPipelineDevicePin(deviceId);
+		this.noteStalePin(deviceId, pinnedDeviceKey, enabledDevices);
 		const selection = pickInferenceDevice({
 			eligible: enabledDevices,
 			loads: targetLoad?.devices ?? [],
 			caps: deviceCaps,
-			pinnedDeviceKey,
-			rotation: this.deps.inferenceRotation
+			pinnedDeviceKey: pinnedDeviceKey !== null && pinnedDeviceKey in enabledDevices ? pinnedDeviceKey : null,
+			rotation: this.deps.inferenceRotation,
+			policy
 		});
 		const deviceKey = selectedDeviceKey(selection);
 		log.info("inference device selection", {
@@ -66296,6 +67816,7 @@ var SessionDispatchController = class {
 			attachedAt = Date.now();
 			this.deps.recordAssignment(deviceId, targetNodeId, decision.reason, decision.reason === "manual");
 			this.sessionRegistry.register(deviceId, targetNodeId, Date.now(), triggeredBy, deviceKey);
+			this.deps.placementStats?.noteStart(targetNodeId, deviceKey ?? "");
 			if (this.sessionRefusals.delete(deviceId)) log.info("detection session refusal cleared — a session opened", {
 				tags: {
 					deviceId,
@@ -66364,7 +67885,7 @@ var SessionDispatchController = class {
 				await this.resolveSessionLifecycleLocked(deviceId, reason);
 			}).catch((err) => {
 				log.warn("detection session: lifecycle re-check failed", { meta: {
-					error: errMsg$1(err),
+					error: errMsg$2(err),
 					reason
 				} });
 			});
@@ -66469,7 +67990,7 @@ var SessionDispatchController = class {
 			log.warn("detection session: teardown detach failed", {
 				tags: { nodeId: session.nodeId },
 				meta: {
-					error: errMsg$1(err),
+					error: errMsg$2(err),
 					reason
 				}
 			});
@@ -66576,7 +68097,7 @@ var SessionDispatchController = class {
 							deviceId,
 							nodeId: session.nodeId
 						},
-						meta: { error: errMsg$1(err) }
+						meta: { error: errMsg$2(err) }
 					});
 				});
 				this.sessionRegistry.deregister(deviceId);
@@ -66597,7 +68118,7 @@ var SessionDispatchController = class {
 						deviceId,
 						nodeId: watchNodeId
 					},
-					meta: { error: errMsg$1(err) }
+					meta: { error: errMsg$2(err) }
 				});
 			});
 			this.motionWatchByDevice.delete(deviceId);
@@ -66780,7 +68301,7 @@ async function sweepMirror(deps, hydrator, cameraIds) {
 				tags: { deviceId },
 				meta: {
 					mirror: hydrator.mirror,
-					error: errMsg$1(err)
+					error: errMsg$2(err)
 				}
 			});
 			return "threw";
@@ -66820,7 +68341,7 @@ async function readCameraIds(deps) {
 			lastError = err;
 		}
 		if (Date.now() >= deadline) {
-			deps.logger.warn("zones mirror boot hydration SKIPPED — camera list never became readable; mirror-only consumers keep whatever the last write left", { meta: { error: lastError === null ? "ctx.api unavailable" : errMsg$1(lastError) } });
+			deps.logger.warn("zones mirror boot hydration SKIPPED — camera list never became readable; mirror-only consumers keep whatever the last write left", { meta: { error: lastError === null ? "ctx.api unavailable" : errMsg$2(lastError) } });
 			return null;
 		}
 		await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
@@ -67441,6 +68962,7 @@ async function buildOrchestratorControllers(deps) {
 		readGlobalSettings: () => globalSettings,
 		onCensus: (entries) => {
 			motionSliceGate?.noteCensus(entries);
+			deps.onRunnerCensus(entries.flatMap((e) => e.load === null ? [] : [e.load]));
 			providerSliceGate?.refreshIfStale("runner-census");
 		}
 	});
@@ -67467,7 +68989,7 @@ async function buildOrchestratorControllers(deps) {
 		} catch (err) {
 			return {
 				kind: "unknown",
-				reason: errMsg$1(err)
+				reason: errMsg$2(err)
 			};
 		}
 	};
@@ -67552,18 +69074,19 @@ async function buildOrchestratorControllers(deps) {
 		readGlobalSettings: () => globalSettings
 	});
 	await NodeStressMoveLedger.declare(deps.ctx().api.settingsStore).then(() => nodeStress.hydrate()).catch((err) => {
-		deps.ctx().logger.warn("node-stress move history unavailable — this boot starts cold", { meta: { error: errMsg$1(err) } });
+		deps.ctx().logger.warn("node-stress move history unavailable — this boot starts cold", { meta: { error: errMsg$2(err) } });
 	});
 	await NodeStressLts.declare(deps.ctx().api.settingsStore).catch((err) => {
-		deps.ctx().logger.warn("node-stress statistics unavailable — no baseline this boot", { meta: { error: errMsg$1(err) } });
+		deps.ctx().logger.warn("node-stress statistics unavailable — no baseline this boot", { meta: { error: errMsg$2(err) } });
 	});
 	const nodeStressLtsTimer = setInterval(() => {
 		nodeStressLts.flushDue().catch((err) => {
-			deps.ctx().logger.warn("node-stress statistics flush failed", { meta: { error: errMsg$1(err) } });
+			deps.ctx().logger.warn("node-stress statistics flush failed", { meta: { error: errMsg$2(err) } });
 		});
 	}, 6e4);
 	nodeStress.start();
 	const inferenceRotation = new RoundRobinInferenceDeviceRotation();
+	const readSessionPlacement = () => parseSessionPlacementPolicy(globalSettings?.[SESSION_PLACEMENT_SETTING_KEY]);
 	/**
 	* Can the watchdog's audio stage ever receive a signal for this camera?
 	* Only `absent` — POSITIVE evidence of no audio track — disarms it.
@@ -67647,6 +69170,8 @@ async function buildOrchestratorControllers(deps) {
 		getInferenceDeviceCaps: (nodeId) => deps.getInferenceDeviceCaps(nodeId),
 		readPipelineDevicePin: (deviceId) => deps.readPipelineDevicePin(deviceId),
 		inferenceRotation,
+		sessionPlacement: () => readSessionPlacement(),
+		placementStats: deps.placementStats,
 		logger: deps.ctx().logger
 	});
 	const deviceConfig = new DeviceConfigContributions({
@@ -67709,7 +69234,7 @@ async function buildOrchestratorControllers(deps) {
 		} catch (err) {
 			return {
 				kind: "unreadable",
-				error: errMsg$1(err)
+				error: errMsg$2(err)
 			};
 		}
 	};
@@ -67743,7 +69268,7 @@ async function buildOrchestratorControllers(deps) {
 			} catch (err) {
 				return {
 					kind: "unreadable",
-					error: errMsg$1(err)
+					error: errMsg$2(err)
 				};
 			}
 		},
@@ -67774,7 +69299,7 @@ async function buildOrchestratorControllers(deps) {
 			} catch (err) {
 				return {
 					kind: "unreadable",
-					error: errMsg$1(err)
+					error: errMsg$2(err)
 				};
 			}
 		},
@@ -67787,7 +69312,7 @@ async function buildOrchestratorControllers(deps) {
 			} catch (err) {
 				return {
 					kind: "unreadable",
-					error: errMsg$1(err)
+					error: errMsg$2(err)
 				};
 			}
 		},
@@ -67858,7 +69383,7 @@ async function buildOrchestratorControllers(deps) {
 		deps.applyRuntimeSettings(globalSettings);
 		await topology.refreshNodeCapabilities();
 	} catch (err) {
-		const msg = errMsg$1(err);
+		const msg = errMsg$2(err);
 		deps.ctx().logger.warn("orchestrator settings load failed — using defaults", { meta: { error: msg } });
 	}
 	const rawNodeId = deps.ctx().kernel.localNodeId ?? "hub";
@@ -67899,7 +69424,7 @@ async function buildOrchestratorControllers(deps) {
 		audio.markNodeOffline(nodeId);
 		deps.forgetInferenceDeviceProbe(nodeId);
 		nodeLifecycle.handleNodeDisconnect(nodeId).catch((err) => {
-			const msg = errMsg$1(err);
+			const msg = errMsg$2(err);
 			deps.ctx().logger.error("failover after disconnect failed", {
 				tags: { nodeId },
 				meta: { error: msg }
@@ -67934,7 +69459,7 @@ async function buildOrchestratorControllers(deps) {
 			deps.subscribeToAudioAnalyzerReadiness(nodeId);
 		}
 		nodeLifecycle.handleNodeConnect(nodeId).catch((err) => {
-			const msg = errMsg$1(err);
+			const msg = errMsg$2(err);
 			deps.ctx().logger.error("reconnect handling failed", {
 				tags: { nodeId },
 				meta: { error: msg }
@@ -67953,7 +69478,7 @@ async function buildOrchestratorControllers(deps) {
 			meta: { capName }
 		});
 		nodeLifecycle.handleNodeDisconnect(nodeId).catch((err) => {
-			const msg = errMsg$1(err);
+			const msg = errMsg$2(err);
 			deps.ctx().logger.error("failover after cap-down failed", {
 				tags: { nodeId },
 				meta: {
@@ -68016,7 +69541,7 @@ async function buildOrchestratorControllers(deps) {
 		doneFlag: settingsStore.bindingsMigrationDoneState,
 		logger: deps.ctx().logger
 	}).catch((err) => {
-		deps.ctxIfReady()?.logger.warn("bindings migration failed — will retry on next boot", { meta: { error: errMsg$1(err) } });
+		deps.ctxIfReady()?.logger.warn("bindings migration failed — will retry on next boot", { meta: { error: errMsg$2(err) } });
 	});
 	migrateStepGating({
 		readCameraSettings: () => settingsStore.readCameraSettingsMap(),
@@ -68029,7 +69554,7 @@ async function buildOrchestratorControllers(deps) {
 		for (let i = 0; deps.ctxIfReady()?.api == null && i < 30; i++) await new Promise((r) => setTimeout(r, 200));
 		if (deps.ctxIfReady() !== null) await deps.resetRemovedModelPins("boot");
 	}).catch((err) => {
-		deps.ctxIfReady()?.logger.warn("step-gating / per-node-device migration failed — retry next boot", { meta: { error: errMsg$1(err) } });
+		deps.ctxIfReady()?.logger.warn("step-gating / per-node-device migration failed — retry next boot", { meta: { error: errMsg$2(err) } });
 	});
 	const zoneRulesProvider = new ZoneRulesProvider({
 		logger: deps.ctx().logger.child("zone-rules"),
@@ -68071,7 +69596,7 @@ async function buildOrchestratorControllers(deps) {
 						deviceId,
 						nodeId: assignment.agentNodeId
 					},
-					meta: { error: errMsg$1(err) }
+					meta: { error: errMsg$2(err) }
 				});
 			});
 		}
@@ -68087,7 +69612,7 @@ async function buildOrchestratorControllers(deps) {
 		}],
 		logger: deps.ctx().logger.child("zones")
 	}).catch((err) => {
-		deps.ctxIfReady()?.logger.warn("zones mirror boot hydration failed", { meta: { error: errMsg$1(err) } });
+		deps.ctxIfReady()?.logger.warn("zones mirror boot hydration failed", { meta: { error: errMsg$2(err) } });
 	});
 	const unsubOrchestratorSubscriptions = wireOrchestratorSubscriptions({
 		eventBus: deps.ctx().eventBus,
@@ -68148,10 +69673,10 @@ async function buildOrchestratorControllers(deps) {
 		deviceSettingsSchema: () => deps.deviceSettingsSchema()
 	});
 	await detectionWiring.hydrateFeaturesMirror().catch((err) => {
-		deps.ctx().logger.warn("device-features mirror not restored — this boot starts cold", { meta: { error: errMsg$1(err) } });
+		deps.ctx().logger.warn("device-features mirror not restored — this boot starts cold", { meta: { error: errMsg$2(err) } });
 	});
 	cameraSensors.start().catch((err) => {
-		deps.ctx().logger.warn("camera sensors: boot refresh failed — waiting for the next lifecycle event", { meta: { error: errMsg$1(err) } });
+		deps.ctx().logger.warn("camera sensors: boot refresh failed — waiting for the next lifecycle event", { meta: { error: errMsg$2(err) } });
 	});
 	return {
 		ledger,
@@ -68180,7 +69705,8 @@ async function buildOrchestratorControllers(deps) {
 		unsubAgentOffline,
 		unsubOrchestratorSubscriptions,
 		pendingRetryTimer,
-		autoRebalanceTimer
+		autoRebalanceTimer,
+		sessionPlacement: () => readSessionPlacement()
 	};
 }
 //#endregion
@@ -68225,6 +69751,20 @@ function buildGlobalSettingsSections(options) {
 			title: "Load Balancer",
 			tab: "pipeline",
 			fields: [
+				{
+					key: SESSION_PLACEMENT_SETTING_KEY,
+					type: "select",
+					label: "Session placement",
+					description: "How a new detection session picks its node and device. Least-loaded = the node with the fewest sessions per unit of weight; an idle node always wins the tie, so weights only matter once nodes are busy. Honour shares = the share of PARALLEL sessions is held to the node and device weights, and a node at its cap yields to a free one. Moving a weight slider never changes this policy.",
+					options: [{
+						value: "least-loaded",
+						label: "Least-loaded"
+					}, {
+						value: "share",
+						label: "Honour shares"
+					}],
+					default: DEFAULT_SESSION_PLACEMENT_POLICY
+				},
 				{
 					key: "fpsMinThreshold",
 					type: "slider",
@@ -68783,6 +70323,959 @@ var pipelineOrchestratorWidgets = [{
 	defaultRows: 4
 }];
 //#endregion
+//#region src/best-settings/plan-diff.ts
+/**
+* The Best settings writes, as pure transforms of the orchestrator's two
+* settings blobs (D745). The plan runs them on the current blobs to SHOW the
+* diff; the apply runs the same functions inside each blob's read-modify-write.
+*
+* What changes — and nothing else:
+*  - node level (`agentSettings[node].inferenceDevices[deviceKey].steps`): the
+*    object-detection `modelId` of every recommended device is set; the
+*    `modelId` pin of every other in-scope step is removed (each runs its
+*    step default again); every model-bound threshold (and its binding key) is
+*    removed from every device's step `settings`, so the running model's own
+*    defaults apply (D738–D741). `enabled`, `weight`, `maxSessions`,
+*    `jumpDeviceKey` and every other setting are kept.
+*  - camera level, scoped to the touched nodes: the same `modelId` pins and
+*    model-bound thresholds are removed from `stepOverridesByDevice[node]` and
+*    from the wholesale `pipelineByAgent[node]` snapshot (recursively). A
+*    wholesale step keeps `enabled`, `children`, `jumpDeviceKey` and its other
+*    settings: the attach provisions the node pin over the snapshot
+*    (`applyDeviceProvisioning`: override ?? base), so once the snapshot pin
+*    is gone the node's recommended model runs.
+*  - never: `stepToggles`, devices' enablement, pins of
+*    embedding steps (cluster-scoped, changing one forces a re-index).
+*/
+/** The root detector step. */
+var DETECTOR_STEP_ID = "object-detection";
+/** Steps whose `modelId` pin Best settings never touches. */
+function isModelPinKept(stepId) {
+	return stepId.endsWith("-embedding");
+}
+function boundKeysFor(input, stepId) {
+	return input.boundKeysByStep[stepId] ?? [];
+}
+/** The model-bound keys present in `settings` (values or bindings), and the rest. */
+function stripBound(settings, boundKeys) {
+	if (settings === void 0) return {
+		kept: void 0,
+		removed: []
+	};
+	const kept = { ...settings };
+	const removed = [];
+	for (const key of boundKeys) for (const k of [key, modelBindingKey(key)]) if (k in kept) {
+		delete kept[k];
+		removed.push(k);
+	}
+	return {
+		kept,
+		removed: removed.toSorted()
+	};
+}
+function pinInScope(stepId) {
+	return !isModelPinKept(stepId);
+}
+/** Rebuild one stored step without the in-scope pin and bound keys. */
+function scrubStep(stepId, step, boundKeys, targetModel) {
+	const before = step.modelId ?? null;
+	let modelId = step.modelId;
+	if (stepId === "object-detection") {
+		if (targetModel !== void 0) modelId = targetModel;
+	} else if (pinInScope(stepId)) modelId = void 0;
+	const { kept, removed } = stripBound(step.settings, boundKeys);
+	const after = modelId ?? null;
+	const next = {
+		...modelId !== void 0 ? { modelId } : {},
+		...kept !== void 0 && Object.keys(kept).length > 0 ? { settings: kept } : {},
+		...step.jumpDeviceKey !== void 0 ? { jumpDeviceKey: step.jumpDeviceKey } : {}
+	};
+	return {
+		next: Object.keys(next).length > 0 ? next : null,
+		pin: before !== after ? {
+			stepId,
+			before,
+			after
+		} : null,
+		cleared: removed
+	};
+}
+/** The node-level transform. Returns the next blob and every change it made. */
+function applyNodeBestSettings(blob, input) {
+	const next = { ...blob };
+	const changes = [];
+	for (const nodeId of [...input.touchedNodes].toSorted()) {
+		const entry = blob[nodeId];
+		const targets = new Map((input.targets.get(nodeId) ?? []).map((t) => [t.deviceKey, t]));
+		const stored = entry?.inferenceDevices ?? {};
+		const deviceKeys = [...new Set([...Object.keys(stored), ...targets.keys()])].toSorted();
+		const nextDevices = {};
+		for (const deviceKey of deviceKeys) {
+			const device = stored[deviceKey];
+			const target = targets.get(deviceKey);
+			const steps = { ...device?.steps };
+			if (target !== void 0 && steps["object-detection"] === void 0) steps[DETECTOR_STEP_ID] = {};
+			const nextSteps = {};
+			const pins = [];
+			const thresholds = [];
+			for (const stepId of Object.keys(steps).toSorted()) {
+				const step = steps[stepId];
+				if (step === void 0) continue;
+				const scrubbed = scrubStep(stepId, step, boundKeysFor(input, stepId), target?.modelId);
+				if (scrubbed.next !== null) nextSteps[stepId] = scrubbed.next;
+				if (scrubbed.pin !== null) pins.push(scrubbed.pin);
+				if (scrubbed.cleared.length > 0) thresholds.push({
+					stepId,
+					keys: scrubbed.cleared
+				});
+			}
+			const madeExplicit = device === void 0;
+			nextDevices[deviceKey] = {
+				...device !== void 0 ? (({ steps: _steps, ...rest }) => rest)(device) : { enabled: target?.effectiveEnabled ?? false },
+				...Object.keys(nextSteps).length > 0 ? { steps: nextSteps } : {}
+			};
+			if (pins.length > 0 || thresholds.length > 0) changes.push({
+				nodeId,
+				deviceKey,
+				madeExplicit,
+				modelPins: pins,
+				thresholds
+			});
+		}
+		if (entry === void 0 && deviceKeys.length === 0) continue;
+		next[nodeId] = {
+			...entry ?? { maxCameras: null },
+			...deviceKeys.length > 0 ? { inferenceDevices: nextDevices } : {}
+		};
+	}
+	return {
+		next,
+		changes
+	};
+}
+/** Scrub a wholesale snapshot tree; collects one clear per changed step. */
+function scrubTree(steps, input, onClear) {
+	return steps.map((step) => {
+		const children = step.children ? scrubTree(step.children, input, onClear) : void 0;
+		const inScope = step.addonId === "object-detection" || pinInScope(step.addonId);
+		const { kept, removed } = stripBound(step.settings, boundKeysFor(input, step.addonId));
+		const dropPin = inScope && step.modelId !== void 0;
+		if (dropPin || removed.length > 0) onClear(step.addonId, dropPin ? step.modelId ?? null : null, removed);
+		const { modelId: _modelId, settings: _settings, children: _children, ...rest } = step;
+		return {
+			...rest,
+			...!dropPin && step.modelId !== void 0 ? { modelId: step.modelId } : {},
+			...kept !== void 0 && Object.keys(kept).length > 0 ? { settings: kept } : {},
+			...children !== void 0 ? { children } : {}
+		};
+	});
+}
+/** The camera-level transform. Returns the next blob and every override it removed. */
+function applyCameraBestSettings(blob, input) {
+	const next = {};
+	const clears = [];
+	for (const key of Object.keys(blob).toSorted((a, b) => Number(a) - Number(b))) {
+		const camera = blob[key];
+		if (camera === void 0) continue;
+		const deviceId = Number(key);
+		let nextCamera = camera;
+		const byNode = camera.stepOverridesByDevice;
+		if (byNode !== void 0) {
+			const nextByNode = {};
+			for (const [nodeId, byDevice] of Object.entries(byNode)) {
+				if (!input.touchedNodes.has(nodeId)) {
+					nextByNode[nodeId] = byDevice;
+					continue;
+				}
+				const nextByDevice = {};
+				for (const [deviceKey, byStep] of Object.entries(byDevice)) {
+					const nextByStep = {};
+					for (const [stepId, patch] of Object.entries(byStep)) {
+						const inScope = stepId === "object-detection" || pinInScope(stepId);
+						const { kept, removed } = stripBound(patch.settings, boundKeysFor(input, stepId));
+						const dropPin = inScope && patch.modelId !== void 0;
+						if (dropPin || removed.length > 0) clears.push({
+							deviceId,
+							source: "step-override",
+							nodeId,
+							deviceKey,
+							stepId,
+							modelIdBefore: dropPin ? patch.modelId ?? null : null,
+							keys: removed
+						});
+						const rebuilt = {
+							...!dropPin && patch.modelId !== void 0 ? { modelId: patch.modelId } : {},
+							...kept !== void 0 && Object.keys(kept).length > 0 ? { settings: kept } : {}
+						};
+						if (Object.keys(rebuilt).length > 0) nextByStep[stepId] = rebuilt;
+					}
+					if (Object.keys(nextByStep).length > 0) nextByDevice[deviceKey] = nextByStep;
+				}
+				if (Object.keys(nextByDevice).length > 0) nextByNode[nodeId] = nextByDevice;
+			}
+			const { stepOverridesByDevice: _drop, ...rest } = nextCamera;
+			nextCamera = {
+				...rest,
+				...Object.keys(nextByNode).length > 0 ? { stepOverridesByDevice: nextByNode } : {}
+			};
+		}
+		const wholesale = camera.pipelineByAgent;
+		if (wholesale !== void 0) {
+			const nextWholesale = {};
+			for (const [nodeId, snapshot] of Object.entries(wholesale)) {
+				if (!input.touchedNodes.has(nodeId)) {
+					nextWholesale[nodeId] = snapshot;
+					continue;
+				}
+				nextWholesale[nodeId] = {
+					...snapshot,
+					steps: scrubTree(snapshot.steps, input, (stepId, modelIdBefore, keys) => {
+						clears.push({
+							deviceId,
+							source: "wholesale",
+							nodeId,
+							deviceKey: null,
+							stepId,
+							modelIdBefore,
+							keys
+						});
+					})
+				};
+			}
+			nextCamera = {
+				...nextCamera,
+				pipelineByAgent: nextWholesale
+			};
+		}
+		next[key] = nextCamera;
+	}
+	return {
+		next,
+		clears
+	};
+}
+//#endregion
+//#region src/best-settings/best-settings-service.ts
+/**
+* Best settings (D745): gather the inputs, compute the plan, and apply exactly
+* the plan the operator confirmed.
+*
+* The plan is the recommender (`@camstack/types` best-settings) over every
+* runner node, plus the diff of the writes (`plan-diff.ts`) and the
+* per-camera detector thresholds the hub's executor would clear. Its
+* `planHash` names everything the apply writes; the apply recomputes the plan
+* and refuses a different hash, so a configuration change between the two is
+* shown to the operator again instead of being written over.
+*
+* Apply order, each phase reported:
+*  1. download every newly picked detector on its node FIRST — a node never
+*     switches to a model it does not have (an N100 compile takes 5–25 s, a
+*     Core ML package 40 MB); any failure stops the apply before a write;
+*  2. camera overrides (one camera-blob read-modify-write);
+*  3. per-camera detector thresholds (the hub executor's store);
+*  4. node model pins (one agent-blob read-modify-write);
+*  5. re-dispatch the cameras of every touched node.
+* A failure after phase 2 leaves "overrides cleared, previous node model",
+* which is a valid configuration (the defaults run); re-running converges.
+*/
+function errMsg(err) {
+	return err instanceof Error ? err.message : String(err);
+}
+/** Canonical JSON (sorted keys) — the plan hash must not depend on key order. */
+function canonical(value) {
+	if (Array.isArray(value)) return `[${value.map(canonical).join(",")}]`;
+	if (typeof value === "object" && value !== null) return `{${Object.entries(value).filter(([, v]) => v !== void 0).toSorted(([a], [b]) => a.localeCompare(b)).map(([k, v]) => `${JSON.stringify(k)}:${canonical(v)}`).join(",")}}`;
+	return JSON.stringify(value);
+}
+function formatsByModelOf(catalog) {
+	const out = {};
+	for (const slot of catalog?.slots ?? []) for (const addon of slot.addons) {
+		if (addon.id !== "object-detection") continue;
+		for (const model of addon.models) out[model.id] = MODEL_FORMATS.filter((f) => f in model.formats);
+	}
+	return out;
+}
+function boundKeysOf(catalogs) {
+	const byStep = /* @__PURE__ */ new Map();
+	for (const catalog of catalogs) for (const slot of catalog?.slots ?? []) for (const addon of slot.addons) {
+		const keys = collectModelBoundKeys(addon.configSchema ?? []);
+		if (keys.length === 0) continue;
+		const set = byStep.get(addon.id) ?? /* @__PURE__ */ new Set();
+		for (const k of keys) set.add(k);
+		byStep.set(addon.id, set);
+	}
+	return Object.fromEntries([...byStep].map(([step, set]) => [step, [...set].toSorted()]));
+}
+/** Bounded fixed point of the hardware share suggestion (D748). */
+var SUGGEST_MAX_ROUNDS = 3;
+/** Integer shares summing to 100 (largest remainder). */
+function toPercent(weights) {
+	const total = [...weights.values()].reduce((a, b) => a + b, 0);
+	const out = /* @__PURE__ */ new Map();
+	if (total <= 0) return out;
+	const raw = [...weights].map(([k, w]) => ({
+		k,
+		exact: w / total * 100
+	}));
+	let assigned = 0;
+	for (const r of raw) {
+		out.set(r.k, Math.floor(r.exact));
+		assigned += Math.floor(r.exact);
+	}
+	const byRemainder = raw.toSorted((a, b) => b.exact - Math.floor(b.exact) - (a.exact - Math.floor(a.exact)) || a.k.localeCompare(b.k));
+	for (let i = 0; i < 100 - assigned; i++) {
+		const r = byRemainder[i % byRemainder.length];
+		out.set(r.k, (out.get(r.k) ?? 0) + 1);
+	}
+	return out;
+}
+var BestSettingsService = class {
+	deps;
+	applying = false;
+	constructor(deps) {
+		this.deps = deps;
+	}
+	async plan(input) {
+		return (await this.computePlan(input.headroom, input.shares)).plan;
+	}
+	/**
+	* Shares proportional to each node's capacity at the models Best settings
+	* would pick under those very shares (D748). Model and load depend on each
+	* other, so it iterates from equal shares until the rounded shares stop
+	* moving, at most {@link SUGGEST_MAX_ROUNDS} rounds. Per device it reports an
+	* ADVISORY session cap — never written, never enforced.
+	*/
+	async suggestShares(input) {
+		let shares = {
+			nodes: {},
+			devices: {}
+		};
+		let result = [];
+		let cameraFps = 10;
+		let rounds = 0;
+		for (let round = 1; round <= SUGGEST_MAX_ROUNDS; round++) {
+			rounds = round;
+			const rec = await this.recommend(input.headroom, shares);
+			cameraFps = rec.cameraFps;
+			result = this.sharesFrom(rec, input.headroom);
+			const next = {
+				nodes: Object.fromEntries(result.flatMap((n) => n.share !== null && n.share > 0 ? [[n.nodeId, n.share]] : [])),
+				devices: Object.fromEntries(result.map((n) => [n.nodeId, Object.fromEntries(n.devices.flatMap((d) => d.share > 0 ? [[d.deviceKey, d.share]] : []))]))
+			};
+			const settled = JSON.stringify(next) === JSON.stringify(shares);
+			shares = next;
+			if (settled) break;
+		}
+		return {
+			headroom: input.headroom,
+			cameraFps,
+			iterations: rounds,
+			nodes: [...result]
+		};
+	}
+	sharesFrom(rec, headroom) {
+		const capacityByNode = /* @__PURE__ */ new Map();
+		const perNode = rec.recommendations.map((r) => {
+			const devices = r.devices.filter((d) => d.enabled && d.available && d.chosen !== null).map((d) => {
+				const fps = d.chosen?.fps ?? 0;
+				return {
+					d,
+					fps,
+					sessions: rec.cameraFps > 0 ? Math.floor(fps * (1 - headroom) / rec.cameraFps) : 0
+				};
+			});
+			const capacity = devices.reduce((sum, x) => sum + x.sessions, 0);
+			if (!r.skipped && capacity > 0) capacityByNode.set(r.nodeId, capacity);
+			return {
+				r,
+				devices,
+				capacity
+			};
+		});
+		const nodePct = toPercent(capacityByNode);
+		return perNode.map(({ r, devices, capacity }) => {
+			const devicePct = toPercent(new Map(devices.map((x) => [x.d.deviceKey, Math.max(x.fps, 0)])));
+			return {
+				nodeId: r.nodeId,
+				share: nodePct.get(r.nodeId) ?? null,
+				capacitySessions: capacity,
+				skippedReason: r.skipped ? r.reasons[0]?.kind ?? "skipped" : capacity > 0 ? null : "no-capacity",
+				devices: devices.map((x) => ({
+					deviceKey: x.d.deviceKey,
+					share: devicePct.get(x.d.deviceKey) ?? 0,
+					modelId: x.d.chosen?.modelId ?? null,
+					fps: x.d.chosen?.fps ?? null,
+					measured: x.d.chosen?.measured ?? false,
+					suggestedMaxSessions: x.sessions
+				}))
+			};
+		});
+	}
+	/**
+	* Gather every node and recommend. `shares` (a what-if or the suggestion's
+	* round) forces share placement with those shares overlaid on the stored
+	* ones; absent, the STORED policy decides how on-motion load is charged.
+	*/
+	async recommend(headroom, shares) {
+		const nodeIds = [...new Set(["hub", ...this.deps.runnerNodeIds()])].toSorted();
+		const gathered = await Promise.all(nodeIds.map(async (nodeId) => {
+			const [devices, hardware, catalog] = await Promise.all([
+				this.deps.readNodeDevices(nodeId),
+				this.deps.readHardware(nodeId).catch(() => null),
+				this.deps.readCatalog(nodeId).catch(() => null)
+			]);
+			return {
+				nodeId,
+				devices,
+				hardware,
+				catalog
+			};
+		}));
+		const deviceShare = (nodeId, key, stored) => shares?.devices[nodeId]?.[key] ?? stored;
+		const nodes = gathered.map((g) => ({
+			nodeId: g.nodeId,
+			reachable: g.devices.reachable && g.catalog !== null,
+			hardware: g.hardware,
+			devices: g.devices.devices.map((d) => ({
+				key: d.key,
+				format: d.format,
+				enabled: d.enabled,
+				available: d.available
+			})),
+			formatsByModel: formatsByModelOf(g.catalog)
+		}));
+		const eligible = gathered.flatMap((g) => g.devices.reachable ? g.devices.devices.filter((d) => d.enabled && d.available).map((d) => ({
+			nodeId: g.nodeId,
+			deviceKey: d.key,
+			weight: deviceShare(g.nodeId, d.key, d.weight)
+		})) : []);
+		const cameras = await this.deps.cameraLoads();
+		const policy = shares ? "share" : this.deps.sessionPlacement();
+		const demand = estimateDeviceDemand({
+			cameras,
+			eligible,
+			peaks: this.deps.peaks(),
+			...policy === "share" ? { shares: {
+				nodes: {
+					...await this.deps.readNodeShares(),
+					...shares?.nodes
+				},
+				clusterPeak: this.deps.clusterPeak()
+			} } : {}
+		});
+		const recommendations = nodes.map((node) => recommendNode({
+			node,
+			demand,
+			headroom
+		}));
+		const cameraFps = cameras.reduce((m, c) => c.mode !== "disabled" && c.runsPipelineRoot ? Math.max(m, c.fps) : m, 0);
+		return {
+			gathered,
+			nodes,
+			recommendations,
+			cameraFps: cameraFps > 0 ? cameraFps : 10
+		};
+	}
+	async computePlan(headroom, shares) {
+		const { gathered, nodes, recommendations } = await this.recommend(headroom, shares);
+		const touchedNodes = new Set(recommendations.filter((r) => !r.skipped).map((r) => r.nodeId));
+		const targets = /* @__PURE__ */ new Map();
+		const formats = /* @__PURE__ */ new Map();
+		for (const rec of recommendations) {
+			if (rec.skipped) continue;
+			const node = nodes.find((n) => n.nodeId === rec.nodeId);
+			const list = [];
+			const byKey = /* @__PURE__ */ new Map();
+			for (const d of rec.devices) {
+				if (d.chosen === null) continue;
+				list.push({
+					deviceKey: d.deviceKey,
+					modelId: d.chosen.modelId,
+					effectiveEnabled: d.enabled
+				});
+				const format = node?.devices.find((x) => x.key === d.deviceKey)?.format;
+				if (format !== void 0) byKey.set(d.deviceKey, format);
+			}
+			targets.set(rec.nodeId, list);
+			formats.set(rec.nodeId, byKey);
+		}
+		const diffInput = {
+			touchedNodes,
+			targets,
+			boundKeysByStep: boundKeysOf(gathered.map((g) => g.catalog))
+		};
+		const nodeChanges = applyNodeBestSettings(await this.deps.readAgentSettings(), diffInput).changes;
+		const cameraClears = applyCameraBestSettings(await this.deps.readCameraSettings(), diffInput).clears;
+		const warnings = [];
+		let detectorStoreClears = [];
+		if (touchedNodes.size > 0) try {
+			const answer = await this.deps.detectorStore({ dryRun: true });
+			detectorStoreClears = answer.entries.map((e) => ({
+				deviceId: e.deviceId,
+				keys: [...e.keys]
+			}));
+			if (answer.refused.length > 0) warnings.push({
+				kind: "detector-store-unreadable",
+				error: `${answer.refused.length} camera store(s) unreadable`
+			});
+		} catch (err) {
+			warnings.push({
+				kind: "detector-store-unreadable",
+				error: errMsg(err)
+			});
+		}
+		const skippedNodes = recommendations.filter((r) => r.skipped).map((r) => r.nodeId);
+		if (detectorStoreClears.length > 0 && skippedNodes.length > 0) warnings.push({
+			kind: "detector-store-cluster-wide",
+			skippedNodes
+		});
+		for (const rec of recommendations) for (const d of rec.devices) if (d.accelerator === "coral" && d.enabled) warnings.push({
+			kind: "coral-enabled",
+			nodeId: rec.nodeId,
+			deviceKey: d.deviceKey
+		});
+		return {
+			plan: {
+				planHash: createHash("sha256").update(canonical({
+					version: 1,
+					headroom,
+					whatIf: shares ?? null,
+					picks: recommendations.map((r) => ({
+						nodeId: r.nodeId,
+						skipped: r.skipped,
+						devices: r.devices.map((d) => [d.deviceKey, d.chosen?.modelId ?? null])
+					})),
+					nodeChanges,
+					cameraClears,
+					detectorStoreClears
+				})).digest("hex"),
+				family: "yolov9",
+				headroom,
+				whatIf: shares !== void 0,
+				generatedAt: this.deps.now(),
+				nodes: recommendations,
+				nodeChanges: [...nodeChanges],
+				cameraClears: [...cameraClears],
+				detectorStoreClears,
+				warnings
+			},
+			diffInput,
+			formats
+		};
+	}
+	async apply(input) {
+		if (this.applying) return {
+			kind: "refused",
+			reason: "apply-in-progress"
+		};
+		this.applying = true;
+		try {
+			return await this.applyLocked(input);
+		} finally {
+			this.applying = false;
+		}
+	}
+	async applyLocked(input) {
+		const { plan, diffInput, formats } = await this.computePlan(input.headroom);
+		if (plan.planHash !== input.planHash) {
+			this.deps.logger.warn("best settings: stale plan refused", { meta: {
+				confirmed: input.planHash,
+				current: plan.planHash
+			} });
+			return {
+				kind: "stale",
+				plan
+			};
+		}
+		const phases = [];
+		const downloads = plan.nodeChanges.flatMap((c) => c.modelPins.filter((p) => p.stepId === "object-detection" && p.after !== null && p.after !== p.before).map((p) => ({
+			nodeId: c.nodeId,
+			modelId: p.after ?? "",
+			format: formats.get(c.nodeId)?.get(c.deviceKey)
+		})));
+		const unique = new Map(downloads.map((d) => [`${d.nodeId}|${d.modelId}|${d.format}`, d]));
+		try {
+			for (const d of unique.values()) {
+				if (d.format === void 0) continue;
+				await this.deps.downloadModel(d.nodeId, d.modelId, d.format);
+			}
+			phases.push({
+				phase: "download",
+				ok: true,
+				detail: `${unique.size} model(s) present on their nodes`
+			});
+		} catch (err) {
+			phases.push({
+				phase: "download",
+				ok: false,
+				detail: errMsg(err)
+			});
+			this.deps.logger.warn("best settings: a model download failed — nothing was written", { meta: { error: errMsg(err) } });
+			return {
+				kind: "aborted",
+				phases
+			};
+		}
+		try {
+			await this.deps.rewriteCameraSettings((prev) => applyCameraBestSettings(prev, diffInput).next);
+			for (const c of plan.cameraClears) this.deps.logger.info("best settings: camera override cleared", {
+				tags: {
+					deviceId: c.deviceId,
+					nodeId: c.nodeId
+				},
+				meta: {
+					deviceId: c.deviceId,
+					source: c.source,
+					deviceKey: c.deviceKey,
+					stepId: c.stepId,
+					modelIdBefore: c.modelIdBefore,
+					keys: c.keys
+				}
+			});
+			phases.push({
+				phase: "camera-overrides",
+				ok: true,
+				detail: `${plan.cameraClears.length} cleared`
+			});
+		} catch (err) {
+			phases.push({
+				phase: "camera-overrides",
+				ok: false,
+				detail: errMsg(err)
+			});
+		}
+		if (plan.detectorStoreClears.length > 0) try {
+			const answer = await this.deps.detectorStore({
+				dryRun: false,
+				deviceIds: plan.detectorStoreClears.map((c) => c.deviceId)
+			});
+			phases.push({
+				phase: "detector-thresholds",
+				ok: answer.refused.length === 0,
+				detail: `${answer.entries.length} cleared, ${answer.refused.length} refused`
+			});
+		} catch (err) {
+			phases.push({
+				phase: "detector-thresholds",
+				ok: false,
+				detail: errMsg(err)
+			});
+		}
+		try {
+			await this.deps.rewriteAgentSettings((prev) => applyNodeBestSettings(prev, diffInput).next);
+			for (const c of plan.nodeChanges) for (const pin of c.modelPins) this.deps.logger.info("best settings: node model set", {
+				tags: { nodeId: c.nodeId },
+				meta: {
+					nodeId: c.nodeId,
+					deviceKey: c.deviceKey,
+					stepId: pin.stepId,
+					from: pin.before,
+					to: pin.after
+				}
+			});
+			phases.push({
+				phase: "node-models",
+				ok: true,
+				detail: `${plan.nodeChanges.length} device(s) updated`
+			});
+		} catch (err) {
+			phases.push({
+				phase: "node-models",
+				ok: false,
+				detail: errMsg(err)
+			});
+		}
+		this.deps.invalidateCatalog();
+		const failed = [];
+		for (const nodeId of [...diffInput.touchedNodes].toSorted()) try {
+			await this.deps.redispatch(nodeId);
+		} catch (err) {
+			failed.push(`${nodeId}: ${errMsg(err)}`);
+		}
+		phases.push({
+			phase: "redispatch",
+			ok: failed.length === 0,
+			detail: failed.length === 0 ? `${diffInput.touchedNodes.size} node(s)` : failed.join("; ")
+		});
+		for (const rec of plan.nodes.filter((r) => r.skipped)) this.deps.logger.info("best settings: node skipped", {
+			tags: { nodeId: rec.nodeId },
+			meta: {
+				nodeId: rec.nodeId,
+				reasons: rec.reasons
+			}
+		});
+		this.deps.logger.info("best settings: applied", { meta: {
+			planHash: plan.planHash,
+			nodeChanges: plan.nodeChanges.length,
+			cameraClears: plan.cameraClears.length,
+			detectorStoreClears: plan.detectorStoreClears.length,
+			phases
+		} });
+		return {
+			kind: "applied",
+			planHash: plan.planHash,
+			phases
+		};
+	}
+};
+//#endregion
+//#region src/best-settings/device-peak-tracker.ts
+var BUCKET_MS = 3600 * 1e3;
+var DevicePeakTracker = class DevicePeakTracker {
+	now;
+	series = /* @__PURE__ */ new Map();
+	cluster = null;
+	constructor(now = () => Date.now()) {
+		this.now = now;
+	}
+	static key(nodeId, deviceKey) {
+		return `${nodeId}\u0000${deviceKey}`;
+	}
+	/** Fold one runner census in. A runner that did not answer is simply absent. */
+	noteCensus(loads) {
+		const now = this.now();
+		const bucket = now - now % BUCKET_MS;
+		let clusterTotal = 0;
+		for (const load of loads) {
+			const rows = load.devices.length > 0 ? load.devices : [{
+				deviceKey: "",
+				attachedCameras: load.attachedCameras
+			}];
+			for (const device of rows) {
+				clusterTotal += device.attachedCameras;
+				const key = DevicePeakTracker.key(load.nodeId, device.deviceKey);
+				let s = this.series.get(key);
+				if (s === void 0) {
+					s = {
+						firstSeenAt: now,
+						buckets: /* @__PURE__ */ new Map()
+					};
+					this.series.set(key, s);
+				}
+				s.buckets.set(bucket, Math.max(s.buckets.get(bucket) ?? 0, device.attachedCameras));
+				for (const start of s.buckets.keys()) if (start + BUCKET_MS <= now - 864e5) s.buckets.delete(start);
+			}
+		}
+		if (loads.length === 0) return;
+		const c = this.cluster ?? {
+			firstSeenAt: now,
+			buckets: /* @__PURE__ */ new Map()
+		};
+		this.cluster = c;
+		c.buckets.set(bucket, Math.max(c.buckets.get(bucket) ?? 0, clusterTotal));
+		for (const start of c.buckets.keys()) if (start + BUCKET_MS <= now - 864e5) c.buckets.delete(start);
+	}
+	/** The cluster-wide parallel peak over the window, or null before any census. */
+	clusterPeak() {
+		const c = this.cluster;
+		if (c === null) return null;
+		const now = this.now();
+		let peak = 0;
+		for (const [start, value] of c.buckets) if (start + BUCKET_MS > now - 864e5) peak = Math.max(peak, value);
+		return {
+			peakSessions: peak,
+			observedForMs: now - c.firstSeenAt
+		};
+	}
+	/** Every observed device's peak over the window and how long it has been watched. */
+	peaks() {
+		const now = this.now();
+		const out = [];
+		for (const [key, s] of this.series) {
+			const [nodeId = "", deviceKey = ""] = key.split("\0");
+			let peak = 0;
+			for (const [start, value] of s.buckets) if (start + BUCKET_MS > now - 864e5) peak = Math.max(peak, value);
+			out.push({
+				nodeId,
+				deviceKey,
+				peakSessions: peak,
+				observedForMs: now - s.firstSeenAt
+			});
+		}
+		return out.toSorted((a, b) => a.nodeId === b.nodeId ? a.deviceKey.localeCompare(b.deviceKey) : a.nodeId.localeCompare(b.nodeId));
+	}
+};
+//#endregion
+//#region src/session-placement-stats.ts
+var RETAIN_MS = 1440 * 60 * 1e3;
+function keyOf(nodeId, deviceKey) {
+	return `${nodeId}\u0000${deviceKey}`;
+}
+function split(key) {
+	const [nodeId = "", deviceKey = ""] = key.split("\0");
+	return {
+		nodeId,
+		deviceKey
+	};
+}
+var SessionPlacementStats = class {
+	now;
+	segments = [];
+	starts = [];
+	yields = [];
+	startedAt;
+	constructor(now = () => Date.now()) {
+		this.now = now;
+		this.startedAt = now();
+	}
+	/** The running-session set changed: open a new segment with these counts. */
+	noteSessions(sessions) {
+		const counts = /* @__PURE__ */ new Map();
+		for (const s of sessions) {
+			const k = keyOf(s.nodeId, s.deviceKey);
+			counts.set(k, (counts.get(k) ?? 0) + 1);
+		}
+		this.segments.push({
+			at: this.now(),
+			counts
+		});
+		this.prune();
+	}
+	noteStart(nodeId, deviceKey) {
+		this.starts.push({
+			at: this.now(),
+			nodeId,
+			deviceKey
+		});
+		this.prune();
+	}
+	/** A share election handed `nodeId`'s turn to another node. */
+	noteYield(nodeId) {
+		this.yields.push({
+			at: this.now(),
+			nodeId
+		});
+		this.prune();
+	}
+	/** For tests: how many segments are retained. */
+	segmentCount() {
+		return this.segments.length;
+	}
+	prune() {
+		const floor = this.now() - RETAIN_MS;
+		while (this.segments.length > 1 && this.segments[1].at <= floor) this.segments.shift();
+		while (this.starts.length > 0 && this.starts[0].at < floor) this.starts.shift();
+		while (this.yields.length > 0 && this.yields[0].at < floor) this.yields.shift();
+	}
+	snapshot(windowMs) {
+		const now = this.now();
+		const from = now - windowMs;
+		const integral = /* @__PURE__ */ new Map();
+		let clusterPeak = 0;
+		for (let i = 0; i < this.segments.length; i++) {
+			const seg = this.segments[i];
+			const end = this.segments[i + 1]?.at ?? now;
+			const start = Math.max(seg.at, from);
+			if (end <= start) continue;
+			let total = 0;
+			for (const [k, n] of seg.counts) {
+				integral.set(k, (integral.get(k) ?? 0) + n * (end - start));
+				total += n;
+			}
+			clusterPeak = Math.max(clusterPeak, total);
+		}
+		const current = this.segments.at(-1)?.counts ?? /* @__PURE__ */ new Map();
+		const nodeIds = /* @__PURE__ */ new Set();
+		for (const k of [...integral.keys(), ...current.keys()]) nodeIds.add(split(k).nodeId);
+		for (const s of this.starts) if (s.at >= from) nodeIds.add(s.nodeId);
+		const clusterIntegral = [...integral.values()].reduce((a, b) => a + b, 0);
+		const nodes = [...nodeIds].toSorted().map((nodeId) => {
+			const deviceKeys = /* @__PURE__ */ new Set();
+			for (const k of [...integral.keys(), ...current.keys()]) {
+				const s = split(k);
+				if (s.nodeId === nodeId) deviceKeys.add(s.deviceKey);
+			}
+			for (const s of this.starts) if (s.at >= from && s.nodeId === nodeId) deviceKeys.add(s.deviceKey);
+			const nodeIntegral = [...deviceKeys].reduce((sum, d) => sum + (integral.get(keyOf(nodeId, d)) ?? 0), 0);
+			const devices = [...deviceKeys].toSorted().map((deviceKey) => ({
+				deviceKey,
+				sessionsNow: current.get(keyOf(nodeId, deviceKey)) ?? 0,
+				sessionsStarted: this.starts.filter((s) => s.at >= from && s.nodeId === nodeId && s.deviceKey === deviceKey).length,
+				observedShare: nodeIntegral > 0 ? (integral.get(keyOf(nodeId, deviceKey)) ?? 0) / nodeIntegral : null
+			}));
+			let peak = 0;
+			for (let i = 0; i < this.segments.length; i++) {
+				const seg = this.segments[i];
+				if ((this.segments[i + 1]?.at ?? now) <= Math.max(seg.at, from)) continue;
+				let n = 0;
+				for (const [k, c] of seg.counts) if (split(k).nodeId === nodeId) n += c;
+				peak = Math.max(peak, n);
+			}
+			return {
+				nodeId,
+				sessionsNow: devices.reduce((s, d) => s + d.sessionsNow, 0),
+				sessionsStarted: devices.reduce((s, d) => s + d.sessionsStarted, 0),
+				observedShare: clusterIntegral > 0 && nodeIntegral > 0 ? nodeIntegral / clusterIntegral : null,
+				peakSessions: peak,
+				yieldsAway: this.yields.filter((y) => y.at >= from && y.nodeId === nodeId).length,
+				devices
+			};
+		});
+		return {
+			observedForMs: Math.min(windowMs, now - this.startedAt),
+			sessionsNow: [...current.values()].reduce((a, b) => a + b, 0),
+			clusterPeakSessions: clusterPeak,
+			nodes
+		};
+	}
+};
+//#endregion
+//#region src/load-balancing-shares.ts
+function nextDevices(stored, shares, effective) {
+	let changed = false;
+	const out = { ...stored };
+	for (const [key, weight] of Object.entries(shares)) {
+		const existing = stored?.[key];
+		if (existing !== void 0) {
+			out[key] = {
+				...existing,
+				weight
+			};
+			changed = true;
+			continue;
+		}
+		const enabled = effective[key];
+		if (enabled === void 0) continue;
+		out[key] = {
+			enabled,
+			weight
+		};
+		changed = true;
+	}
+	return changed ? out : stored;
+}
+function applyLoadBalancingShares(prev, write) {
+	const next = { ...prev };
+	const nodeIds = new Set([...Object.keys(write.nodes), ...Object.keys(write.devices)]);
+	for (const nodeId of nodeIds) {
+		const existing = prev[nodeId];
+		const nodeShare = write.nodes[nodeId];
+		const devices = nextDevices(existing?.inferenceDevices, write.devices[nodeId] ?? {}, write.effectiveEnabled[nodeId] ?? {});
+		if (nodeShare === void 0 && devices === existing?.inferenceDevices) continue;
+		next[nodeId] = {
+			...existing ?? { maxCameras: null },
+			...nodeShare !== void 0 ? { detectWeight: nodeShare } : {},
+			...devices !== void 0 ? { inferenceDevices: devices } : {}
+		};
+	}
+	return next;
+}
+//#endregion
+//#region src/stale-device-pins.ts
+function findStaleDevicePins(pins, nodes) {
+	const usable = /* @__PURE__ */ new Map();
+	for (const node of nodes) for (const d of node.devices) usable.set(d.key, (usable.get(d.key) ?? false) || d.enabled && d.available);
+	return pins.flatMap((pin) => {
+		const state = usable.get(pin.deviceKey);
+		if (state === true) return [];
+		return [{
+			deviceId: pin.deviceId,
+			deviceKey: pin.deviceKey,
+			reason: state === false ? "disabled" : "absent"
+		}];
+	}).toSorted((a, b) => a.deviceId - b.deviceId);
+}
+//#endregion
 //#region src/index.ts
 /**
 * addon-pipeline-orchestrator — hub-side camera-to-agent load balancer.
@@ -68850,6 +71343,13 @@ var PipelineOrchestratorAddon = class PipelineOrchestratorAddon extends BaseAddo
 	* not a claim this flag makes.
 	*/
 	clusterModelChoiceReady = false;
+	/** The per-device 24 h peak of concurrent sessions, fed by every runner census (D745). */
+	devicePeaks = new DevicePeakTracker();
+	/** What session placement did (D748): the Load balancing tab's "actual" column. */
+	placementStats = new SessionPlacementStats();
+	/** The stored session placement policy (D748); `least-loaded` before init. */
+	readSessionPlacement = () => "least-loaded";
+	bestSettingsService = null;
 	/**
 	* Single owner of the shared placement state (`assignments`/`cameraConfigs`/
 	* `pendingReasons`/`dispatchingDevices`) — see `placement-ledger.ts` (S6
@@ -69126,6 +71626,8 @@ var PipelineOrchestratorAddon = class PipelineOrchestratorAddon extends BaseAddo
 			rebalance: (opts) => this.rebalance(opts),
 			setCameraPipelineForAgent: (input) => this.setCameraPipelineForAgent(input),
 			maintenancePaused: () => this.storageMigrationLeaseId !== null,
+			onRunnerCensus: (loads) => this.devicePeaks.noteCensus(loads),
+			placementStats: this.placementStats,
 			setTopology: (topology) => {
 				this.topology = topology;
 			},
@@ -69152,6 +71654,7 @@ var PipelineOrchestratorAddon = class PipelineOrchestratorAddon extends BaseAddo
 		this.nodeStress = controllers.nodeStress;
 		this.placement = controllers.placement;
 		this.session = controllers.session;
+		this.readSessionPlacement = controllers.sessionPlacement;
 		this.deviceConfig = controllers.deviceConfig;
 		this.cameraStatusService = controllers.cameraStatusService;
 		this.cameraSwitchService = controllers.cameraSwitchService;
@@ -69267,7 +71770,7 @@ var PipelineOrchestratorAddon = class PipelineOrchestratorAddon extends BaseAddo
 		for (const deviceId of this.detectionWiring.activeDetectionDeviceIds()) try {
 			await this.releaseCamera({ deviceId });
 		} catch (err) {
-			const msg = errMsg$1(err);
+			const msg = errMsg$2(err);
 			this.ctx.logger.debug("releaseCamera failed during shutdown", {
 				tags: { deviceId },
 				meta: { error: msg }
@@ -69644,26 +72147,6 @@ var PipelineOrchestratorAddon = class PipelineOrchestratorAddon extends BaseAddo
 		this.reconcile.schedulePendingRetry();
 		return { success: true };
 	}
-	async setAgentDetectWeight(input) {
-		const existing = (await this.settingsStore.readAgentSettingsMap())[input.agentNodeId];
-		const weight = input.detectWeight ?? 1;
-		const next = existing ? {
-			...existing,
-			detectWeight: weight
-		} : {
-			maxCameras: null,
-			detectWeight: weight
-		};
-		await this.settingsStore.writeAgentSettings(input.agentNodeId, next);
-		this.ctx.logger.info("agentSettings.detectWeight updated", {
-			tags: { nodeId: input.agentNodeId },
-			meta: { detectWeight: weight ?? null }
-		});
-		this.rebalance().catch((err) => {
-			this.ctx.logger.warn("setAgentDetectWeight: rebalance failed", { meta: { error: err instanceof Error ? err.message : String(err) } });
-		});
-		return { success: true };
-	}
 	/**
 	* Set one node's placement capabilities — the per-node record that replaced
 	* the four flat orchestrator lists. Each flag is a tri-state patch: omit to
@@ -70062,7 +72545,7 @@ var PipelineOrchestratorAddon = class PipelineOrchestratorAddon extends BaseAddo
 				tags: { nodeId },
 				meta: {
 					nodeId,
-					error: errMsg$1(err)
+					error: errMsg$2(err)
 				}
 			});
 			return null;
@@ -70168,7 +72651,7 @@ var PipelineOrchestratorAddon = class PipelineOrchestratorAddon extends BaseAddo
 				tags: { nodeId },
 				meta: {
 					nodeId,
-					error: errMsg$1(err)
+					error: errMsg$2(err)
 				}
 			});
 			return {
@@ -70215,7 +72698,7 @@ var PipelineOrchestratorAddon = class PipelineOrchestratorAddon extends BaseAddo
 		} catch (err) {
 			this.ctx.logger.warn("resetNodePipelineDefaults: executor clearDeviceOverrides failed (node offline?)", {
 				tags: { nodeId: node },
-				meta: { error: errMsg$1(err) }
+				meta: { error: errMsg$2(err) }
 			});
 		}
 		this.settingsStore.invalidateCatalog();
@@ -70226,7 +72709,7 @@ var PipelineOrchestratorAddon = class PipelineOrchestratorAddon extends BaseAddo
 		} catch (err) {
 			this.ctx.logger.warn("resetNodePipelineDefaults: effective-model probe failed (node offline?)", {
 				tags: { nodeId: node },
-				meta: { error: errMsg$1(err) }
+				meta: { error: errMsg$2(err) }
 			});
 		}
 		this.ctx.logger.info("node pipeline reset to hardware-aware defaults", {
@@ -70242,6 +72725,137 @@ var PipelineOrchestratorAddon = class PipelineOrchestratorAddon extends BaseAddo
 			clearedCameraOverrides
 		};
 	}
+	bestSettings() {
+		if (this.bestSettingsService !== null) return this.bestSettingsService;
+		const store = this.settingsStore;
+		this.bestSettingsService = new BestSettingsService({
+			logger: this.ctx.logger,
+			runnerNodeIds: () => this.topology.collectRunnerNodeIds(),
+			readNodeDevices: (nodeId) => this.getNodeInferenceDevices({ nodeId }),
+			readHardware: async (nodeId) => {
+				const api = this.ctx.api;
+				if (!api) return null;
+				return nodeId === this.localNodeId ? api.platformProbe.getHardware.query() : api.platformProbe.getHardware.query({ nodeId });
+			},
+			readCatalog: (nodeId) => store.readCatalogForNode(nodeId),
+			readAgentSettings: () => store.readAgentSettingsMap(),
+			readCameraSettings: () => store.readCameraSettingsMap(),
+			rewriteAgentSettings: (transform) => store.rewriteAgentSettingsMap(transform),
+			rewriteCameraSettings: (transform) => store.rewriteCameraSettingsMap(transform),
+			cameraLoads: () => this.bestSettingsCameraLoads(),
+			peaks: () => this.devicePeaks.peaks(),
+			clusterPeak: () => this.devicePeaks.clusterPeak(),
+			sessionPlacement: () => this.readSessionPlacement(),
+			readNodeShares: () => store.buildNodeWeights(),
+			detectorStore: async (input) => {
+				const api = this.ctx.api;
+				if (!api) throw new Error("ctx.api unavailable");
+				return api.pipelineExecutor.clearModelBoundDeviceOverrides.mutate({
+					nodeId: this.localNodeId,
+					dryRun: input.dryRun,
+					...input.deviceIds !== void 0 ? { deviceIds: input.deviceIds } : {}
+				});
+			},
+			downloadModel: async (nodeId, modelId, format) => {
+				const api = this.ctx.api;
+				if (!api) throw new Error("ctx.api unavailable");
+				await api.pipelineExecutor.downloadModel.mutate({
+					addonId: "object-detection",
+					modelId,
+					format
+				}, nodePin(nodeId));
+			},
+			invalidateCatalog: () => store.invalidateCatalog(),
+			redispatch: (nodeId) => this.placement.redispatchCamerasOnAgent(nodeId),
+			now: () => Date.now()
+		});
+		return this.bestSettingsService;
+	}
+	/** Every camera with detection started, as the recommender charges it (D745). */
+	async bestSettingsCameraLoads() {
+		const standing = new Map(this.getPipelineAssignments().map((a) => [a.deviceId, a.agentNodeId]));
+		const loads = [];
+		for (const [deviceId, config] of this.detectionWiring.activeDetections) {
+			const nodePin = await this.readPipelinePin(deviceId);
+			const pinnedKey = await this.readPipelineDevicePin(deviceId);
+			const standingNode = config.detectionMode === "always-on" ? standing.get(deviceId) ?? null : null;
+			loads.push({
+				deviceId,
+				mode: config.detectionMode,
+				fps: config.detectionFps,
+				runsPipelineRoot: (config.detectionSources ?? ["pipeline"]).includes("pipeline"),
+				standingNodeId: standingNode,
+				nodePinId: nodePin,
+				devicePin: pinnedKey !== null ? {
+					nodeId: nodePin ?? standingNode,
+					deviceKey: pinnedKey
+				} : null
+			});
+		}
+		return loads;
+	}
+	async planBestSettings(input) {
+		return this.bestSettings().plan(input);
+	}
+	/**
+	* Node + device shares in ONE read-modify-write of the agent settings. A
+	* device with no stored entry is made explicit with its effective
+	* enablement, read from the probe-aware device list. Never touches the
+	* `sessionPlacement` policy.
+	*/
+	async setLoadBalancingShares(input) {
+		const effectiveEnabled = {};
+		for (const nodeId of Object.keys(input.devices)) {
+			const read = await this.getNodeInferenceDevices({ nodeId });
+			effectiveEnabled[nodeId] = Object.fromEntries(read.devices.map((d) => [d.key, d.enabled]));
+		}
+		await this.settingsStore.rewriteAgentSettingsMap((prev) => applyLoadBalancingShares(prev, {
+			nodes: input.nodes,
+			devices: input.devices,
+			effectiveEnabled
+		}));
+		this.ctx.logger.info("load balancing shares updated", { meta: {
+			nodes: JSON.stringify(input.nodes),
+			devices: JSON.stringify(input.devices),
+			policy: this.readSessionPlacement()
+		} });
+		if (Object.keys(input.nodes).length > 0) this.rebalance().catch((err) => {
+			this.ctx.logger.warn("setLoadBalancingShares: rebalance failed", { meta: { error: errMsg$2(err) } });
+		});
+		return { success: true };
+	}
+	async getPlacementStats(input) {
+		const snap = this.placementStats.snapshot(input.windowMs);
+		return {
+			policy: this.readSessionPlacement(),
+			windowMs: input.windowMs,
+			observedForMs: snap.observedForMs,
+			sessionsNow: snap.sessionsNow,
+			clusterPeakSessions: snap.clusterPeakSessions,
+			nodes: snap.nodes,
+			stalePins: await this.listStaleDevicePins()
+		};
+	}
+	/** Device pins the session path cannot honour — see `stale-device-pins.ts`. */
+	async listStaleDevicePins() {
+		const nodeIds = [...new Set(["hub", ...this.topology.collectRunnerNodeIds()])];
+		const offered = await Promise.all(nodeIds.map(async (nodeId) => ({ devices: (await this.getNodeInferenceDevices({ nodeId }).catch(() => null))?.devices ?? [] })));
+		const pins = [];
+		for (const deviceId of this.detectionWiring.activeDetections.keys()) {
+			const deviceKey = await this.readPipelineDevicePin(deviceId);
+			if (deviceKey !== null) pins.push({
+				deviceId,
+				deviceKey
+			});
+		}
+		return findStaleDevicePins(pins, offered);
+	}
+	async suggestShares(input) {
+		return this.bestSettings().suggestShares(input);
+	}
+	async applyBestSettings(input) {
+		return this.bestSettings().apply(input);
+	}
 	async getCameraSettings(input) {
 		return (await this.settingsStore.readCameraSettingsMap())[String(input.deviceId)] ?? null;
 	}
@@ -70498,7 +73112,7 @@ var PipelineOrchestratorAddon = class PipelineOrchestratorAddon extends BaseAddo
 				tags: { deviceId },
 				meta: {
 					capName,
-					error: errMsg$1(err)
+					error: errMsg$2(err)
 				}
 			});
 			return true;