@camstack/addon-pipeline-orchestrator 1.2.291 → 1.2.293

package/dist/index.js

@@ -5410,7 +5410,7 @@ var ZodIssueCode = {
 var ZodFirstPartyTypeKind;
 ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {});
 //#endregion
-//#region ../types/dist/sleep-C16NCZR2.mjs
+//#region ../types/dist/sleep-DAJ9Er57.mjs
 /**
 * The audio chunk plane's byte format, and the ONE expansion from a coded
 * window to float samples (D455).
@@ -24661,7 +24661,7 @@ var pipelineExecutorCapability = {
 			auth: "admin"
 		}),
 		/**
-		* Best settings (D745): the MODEL-BOUND thresholds (`bindsToModel` keys of
+		* Auto tune (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
@@ -25033,111 +25033,17 @@ var pipelineExecutorCapability = {
 	}
 };
 /**
-* 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
+* The wire shapes of the Auto tune 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
+* (`recommend.ts`) are the TS face of the same data; these
 * schemas are what crosses the cap boundary.
 */
 var ModelFormatSchema$1 = _enum(MODEL_FORMATS);
+/** The operator's range for it. */
+var MIN_SESSIONS_PER_DEVICE_RANGE = {
+	min: 1,
+	max: 8
+};
 var HardwareClassIdSchema = _enum([
 	"intel-core-ultra",
 	"intel-n-series",
@@ -25155,8 +25061,9 @@ var AcceleratorKindSchema = _enum([
 ]);
 var RecommendationReasonSchema = discriminatedUnion("kind", [
 	object({
-		kind: literal("fits"),
-		utilisation: number()
+		kind: literal("capacity"),
+		sessions: number(),
+		minSessions: number()
 	}),
 	object({
 		kind: literal("tie-faster"),
@@ -25171,16 +25078,13 @@ var RecommendationReasonSchema = discriminatedUnion("kind", [
 	}),
 	object({
 		kind: literal("no-fit-lightest"),
-		utilisation: number()
+		sessions: number(),
+		minSessions: 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") }),
@@ -25196,28 +25100,13 @@ var RecommendationReasonSchema = discriminatedUnion("kind", [
 		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(),
+	/** Parallel sessions at the camera rate with the headroom kept free: ⌊fps × (1 − headroom) / camera fps⌋. */
+	capacitySessions: number(),
 	personRecall: number()
 });
 var DeviceRecommendationSchema = object({
@@ -25225,7 +25114,6 @@ var DeviceRecommendationSchema = object({
 	accelerator: AcceleratorKindSchema.nullable(),
 	enabled: boolean(),
 	available: boolean(),
-	demand: DeviceDemandSchema.nullable(),
 	chosen: DeviceModelChoiceSchema.nullable(),
 	reasons: array(RecommendationReasonSchema).readonly()
 });
@@ -25267,7 +25155,7 @@ var DetectorStoreClearSchema = object({
 	deviceId: number(),
 	keys: array(string()).readonly()
 });
-var BestSettingsWarningSchema = discriminatedUnion("kind", [
+var AutoTuneWarningSchema = discriminatedUnion("kind", [
 	object({
 		kind: literal("detector-store-cluster-wide"),
 		skippedNodes: array(string()).readonly()
@@ -25282,36 +25170,37 @@ var BestSettingsWarningSchema = discriminatedUnion("kind", [
 		deviceKey: string()
 	})
 ]);
-var BestSettingsOptionsSchema = object({
+var AutoTuneOptionsSchema = 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.
+	* The least number of parallel sessions every device must sustain at the
+	* camera rate with the headroom kept free (D755). The most accurate model
+	* that reaches it wins.
 	*/
-	shares: LoadBalancingSharesInputSchema.optional()
+	minSessionsPerDevice: number().int().min(MIN_SESSIONS_PER_DEVICE_RANGE.min).max(MIN_SESSIONS_PER_DEVICE_RANGE.max).default(2)
 });
-var BestSettingsPlanSchema = object({
+var AutoTunePlanSchema = 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(),
+	minSessionsPerDevice: number(),
+	/** The detection rate a session is counted at (the fastest camera running the pipeline root). */
+	cameraFps: number(),
 	generatedAt: number(),
 	nodes: array(NodeRecommendationSchema).readonly(),
 	nodeChanges: array(NodeDeviceChangeSchema).readonly(),
 	cameraClears: array(CameraOverrideClearSchema).readonly(),
 	detectorStoreClears: array(DetectorStoreClearSchema).readonly(),
-	warnings: array(BestSettingsWarningSchema).readonly()
+	warnings: array(AutoTuneWarningSchema).readonly()
 });
-var BestSettingsApplyInputSchema = object({
+var AutoTuneApplyInputSchema = object({
 	planHash: string(),
-	headroom: number().min(.3).max(.5).default(.4)
+	headroom: number().min(.3).max(.5).default(.4),
+	minSessionsPerDevice: number().int().min(MIN_SESSIONS_PER_DEVICE_RANGE.min).max(MIN_SESSIONS_PER_DEVICE_RANGE.max).default(2)
 });
-var BestSettingsPhaseResultSchema = object({
+var AutoTunePhaseResultSchema = object({
 	phase: _enum([
 		"download",
 		"camera-overrides",
@@ -25322,25 +25211,225 @@ var BestSettingsPhaseResultSchema = object({
 	ok: boolean(),
 	detail: string()
 });
-var BestSettingsApplyResultSchema = discriminatedUnion("kind", [
+var AutoTuneApplyResultSchema = discriminatedUnion("kind", [
 	object({
 		kind: literal("applied"),
 		planHash: string(),
-		phases: array(BestSettingsPhaseResultSchema).readonly()
+		phases: array(AutoTunePhaseResultSchema).readonly()
 	}),
 	object({
 		kind: literal("aborted"),
-		phases: array(BestSettingsPhaseResultSchema).readonly()
+		phases: array(AutoTunePhaseResultSchema).readonly()
 	}),
 	object({
 		kind: literal("stale"),
-		plan: BestSettingsPlanSchema
+		plan: AutoTunePlanSchema
 	}),
 	object({
 		kind: literal("refused"),
 		reason: _enum(["apply-in-progress"])
 	})
 ]);
+/**
+* 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"]);
+/**
+* `share` since D750: the percentages are held by default. `least-loaded` stays
+* selectable.
+*/
+var DEFAULT_SESSION_PLACEMENT_POLICY = "share";
+/** 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. */
+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()
+});
+/**
+* Where an automatic share's capacity comes from (D755).
+*  - `hardware` — the static capacity of each device at its Auto tune model:
+*    the measured latency table for the node's hardware class.
+*  - `benchmark` — the node's own measured capacity (node benchmark results).
+*    A node with no results falls back to `hardware`, and says so.
+*/
+var CapacitySourceSchema = _enum(["hardware", "benchmark"]);
+/** Why a node under the `benchmark` source was sized from hardware instead. */
+var CapacityFallbackSchema = _enum(["no-benchmark-results", "partial-benchmark-results"]);
+var SuggestSharesInputSchema = object({
+	headroom: number().min(.3).max(.5).default(.4),
+	/** Default `hardware`. */
+	source: CapacitySourceSchema.default("hardware")
+});
+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; null when sized by a benchmark. */
+	fps: number().nullable(),
+	/** False for a table cell derived from another chip; true for a measured cell or a benchmark. */
+	measured: boolean(),
+	/**
+	* Advisory session cap: ⌊fps × (1 − headroom) / camera fps⌋ from the table,
+	* or the benchmark's measured max sessions. 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(),
+	/** What this node's capacity was read from; null when the node is skipped. */
+	capacitySource: CapacitySourceSchema.nullable(),
+	/** Set when the `benchmark` source was asked for and this node used `hardware`. */
+	capacityFallback: CapacityFallbackSchema.nullable()
+});
+var SuggestSharesResultSchema = object({
+	headroom: number(),
+	/** The source asked for; each node says what it actually used. */
+	source: CapacitySourceSchema,
+	/** Camera detection rate the capacity is counted in (the fastest camera's fps). */
+	cameraFps: number(),
+	/** The Auto tune capacity floor the models were picked at. */
+	minSessionsPerDevice: number(),
+	nodes: array(SuggestedNodeShareSchema).readonly()
+});
+/**
+* Where the node and device shares come from (D750, D755).
+*  - `hardware` (default) — computed by the system from each node's static
+*    capacity (its accelerators at their Auto tune models, from the measured
+*    latency table), recomputed whenever a node or device joins, leaves, is
+*    switched on or off, or changes model. No load input.
+*  - `benchmark` — the same, from each node's measured capacity (node
+*    benchmark results); a node without results falls back to `hardware`.
+*  - `manual` — the operator's stored sliders.
+* Either way a node or device that cannot take sessions gives its share to
+* the others in proportion; the stored values are never rewritten for that.
+*/
+var ShareSourceSchema = _enum([
+	"hardware",
+	"benchmark",
+	"manual"
+]);
+var DEFAULT_SHARE_SOURCE = "hardware";
+/** `hardware` or `benchmark`: the system computes the shares. */
+function isAutomaticShareSource(source) {
+	return source !== "manual";
+}
+/** Headroom the automatic shares are computed at (Auto tune's default). */
+var AUTO_SHARE_HEADROOM = .4;
+/** The global-settings key the share source is stored under (orchestrator `load` section). */
+var SHARE_SOURCE_SETTING_KEY = "shareSource";
+/**
+* Parse a stored value; anything unknown is the default. `auto` (D750, before
+* D755 split it) reads as `hardware` — that is what it computed.
+*/
+function parseShareSource(value) {
+	const parsed = ShareSourceSchema.safeParse(value);
+	return parsed.success ? parsed.data : DEFAULT_SHARE_SOURCE;
+}
+var SetShareSourceInputSchema = object({ source: ShareSourceSchema });
+object({
+	nodes: record(string(), number()),
+	devices: record(string(), record(string(), number()))
+});
+var EffectiveDeviceShareSchema = object({
+	deviceKey: string(),
+	/** Can take sessions now (enabled, available, can run the root). */
+	eligible: boolean(),
+	/** The share the source assigns, as a percentage of the node's devices. */
+	configuredPct: number(),
+	/** The share actually used, after an ineligible device's share went to the others. */
+	effectivePct: number()
+});
+var EffectiveNodeShareSchema = object({
+	nodeId: string(),
+	eligible: boolean(),
+	configuredPct: number(),
+	effectivePct: number(),
+	/** Automatic sources: what this node's share was computed from; null under `manual` or before the first answer. */
+	capacitySource: CapacitySourceSchema.nullable(),
+	/** Automatic `benchmark`: why this node used `hardware` instead. */
+	capacityFallback: CapacityFallbackSchema.nullable(),
+	devices: array(EffectiveDeviceShareSchema).readonly()
+});
+var EffectiveSharesSchema = object({
+	source: ShareSourceSchema,
+	policy: SessionPlacementPolicySchema,
+	/** An automatic source with no computed answer yet: the stored sliders are used meanwhile. */
+	autoPending: boolean(),
+	/** When the automatic shares were last computed (ms epoch); null = never. */
+	computedAt: number().nullable(),
+	/** What made the system recompute them last. */
+	trigger: string().nullable(),
+	nodes: array(EffectiveNodeShareSchema).readonly(),
+	/** The relative weights the election reads (before eligibility). */
+	nodeWeights: record(string(), number()),
+	deviceWeights: record(string(), record(string(), number()))
+});
 object({
 	activeCameras: number(),
 	throttledCameras: number(),
@@ -26748,8 +26837,10 @@ var CameraStepOverridePatchSchema = object({
 	modelId: string().optional(),
 	settings: record(string(), unknown()).readonly().optional()
 });
+var CameraStepSettingsSchema = record(string(), record(string(), unknown()).readonly());
 var CameraPipelineSettingsSchema = object({
 	stepToggles: record(string(), boolean()).optional(),
+	stepSettings: CameraStepSettingsSchema.optional(),
 	stepOverridesByDevice: record(string(), record(string(), record(string(), CameraStepOverridePatchSchema))).optional(),
 	pipelineByAgent: record(string(), CameraPipelineForAgentSchema).optional()
 });
@@ -27515,23 +27606,25 @@ var pipelineOrchestratorCapability = {
 			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
+		* Auto tune (D745, D755) — DRY RUN. Recommends ONE detector family
+		* (YOLOv9) for the whole cluster from each node's static hardware class
+		* and the measured latency table: per device, the most accurate model
+		* that sustains at least `minSessionsPerDevice` parallel sessions at the
+		* camera rate with the headroom kept free (no load input), 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" }),
+		planAutoTune: method(AutoTuneOptionsSchema, AutoTunePlanSchema, { auth: "admin" }),
 		/**
-		* Best settings (D745) — APPLY the plan the operator confirmed. Recomputes
+		* Auto tune (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, {
+		applyAutoTune: method(AutoTuneApplyInputSchema, AutoTuneApplyResultSchema, {
 			kind: "mutation",
 			auth: "admin"
 		}),
@@ -27556,12 +27649,32 @@ var pipelineOrchestratorCapability = {
 		*/
 		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.
+		* Load balancing (D748, D755) — shares proportional to each node's
+		* capacity in parallel sessions: from the latency table at the models
+		* Auto tune picks (`hardware`), or from node benchmark results
+		* (`benchmark`, each node without results falling back to `hardware` and
+		* saying so). The automatic shares are exactly this answer. Per device,
+		* an ADVISORY session cap. Writes nothing.
 		*/
 		suggestShares: method(SuggestSharesInputSchema, SuggestSharesResultSchema, { auth: "admin" }),
+		/**
+		* Load balancing (D750) — the shares placement reads now: the source
+		* (automatic capacity shares or the operator's sliders), each node's and
+		* device's configured share, and the effective share after a node or
+		* device that cannot take sessions gave its share to the others.
+		*/
+		getEffectiveShares: method(_void(), EffectiveSharesSchema, { auth: "admin" }),
+		/**
+		* Load balancing (D750, D755) — switch the share source: `hardware`
+		* (automatic, from static capacity), `benchmark` (automatic, from node
+		* benchmark results) or `manual`. Going manual seeds the sliders with the
+		* current automatic shares (one atomic write), so nothing jumps; going
+		* to an automatic source recomputes at once.
+		*/
+		setShareSource: method(SetShareSourceInputSchema, object({ success: literal(true) }), {
+			kind: "mutation",
+			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. */
@@ -27591,6 +27704,22 @@ var pipelineOrchestratorCapability = {
 			kind: "mutation",
 			auth: "admin"
 		}),
+		/**
+		* Write or clear one step's CAMERA-WIDE settings (D754) — the fields this
+		* camera overrides on every accelerator it runs on. `settings` is the
+		* whole field-level bag for that step (only the overridden keys; a
+		* model-bound field travels with its binding key); `null` or `{}` clears
+		* it. Merged at dispatch between the node base and the per-(node,device)
+		* override, key by key.
+		*/
+		setCameraStepSettings: method(object({
+			deviceId: number(),
+			addonId: string(),
+			settings: record(string(), unknown()).nullable()
+		}), object({ success: literal(true) }), {
+			kind: "mutation",
+			auth: "admin"
+		}),
 		/** Write or clear the wholesale per-agent pipeline override. Pass `pipeline: null` to drop the override. */
 		setCameraPipelineForAgent: method(object({
 			deviceId: number(),
@@ -43585,7 +43714,7 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
-	"pipelineOrchestrator.applyBestSettings": {
+	"pipelineOrchestrator.applyAutoTune": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
 		addonId: null,
@@ -43705,6 +43834,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"pipelineOrchestrator.getEffectiveShares": {
+		capName: "pipeline-orchestrator",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"pipelineOrchestrator.getGlobalMetrics": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
@@ -43771,7 +43906,7 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
-	"pipelineOrchestrator.planBestSettings": {
+	"pipelineOrchestrator.planAutoTune": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
 		addonId: null,
@@ -43873,6 +44008,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"pipelineOrchestrator.setCameraStepSettings": {
+		capName: "pipeline-orchestrator",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"pipelineOrchestrator.setCameraStepToggle": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
@@ -43903,6 +44044,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"pipelineOrchestrator.setShareSource": {
+		capName: "pipeline-orchestrator",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"pipelineOrchestrator.suggestShares": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
@@ -49343,6 +49490,11 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"pipelineOrchestrator.setCameraStepSettings": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"pipelineOrchestrator.setCameraStepToggle": [{
 		name: "deviceId",
 		form: "single",
@@ -51141,7 +51293,7 @@ function modelBindingKey(key) {
 /**
 * 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).
+* and the orchestrator's Auto tune (which clears those overrides, D745).
 */
 function collectModelBoundKeys(fields) {
 	return fields.flatMap((field) => {
@@ -51633,140 +51785,25 @@ var DETECTOR_ACCURACY = {
 		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";
+var AUTO_TUNE_FAMILY = "yolov9";
+/** Parallel sessions one device sustains at `fps` with `headroom` kept free. */
+function capacitySessionsOf(fps, headroom, cameraFps) {
+	if (!(fps > 0) || !(cameraFps > 0)) return 0;
+	return Math.max(0, Math.floor(fps * (1 - headroom) / cameraFps + 1e-9));
+}
 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 sessionsOn(cell, sizing) {
+	return cell === void 0 ? 0 : capacitySessionsOf(cell.fps, sizing.headroom, sizing.cameraFps);
 }
-function fitsOn(cell, demand, headroom) {
-	const budget = cell.fps * (1 - headroom);
-	return budget >= (demand?.demandFps ?? 0) && budget >= (demand?.maxCameraFps ?? 0);
+function fitsOn(cell, sizing) {
+	return sessionsOn(cell, sizing) >= sizing.minSessions;
 }
 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) => ({
+	return Object.keys(DETECTOR_ACCURACY).filter((id) => id.startsWith(AUTO_TUNE_FAMILY)).filter((id) => contexts.every((c) => c.column[id] !== void 0 && (formatsByModel[id] ?? []).includes(c.device.format))).map((id) => ({
 		modelId: id,
 		personRecall: DETECTOR_ACCURACY[id]?.personRecall ?? 0
 	})).toSorted((a, b) => b.personRecall - a.personRecall || a.modelId.localeCompare(b.modelId));
@@ -51774,28 +51811,24 @@ function candidatesFor(contexts, formatsByModel) {
 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);
+/** The fewest sessions any device of the group sustains with this model. */
+function worstSessions(contexts, modelId, sizing) {
+	return contexts.reduce((worst, c) => Math.min(worst, sessionsOn(c.column[modelId], sizing)), Number.POSITIVE_INFINITY);
 }
 /** One model for a group of devices that must agree (step 2–4 of the header). */
-function pickForGroup(contexts, formatsByModel, headroom) {
+function pickForGroup(contexts, formatsByModel, sizing) {
 	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);
-	}));
+	const fitting = candidates.filter((c) => contexts.every((ctx) => fitsOn(ctx.column[c.modelId], sizing)));
 	if (fitting.length === 0) {
-		const lightest = candidates.toSorted((a, b) => worstUtilisation(contexts, a.modelId) - worstUtilisation(contexts, b.modelId))[0];
+		const lightest = candidates.toSorted((a, b) => worstSessions(contexts, b.modelId, sizing) - worstSessions(contexts, a.modelId, sizing) || totalLatency(contexts, a.modelId) - totalLatency(contexts, b.modelId))[0];
 		if (lightest === void 0) return null;
 		return {
 			modelId: lightest.modelId,
 			reasons: [{
 				kind: "no-fit-lightest",
-				utilisation: worstUtilisation(contexts, lightest.modelId)
+				sessions: worstSessions(contexts, lightest.modelId, sizing),
+				minSessions: sizing.minSessions
 			}]
 		};
 	}
@@ -51805,10 +51838,7 @@ function pickForGroup(contexts, formatsByModel, headroom) {
 	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 ?? "";
+		const limitedBy = contexts.find((ctx) => !fitsOn(ctx.column[mostAccurate.modelId], sizing))?.device.key ?? "";
 		reasons.push({
 			kind: "stepped-down",
 			from: mostAccurate.modelId,
@@ -51826,7 +51856,7 @@ function pickForGroup(contexts, formatsByModel, headroom) {
 		reasons
 	};
 }
-function choiceOn(ctx, modelId) {
+function choiceOn(ctx, modelId, sizing) {
 	const cell = ctx.column[modelId];
 	if (cell === void 0) return null;
 	return {
@@ -51834,23 +51864,20 @@ function choiceOn(ctx, modelId) {
 		p50Ms: cell.p50Ms,
 		fps: cell.fps,
 		measured: cell.measured,
-		utilisation: utilisationOf(cell, ctx.demand),
+		capacitySessions: sessionsOn(cell, sizing),
 		personRecall: DETECTOR_ACCURACY[modelId]?.personRecall ?? 0
 	};
 }
-function deviceReasonsFor(ctx, choice) {
+function deviceReasonsFor(choice, sizing) {
 	const out = [{
-		kind: "fits",
-		utilisation: choice.utilisation
+		kind: "capacity",
+		sessions: choice.capacitySessions,
+		minSessions: sizing.minSessions
 	}];
 	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) {
@@ -51866,7 +51893,6 @@ function skippedNode(node, reason, hardwareClass) {
 			accelerator: node.hardware ? acceleratorKindOf(d.key, node.hardware) : null,
 			enabled: d.enabled,
 			available: d.available,
-			demand: null,
 			chosen: null,
 			reasons: []
 		})),
@@ -51876,7 +51902,11 @@ function skippedNode(node, reason, hardwareClass) {
 /** Recommend one node. See the module header. */
 function recommendNode(input) {
 	const { node } = input;
-	const headroom = input.headroom ?? .4;
+	const sizing = {
+		headroom: input.headroom ?? .4,
+		cameraFps: input.cameraFps ?? 10,
+		minSessions: input.minSessionsPerDevice ?? 2
+	};
 	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);
@@ -51887,7 +51917,6 @@ function recommendNode(input) {
 		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();
@@ -51916,8 +51945,7 @@ function recommendNode(input) {
 		contexts.set(device.key, {
 			device,
 			accelerator,
-			column,
-			demand: demandByKey.get(device.key) ?? null
+			column
 		});
 	}
 	const isCpu = (a) => a === "x86-cpu" || a === "arm-cpu";
@@ -51927,23 +51955,23 @@ function recommendNode(input) {
 	const reasonsByKey = /* @__PURE__ */ new Map();
 	const nodeReasons = [];
 	let acceleratorModelId = null;
-	const groupPick = accelerators.length > 0 ? pickForGroup(accelerators, node.formatsByModel, headroom) : null;
+	const groupPick = accelerators.length > 0 ? pickForGroup(accelerators, node.formatsByModel, sizing) : null;
 	if (groupPick !== null) {
 		acceleratorModelId = groupPick.modelId;
 		nodeReasons.push(...groupPick.reasons);
 		for (const ctx of accelerators) {
-			const choice = choiceOn(ctx, groupPick.modelId);
+			const choice = choiceOn(ctx, groupPick.modelId, sizing);
 			if (choice === null) continue;
 			chosenByKey.set(ctx.device.key, choice);
-			reasonsByKey.set(ctx.device.key, deviceReasonsFor(ctx, choice));
+			reasonsByKey.set(ctx.device.key, deviceReasonsFor(choice, sizing));
 		}
 	} 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);
+		const pick = pickForGroup([ctx], node.formatsByModel, sizing);
+		const choice = pick === null ? null : choiceOn(ctx, pick.modelId, sizing);
 		if (pick === null || choice === null) {
 			reasonsByKey.set(ctx.device.key, [{
 				kind: "no-family-build",
@@ -51955,7 +51983,7 @@ function recommendNode(input) {
 		reasonsByKey.set(ctx.device.key, [
 			{ kind: "cpu-device" },
 			...pick.reasons,
-			...deviceReasonsFor(ctx, choice)
+			...deviceReasonsFor(choice, sizing)
 		]);
 	}
 	return {
@@ -51970,7 +51998,6 @@ function recommendNode(input) {
 			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) ?? []
 		})),
@@ -52018,6 +52045,204 @@ function electByShare(candidates) {
 	};
 }
 /**
+* The shares a session election actually reads, and the view the Load
+* balancing tab shows (D750). Pure.
+*
+* The SOURCE decides the configured weights: the automatic capacity shares
+* (`hardware` or `benchmark`, D755), or the operator's stored sliders. Eligibility decides the effective ones: a
+* node or device that cannot take a session now (offline, switched off, no
+* detect capability, unable to run the root) contributes nothing, and the
+* others split its share in proportion to their own. That redistribution is
+* exactly what `electByShare` does over its candidate set, so the view and
+* the election cannot disagree; the stored values are never rewritten for it.
+*/
+/** Weight a node or device has when its source names none (the balancer's own default). */
+var DEFAULT_WEIGHT = 1;
+function positive(value) {
+	return value !== void 0 && value > 0 ? value : DEFAULT_WEIGHT;
+}
+function percentages(keys, weightOf, counts) {
+	const total = keys.reduce((sum, k) => sum + (counts(k) ? weightOf(k) : 0), 0);
+	return new Map(keys.map((k) => [k, total > 0 && counts(k) ? Math.round(weightOf(k) / total * 1e3) / 10 : 0]));
+}
+function resolveEffectiveShares(input) {
+	const useAuto = isAutomaticShareSource(input.source) && input.auto !== null;
+	const weights = useAuto && input.auto !== null ? input.auto : input.stored;
+	const nodeWeights = {};
+	for (const nodeId of input.nodeIds) nodeWeights[nodeId] = positive(weights.nodes[nodeId]);
+	const eligibleNodes = new Set(input.eligibleNodes);
+	const configured = percentages(input.nodeIds, (k) => nodeWeights[k] ?? DEFAULT_WEIGHT, () => true);
+	const effective = percentages(input.nodeIds, (k) => nodeWeights[k] ?? DEFAULT_WEIGHT, (k) => eligibleNodes.has(k));
+	const deviceWeights = {};
+	const nodes = input.nodeIds.map((nodeId) => {
+		const eligibleKeys = new Set(input.eligibleDevices[nodeId] ?? []);
+		const named = weights.devices[nodeId] ?? {};
+		const keys = [...new Set([...Object.keys(named), ...eligibleKeys])].toSorted();
+		const perDevice = {};
+		for (const key of keys) perDevice[key] = positive(named[key]);
+		if (keys.length > 0) deviceWeights[nodeId] = perDevice;
+		const devConfigured = percentages(keys, (k) => perDevice[k] ?? DEFAULT_WEIGHT, () => true);
+		const devEffective = percentages(keys, (k) => perDevice[k] ?? DEFAULT_WEIGHT, (k) => eligibleNodes.has(nodeId) && eligibleKeys.has(k));
+		const devices = keys.map((deviceKey) => ({
+			deviceKey,
+			eligible: eligibleKeys.has(deviceKey),
+			configuredPct: devConfigured.get(deviceKey) ?? 0,
+			effectivePct: devEffective.get(deviceKey) ?? 0
+		}));
+		const capacity = useAuto ? input.autoCapacity?.[nodeId] : void 0;
+		return {
+			nodeId,
+			eligible: eligibleNodes.has(nodeId),
+			configuredPct: configured.get(nodeId) ?? 0,
+			effectivePct: effective.get(nodeId) ?? 0,
+			capacitySource: capacity?.source ?? null,
+			capacityFallback: capacity?.fallback ?? null,
+			devices
+		};
+	});
+	return {
+		source: input.source,
+		policy: input.policy ?? "share",
+		autoPending: isAutomaticShareSource(input.source) && input.auto === null,
+		computedAt: input.computedAt ?? null,
+		trigger: input.trigger ?? null,
+		nodes,
+		nodeWeights,
+		deviceWeights
+	};
+}
+/**
+* Automatic shares from CAPACITY (D755). Pure.
+*
+* A node's share is its capacity in parallel sessions over the cluster's; a
+* device's share inside its node follows its throughput. There is no load
+* input: nothing here depends on how many sessions ran, only on what each
+* node can carry.
+*
+* Two places a capacity can come from:
+*  - `hardware` — each enabled accelerator at its Auto tune model, from the
+*    measured latency table: ⌊fps × (1 − headroom) / camera fps⌋ sessions;
+*  - `benchmark` — the node's own measured max sessions per device, read
+*    through a {@link NodeCapacitySource}. A node whose results do not cover
+*    every enabled device it would be sized on is sized from `hardware`
+*    instead, and the answer says so per node — never a silent mix.
+*/
+/** A source that has no results — the benchmark store before it exists. */
+var NO_MEASURED_CAPACITY = { readMeasuredCapacity: async () => /* @__PURE__ */ new Map() };
+/** Integer shares summing to 100 (largest remainder); ties broken by key. */
+function toPercentShares(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 remainder = (exact) => Math.round((exact - Math.floor(exact)) * 1e6);
+	const byRemainder = raw.toSorted((a, b) => remainder(b.exact) - remainder(a.exact) || a.k.localeCompare(b.k));
+	for (let i = 0; i < 100 - assigned; i++) {
+		const r = byRemainder[i % byRemainder.length];
+		if (r === void 0) break;
+		out.set(r.k, (out.get(r.k) ?? 0) + 1);
+	}
+	return out;
+}
+function hardwareDevices(rec, headroom, cameraFps) {
+	return rec.devices.filter((d) => d.enabled && d.available && d.chosen !== null).map((d) => {
+		const fps = d.chosen?.fps ?? 0;
+		return {
+			deviceKey: d.deviceKey,
+			sessions: capacitySessionsOf(fps, headroom, cameraFps),
+			weight: Math.max(fps, 0),
+			modelId: d.chosen?.modelId ?? null,
+			fps: d.chosen?.fps ?? null,
+			measured: d.chosen?.measured ?? false
+		};
+	});
+}
+function sizeNode(rec, input) {
+	const fromHardware = (fallback) => {
+		const devices = rec.skipped ? [] : hardwareDevices(rec, input.headroom, input.cameraFps);
+		const capacity = devices.reduce((sum, d) => sum + d.sessions, 0);
+		return {
+			rec,
+			devices,
+			capacitySource: rec.skipped ? null : "hardware",
+			capacityFallback: rec.skipped ? null : fallback,
+			skippedReason: rec.skipped ? rec.reasons[0]?.kind ?? "skipped" : capacity > 0 ? null : "no-capacity"
+		};
+	};
+	if (input.source === "hardware") return fromHardware(null);
+	if (!rec.reachable) return fromHardware(null);
+	const results = input.measured.get(rec.nodeId);
+	const byKey = new Map((results?.devices ?? []).map((d) => [d.deviceKey, d]));
+	const usable = rec.devices.filter((d) => d.enabled && d.available);
+	const mustCover = rec.devices.filter((d) => d.enabled && d.available && d.chosen !== null);
+	const covered = usable.filter((d) => byKey.has(d.deviceKey));
+	if (covered.length === 0) return fromHardware("no-benchmark-results");
+	if (mustCover.some((d) => !byKey.has(d.deviceKey))) return fromHardware("partial-benchmark-results");
+	const devices = covered.map((d) => {
+		const row = byKey.get(d.deviceKey);
+		const sessions = Math.max(0, Math.floor(row?.maxSessions ?? 0));
+		return {
+			deviceKey: d.deviceKey,
+			sessions,
+			weight: sessions,
+			modelId: row?.modelId ?? null,
+			fps: null,
+			measured: true
+		};
+	});
+	return {
+		rec,
+		devices,
+		capacitySource: "benchmark",
+		capacityFallback: null,
+		skippedReason: devices.reduce((sum, d) => sum + d.sessions, 0) > 0 ? null : "no-capacity"
+	};
+}
+/** Shares proportional to capacity — the automatic shares and the suggestion are this. */
+function computeCapacityShares(input) {
+	const sized = input.recommendations.map((rec) => sizeNode(rec, input));
+	const capacityByNode = /* @__PURE__ */ new Map();
+	for (const node of sized) {
+		const capacity = node.devices.reduce((sum, d) => sum + d.sessions, 0);
+		if (node.skippedReason === null && capacity > 0) capacityByNode.set(node.rec.nodeId, capacity);
+	}
+	const nodePct = toPercentShares(capacityByNode);
+	const nodes = sized.map((node) => {
+		const devicePct = toPercentShares(new Map(node.devices.map((d) => [d.deviceKey, d.weight])));
+		return {
+			nodeId: node.rec.nodeId,
+			share: nodePct.get(node.rec.nodeId) ?? null,
+			capacitySessions: node.devices.reduce((sum, d) => sum + d.sessions, 0),
+			skippedReason: node.skippedReason,
+			capacitySource: node.capacitySource,
+			capacityFallback: node.capacityFallback,
+			devices: node.devices.map((d) => ({
+				deviceKey: d.deviceKey,
+				share: devicePct.get(d.deviceKey) ?? 0,
+				modelId: d.modelId,
+				fps: d.fps,
+				measured: d.measured,
+				suggestedMaxSessions: d.sessions
+			}))
+		};
+	});
+	return {
+		headroom: input.headroom,
+		source: input.source,
+		cameraFps: input.cameraFps,
+		minSessionsPerDevice: input.minSessionsPerDevice,
+		nodes
+	};
+}
+/**
 * THE detail-crop convention — the single derivation of the rectangle a
 * detail/enrichment step (clip-embedding, face-detection, plate-detection…)
 * is fed.
@@ -62411,6 +62636,7 @@ function planStressFailover(input, now, guards = DEFAULT_STRESS_FAILOVER_GUARDS)
 	};
 	const okByNode = new Map(input.verdicts.filter((v) => v.state === "ok").map((v) => [v.nodeId, v]));
 	const sourceAttached = input.attachedByNode[saturated.nodeId] ?? 0;
+	if (input.shares !== void 0) return planShareTarget(input, input.shares, saturated, movable, okByNode, now, guards);
 	for (const camera of movable) {
 		const banned = new Set(input.history.filter((h) => h.deviceId === camera.deviceId && now - h.at < guards.returnBanMs).map((h) => h.fromNodeId));
 		const target = camera.eligibleNodes.filter((nodeId) => nodeId !== saturated.nodeId && !banned.has(nodeId)).map((nodeId) => okByNode.get(nodeId)).filter((v) => v !== void 0).filter((v) => {
@@ -62435,6 +62661,52 @@ function planStressFailover(input, now, guards = DEFAULT_STRESS_FAILOVER_GUARDS)
 		nodeId: saturated.nodeId
 	};
 }
+/** Deficits equal up to float noise. */
+var SHARE_EPSILON = 1e-9;
+function underCap(input, nodeId) {
+	const cap = input.nodeCaps?.[nodeId];
+	const attached = input.attachedByNode[nodeId] ?? 0;
+	return cap === null || cap === void 0 || cap <= 0 || attached < cap;
+}
+/**
+* Share placement's failover target (D750): among the camera's eligible,
+* `ok`, under-cap nodes, the one furthest below its share of the cameras
+* attached across the source and those nodes — the same deficit rule a new
+* session is placed by. A node at or over its share is no target, so a move
+* never undoes the balance. Nothing below its share ⇒ hold, naming the camera.
+*/
+function planShareTarget(input, shares, saturated, movable, okByNode, now, guards) {
+	const shareOf = (nodeId) => {
+		const share = shares[nodeId];
+		return share !== void 0 && share > 0 ? share : 0;
+	};
+	for (const camera of movable) {
+		const banned = new Set(input.history.filter((h) => h.deviceId === camera.deviceId && now - h.at < guards.returnBanMs).map((h) => h.fromNodeId));
+		const healthy = camera.eligibleNodes.filter((nodeId) => nodeId !== saturated.nodeId && !banned.has(nodeId)).map((nodeId) => okByNode.get(nodeId)).filter((v) => v !== void 0).filter((v) => underCap(input, v.nodeId));
+		const set = [saturated.nodeId, ...healthy.map((v) => v.nodeId)];
+		const shareSum = set.reduce((sum, nodeId) => sum + shareOf(nodeId), 0);
+		const attachedSum = set.reduce((sum, nodeId) => sum + (input.attachedByNode[nodeId] ?? 0), 0);
+		if (shareSum <= 0) continue;
+		const deficit = (nodeId) => shareOf(nodeId) / shareSum * attachedSum - (input.attachedByNode[nodeId] ?? 0);
+		const target = healthy.filter((v) => deficit(v.nodeId) > SHARE_EPSILON).toSorted((a, b) => deficit(b.nodeId) - deficit(a.nodeId) || a.signals.score - b.signals.score || a.nodeId.localeCompare(b.nodeId))[0];
+		if (!target) continue;
+		return {
+			kind: "move",
+			deviceId: camera.deviceId,
+			fromNodeId: saturated.nodeId,
+			toNodeId: target.nodeId,
+			fromScore: saturated.signals.score,
+			toScore: target.signals.score
+		};
+	}
+	const first = movable[0];
+	return {
+		kind: "hold",
+		reason: "no-target",
+		nodeId: saturated.nodeId,
+		...first !== void 0 ? { deviceId: first.deviceId } : {}
+	};
+}
 //#endregion
 //#region src/node-stress-controller.ts
 /** Narrow an unknown settings value to a {@link NodeStressMode}. */
@@ -62643,17 +62915,27 @@ var NodeStressController = class NodeStressController {
 		if (!verdicts.some((v) => v.state === "saturated")) return;
 		this.deps.moves.pruneOlderThan(now - NodeStressController.HISTORY_TTL_MS);
 		const history = this.deps.moves.entries().filter((h) => now - h.at < NodeStressController.HISTORY_TTL_MS);
+		const candidates = await this.collectCandidates(now);
+		const shares = await this.deps.readFailoverShares?.() ?? null;
 		const plan = planStressFailover({
 			verdicts,
-			candidates: await this.collectCandidates(now),
+			candidates,
 			history,
 			nodeCaps: await this.deps.settingsStore.buildNodeCaps(),
-			attachedByNode: this.attachedByNode()
+			attachedByNode: this.attachedByNode(),
+			...shares !== null ? { shares } : {}
 		}, now, this.guards());
 		if (plan.kind === "hold") {
 			this.deps.logger.warn("node saturated — no failover applied", {
-				tags: { nodeId: plan.nodeId ?? "" },
-				meta: { reason: plan.reason }
+				tags: {
+					nodeId: plan.nodeId ?? "",
+					...plan.deviceId !== void 0 ? { deviceId: plan.deviceId } : {}
+				},
+				meta: {
+					reason: plan.reason,
+					rule: shares !== null ? "share-deficit" : "fewest-cameras",
+					...plan.reason === "no-target" && shares !== null ? { why: "no healthy node below its share can take it" } : {}
+				}
 			});
 			return;
 		}
@@ -64432,6 +64714,7 @@ var StoredCameraPipelineForAgentSchema = object({
 });
 var StoredCameraPipelineSettingsSchema = object({
 	stepToggles: record(string(), boolean()).optional(),
+	stepSettings: record(string(), record(string(), unknown()).readonly()).optional(),
 	stepOverridesByDevice: record(string(), record(string(), record(string(), StoredCameraStepOverridePatchSchema))).optional(),
 	stepOverridesByAgent: record(string(), record(string(), LegacyCameraStepOverridePatchSchema)).optional(),
 	pipelineByAgent: record(string(), StoredCameraPipelineForAgentSchema).optional(),
@@ -64751,6 +65034,30 @@ var PipelineSettingsStore = class PipelineSettingsStore {
 			};
 		});
 	}
+	/**
+	* Write or clear one camera's CAMERA-WIDE settings for `addonId` (D754): the
+	* field-level bag merged between the node base and the per-(node,device)
+	* override on every accelerator. `null` or an empty bag deletes the step's
+	* entry; an empty layer is pruned. Read-patch-write, immutable.
+	*/
+	async writeCameraStepSettings(deviceId, addonId, settings) {
+		await this.cameraSettingsState.update((prev) => {
+			const key = String(deviceId);
+			const camera = prev[key] ?? {};
+			const nextLayer = { ...camera.stepSettings };
+			if (settings === null || Object.keys(settings).length === 0) delete nextLayer[addonId];
+			else nextLayer[addonId] = { ...settings };
+			const { stepSettings: _drop, ...rest } = camera;
+			const nextCamera = {
+				...rest,
+				...Object.keys(nextLayer).length > 0 ? { stepSettings: nextLayer } : {}
+			};
+			return {
+				...prev,
+				[key]: nextCamera
+			};
+		});
+	}
 	/** Purge one device's entry through the durable handle (whole-blob round-trip). */
 	async deleteCameraSettings(deviceId) {
 		await this.cameraSettingsState.update((prev) => {
@@ -65265,12 +65572,30 @@ var PipelineSettingsStore = class PipelineSettingsStore {
 	* `balance()` call so unpinned cameras distribute proportionally to weight.
 	*/
 	async buildNodeWeights() {
+		if (this.effectiveNodeWeights !== null) return this.effectiveNodeWeights();
+		return this.buildStoredNodeWeights();
+	}
+	/**
+	* The operator's stored node sliders, whatever the share source — what
+	* `manual` applies and what `auto` falls back to before its first answer.
+	*/
+	async buildStoredNodeWeights() {
 		const blob = await this.agentSettingsState.get();
 		const weights = {};
 		for (const [nodeId, settings] of Object.entries(blob)) if (typeof settings.detectWeight === "number" && settings.detectWeight > 0) weights[nodeId] = settings.detectWeight;
 		return weights;
 	}
 	/**
+	* Where {@link buildNodeWeights} reads from once the share source is wired
+	* (D750): the effective shares (automatic or manual). Every balancer, the
+	* share election and the stress failover read through it, so they can never
+	* disagree on what a node's share is. Unset (tests, early boot) ⇒ stored.
+	*/
+	effectiveNodeWeights = null;
+	setEffectiveNodeWeights(read) {
+		this.effectiveNodeWeights = read;
+	}
+	/**
 	* The per-(node,device) BASE provisioning (C7.2/C7.4) for one `(node,
 	* deviceKey)` — the effective `stepId → {modelId?, settings?}` map the
 	* dispatch provisioning stage attaches onto the resolved step tree before
@@ -65299,13 +65624,14 @@ var PipelineSettingsStore = class PipelineSettingsStore {
 	async readDeviceProvisioning(deviceId, nodeId, deviceKeys) {
 		const [agentBlob, cameraMap] = await Promise.all([this.agentSettingsState.get(), this.readCameraSettingsMap()]);
 		const devices = agentBlob[nodeId]?.inferenceDevices;
-		const byDevice = cameraMap[String(deviceId)]?.stepOverridesByDevice?.[nodeId];
+		const camera = cameraMap[String(deviceId)];
+		const byDevice = camera?.stepOverridesByDevice?.[nodeId];
 		const out = /* @__PURE__ */ new Map();
 		for (const deviceKey of deviceKeys) {
-			const override = deviceKey === "" ? void 0 : byDevice?.[deviceKey];
+			const perDevice = deviceKey === "" ? void 0 : byDevice?.[deviceKey];
 			out.set(deviceKey, {
 				base: foldNodeStepSettings(devices, deviceKey),
-				override: override ? { ...override } : {}
+				override: layerCameraStepSettings(camera?.stepSettings, perDevice)
 			});
 		}
 		return out;
@@ -65369,6 +65695,30 @@ var PipelineSettingsStore = class PipelineSettingsStore {
 		return `tpl_${Date.now().toString(36).slice(-6)}${rand}`;
 	}
 };
+/**
+* The camera's override for one accelerator, with its CAMERA-WIDE settings
+* (D754) folded underneath: per step, `settings = { ...camera, ...perDevice }`
+* (a per-accelerator key wins), and the per-accelerator `modelId` kept as is —
+* the camera layer carries no model. The result is what
+* `applyDeviceProvisioning` merges over the node base, so the full order is
+* node ⊕ camera ⊕ camera-per-accelerator. Fresh objects; a camera with neither
+* layer yields `{}`.
+*/
+function layerCameraStepSettings(cameraWide, perDevice) {
+	const out = { ...perDevice };
+	for (const [stepId, settings] of Object.entries(cameraWide ?? {})) {
+		if (Object.keys(settings).length === 0) continue;
+		const own = out[stepId];
+		out[stepId] = {
+			...own,
+			settings: {
+				...settings,
+				...own?.settings
+			}
+		};
+	}
+	return out;
+}
 //#endregion
 //#region src/pipeline-watchdog.ts
 var DEFAULT_WATCHDOG_THRESHOLDS = {
@@ -67628,9 +67978,10 @@ var SessionDispatchController = class {
 			deviceId: a.deviceId,
 			nodeId: a.agentNodeId
 		}))]);
+		const present = new Set(this.deps.topology.knownRunnerNodeIds());
 		const election = electNodeByShare({
 			loads: input.loads,
-			eligible: input.eligible,
+			eligible: input.eligible.filter((nodeId) => present.has(nodeId)),
 			weights: input.weights,
 			caps: input.nodeCaps,
 			runningByNode: running
@@ -68990,7 +69341,6 @@ 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");
 		}
 	});
@@ -69099,7 +69449,8 @@ async function buildOrchestratorControllers(deps) {
 		attach: (nodeId, config) => placement.attachOn(nodeId, config),
 		detach: (nodeId, deviceId) => placement.detachOn(nodeId, deviceId),
 		readPipelinePin: (deviceId) => deps.readPipelinePin(deviceId),
-		readGlobalSettings: () => globalSettings
+		readGlobalSettings: () => globalSettings,
+		readFailoverShares: async () => readSessionPlacement() === "share" ? settingsStore.buildNodeWeights() : null
 	});
 	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$2(err) } });
@@ -69115,6 +69466,7 @@ async function buildOrchestratorControllers(deps) {
 	nodeStress.start();
 	const inferenceRotation = new RoundRobinInferenceDeviceRotation();
 	const readSessionPlacement = () => parseSessionPlacementPolicy(globalSettings?.[SESSION_PLACEMENT_SETTING_KEY]);
+	const readShareSource = () => parseShareSource(globalSettings?.[SHARE_SOURCE_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.
@@ -69451,6 +69803,7 @@ async function buildOrchestratorControllers(deps) {
 		nodeLifecycle.unsubscribeDetectionPipelineReadiness(nodeId);
 		audio.markNodeOffline(nodeId);
 		deps.forgetInferenceDeviceProbe(nodeId);
+		if (!nodeId.includes("/")) deps.noteShareTopologyChange(`node-offline:${nodeId}`);
 		nodeLifecycle.handleNodeDisconnect(nodeId).catch((err) => {
 			const msg = errMsg$2(err);
 			deps.ctx().logger.error("failover after disconnect failed", {
@@ -69494,6 +69847,7 @@ async function buildOrchestratorControllers(deps) {
 			});
 		});
 		reconcile.scheduleReconcile();
+		if (!nodeId.includes("/")) deps.noteShareTopologyChange(`node-online:${nodeId}`);
 	});
 	const unsubAgentOnline = () => {
 		unsubAgentOnlineEvent();
@@ -69734,7 +70088,8 @@ async function buildOrchestratorControllers(deps) {
 		unsubOrchestratorSubscriptions,
 		pendingRetryTimer,
 		autoRebalanceTimer,
-		sessionPlacement: () => readSessionPlacement()
+		sessionPlacement: () => readSessionPlacement(),
+		shareSource: () => readShareSource()
 	};
 }
 //#endregion
@@ -69783,13 +70138,13 @@ function buildGlobalSettingsSections(options) {
 					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.",
+					description: "How a new detection session picks its node and device. Honour shares (default) = the share of PARALLEL sessions is held to the node and device shares, and a node at its cap yields to a free one. 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.",
 					options: [{
-						value: "least-loaded",
-						label: "Least-loaded"
-					}, {
 						value: "share",
 						label: "Honour shares"
+					}, {
+						value: "least-loaded",
+						label: "Least-loaded"
 					}],
 					default: DEFAULT_SESSION_PLACEMENT_POLICY
 				},
@@ -70351,9 +70706,9 @@ var pipelineOrchestratorWidgets = [{
 	defaultRows: 4
 }];
 //#endregion
-//#region src/best-settings/plan-diff.ts
+//#region src/auto-tune/plan-diff.ts
 /**
-* The Best settings writes, as pure transforms of the orchestrator's two
+* The Auto tune 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.
 *
@@ -70377,7 +70732,7 @@ var pipelineOrchestratorWidgets = [{
 */
 /** The root detector step. */
 var DETECTOR_STEP_ID = "object-detection";
-/** Steps whose `modelId` pin Best settings never touches. */
+/** Steps whose `modelId` pin Auto tune never touches. */
 function isModelPinKept(stepId) {
 	return stepId.endsWith("-embedding");
 }
@@ -70429,7 +70784,7 @@ function scrubStep(stepId, step, boundKeys, targetModel) {
 	};
 }
 /** The node-level transform. Returns the next blob and every change it made. */
-function applyNodeBestSettings(blob, input) {
+function applyNodeAutoTune(blob, input) {
 	const next = { ...blob };
 	const changes = [];
 	for (const nodeId of [...input.touchedNodes].toSorted()) {
@@ -70499,7 +70854,7 @@ function scrubTree(steps, input, onClear) {
 	});
 }
 /** The camera-level transform. Returns the next blob and every override it removed. */
-function applyCameraBestSettings(blob, input) {
+function applyCameraAutoTune(blob, input) {
 	const next = {};
 	const clears = [];
 	for (const key of Object.keys(blob).toSorted((a, b) => Number(a) - Number(b))) {
@@ -70583,13 +70938,15 @@ function applyCameraBestSettings(blob, input) {
 	};
 }
 //#endregion
-//#region src/best-settings/best-settings-service.ts
+//#region src/auto-tune/auto-tune-service.ts
 /**
-* Best settings (D745): gather the inputs, compute the plan, and apply exactly
-* the plan the operator confirmed.
+* Auto tune (D745, D755): 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
+* The plan is the recommender (`@camstack/types` auto-tune) over every
+* runner node — sized by a capacity floor (`minSessionsPerDevice` parallel
+* sessions per device at the camera rate), never by observed or estimated
+* load — 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
@@ -70606,6 +70963,9 @@ function applyCameraBestSettings(blob, input) {
 * A failure after phase 2 leaves "overrides cleared, previous node model",
 * which is a valid configuration (the defaults run); re-running converges.
 */
+function minSessionsOf(input) {
+	return input.minSessionsPerDevice ?? 2;
+}
 function errMsg(err) {
 	return err instanceof Error ? err.message : String(err);
 }
@@ -70634,117 +70994,45 @@ function boundKeysOf(catalogs) {
 	}
 	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 {
+var AutoTuneService = class {
 	deps;
 	applying = false;
 	constructor(deps) {
 		this.deps = deps;
 	}
 	async plan(input) {
-		return (await this.computePlan(input.headroom, input.shares)).plan;
+		return (await this.computePlan(input.headroom, minSessionsOf(input))).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.
+	* Shares proportional to each node's capacity in parallel sessions (D755):
+	* from the latency table at the models Auto tune picks at its defaults
+	* (`hardware`), or from node benchmark results (`benchmark`), a node
+	* without results falling back to `hardware` and saying so. ONE pass, and
+	* nothing but capacity goes in — the automatic shares are exactly this.
+	* 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;
+		const source = input.source ?? "hardware";
+		const minSessionsPerDevice = 2;
+		const rec = await this.recommend(input.headroom, minSessionsPerDevice);
+		let measured = /* @__PURE__ */ new Map();
+		if (source === "benchmark") try {
+			measured = await this.deps.measuredCapacity.readMeasuredCapacity(rec.recommendations.map((r) => r.nodeId));
+		} catch (err) {
+			this.deps.logger.warn("load balancing: benchmark results unreadable — sized from hardware", { meta: { error: errMsg(err) } });
 		}
-		return {
+		return computeCapacityShares({
+			recommendations: rec.recommendations,
+			source,
+			measured,
 			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
-				}))
-			};
+			cameraFps: rec.cameraFps,
+			minSessionsPerDevice
 		});
 	}
-	/**
-	* 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) {
+	/** Gather every node and recommend. Nothing but hardware, catalog and the sizing goes in. */
+	async recommend(headroom, minSessionsPerDevice) {
 		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([
@@ -70759,7 +71047,6 @@ var BestSettingsService = class {
 				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,
@@ -70772,40 +71059,22 @@ var BestSettingsService = class {
 			})),
 			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);
+		const observedFps = await this.deps.cameraFps();
+		const cameraFps = observedFps !== null && observedFps > 0 ? observedFps : 10;
 		return {
 			gathered,
 			nodes,
-			recommendations,
-			cameraFps: cameraFps > 0 ? cameraFps : 10
+			recommendations: nodes.map((node) => recommendNode({
+				node,
+				headroom,
+				minSessionsPerDevice,
+				cameraFps
+			})),
+			cameraFps
 		};
 	}
-	async computePlan(headroom, shares) {
-		const { gathered, nodes, recommendations } = await this.recommend(headroom, shares);
+	async computePlan(headroom, minSessionsPerDevice) {
+		const { gathered, nodes, recommendations, cameraFps } = await this.recommend(headroom, minSessionsPerDevice);
 		const touchedNodes = new Set(recommendations.filter((r) => !r.skipped).map((r) => r.nodeId));
 		const targets = /* @__PURE__ */ new Map();
 		const formats = /* @__PURE__ */ new Map();
@@ -70832,8 +71101,8 @@ var BestSettingsService = class {
 			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 nodeChanges = applyNodeAutoTune(await this.deps.readAgentSettings(), diffInput).changes;
+		const cameraClears = applyCameraAutoTune(await this.deps.readCameraSettings(), diffInput).clears;
 		const warnings = [];
 		let detectorStoreClears = [];
 		if (touchedNodes.size > 0) try {
@@ -70865,9 +71134,10 @@ var BestSettingsService = class {
 		return {
 			plan: {
 				planHash: (0, node_crypto.createHash)("sha256").update(canonical({
-					version: 1,
+					version: 2,
 					headroom,
-					whatIf: shares ?? null,
+					minSessionsPerDevice,
+					cameraFps,
 					picks: recommendations.map((r) => ({
 						nodeId: r.nodeId,
 						skipped: r.skipped,
@@ -70879,7 +71149,8 @@ var BestSettingsService = class {
 				})).digest("hex"),
 				family: "yolov9",
 				headroom,
-				whatIf: shares !== void 0,
+				minSessionsPerDevice,
+				cameraFps,
 				generatedAt: this.deps.now(),
 				nodes: recommendations,
 				nodeChanges: [...nodeChanges],
@@ -70904,9 +71175,9 @@ var BestSettingsService = class {
 		}
 	}
 	async applyLocked(input) {
-		const { plan, diffInput, formats } = await this.computePlan(input.headroom);
+		const { plan, diffInput, formats } = await this.computePlan(input.headroom, minSessionsOf(input));
 		if (plan.planHash !== input.planHash) {
-			this.deps.logger.warn("best settings: stale plan refused", { meta: {
+			this.deps.logger.warn("auto tune: stale plan refused", { meta: {
 				confirmed: input.planHash,
 				current: plan.planHash
 			} });
@@ -70938,15 +71209,15 @@ var BestSettingsService = class {
 				ok: false,
 				detail: errMsg(err)
 			});
-			this.deps.logger.warn("best settings: a model download failed — nothing was written", { meta: { error: errMsg(err) } });
+			this.deps.logger.warn("auto tune: 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", {
+			await this.deps.rewriteCameraSettings((prev) => applyCameraAutoTune(prev, diffInput).next);
+			for (const c of plan.cameraClears) this.deps.logger.info("auto tune: camera override cleared", {
 				tags: {
 					deviceId: c.deviceId,
 					nodeId: c.nodeId
@@ -70990,8 +71261,8 @@ var BestSettingsService = class {
 			});
 		}
 		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", {
+			await this.deps.rewriteAgentSettings((prev) => applyNodeAutoTune(prev, diffInput).next);
+			for (const c of plan.nodeChanges) for (const pin of c.modelPins) this.deps.logger.info("auto tune: node model set", {
 				tags: { nodeId: c.nodeId },
 				meta: {
 					nodeId: c.nodeId,
@@ -71025,14 +71296,14 @@ var BestSettingsService = class {
 			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", {
+		for (const rec of plan.nodes.filter((r) => r.skipped)) this.deps.logger.info("auto tune: node skipped", {
 			tags: { nodeId: rec.nodeId },
 			meta: {
 				nodeId: rec.nodeId,
 				reasons: rec.reasons
 			}
 		});
-		this.deps.logger.info("best settings: applied", { meta: {
+		this.deps.logger.info("auto tune: applied", { meta: {
 			planHash: plan.planHash,
 			nodeChanges: plan.nodeChanges.length,
 			cameraClears: plan.cameraClears.length,
@@ -71047,83 +71318,6 @@ var BestSettingsService = class {
 	}
 };
 //#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) {
@@ -71289,6 +71483,212 @@ function applyLoadBalancingShares(prev, write) {
 	return next;
 }
 //#endregion
+//#region src/load-balancing/effective-shares-service.ts
+/** Skips that mean "not readable yet", never "cannot take sessions". */
+var NOT_READY_REASONS = new Set(["node-offline", "no-hardware-facts"]);
+function capacityFrom(result) {
+	const out = {};
+	for (const node of result.nodes) if (node.capacitySource !== null) out[node.nodeId] = {
+		source: node.capacitySource,
+		fallback: node.capacityFallback
+	};
+	return out;
+}
+function weightsFrom(result) {
+	const nodes = {};
+	const devices = {};
+	for (const node of result.nodes) {
+		if (node.share !== null && node.share > 0) nodes[node.nodeId] = node.share;
+		const perDevice = {};
+		for (const d of node.devices) if (d.share > 0) perDevice[d.deviceKey] = d.share;
+		if (Object.keys(perDevice).length > 0) devices[node.nodeId] = perDevice;
+	}
+	return {
+		nodes,
+		devices
+	};
+}
+var EffectiveSharesService = class EffectiveSharesService {
+	deps;
+	/** An automatic answer older than this is recomputed by the reconcile. */
+	static MAX_AGE_MS = 15 * 6e4;
+	/** Reconcile cadence. */
+	static RECONCILE_MS = 6e4;
+	answer = null;
+	inFlight = null;
+	pendingTrigger = null;
+	timer = null;
+	constructor(deps) {
+		this.deps = deps;
+	}
+	now() {
+		return this.deps.now?.() ?? Date.now();
+	}
+	/** The last automatic answer for the CURRENT source; null = none yet. */
+	current() {
+		return this.usable();
+	}
+	/** The answer, when the source is automatic and the answer was computed for it. */
+	usable() {
+		const source = this.deps.readSource();
+		if (!isAutomaticShareSource(source)) return null;
+		return this.answer !== null && this.answer.source === source ? this.answer : null;
+	}
+	/** Node weights the election reads. */
+	async nodeWeights() {
+		const answer = this.usable();
+		if (answer !== null) return { ...answer.weights.nodes };
+		return { ...(await this.deps.readStored()).nodes };
+	}
+	/** The weights of a node's ELIGIBLE devices (`eligible` carries their stored weights). */
+	deviceWeights(nodeId, eligible) {
+		const answer = this.usable();
+		if (answer === null) return { ...eligible };
+		const auto = answer.weights.devices[nodeId] ?? {};
+		const out = {};
+		for (const [key, stored] of Object.entries(eligible)) {
+			const share = auto[key];
+			out[key] = share !== void 0 && share > 0 ? share : stored;
+		}
+		return out;
+	}
+	/** Both maps, as the Auto tune recommender charges load by them. */
+	async effectiveWeights() {
+		return this.usable()?.weights ?? this.deps.readStored();
+	}
+	/**
+	* Recompute now (automatic sources only). Concurrent calls coalesce: one
+	* runs, and one trailing run picks up whatever was reported meanwhile.
+	*/
+	async recompute(trigger) {
+		if (!isAutomaticShareSource(this.deps.readSource())) return;
+		if (this.inFlight !== null) {
+			this.pendingTrigger = trigger;
+			return this.inFlight;
+		}
+		this.inFlight = this.run(trigger).finally(() => {
+			this.inFlight = null;
+		});
+		await this.inFlight;
+		const trailing = this.pendingTrigger;
+		if (trailing !== null) {
+			this.pendingTrigger = null;
+			await this.recompute(trailing);
+		}
+	}
+	async run(trigger) {
+		const source = this.deps.readSource();
+		if (!isAutomaticShareSource(source)) return;
+		let signature;
+		let result;
+		try {
+			signature = await this.deps.topologySignature();
+			result = await this.deps.suggest(source);
+		} catch (err) {
+			this.deps.logger.warn("load balancing: automatic shares not recomputed — last answer kept", { meta: {
+				trigger,
+				error: errMsg$2(err),
+				hasAnswer: this.answer !== null
+			} });
+			return;
+		}
+		const before = this.answer?.weights ?? null;
+		const after = weightsFrom(result);
+		const notReady = result.nodes.filter((n) => n.share === null && NOT_READY_REASONS.has(n.skippedReason ?? "")).map((n) => n.nodeId).toSorted();
+		const capacity = capacityFrom(result);
+		this.answer = {
+			weights: after,
+			capacity,
+			source,
+			computedAt: this.now(),
+			trigger,
+			signature,
+			notReady
+		};
+		const nodeIds = [...new Set([...Object.keys(before?.nodes ?? {}), ...result.nodes.map((n) => n.nodeId)])];
+		const log = before !== null && JSON.stringify(before) === JSON.stringify(after) && trigger.startsWith("reconcile:not-ready") ? this.deps.logger.debug.bind(this.deps.logger) : this.deps.logger.info.bind(this.deps.logger);
+		for (const nodeId of nodeIds.toSorted()) log("load balancing: automatic shares recomputed", {
+			tags: { nodeId },
+			meta: {
+				trigger,
+				source,
+				capacitySource: capacity[nodeId]?.source ?? null,
+				capacityFallback: capacity[nodeId]?.fallback ?? null,
+				notReady: notReady.includes(nodeId),
+				before: before?.nodes[nodeId] ?? null,
+				after: after.nodes[nodeId] ?? null,
+				devicesBefore: JSON.stringify(before?.devices[nodeId] ?? {}),
+				devicesAfter: JSON.stringify(after.devices[nodeId] ?? {})
+			}
+		});
+	}
+	/**
+	* Recompute if there is no answer for the current source, a node was not
+	* readable yet, the topology changed or the answer has grown old
+	* (automatic sources only).
+	*/
+	async reconcile() {
+		const source = this.deps.readSource();
+		if (!isAutomaticShareSource(source)) return;
+		if (this.answer === null) return this.recompute("reconcile:first");
+		if (this.answer.source !== source) return this.recompute(`reconcile:source:${source}`);
+		if (this.answer.notReady.length > 0) return this.recompute(`reconcile:not-ready:${this.answer.notReady.join(",")}`);
+		if (this.now() - this.answer.computedAt > EffectiveSharesService.MAX_AGE_MS) return this.recompute("reconcile:age");
+		let signature;
+		try {
+			signature = await this.deps.topologySignature();
+		} catch (err) {
+			this.deps.logger.debug("load balancing: topology signature unreadable — reconcile skipped", { meta: { error: errMsg$2(err) } });
+			return;
+		}
+		if (signature !== this.answer.signature) return this.recompute("reconcile:topology");
+	}
+	start() {
+		if (this.timer !== null) return;
+		this.timer = setInterval(() => {
+			this.reconcile();
+		}, EffectiveSharesService.RECONCILE_MS);
+		this.timer.unref?.();
+	}
+	stop() {
+		if (this.timer !== null) clearInterval(this.timer);
+		this.timer = null;
+	}
+};
+//#endregion
+//#region src/load-balancing/share-inputs.ts
+/** The operator's sliders: node `detectWeight` and device `weight` (positive only). */
+function storedShareWeights(blob) {
+	const nodes = {};
+	const devices = {};
+	for (const [nodeId, settings] of Object.entries(blob)) {
+		if (typeof settings.detectWeight === "number" && settings.detectWeight > 0) nodes[nodeId] = settings.detectWeight;
+		const perDevice = {};
+		for (const [key, entry] of Object.entries(settings.inferenceDevices ?? {})) if (typeof entry.weight === "number" && entry.weight > 0) perDevice[key] = entry.weight;
+		if (Object.keys(perDevice).length > 0) devices[nodeId] = perDevice;
+	}
+	return {
+		nodes,
+		devices
+	};
+}
+/**
+* A string that changes whenever an input of the automatic shares does: the
+* nodes present, each node's detect capability, which devices are switched on
+* and which detector model each runs. Sliders and caps are left out — they do
+* not change capacity.
+*/
+function shareTopologySignature(nodeIds, blob) {
+	return [...nodeIds].toSorted().map((nodeId) => {
+		const settings = blob[nodeId];
+		const devices = Object.entries(settings?.inferenceDevices ?? {}).toSorted(([a], [b]) => a.localeCompare(b)).map(([key, entry]) => {
+			const model = entry.steps?.["object-detection"]?.modelId ?? "";
+			return `${key}=${entry.enabled ? "on" : "off"}:${model}`;
+		});
+		return `${nodeId}|detect=${String(settings?.detect ?? "default")}|${devices.join(",")}`;
+	}).join(";");
+}
+//#endregion
 //#region src/stale-device-pins.ts
 function findStaleDevicePins(pins, nodes) {
 	const usable = /* @__PURE__ */ new Map();
@@ -71372,12 +71772,14 @@ var PipelineOrchestratorAddon = class PipelineOrchestratorAddon extends BaseAddo
 	*/
 	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;
+	/** The stored session placement policy (D748, default `share` since D750). */
+	readSessionPlacement = () => DEFAULT_SESSION_PLACEMENT_POLICY;
+	/** Where the shares come from (D750); `auto` before init. */
+	readShareSource = () => DEFAULT_SHARE_SOURCE;
+	autoTuneService = null;
+	effectiveSharesService = null;
 	/**
 	* Single owner of the shared placement state (`assignments`/`cameraConfigs`/
 	* `pendingReasons`/`dispatchingDevices`) — see `placement-ledger.ts` (S6
@@ -71626,6 +72028,7 @@ var PipelineOrchestratorAddon = class PipelineOrchestratorAddon extends BaseAddo
 			getEligibleInferenceDevices: (nodeId, read) => this.resolveEligibleInferenceDevices(nodeId, read),
 			getEligibleInferenceDevicesIfCached: (nodeId) => this.resolveEligibleInferenceDevicesIfCached(nodeId),
 			forgetInferenceDeviceProbe: (nodeId) => this.forgetInferenceDeviceProbe(nodeId),
+			noteShareTopologyChange: (trigger) => this.noteShareChange(trigger),
 			isNodeInferenceUsable: (nodeId) => this.isNodeInferenceUsable(nodeId),
 			getInferenceDeviceCaps: (nodeId) => this.getInferenceDeviceCaps(nodeId),
 			readPipelineDevicePin: (deviceId) => this.readPipelineDevicePin(deviceId),
@@ -71654,7 +72057,6 @@ 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;
@@ -71683,6 +72085,10 @@ var PipelineOrchestratorAddon = class PipelineOrchestratorAddon extends BaseAddo
 		this.placement = controllers.placement;
 		this.session = controllers.session;
 		this.readSessionPlacement = controllers.sessionPlacement;
+		this.readShareSource = controllers.shareSource;
+		this.settingsStore.setEffectiveNodeWeights(() => this.effectiveShares().nodeWeights());
+		this.effectiveShares().start();
+		this.noteShareChange("startup");
 		this.deviceConfig = controllers.deviceConfig;
 		this.cameraStatusService = controllers.cameraStatusService;
 		this.cameraSwitchService = controllers.cameraSwitchService;
@@ -71808,6 +72214,7 @@ var PipelineOrchestratorAddon = class PipelineOrchestratorAddon extends BaseAddo
 		this.detectionWiring = null;
 		this.unsubAgentOffline?.();
 		this.unsubAgentOffline = null;
+		this.effectiveSharesService?.stop();
 		this.unsubAgentOnline?.();
 		this.unsubAgentOnline = null;
 		this.nodeLifecycle?.dispose();
@@ -72210,6 +72617,7 @@ var PipelineOrchestratorAddon = class PipelineOrchestratorAddon extends BaseAddo
 		await this.topology.refreshNodeCapabilities();
 		this.topology.addKnownRunnerNode(input.agentNodeId);
 		this.reconcile.schedulePendingRetry();
+		if (input.detect !== void 0) this.noteShareChange(`node-detect:${input.agentNodeId}`);
 		return { success: true };
 	}
 	/**
@@ -72299,6 +72707,7 @@ var PipelineOrchestratorAddon = class PipelineOrchestratorAddon extends BaseAddo
 		});
 		await this.resetRemovedModelPins("node-device-write");
 		this.reconcile.schedulePendingRetry();
+		this.noteShareChange(`node-devices:${input.agentNodeId}`);
 		return { success: true };
 	}
 	/**
@@ -72379,7 +72788,7 @@ var PipelineOrchestratorAddon = class PipelineOrchestratorAddon extends BaseAddo
 			});
 			throw new Error(`inference device eligibility: node "${nodeId}" catalog not answered`);
 		}
-		return this.electableDevices(nodeId, probed, catalog);
+		return this.effectiveShares().deviceWeights(nodeId, await this.electableDevices(nodeId, probed, catalog));
 	}
 	/**
 	* Forget a node's last device probe (pre-ship review, M4). Called when the
@@ -72423,7 +72832,7 @@ var PipelineOrchestratorAddon = class PipelineOrchestratorAddon extends BaseAddo
 		this.refreshInferenceDeviceProbe(nodeId);
 		return {
 			kind: "eligible",
-			eligible: await this.electableDevices(nodeId, known, catalog)
+			eligible: this.effectiveShares().deviceWeights(nodeId, await this.electableDevices(nodeId, known, catalog))
 		};
 	}
 	/**
@@ -72753,10 +73162,10 @@ var PipelineOrchestratorAddon = class PipelineOrchestratorAddon extends BaseAddo
 			clearedCameraOverrides
 		};
 	}
-	bestSettings() {
-		if (this.bestSettingsService !== null) return this.bestSettingsService;
+	autoTune() {
+		if (this.autoTuneService !== null) return this.autoTuneService;
 		const store = this.settingsStore;
-		this.bestSettingsService = new BestSettingsService({
+		this.autoTuneService = new AutoTuneService({
 			logger: this.ctx.logger,
 			runnerNodeIds: () => this.topology.collectRunnerNodeIds(),
 			readNodeDevices: (nodeId) => this.getNodeInferenceDevices({ nodeId }),
@@ -72770,11 +73179,8 @@ var PipelineOrchestratorAddon = class PipelineOrchestratorAddon extends BaseAddo
 			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(),
+			cameraFps: async () => this.autoTuneCameraFps(),
+			measuredCapacity: NO_MEASURED_CAPACITY,
 			detectorStore: async (input) => {
 				const api = this.ctx.api;
 				if (!api) throw new Error("ctx.api unavailable");
@@ -72797,33 +73203,23 @@ var PipelineOrchestratorAddon = class PipelineOrchestratorAddon extends BaseAddo
 			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 this.autoTuneService;
+	}
+	/**
+	* The rate one detection session is counted at (D755): the fastest camera
+	* with detection started that runs the pipeline root; null when none does.
+	*/
+	autoTuneCameraFps() {
+		let fps = 0;
+		for (const config of this.detectionWiring.activeDetections.values()) {
+			if (config.detectionMode === "disabled") continue;
+			if (!(config.detectionSources ?? ["pipeline"]).includes("pipeline")) continue;
+			fps = Math.max(fps, config.detectionFps);
 		}
-		return loads;
+		return fps > 0 ? fps : null;
 	}
-	async planBestSettings(input) {
-		return this.bestSettings().plan(input);
+	async planAutoTune(input) {
+		return this.autoTune().plan(input);
 	}
 	/**
 	* Node + device shares in ONE read-modify-write of the agent settings. A
@@ -72879,10 +73275,79 @@ var PipelineOrchestratorAddon = class PipelineOrchestratorAddon extends BaseAddo
 		return findStaleDevicePins(pins, offered);
 	}
 	async suggestShares(input) {
-		return this.bestSettings().suggestShares(input);
+		return this.autoTune().suggestShares(input);
 	}
-	async applyBestSettings(input) {
-		return this.bestSettings().apply(input);
+	async applyAutoTune(input) {
+		const result = await this.autoTune().apply(input);
+		if (result.kind === "applied") this.noteShareChange("auto-tune-applied");
+		return result;
+	}
+	effectiveShares() {
+		if (this.effectiveSharesService !== null) return this.effectiveSharesService;
+		const store = this.settingsStore;
+		this.effectiveSharesService = new EffectiveSharesService({
+			readSource: () => this.readShareSource(),
+			readStored: async () => storedShareWeights(await store.readAgentSettingsMap()),
+			suggest: (source) => this.autoTune().suggestShares({
+				headroom: AUTO_SHARE_HEADROOM,
+				source
+			}),
+			topologySignature: async () => shareTopologySignature([...new Set(["hub", ...this.topology.collectRunnerNodeIds()])], await store.readAgentSettingsMap()),
+			logger: this.ctx.logger
+		});
+		return this.effectiveSharesService;
+	}
+	/** Something the automatic shares depend on changed: recompute now (best effort). */
+	noteShareChange(trigger) {
+		if (this.settingsStore === null) return;
+		this.effectiveShares().recompute(trigger).catch((err) => {
+			this.ctx.logger.warn("load balancing: share recompute failed", { meta: {
+				trigger,
+				error: errMsg$2(err)
+			} });
+		});
+	}
+	async getEffectiveShares() {
+		const service = this.effectiveShares();
+		const nodeIds = [...new Set(["hub", ...this.topology.collectRunnerNodeIds()])].toSorted();
+		const rows = await Promise.all(nodeIds.map(async (nodeId) => ({
+			nodeId,
+			read: await this.getNodeInferenceDevices({ nodeId }).catch(() => null)
+		})));
+		const detectable = new Set(this.topology.detectionEligibleNodes());
+		const eligibleNodes = rows.filter((r) => r.read !== null && r.read.reachable && detectable.has(r.nodeId) && this.isNodeInferenceUsable(r.nodeId)).map((r) => r.nodeId);
+		const eligibleDevices = {};
+		for (const r of rows) {
+			if (r.read === null) continue;
+			eligibleDevices[r.nodeId] = r.read.devices.filter((d) => d.enabled && d.available && d.exclusion === null).map((d) => d.key);
+		}
+		const auto = service.current();
+		return resolveEffectiveShares({
+			source: this.readShareSource(),
+			policy: this.readSessionPlacement(),
+			nodeIds,
+			stored: storedShareWeights(await this.settingsStore.readAgentSettingsMap()),
+			auto: auto?.weights ?? null,
+			...auto !== null ? { autoCapacity: auto.capacity } : {},
+			eligibleNodes,
+			eligibleDevices,
+			computedAt: auto?.computedAt ?? null,
+			trigger: auto?.trigger ?? null
+		});
+	}
+	async setShareSource(input) {
+		const previous = this.readShareSource();
+		if (input.source === "manual" && isAutomaticShareSource(previous)) {
+			const auto = this.effectiveShares().current();
+			if (auto !== null) await this.setLoadBalancingShares(auto.weights);
+		}
+		await this.updateGlobalSettings({ [SHARE_SOURCE_SETTING_KEY]: input.source });
+		this.ctx.logger.info("load balancing: share source changed", { meta: {
+			from: previous,
+			to: input.source
+		} });
+		if (isAutomaticShareSource(input.source)) this.noteShareChange(`source:${input.source}`);
+		return { success: true };
 	}
 	async getCameraSettings(input) {
 		return (await this.settingsStore.readCameraSettingsMap())[String(input.deviceId)] ?? null;
@@ -72913,6 +73378,16 @@ var PipelineOrchestratorAddon = class PipelineOrchestratorAddon extends BaseAddo
 		await this.emitResolvedCameraUpdated(input.deviceId);
 		return { success: true };
 	}
+	/**
+	* D754 — write or clear one step's CAMERA-WIDE settings (field-level bag,
+	* merged under the per-(node,device) override on every accelerator). No
+	* deviceKey to validate: the layer is node-independent by construction.
+	*/
+	async setCameraStepSettings(input) {
+		await this.settingsStore.writeCameraStepSettings(input.deviceId, input.addonId, input.settings);
+		await this.emitResolvedCameraUpdated(input.deviceId);
+		return { success: true };
+	}
 	async setCameraPipelineForAgent(input) {
 		const existing = (await this.settingsStore.readCameraSettingsMap())[String(input.deviceId)] ?? {};
 		const nextByAgent = { ...existing.pipelineByAgent };