@camstack/types 1.2.318 → 1.2.320

package/dist/index.js

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_sleep = require("./sleep-DyF95STh.js");
+const require_sleep = require("./sleep-AalHiRYL.js");
 const require_event_category = require("./event-category-DmS_tLsU.js");
 const require_composition = require("./composition-BLWAivB2.js");
 const require_err_msg = require("./err-msg-Dx2Kor0g.js");
@@ -26870,7 +26870,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
@@ -27242,115 +27242,21 @@ var pipelineExecutorCapability = {
 	}
 };
 //#endregion
-//#region src/pipeline/load-balancing/schemas.ts
-/**
-* Wire shapes of the Load balancing surface (D748): the session placement
-* policy, the atomic share write, the observed placement statistics, the
-* hardware share suggestion and the stale device pins.
-*/
+//#region src/pipeline/auto-tune/plan-schemas.ts
 /**
-* How a new detection session picks its node and device.
-*  - `least-loaded` — the historical rule: lowest `attached / weight`, a
-*    constant node order at a tie (D37). An idle node always ties at 0, so a
-*    weight only bites once a node already holds a session.
-*  - `share` — the share of PARALLEL sessions is held to the weights, and a
-*    full or drowning node yields to a free one (D748).
-*/
-var SessionPlacementPolicySchema = zod.z.enum(["least-loaded", "share"]);
-var DEFAULT_SESSION_PLACEMENT_POLICY = "least-loaded";
-/** The global-settings key the policy is stored under (orchestrator `load` section). */
-var SESSION_PLACEMENT_SETTING_KEY = "sessionPlacement";
-/** Parse a stored value; anything unknown is the default (nothing changes on deploy). */
-function parseSessionPlacementPolicy(value) {
-	const parsed = SessionPlacementPolicySchema.safeParse(value);
-	return parsed.success ? parsed.data : DEFAULT_SESSION_PLACEMENT_POLICY;
-}
-var LoadBalancingSharesInputSchema = zod.z.object({
-	/** nodeId → share (> 0). A node left out keeps its weight. */
-	nodes: zod.z.record(zod.z.string(), zod.z.number().positive()).default({}),
-	/** nodeId → deviceKey → share (> 0). A device left out keeps its weight. */
-	devices: zod.z.record(zod.z.string(), zod.z.record(zod.z.string(), zod.z.number().positive())).default({})
-});
-var PlacementStatsInputSchema = zod.z.object({ 
-/** Window the observed shares are averaged over (default 1 h, max 24 h). */
-windowMs: zod.z.number().int().min(6e4).max(1440 * 60 * 1e3).default(3600 * 1e3) });
-var PlacementDeviceStatsSchema = zod.z.object({
-	deviceKey: zod.z.string(),
-	/** Sessions running on this device now. */
-	sessionsNow: zod.z.number(),
-	/** Sessions started on this device inside the window. */
-	sessionsStarted: zod.z.number(),
-	/** Time-weighted share of the node's parallel sessions over the window (0–1); null = no session ran. */
-	observedShare: zod.z.number().nullable()
-});
-var PlacementNodeStatsSchema = zod.z.object({
-	nodeId: zod.z.string(),
-	sessionsNow: zod.z.number(),
-	sessionsStarted: zod.z.number(),
-	/** Time-weighted share of the cluster's parallel sessions over the window (0–1); null = none ran. */
-	observedShare: zod.z.number().nullable(),
-	/** Most sessions this node ran at once inside the window. */
-	peakSessions: zod.z.number(),
-	/** Sessions a share election handed elsewhere because this node was full or drowning. */
-	yieldsAway: zod.z.number(),
-	devices: zod.z.array(PlacementDeviceStatsSchema).readonly()
-});
-/** A camera's device pin that the session path cannot honour. */
-var StaleDevicePinSchema = zod.z.object({
-	deviceId: zod.z.number(),
-	deviceKey: zod.z.string(),
-	/** `disabled` — the key exists on some node but is not enabled anywhere; `absent` — no node has it. */
-	reason: zod.z.enum(["disabled", "absent"])
-});
-var PlacementStatsSchema = zod.z.object({
-	policy: SessionPlacementPolicySchema,
-	windowMs: zod.z.number(),
-	/** How much of the window was actually observed (the hub keeps it in memory). */
-	observedForMs: zod.z.number(),
-	sessionsNow: zod.z.number(),
-	/** Most parallel sessions across the cluster inside the window. */
-	clusterPeakSessions: zod.z.number(),
-	nodes: zod.z.array(PlacementNodeStatsSchema).readonly(),
-	stalePins: zod.z.array(StaleDevicePinSchema).readonly()
-});
-var SuggestSharesInputSchema = zod.z.object({ headroom: zod.z.number().min(.3).max(.5).default(.4) });
-var SuggestedDeviceShareSchema = zod.z.object({
-	deviceKey: zod.z.string(),
-	/** Share of the node (0–100, rounded). */
-	share: zod.z.number(),
-	modelId: zod.z.string().nullable(),
-	/** Inferences per second at that model, from the measured table. */
-	fps: zod.z.number().nullable(),
-	measured: zod.z.boolean(),
-	/** Advisory session cap: ⌊fps × (1 − headroom) / camera fps⌋. Never enforced. */
-	suggestedMaxSessions: zod.z.number().nullable()
-});
-var SuggestedNodeShareSchema = zod.z.object({
-	nodeId: zod.z.string(),
-	/** Share of the cluster (0–100, rounded); null = node skipped (offline, unknown hardware). */
-	share: zod.z.number().nullable(),
-	/** Parallel sessions the node sustains at the suggested models with the headroom kept free. */
-	capacitySessions: zod.z.number(),
-	devices: zod.z.array(SuggestedDeviceShareSchema).readonly(),
-	skippedReason: zod.z.string().nullable()
-});
-var SuggestSharesResultSchema = zod.z.object({
-	headroom: zod.z.number(),
-	/** Camera detection rate the capacity is counted in (the fastest camera's fps). */
-	cameraFps: zod.z.number(),
-	/** How many share → model → capacity rounds ran before the shares stopped moving (≤ 3). */
-	iterations: zod.z.number(),
-	nodes: zod.z.array(SuggestedNodeShareSchema).readonly()
-});
-//#endregion
-//#region src/pipeline/best-settings/plan-schemas.ts
-/**
-* The wire shapes of the Best settings plan and apply (D745), used by the
+* 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 = zod.z.enum(MODEL_FORMATS);
+/** Default least number of parallel sessions per device Auto tune keeps (D755). */
+var DEFAULT_MIN_SESSIONS_PER_DEVICE = 2;
+/** The operator's range for it. */
+var MIN_SESSIONS_PER_DEVICE_RANGE = {
+	min: 1,
+	max: 8
+};
 var HardwareClassIdSchema = zod.z.enum([
 	"intel-core-ultra",
 	"intel-n-series",
@@ -27368,8 +27274,9 @@ var AcceleratorKindSchema = zod.z.enum([
 ]);
 var RecommendationReasonSchema = zod.z.discriminatedUnion("kind", [
 	zod.z.object({
-		kind: zod.z.literal("fits"),
-		utilisation: zod.z.number()
+		kind: zod.z.literal("capacity"),
+		sessions: zod.z.number(),
+		minSessions: zod.z.number()
 	}),
 	zod.z.object({
 		kind: zod.z.literal("tie-faster"),
@@ -27384,16 +27291,13 @@ var RecommendationReasonSchema = zod.z.discriminatedUnion("kind", [
 	}),
 	zod.z.object({
 		kind: zod.z.literal("no-fit-lightest"),
-		utilisation: zod.z.number()
+		sessions: zod.z.number(),
+		minSessions: zod.z.number()
 	}),
 	zod.z.object({
 		kind: zod.z.literal("derived-latency"),
 		modelId: zod.z.string()
 	}),
-	zod.z.object({
-		kind: zod.z.literal("estimated-load"),
-		observedForMs: zod.z.number().nullable()
-	}),
 	zod.z.object({ kind: zod.z.literal("cpu-device") }),
 	zod.z.object({ kind: zod.z.literal("coral-untouched") }),
 	zod.z.object({ kind: zod.z.literal("device-disabled") }),
@@ -27409,28 +27313,13 @@ var RecommendationReasonSchema = zod.z.discriminatedUnion("kind", [
 		format: ModelFormatSchema$1
 	})
 ]);
-var DeviceDemandSchema = zod.z.object({
-	nodeId: zod.z.string(),
-	deviceKey: zod.z.string(),
-	demandFps: zod.z.number(),
-	maxCameraFps: zod.z.number(),
-	alwaysOnCameras: zod.z.number(),
-	onMotionSessions: zod.z.number(),
-	onMotionSource: zod.z.enum([
-		"observed-24h",
-		"estimate",
-		"none"
-	]),
-	observedForMs: zod.z.number().nullable(),
-	/** How on-motion sessions were charged: per-device observation, or split by share (D748). */
-	placement: SessionPlacementPolicySchema
-});
 var DeviceModelChoiceSchema = zod.z.object({
 	modelId: zod.z.string(),
 	p50Ms: zod.z.number(),
 	fps: zod.z.number(),
 	measured: zod.z.boolean(),
-	utilisation: zod.z.number(),
+	/** Parallel sessions at the camera rate with the headroom kept free: ⌊fps × (1 − headroom) / camera fps⌋. */
+	capacitySessions: zod.z.number(),
 	personRecall: zod.z.number()
 });
 var DeviceRecommendationSchema = zod.z.object({
@@ -27438,7 +27327,6 @@ var DeviceRecommendationSchema = zod.z.object({
 	accelerator: AcceleratorKindSchema.nullable(),
 	enabled: zod.z.boolean(),
 	available: zod.z.boolean(),
-	demand: DeviceDemandSchema.nullable(),
 	chosen: DeviceModelChoiceSchema.nullable(),
 	reasons: zod.z.array(RecommendationReasonSchema).readonly()
 });
@@ -27480,7 +27368,7 @@ var DetectorStoreClearSchema = zod.z.object({
 	deviceId: zod.z.number(),
 	keys: zod.z.array(zod.z.string()).readonly()
 });
-var BestSettingsWarningSchema = zod.z.discriminatedUnion("kind", [
+var AutoTuneWarningSchema = zod.z.discriminatedUnion("kind", [
 	zod.z.object({
 		kind: zod.z.literal("detector-store-cluster-wide"),
 		skippedNodes: zod.z.array(zod.z.string()).readonly()
@@ -27495,36 +27383,37 @@ var BestSettingsWarningSchema = zod.z.discriminatedUnion("kind", [
 		deviceKey: zod.z.string()
 	})
 ]);
-var BestSettingsOptionsSchema = zod.z.object({
+var AutoTuneOptionsSchema = zod.z.object({
 	/** Share of each accelerator's throughput kept free (0.3–0.5). */
 	headroom: zod.z.number().min(.3).max(.5).default(.4),
 	/**
-	* What-if shares (D748): plan as if these node/device shares were stored
-	* and the policy were `share`. Absent = the stored shares under the stored
-	* policy. A what-if plan is for display; apply always re-plans from what
-	* is stored.
+	* 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: zod.z.number().int().min(MIN_SESSIONS_PER_DEVICE_RANGE.min).max(MIN_SESSIONS_PER_DEVICE_RANGE.max).default(2)
 });
-var BestSettingsPlanSchema = zod.z.object({
+var AutoTunePlanSchema = zod.z.object({
 	/** Hash of everything the apply will write — the apply refuses a different one. */
 	planHash: zod.z.string(),
 	family: zod.z.literal("yolov9"),
 	headroom: zod.z.number(),
-	/** Planned under what-if shares (D748): for display — apply refuses it as stale. */
-	whatIf: zod.z.boolean(),
+	minSessionsPerDevice: zod.z.number(),
+	/** The detection rate a session is counted at (the fastest camera running the pipeline root). */
+	cameraFps: zod.z.number(),
 	generatedAt: zod.z.number(),
 	nodes: zod.z.array(NodeRecommendationSchema).readonly(),
 	nodeChanges: zod.z.array(NodeDeviceChangeSchema).readonly(),
 	cameraClears: zod.z.array(CameraOverrideClearSchema).readonly(),
 	detectorStoreClears: zod.z.array(DetectorStoreClearSchema).readonly(),
-	warnings: zod.z.array(BestSettingsWarningSchema).readonly()
+	warnings: zod.z.array(AutoTuneWarningSchema).readonly()
 });
-var BestSettingsApplyInputSchema = zod.z.object({
+var AutoTuneApplyInputSchema = zod.z.object({
 	planHash: zod.z.string(),
-	headroom: zod.z.number().min(.3).max(.5).default(.4)
+	headroom: zod.z.number().min(.3).max(.5).default(.4),
+	minSessionsPerDevice: zod.z.number().int().min(MIN_SESSIONS_PER_DEVICE_RANGE.min).max(MIN_SESSIONS_PER_DEVICE_RANGE.max).default(2)
 });
-var BestSettingsPhaseResultSchema = zod.z.object({
+var AutoTunePhaseResultSchema = zod.z.object({
 	phase: zod.z.enum([
 		"download",
 		"camera-overrides",
@@ -27535,19 +27424,19 @@ var BestSettingsPhaseResultSchema = zod.z.object({
 	ok: zod.z.boolean(),
 	detail: zod.z.string()
 });
-var BestSettingsApplyResultSchema = zod.z.discriminatedUnion("kind", [
+var AutoTuneApplyResultSchema = zod.z.discriminatedUnion("kind", [
 	zod.z.object({
 		kind: zod.z.literal("applied"),
 		planHash: zod.z.string(),
-		phases: zod.z.array(BestSettingsPhaseResultSchema).readonly()
+		phases: zod.z.array(AutoTunePhaseResultSchema).readonly()
 	}),
 	zod.z.object({
 		kind: zod.z.literal("aborted"),
-		phases: zod.z.array(BestSettingsPhaseResultSchema).readonly()
+		phases: zod.z.array(AutoTunePhaseResultSchema).readonly()
 	}),
 	zod.z.object({
 		kind: zod.z.literal("stale"),
-		plan: BestSettingsPlanSchema
+		plan: AutoTunePlanSchema
 	}),
 	zod.z.object({
 		kind: zod.z.literal("refused"),
@@ -27555,6 +27444,209 @@ var BestSettingsApplyResultSchema = zod.z.discriminatedUnion("kind", [
 	})
 ]);
 //#endregion
+//#region src/pipeline/load-balancing/schemas.ts
+/**
+* Wire shapes of the Load balancing surface (D748): the session placement
+* policy, the atomic share write, the observed placement statistics, the
+* hardware share suggestion and the stale device pins.
+*/
+/**
+* How a new detection session picks its node and device.
+*  - `least-loaded` — the historical rule: lowest `attached / weight`, a
+*    constant node order at a tie (D37). An idle node always ties at 0, so a
+*    weight only bites once a node already holds a session.
+*  - `share` — the share of PARALLEL sessions is held to the weights, and a
+*    full or drowning node yields to a free one (D748).
+*/
+var SessionPlacementPolicySchema = zod.z.enum(["least-loaded", "share"]);
+/**
+* `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 = zod.z.object({
+	/** nodeId → share (> 0). A node left out keeps its weight. */
+	nodes: zod.z.record(zod.z.string(), zod.z.number().positive()).default({}),
+	/** nodeId → deviceKey → share (> 0). A device left out keeps its weight. */
+	devices: zod.z.record(zod.z.string(), zod.z.record(zod.z.string(), zod.z.number().positive())).default({})
+});
+var PlacementStatsInputSchema = zod.z.object({ 
+/** Window the observed shares are averaged over (default 1 h, max 24 h). */
+windowMs: zod.z.number().int().min(6e4).max(1440 * 60 * 1e3).default(3600 * 1e3) });
+var PlacementDeviceStatsSchema = zod.z.object({
+	deviceKey: zod.z.string(),
+	/** Sessions running on this device now. */
+	sessionsNow: zod.z.number(),
+	/** Sessions started on this device inside the window. */
+	sessionsStarted: zod.z.number(),
+	/** Time-weighted share of the node's parallel sessions over the window (0–1); null = no session ran. */
+	observedShare: zod.z.number().nullable()
+});
+var PlacementNodeStatsSchema = zod.z.object({
+	nodeId: zod.z.string(),
+	sessionsNow: zod.z.number(),
+	sessionsStarted: zod.z.number(),
+	/** Time-weighted share of the cluster's parallel sessions over the window (0–1); null = none ran. */
+	observedShare: zod.z.number().nullable(),
+	/** Most sessions this node ran at once inside the window. */
+	peakSessions: zod.z.number(),
+	/** Sessions a share election handed elsewhere because this node was full or drowning. */
+	yieldsAway: zod.z.number(),
+	devices: zod.z.array(PlacementDeviceStatsSchema).readonly()
+});
+/** A camera's device pin that the session path cannot honour. */
+var StaleDevicePinSchema = zod.z.object({
+	deviceId: zod.z.number(),
+	deviceKey: zod.z.string(),
+	/** `disabled` — the key exists on some node but is not enabled anywhere; `absent` — no node has it. */
+	reason: zod.z.enum(["disabled", "absent"])
+});
+var PlacementStatsSchema = zod.z.object({
+	policy: SessionPlacementPolicySchema,
+	windowMs: zod.z.number(),
+	/** How much of the window was actually observed (the hub keeps it in memory). */
+	observedForMs: zod.z.number(),
+	sessionsNow: zod.z.number(),
+	/** Most parallel sessions across the cluster inside the window. */
+	clusterPeakSessions: zod.z.number(),
+	nodes: zod.z.array(PlacementNodeStatsSchema).readonly(),
+	stalePins: zod.z.array(StaleDevicePinSchema).readonly()
+});
+/**
+* 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 = zod.z.enum(["hardware", "benchmark"]);
+/** Why a node under the `benchmark` source was sized from hardware instead. */
+var CapacityFallbackSchema = zod.z.enum(["no-benchmark-results", "partial-benchmark-results"]);
+var SuggestSharesInputSchema = zod.z.object({
+	headroom: zod.z.number().min(.3).max(.5).default(.4),
+	/** Default `hardware`. */
+	source: CapacitySourceSchema.default("hardware")
+});
+var SuggestedDeviceShareSchema = zod.z.object({
+	deviceKey: zod.z.string(),
+	/** Share of the node (0–100, rounded). */
+	share: zod.z.number(),
+	modelId: zod.z.string().nullable(),
+	/** Inferences per second at that model, from the measured table; null when sized by a benchmark. */
+	fps: zod.z.number().nullable(),
+	/** False for a table cell derived from another chip; true for a measured cell or a benchmark. */
+	measured: zod.z.boolean(),
+	/**
+	* Advisory session cap: ⌊fps × (1 − headroom) / camera fps⌋ from the table,
+	* or the benchmark's measured max sessions. Never enforced.
+	*/
+	suggestedMaxSessions: zod.z.number().nullable()
+});
+var SuggestedNodeShareSchema = zod.z.object({
+	nodeId: zod.z.string(),
+	/** Share of the cluster (0–100, rounded); null = node skipped (offline, unknown hardware). */
+	share: zod.z.number().nullable(),
+	/** Parallel sessions the node sustains at the suggested models with the headroom kept free. */
+	capacitySessions: zod.z.number(),
+	devices: zod.z.array(SuggestedDeviceShareSchema).readonly(),
+	skippedReason: zod.z.string().nullable(),
+	/** 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 = zod.z.object({
+	headroom: zod.z.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: zod.z.number(),
+	/** The Auto tune capacity floor the models were picked at. */
+	minSessionsPerDevice: zod.z.number(),
+	nodes: zod.z.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 = zod.z.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 = zod.z.object({ source: ShareSourceSchema });
+/** Raw relative weights (any scale) per node and per node's device. */
+var ShareWeightsSchema = zod.z.object({
+	nodes: zod.z.record(zod.z.string(), zod.z.number()),
+	devices: zod.z.record(zod.z.string(), zod.z.record(zod.z.string(), zod.z.number()))
+});
+var EffectiveDeviceShareSchema = zod.z.object({
+	deviceKey: zod.z.string(),
+	/** Can take sessions now (enabled, available, can run the root). */
+	eligible: zod.z.boolean(),
+	/** The share the source assigns, as a percentage of the node's devices. */
+	configuredPct: zod.z.number(),
+	/** The share actually used, after an ineligible device's share went to the others. */
+	effectivePct: zod.z.number()
+});
+var EffectiveNodeShareSchema = zod.z.object({
+	nodeId: zod.z.string(),
+	eligible: zod.z.boolean(),
+	configuredPct: zod.z.number(),
+	effectivePct: zod.z.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: zod.z.array(EffectiveDeviceShareSchema).readonly()
+});
+var EffectiveSharesSchema = zod.z.object({
+	source: ShareSourceSchema,
+	policy: SessionPlacementPolicySchema,
+	/** An automatic source with no computed answer yet: the stored sliders are used meanwhile. */
+	autoPending: zod.z.boolean(),
+	/** When the automatic shares were last computed (ms epoch); null = never. */
+	computedAt: zod.z.number().nullable(),
+	/** What made the system recompute them last. */
+	trigger: zod.z.string().nullable(),
+	nodes: zod.z.array(EffectiveNodeShareSchema).readonly(),
+	/** The relative weights the election reads (before eligibility). */
+	nodeWeights: zod.z.record(zod.z.string(), zod.z.number()),
+	deviceWeights: zod.z.record(zod.z.string(), zod.z.record(zod.z.string(), zod.z.number()))
+});
+//#endregion
 //#region src/capabilities/schemas/orchestrator-metrics.ts
 /** Shared Zod schemas for the runtime pipeline orchestrator metrics. */
 var OrchestratorMetricsSchema = zod.z.object({
@@ -29167,8 +29259,10 @@ var CameraStepOverridePatchSchema = zod.z.object({
 	modelId: zod.z.string().optional(),
 	settings: zod.z.record(zod.z.string(), zod.z.unknown()).readonly().optional()
 });
+var CameraStepSettingsSchema = zod.z.record(zod.z.string(), zod.z.record(zod.z.string(), zod.z.unknown()).readonly());
 var CameraPipelineSettingsSchema = zod.z.object({
 	stepToggles: zod.z.record(zod.z.string(), zod.z.boolean()).optional(),
+	stepSettings: CameraStepSettingsSchema.optional(),
 	stepOverridesByDevice: zod.z.record(zod.z.string(), zod.z.record(zod.z.string(), zod.z.record(zod.z.string(), CameraStepOverridePatchSchema))).optional(),
 	pipelineByAgent: zod.z.record(zod.z.string(), CameraPipelineForAgentSchema).optional()
 });
@@ -29980,23 +30074,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: require_sleep.method(BestSettingsOptionsSchema, BestSettingsPlanSchema, { auth: "admin" }),
+		planAutoTune: require_sleep.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: require_sleep.method(BestSettingsApplyInputSchema, BestSettingsApplyResultSchema, {
+		applyAutoTune: require_sleep.method(AutoTuneApplyInputSchema, AutoTuneApplyResultSchema, {
 			kind: "mutation",
 			auth: "admin"
 		}),
@@ -30021,12 +30117,32 @@ var pipelineOrchestratorCapability = {
 		*/
 		getPlacementStats: require_sleep.method(PlacementStatsInputSchema, PlacementStatsSchema, { auth: "admin" }),
 		/**
-		* Load balancing (D748) — shares proportional to each node's measured
-		* capacity at the models Best settings would pick, iterated (≤ 3 rounds)
-		* until the shares stop moving; per device, an ADVISORY session cap.
-		* Writes nothing.
+		* 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: require_sleep.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: require_sleep.method(zod.z.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: require_sleep.method(SetShareSourceInputSchema, zod.z.object({ success: zod.z.literal(true) }), {
+			kind: "mutation",
+			auth: "admin"
+		}),
 		/** Read one camera's settings. Null when never touched (inherits agent defaults fully). */
 		getCameraSettings: require_sleep.method(zod.z.object({ deviceId: zod.z.number() }), CameraPipelineSettingsSchema.nullable()),
 		/** Set or clear the 3-state toggle for one (camera, addonId). Pass `enabled: null` to clear and revert to agent default. */
@@ -30056,6 +30172,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: require_sleep.method(zod.z.object({
+			deviceId: zod.z.number(),
+			addonId: zod.z.string(),
+			settings: zod.z.record(zod.z.string(), zod.z.unknown()).nullable()
+		}), zod.z.object({ success: zod.z.literal(true) }), {
+			kind: "mutation",
+			auth: "admin"
+		}),
 		/** Write or clear the wholesale per-agent pipeline override. Pass `pipeline: null` to drop the override. */
 		setCameraPipelineForAgent: require_sleep.method(zod.z.object({
 			deviceId: zod.z.number(),
@@ -56331,7 +56463,7 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "view"
 	},
-	"pipelineOrchestrator.applyBestSettings": {
+	"pipelineOrchestrator.applyAutoTune": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
 		addonId: null,
@@ -56451,6 +56583,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"pipelineOrchestrator.getEffectiveShares": {
+		capName: "pipeline-orchestrator",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"pipelineOrchestrator.getGlobalMetrics": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
@@ -56517,7 +56655,7 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "create"
 	},
-	"pipelineOrchestrator.planBestSettings": {
+	"pipelineOrchestrator.planAutoTune": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
 		addonId: null,
@@ -56619,6 +56757,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"pipelineOrchestrator.setCameraStepSettings": {
+		capName: "pipeline-orchestrator",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"pipelineOrchestrator.setCameraStepToggle": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
@@ -56649,6 +56793,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"pipelineOrchestrator.setShareSource": {
+		capName: "pipeline-orchestrator",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"pipelineOrchestrator.suggestShares": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
@@ -65413,6 +65563,11 @@ var METHOD_DEVICE_SELECTORS = Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"pipelineOrchestrator.setCameraStepSettings": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"pipelineOrchestrator.setCameraStepToggle": [{
 		name: "deviceId",
 		form: "single",
@@ -66397,6 +66552,7 @@ var SYSTEM_SCOPE_DEVICE_METHODS = [
 	"pipelineOrchestrator.setCameraPipelineForAgent",
 	"pipelineOrchestrator.setCameraSensors",
 	"pipelineOrchestrator.setCameraStepOverride",
+	"pipelineOrchestrator.setCameraStepSettings",
 	"pipelineOrchestrator.setCameraStepToggle",
 	"pipelineOrchestrator.setCameraSwitch",
 	"pipelineOrchestrator.setPipelineDevicePin",
@@ -67415,11 +67571,13 @@ function createSystemProxy(api) {
 			setAgentInferenceDevices: (input) => dispatch("pipelineOrchestrator", "setAgentInferenceDevices", "mutation", input),
 			getNodeInferenceDevices: (input) => dispatch("pipelineOrchestrator", "getNodeInferenceDevices", "query", input),
 			resetNodePipelineDefaults: (input) => dispatch("pipelineOrchestrator", "resetNodePipelineDefaults", "mutation", input),
-			planBestSettings: (input) => dispatch("pipelineOrchestrator", "planBestSettings", "query", input),
-			applyBestSettings: (input) => dispatch("pipelineOrchestrator", "applyBestSettings", "mutation", input),
+			planAutoTune: (input) => dispatch("pipelineOrchestrator", "planAutoTune", "query", input),
+			applyAutoTune: (input) => dispatch("pipelineOrchestrator", "applyAutoTune", "mutation", input),
 			setLoadBalancingShares: (input) => dispatch("pipelineOrchestrator", "setLoadBalancingShares", "mutation", input),
 			getPlacementStats: (input) => dispatch("pipelineOrchestrator", "getPlacementStats", "query", input),
 			suggestShares: (input) => dispatch("pipelineOrchestrator", "suggestShares", "query", input),
+			getEffectiveShares: (input) => dispatch("pipelineOrchestrator", "getEffectiveShares", "query", input),
+			setShareSource: (input) => dispatch("pipelineOrchestrator", "setShareSource", "mutation", input),
 			getCameraStatuses: (input) => dispatch("pipelineOrchestrator", "getCameraStatuses", "query", input),
 			setCameraSensors: (input) => dispatch("pipelineOrchestrator", "setCameraSensors", "mutation", input),
 			reconcileFromDisk: (input) => dispatch("pipelineOrchestrator", "reconcileFromDisk", "mutation", input),
@@ -72383,7 +72541,7 @@ function clearModelBoundOverrides(settings, boundKeys, modelId) {
 /**
 * 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) => {
@@ -72392,7 +72550,136 @@ function collectModelBoundKeys(fields) {
 	});
 }
 //#endregion
-//#region src/pipeline/best-settings/hardware-class.ts
+//#region src/pipeline/step-settings-layers.ts
+/**
+* The layers of a detection step's settings, and the field-level edits on them
+* (D754).
+*
+* A step's settings reach a session through up to three stored layers, merged
+* key by key — a key in a higher layer wins:
+*
+*   node         the node's folded base (`inferenceDevices[node][*].steps`)
+*   camera       `cameraSettings[cam].stepSettings[step]` — every accelerator
+*   accelerator  `cameraSettings[cam].stepOverridesByDevice[node][key][step].settings`
+*
+* Below them sits the default: the running model's (D738) or the field's own.
+*
+* Every layer is SPARSE and FIELD-LEVEL. A key present in a layer is an
+* override; an absent key inherits. Two consequences that every editor must
+* respect, and why this module exists:
+*
+*   - A model-bound field (D738) occupies TWO keys, its value and
+*     `<key>ModelId`. They are written, compared and removed as one unit — a
+*     value without its binding over a lower layer's binding would be judged
+*     against the wrong model.
+*   - An editor writes a DIFF against the merged layers below, never a copy of
+*     them. A copy pins every field at the value it had that day, so later
+*     edits below never reach it (the full-copy "Override" this replaced).
+*/
+/** Top-down order of the stored layers. */
+var LAYER_ORDER = [
+	"accelerator",
+	"camera",
+	"node"
+];
+/**
+* The keys one field occupies in a bag: its own, plus its binding key when it
+* binds to a model. `boundKeys` = `collectModelBoundKeys(schema)`.
+*/
+function fieldUnitKeys(key, boundKeys) {
+	return boundKeys.includes(key) ? [key, modelBindingKey(key)] : [key];
+}
+/** The field a stored key belongs to (`minConfidencePersonModelId` → `minConfidencePerson`). */
+function unitOf(storedKey, boundKeys) {
+	return boundKeys.find((k) => modelBindingKey(k) === storedKey) ?? storedKey;
+}
+/** Structural equality for stored values (numbers, strings, booleans, arrays, plain objects). */
+function settingValuesEqual(a, b) {
+	if (Object.is(a, b)) return true;
+	if (Array.isArray(a) && Array.isArray(b)) return a.length === b.length && a.every((v, i) => settingValuesEqual(v, b[i]));
+	if (isPlainObject(a) && isPlainObject(b)) {
+		const ka = Object.keys(a);
+		const kb = Object.keys(b);
+		return ka.length === kb.length && ka.every((k) => settingValuesEqual(a[k], b[k]));
+	}
+	return false;
+}
+function isPlainObject(v) {
+	return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+/** Merge bags bottom-up (later wins, per key). Fresh object. */
+function mergeSettingsBags(...bags) {
+	return bags.reduce((acc, bag) => ({
+		...acc,
+		...bag
+	}), {});
+}
+/** The merged value of the layers BELOW `layer` (what removing a key from `layer` falls back to). */
+function settingsBelow(layers, layer) {
+	return mergeSettingsBags(...LAYER_ORDER.slice(LAYER_ORDER.indexOf(layer) + 1).toReversed().map((id) => layers[id]));
+}
+/** The effective bag: every stored layer merged. */
+function effectiveStepSettings(layers) {
+	return mergeSettingsBags(layers.node, layers.camera, layers.accelerator);
+}
+/** The highest stored layer that holds any key of `key`'s unit, or `default`. */
+function stepSettingSource(layers, key, boundKeys) {
+	const unit = fieldUnitKeys(key, boundKeys);
+	for (const id of LAYER_ORDER) {
+		const bag = layers[id];
+		if (bag !== void 0 && unit.some((k) => bag[k] !== void 0)) return id;
+	}
+	return "default";
+}
+/**
+* `layer` with `key`'s unit set from `values` (a bag carrying the unit's new
+* value — e.g. the editor's whole next settings bag). A unit key that `values`
+* does not carry is removed from the layer. Fresh object.
+*/
+function withFieldFrom(layer, key, values, boundKeys) {
+	const out = { ...layer };
+	for (const k of fieldUnitKeys(key, boundKeys)) if (values[k] === void 0) delete out[k];
+	else out[k] = values[k];
+	return out;
+}
+/** `layer` without `key`'s unit — "reset to the next level". Fresh object. */
+function withoutField(layer, key, boundKeys) {
+	const out = { ...layer };
+	for (const k of fieldUnitKeys(key, boundKeys)) delete out[k];
+	return out;
+}
+/** Every field unit stored in `layer`, by its field key. */
+function unitsIn(layer, boundKeys) {
+	return [...new Set(Object.keys(layer).map((k) => unitOf(k, boundKeys)))];
+}
+/** True when every key of `key`'s unit has the same value in `layer` as in `below`. */
+function unitEqualsBelow(layer, below, key, boundKeys) {
+	return fieldUnitKeys(key, boundKeys).every((k) => settingValuesEqual(layer[k], below[k]));
+}
+/**
+* `layer` reduced to the fields that DIFFER from `below` — what an editor
+* stores. A unit is kept or dropped whole. `undefined` when nothing is left.
+*/
+function diffStepSettings(layer, below, boundKeys) {
+	if (layer === void 0) return void 0;
+	const out = {};
+	for (const unit of unitsIn(layer, boundKeys)) {
+		if (unitEqualsBelow(layer, below, unit, boundKeys)) continue;
+		for (const k of fieldUnitKeys(unit, boundKeys)) if (layer[k] !== void 0) out[k] = layer[k];
+	}
+	return Object.keys(out).length > 0 ? out : void 0;
+}
+/**
+* The fields `layer` stores at exactly the value of the layers below — a
+* legacy full copy's leftovers. They change nothing today and stop every
+* later edit below from reaching this layer. Sorted.
+*/
+function fieldsPinnedAtValueBelow(layer, below, boundKeys) {
+	if (layer === void 0) return [];
+	return unitsIn(layer, boundKeys).filter((unit) => unitEqualsBelow(layer, below, unit, boundKeys)).toSorted();
+}
+//#endregion
+//#region src/pipeline/auto-tune/hardware-class.ts
 var APPLE_CHIP = /^Apple M(\d+)(?:\s+(Pro|Max|Ultra))?\b/i;
 var INTEL_CORE_ULTRA = /Core\(TM\)\s+Ultra|Core Ultra/i;
 var INTEL_N_SERIES = /Intel\(R\)\s+N\d{2,3}\b|\bIntel\s+N\d{2,3}\b/i;
@@ -72448,7 +72735,7 @@ function acceleratorKindOf(deviceKey, hw) {
 	return null;
 }
 //#endregion
-//#region src/pipeline/best-settings/detector-performance.ts
+//#region src/pipeline/auto-tune/detector-performance.ts
 var DETECTOR_PERF = {
 	"intel-core-ultra": {
 		"intel-npu": {
@@ -72880,149 +73167,32 @@ var DETECTOR_ACCURACY = {
 	}
 };
 //#endregion
-//#region src/pipeline/best-settings/demand.ts
-var DEFAULT_DEMAND_OPTIONS = {
-	onMotionConcurrency: .25,
-	onMotionMinConcurrent: 2
-};
-/** A full observation window. */
-var OBSERVATION_WINDOW_MS = 1440 * 60 * 1e3;
-function deviceId(nodeId, deviceKey) {
-	return `${nodeId}\u0000${deviceKey}`;
-}
-function charges(load) {
-	return load.mode !== "disabled" && load.runsPipelineRoot && load.fps > 0;
-}
-/** The highest `count` rates, summed. */
-function topRatesSum(rates, count) {
-	return rates.toSorted((a, b) => b - a).slice(0, Math.max(0, count)).reduce((sum, r) => sum + r, 0);
-}
-/** Concurrent on-motion sessions assumed cluster-wide without an observation. */
-function estimatedConcurrentSessions(cameraCount, options) {
-	if (cameraCount <= 0) return 0;
-	const share = Math.ceil(options.onMotionConcurrency * cameraCount);
-	return Math.min(cameraCount, Math.max(share, Math.min(cameraCount, options.onMotionMinConcurrent)));
-}
-/**
-* Demand on every eligible device of the cluster.
-*/
-function estimateDeviceDemand(input) {
-	const options = input.options ?? DEFAULT_DEMAND_OPTIONS;
-	const placement = input.shares ? "share" : "least-loaded";
-	const eligibleById = new Map(input.eligible.map((d) => [deviceId(d.nodeId, d.deviceKey), d]));
-	const peakById = new Map(input.peaks.map((p) => [deviceId(p.nodeId, p.deviceKey), p]));
-	const weightByNode = /* @__PURE__ */ new Map();
-	const eligibleCountByNode = /* @__PURE__ */ new Map();
-	for (const d of input.eligible) {
-		weightByNode.set(d.nodeId, (weightByNode.get(d.nodeId) ?? 0) + Math.max(d.weight, 0));
-		eligibleCountByNode.set(d.nodeId, (eligibleCountByNode.get(d.nodeId) ?? 0) + 1);
-	}
-	const pinnedFps = /* @__PURE__ */ new Map();
-	const alwaysOnFps = /* @__PURE__ */ new Map();
-	const alwaysOnCount = /* @__PURE__ */ new Map();
-	const maxFps = /* @__PURE__ */ new Map();
-	const onMotionRates = [];
-	const bump = (map, key, by) => {
-		map.set(key, (map.get(key) ?? 0) + by);
-	};
-	const noteMax = (key, fps) => {
-		maxFps.set(key, Math.max(maxFps.get(key) ?? 0, fps));
-	};
-	const pinNodeOf = (pin) => {
-		if (pin.nodeId !== null) return pin.nodeId;
-		const holders = input.eligible.filter((d) => d.deviceKey === pin.deviceKey);
-		return holders.length === 1 ? holders[0].nodeId : null;
-	};
-	let alwaysOnTotal = 0;
-	for (const cam of input.cameras) {
-		if (!charges(cam)) continue;
-		const pinNode = cam.devicePin !== null ? pinNodeOf(cam.devicePin) : null;
-		if (cam.devicePin !== null && pinNode !== null) {
-			const key = deviceId(pinNode, cam.devicePin.deviceKey);
-			if (!eligibleById.has(key)) continue;
-			bump(pinnedFps, key, cam.fps);
-			noteMax(key, cam.fps);
-			continue;
-		}
-		const standing = cam.mode === "always-on" && cam.standingNodeId !== null ? cam.standingNodeId : cam.nodePinId;
-		if (standing !== null) {
-			if (cam.mode === "always-on") alwaysOnTotal += 1;
-			const nodeWeight = weightByNode.get(standing) ?? 0;
-			for (const d of input.eligible) {
-				if (d.nodeId !== standing || nodeWeight <= 0) continue;
-				const key = deviceId(d.nodeId, d.deviceKey);
-				const share = Math.max(d.weight, 0) / nodeWeight;
-				bump(alwaysOnFps, key, cam.fps * share);
-				bump(alwaysOnCount, key, share);
-				noteMax(key, cam.fps);
-			}
-			continue;
-		}
-		onMotionRates.push(cam.fps);
-	}
-	const fastestOnMotion = onMotionRates.reduce((m, r) => Math.max(m, r), 0);
-	const nodeCount = weightByNode.size;
-	const estimatedTotal = estimatedConcurrentSessions(onMotionRates.length, options);
-	const clusterPeak = input.shares?.clusterPeak ?? null;
-	const clusterObserved = clusterPeak !== null && clusterPeak.observedForMs >= 864e5;
-	const clusterSessions = clusterObserved ? Math.max(0, clusterPeak.peakSessions - alwaysOnTotal) : estimatedTotal;
-	const shareSum = [...weightByNode.keys()].reduce((sum, nodeId) => sum + Math.max(input.shares?.nodes[nodeId] ?? 0, 0), 0);
-	return input.eligible.map((d) => {
-		const key = deviceId(d.nodeId, d.deviceKey);
-		const peak = peakById.get(key) ?? (eligibleCountByNode.get(d.nodeId) === 1 ? peakById.get(deviceId(d.nodeId, "")) : void 0);
-		const alwaysOn = alwaysOnCount.get(key) ?? 0;
-		let onMotionSessions = 0;
-		let onMotionSource = "none";
-		if (onMotionRates.length > 0 && input.shares !== void 0) {
-			const nodeWeight = weightByNode.get(d.nodeId) ?? 0;
-			const nodeShare = shareSum > 0 ? Math.max(input.shares.nodes[d.nodeId] ?? 0, 0) / shareSum : 0;
-			const deviceShare = nodeWeight > 0 ? Math.max(d.weight, 0) / nodeWeight : 0;
-			onMotionSessions = Math.max(0, Math.ceil(clusterSessions * nodeShare * deviceShare - 1e-9));
-			onMotionSource = clusterObserved ? "observed-24h" : "estimate";
-		} else if (onMotionRates.length > 0) if (peak !== void 0 && peak.observedForMs >= 864e5) {
-			onMotionSessions = Math.max(0, Math.round(peak.peakSessions - alwaysOn));
-			onMotionSource = "observed-24h";
-		} else {
-			const nodeWeight = weightByNode.get(d.nodeId) ?? 0;
-			const share = nodeCount > 0 && nodeWeight > 0 ? Math.max(d.weight, 0) / nodeWeight / nodeCount : 0;
-			onMotionSessions = Math.ceil(estimatedTotal * share);
-			onMotionSource = "estimate";
-		}
-		const demandFps = (pinnedFps.get(key) ?? 0) + (alwaysOnFps.get(key) ?? 0) + topRatesSum(onMotionRates, onMotionSessions);
-		return {
-			nodeId: d.nodeId,
-			deviceKey: d.deviceKey,
-			demandFps: Math.round(demandFps * 100) / 100,
-			maxCameraFps: Math.max(maxFps.get(key) ?? 0, fastestOnMotion),
-			alwaysOnCameras: Math.round(alwaysOn * 100) / 100,
-			onMotionSessions,
-			onMotionSource,
-			observedForMs: input.shares !== void 0 ? clusterPeak?.observedForMs ?? null : peak?.observedForMs ?? null,
-			placement
-		};
-	}).toSorted((a, b) => a.nodeId === b.nodeId ? a.deviceKey.localeCompare(b.deviceKey) : a.nodeId.localeCompare(b.nodeId));
-}
-//#endregion
-//#region src/pipeline/best-settings/recommend.ts
+//#region src/pipeline/auto-tune/recommend.ts
 /** The family the cluster runs. */
-var BEST_SETTINGS_FAMILY = "yolov9";
+var AUTO_TUNE_FAMILY = "yolov9";
 /** Recall within this of the best counts as a tie — the faster one wins. */
 var RECALL_TIE = .02;
 /** Default share of an accelerator's throughput kept free. */
 var DEFAULT_HEADROOM = .4;
+/** Detection rate a session is counted at when no camera says otherwise. */
+var DEFAULT_CAMERA_FPS = 10;
+/** Parallel sessions one device sustains at `fps` with `headroom` kept free. */
+function capacitySessionsOf(fps, headroom, cameraFps) {
+	if (!(fps > 0) || !(cameraFps > 0)) return 0;
+	return Math.max(0, Math.floor(fps * (1 - headroom) / cameraFps + 1e-9));
+}
 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));
@@ -73030,28 +73200,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
 			}]
 		};
 	}
@@ -73061,10 +73227,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,
@@ -73082,7 +73245,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 {
@@ -73090,23 +73253,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) {
@@ -73122,7 +73282,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: []
 		})),
@@ -73132,7 +73291,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);
@@ -73143,7 +73306,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();
@@ -73172,8 +73334,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";
@@ -73183,23 +73344,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",
@@ -73211,7 +73372,7 @@ function recommendNode(input) {
 		reasonsByKey.set(ctx.device.key, [
 			{ kind: "cpu-device" },
 			...pick.reasons,
-			...deviceReasonsFor(ctx, choice)
+			...deviceReasonsFor(choice, sizing)
 		]);
 	}
 	return {
@@ -73226,7 +73387,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) ?? []
 		})),
@@ -73276,6 +73436,208 @@ function electByShare(candidates) {
 	};
 }
 //#endregion
+//#region src/pipeline/load-balancing/effective-shares.ts
+/**
+* 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
+	};
+}
+//#endregion
+//#region src/pipeline/load-balancing/capacity-shares.ts
+/**
+* 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
+	};
+}
+//#endregion
 //#region src/pipeline/root-face-crop.ts
 /** Side of the square, as a multiple of the face box's longer side. */
 var ROOT_FACE_REFINE_SCALE = 1.6;
@@ -75420,6 +75782,8 @@ exports.AUDIO_PRESETS = require_composition.AUDIO_PRESETS;
 exports.AUDIO_SCALE_EPOCH_ISO = AUDIO_SCALE_EPOCH_ISO;
 exports.AUDIO_SCALE_EPOCH_MS = AUDIO_SCALE_EPOCH_MS;
 exports.AUTOMATIC_HUB_ADDRESS_FLAGS = AUTOMATIC_HUB_ADDRESS_FLAGS;
+exports.AUTO_SHARE_HEADROOM = AUTO_SHARE_HEADROOM;
+exports.AUTO_TUNE_FAMILY = AUTO_TUNE_FAMILY;
 exports.AcceleratorKindSchema = AcceleratorKindSchema;
 exports.AccessoriesStatusSchema = AccessoriesStatusSchema;
 exports.AccessoryKind = AccessoryKind;
@@ -75487,6 +75851,12 @@ exports.AudioMetricsSnapshotSchema = AudioMetricsSnapshotSchema;
 exports.AudioPcmChunkSchema = AudioPcmChunkSchema;
 exports.AudioStreamPickSchema = require_sleep.AudioStreamPickSchema;
 exports.AuthResultSchema = AuthResultSchema;
+exports.AutoTuneApplyInputSchema = AutoTuneApplyInputSchema;
+exports.AutoTuneApplyResultSchema = AutoTuneApplyResultSchema;
+exports.AutoTuneOptionsSchema = AutoTuneOptionsSchema;
+exports.AutoTunePhaseResultSchema = AutoTunePhaseResultSchema;
+exports.AutoTunePlanSchema = AutoTunePlanSchema;
+exports.AutoTuneWarningSchema = AutoTuneWarningSchema;
 exports.AutoUpdateSettingsSchema = AutoUpdateSettingsSchema;
 exports.AutomationActionSchema = AutomationActionSchema;
 exports.AutomationConditionOperatorSchema = AutomationConditionOperatorSchema;
@@ -75499,7 +75869,6 @@ exports.BASE_DEVICE_CAPS = BASE_DEVICE_CAPS;
 exports.BASE_LIVE_EGRESS_PROFILE = BASE_LIVE_EGRESS_PROFILE;
 exports.BATTERY_DEVICE_PROFILE = BATTERY_DEVICE_PROFILE;
 exports.BATTERY_UNREACHABLE_AFTER_MS = BATTERY_UNREACHABLE_AFTER_MS;
-exports.BEST_SETTINGS_FAMILY = BEST_SETTINGS_FAMILY;
 exports.BIRTH_DECISION_DEFAULT_LIMIT = BIRTH_DECISION_DEFAULT_LIMIT;
 exports.BOOT_RECOVERY_BACKOFF_MS = require_sleep.BOOT_RECOVERY_BACKOFF_MS;
 exports.BUILTIN_RESULT_KINDS = BUILTIN_RESULT_KINDS;
@@ -75515,12 +75884,6 @@ exports.BaseAddon = require_sleep.BaseAddon;
 exports.BaseDevice = BaseDevice;
 exports.BaseDeviceProvider = BaseDeviceProvider;
 exports.BatteryStatusSchema = BatteryStatusSchema;
-exports.BestSettingsApplyInputSchema = BestSettingsApplyInputSchema;
-exports.BestSettingsApplyResultSchema = BestSettingsApplyResultSchema;
-exports.BestSettingsOptionsSchema = BestSettingsOptionsSchema;
-exports.BestSettingsPhaseResultSchema = BestSettingsPhaseResultSchema;
-exports.BestSettingsPlanSchema = BestSettingsPlanSchema;
-exports.BestSettingsWarningSchema = BestSettingsWarningSchema;
 exports.BinaryStatusSchema = BinaryStatusSchema;
 exports.BirthDecisionQueryInputSchema = BirthDecisionQueryInputSchema;
 exports.BirthDecisionRecordSchema = BirthDecisionRecordSchema;
@@ -75652,6 +76015,8 @@ exports.CameraSwitchWarningSchema = CameraSwitchWarningSchema;
 exports.CandidateQueryFilterSchema = CandidateQueryFilterSchema;
 exports.CapScopeSchema = CapScopeSchema;
 exports.CapabilityBindingsSchema = CapabilityBindingsSchema;
+exports.CapacityFallbackSchema = CapacityFallbackSchema;
+exports.CapacitySourceSchema = CapacitySourceSchema;
 exports.CarbonMonoxideStatusSchema = CarbonMonoxideStatusSchema;
 exports.ChargingStatus = require_err_msg.ChargingStatus;
 exports.ClaimOutcomeSchema = ClaimOutcomeSchema;
@@ -75776,12 +76141,12 @@ exports.DECLARED_DEVICE_SWEEP_LIMIT = DECLARED_DEVICE_SWEEP_LIMIT;
 exports.DECLARED_INTEGRATION_FIXED_KEY = DECLARED_INTEGRATION_FIXED_KEY;
 exports.DEFAULT_ADDON_PLACEMENT = DEFAULT_ADDON_PLACEMENT;
 exports.DEFAULT_AUDIO_ANALYZER_CONFIG = DEFAULT_AUDIO_ANALYZER_CONFIG;
+exports.DEFAULT_CAMERA_FPS = DEFAULT_CAMERA_FPS;
 exports.DEFAULT_CAMERA_SENSOR_MODE = DEFAULT_CAMERA_SENSOR_MODE;
 exports.DEFAULT_CLUSTER_STEP_MODELS = DEFAULT_CLUSTER_STEP_MODELS;
 exports.DEFAULT_CLUSTER_STEP_SETTINGS = DEFAULT_CLUSTER_STEP_SETTINGS;
 exports.DEFAULT_CORE_BLOCK_ENTRY = DEFAULT_CORE_BLOCK_ENTRY;
 exports.DEFAULT_DECODER_HWACCEL_CONFIG = DEFAULT_DECODER_HWACCEL_CONFIG;
-exports.DEFAULT_DEMAND_OPTIONS = DEFAULT_DEMAND_OPTIONS;
 exports.DEFAULT_DETAIL_CROP_CONVENTION = DEFAULT_DETAIL_CROP_CONVENTION;
 exports.DEFAULT_EVENTS_BAND_BUFFER_SEC = DEFAULT_EVENTS_BAND_BUFFER_SEC;
 exports.DEFAULT_EVENT_COLOR = DEFAULT_EVENT_COLOR;
@@ -75789,6 +76154,7 @@ exports.DEFAULT_FEATURES = DEFAULT_FEATURES;
 exports.DEFAULT_FIRST_SIGHTING_FRESHNESS_MS = require_composition.DEFAULT_FIRST_SIGHTING_FRESHNESS_MS;
 exports.DEFAULT_HEADROOM = DEFAULT_HEADROOM;
 exports.DEFAULT_MIN_LANDMARK_FACE_SIZE_PX = DEFAULT_MIN_LANDMARK_FACE_SIZE_PX;
+exports.DEFAULT_MIN_SESSIONS_PER_DEVICE = DEFAULT_MIN_SESSIONS_PER_DEVICE;
 exports.DEFAULT_NATIVE_LEASE_SETTINGS = DEFAULT_NATIVE_LEASE_SETTINGS;
 exports.DEFAULT_OVERLAY_LAYERS = DEFAULT_OVERLAY_LAYERS;
 exports.DEFAULT_POOL_MEMORY_POLICY = DEFAULT_POOL_MEMORY_POLICY;
@@ -75796,6 +76162,7 @@ exports.DEFAULT_RECORDING_PROFILES = DEFAULT_RECORDING_PROFILES;
 exports.DEFAULT_RETENTION = DEFAULT_RETENTION;
 exports.DEFAULT_RUNTIME_STATE_DURABILITY = require_sleep.DEFAULT_RUNTIME_STATE_DURABILITY;
 exports.DEFAULT_SESSION_PLACEMENT_POLICY = DEFAULT_SESSION_PLACEMENT_POLICY;
+exports.DEFAULT_SHARE_SOURCE = DEFAULT_SHARE_SOURCE;
 exports.DEFAULT_TIMELAPSE_PREVIEW_TEXT = DEFAULT_TIMELAPSE_PREVIEW_TEXT;
 exports.DEFAULT_TOKEN_EXPIRY = DEFAULT_TOKEN_EXPIRY;
 exports.DERIVED_CAMERA_SILENCED_CAP_NAMES = DERIVED_CAMERA_SILENCED_CAP_NAMES;
@@ -75848,7 +76215,6 @@ exports.DetectorStoreClearSchema = DetectorStoreClearSchema;
 exports.DeviceAdminLinkSchema = DeviceAdminLinkSchema;
 exports.DeviceCodeSeveritySchema = DeviceCodeSeveritySchema;
 exports.DeviceConfig = DeviceConfig;
-exports.DeviceDemandSchema = DeviceDemandSchema;
 exports.DeviceDiscoveryStatusSchema = DeviceDiscoveryStatusSchema;
 exports.DeviceExportExposeInputSchema = ExposeInputSchema;
 exports.DeviceExportStatusSchema = DeviceExportStatusSchema;
@@ -75897,6 +76263,9 @@ exports.EXTENSION_SLOTS = EXTENSION_SLOTS;
 exports.EXTENSION_SLOT_IDS = EXTENSION_SLOT_IDS;
 exports.EXTENSION_SLOT_LISTING_METHOD = EXTENSION_SLOT_LISTING_METHOD;
 exports.EXTENSION_SLOT_REF_SEPARATOR = EXTENSION_SLOT_REF_SEPARATOR;
+exports.EffectiveDeviceShareSchema = EffectiveDeviceShareSchema;
+exports.EffectiveNodeShareSchema = EffectiveNodeShareSchema;
+exports.EffectiveSharesSchema = EffectiveSharesSchema;
 exports.EffectiveTuningSchema = EffectiveTuningSchema;
 exports.EgressEncodeSchema = EgressEncodeSchema;
 exports.EgressRateControlSchema = EgressRateControlSchema;
@@ -76153,6 +76522,7 @@ exports.MEDIA_PRESENCE_OWNER_KINDS = MEDIA_PRESENCE_OWNER_KINDS;
 exports.METHOD_ACCESS_MAP = METHOD_ACCESS_MAP;
 exports.METHOD_DEVICE_SELECTORS = METHOD_DEVICE_SELECTORS;
 exports.MINUTES_PER_DAY = MINUTES_PER_DAY;
+exports.MIN_SESSIONS_PER_DEVICE_RANGE = MIN_SESSIONS_PER_DEVICE_RANGE;
 exports.MODEL_FORMATS = MODEL_FORMATS;
 exports.MODEL_HOSTING = MODEL_HOSTING;
 exports.MODEL_PROVIDER_IDS = MODEL_PROVIDER_IDS;
@@ -76315,6 +76685,7 @@ exports.NC_TEMPLATE_VARS = NC_TEMPLATE_VARS;
 exports.NC_UPDATE_EVENT_PACKAGE_NAMES = NC_UPDATE_EVENT_PACKAGE_NAMES;
 exports.NETWORK_LINK_TYPES = NETWORK_LINK_TYPES;
 exports.NETWORK_LINK_UNKNOWN = NETWORK_LINK_UNKNOWN;
+exports.NO_MEASURED_CAPACITY = NO_MEASURED_CAPACITY;
 exports.NativeCropBboxSchema = NativeCropBboxSchema;
 exports.NativeCropRefSchema = NativeCropRefSchema;
 exports.NativeCropResultSchema = NativeCropResultSchema;
@@ -76445,7 +76816,6 @@ exports.NotificationFormatSchema = NotificationFormatSchema;
 exports.NotificationSchema = NotificationSchema;
 exports.NotifierStatusSchema = NotifierStatusSchema;
 exports.NumericSensorStatusSchema = NumericSensorStatusSchema;
-exports.OBSERVATION_WINDOW_MS = OBSERVATION_WINDOW_MS;
 exports.OPERATOR_WRITTEN_STALE_MS = OPERATOR_WRITTEN_STALE_MS;
 exports.OPS_LOG_DEFAULT_LIMIT = OPS_LOG_DEFAULT_LIMIT;
 exports.OPS_LOG_RING_DEFAULT_MAX = OPS_LOG_RING_DEFAULT_MAX;
@@ -76692,6 +77062,7 @@ exports.SCOPE_PRESETS = SCOPE_PRESETS;
 exports.SENSOR_FEATURES = SENSOR_FEATURES;
 exports.SENSOR_MAP = SENSOR_MAP;
 exports.SESSION_PLACEMENT_SETTING_KEY = SESSION_PLACEMENT_SETTING_KEY;
+exports.SHARE_SOURCE_SETTING_KEY = SHARE_SOURCE_SETTING_KEY;
 exports.SHARE_VIEW_KINDS = require_sleep.SHARE_VIEW_KINDS;
 exports.SINGLE_HUB_ADDRESS_ROLES = SINGLE_HUB_ADDRESS_ROLES;
 exports.SOURCE_CAPS = require_composition.SOURCE_CAPS;
@@ -76741,6 +77112,7 @@ exports.SessionPlacementPolicySchema = SessionPlacementPolicySchema;
 exports.SessionTriggerSchema = SessionTriggerSchema;
 exports.SetCameraSensorsInputSchema = SetCameraSensorsInputSchema;
 exports.SetLoggingSettingsInputSchema = SetLoggingSettingsInputSchema;
+exports.SetShareSourceInputSchema = SetShareSourceInputSchema;
 exports.SetSiteLocationInputSchema = SetSiteLocationInputSchema;
 exports.SetTrackPurityInputSchema = SetTrackPurityInputSchema;
 exports.SetTrackPurityResultSchema = SetTrackPurityResultSchema;
@@ -76749,6 +77121,8 @@ exports.SettingsPatchSchema = SettingsPatchSchema;
 exports.SettingsRecordSchema = SettingsRecordSchema;
 exports.SettingsSchemaWithValuesSchema = SettingsSchemaWithValuesSchema;
 exports.SettingsUpdateResultSchema = SettingsUpdateResultSchema;
+exports.ShareSourceSchema = ShareSourceSchema;
+exports.ShareWeightsSchema = ShareWeightsSchema;
 exports.ShmRingStatsSchema = ShmRingStatsSchema;
 exports.SiteLocationSchema = SiteLocationSchema;
 exports.SiteLocationSourceSchema = SiteLocationSourceSchema;
@@ -77047,6 +77421,7 @@ exports.cameraSensorRefKey = cameraSensorRefKey;
 exports.cameraStreamsCapability = cameraStreamsCapability;
 exports.canConvertUnit = canConvertUnit;
 exports.canonicalEgressPlan = canonicalEgressPlan;
+exports.capacitySessionsOf = capacitySessionsOf;
 exports.carbonMonoxideCapability = carbonMonoxideCapability;
 exports.cellsToRects = cellsToRects;
 exports.checkRoleAddress = checkRoleAddress;
@@ -77088,6 +77463,7 @@ exports.compositionReadKey = require_composition.compositionReadKey;
 exports.compositionSliceKey = require_composition.compositionSliceKey;
 exports.compositionSourceKey = require_composition.compositionSourceKey;
 exports.compositionSourceRefs = compositionSourceRefs;
+exports.computeCapacityShares = computeCapacityShares;
 exports.conditionDepth = conditionDepth;
 exports.conditionExclusionReason = conditionExclusionReason;
 exports.conditionVisibleForKind = conditionVisibleForKind;
@@ -77174,6 +77550,7 @@ exports.deviceProviderCapability = deviceProviderCapability;
 exports.deviceSelectorMatches = deviceSelectorMatches;
 exports.deviceStateCapability = deviceStateCapability;
 exports.deviceStatusCapability = deviceStatusCapability;
+exports.diffStepSettings = diffStepSettings;
 exports.disarmRoseMemory = require_composition.disarmRoseMemory;
 exports.displayIconEntry = displayIconEntry;
 exports.displayIconsInGroup = displayIconsInGroup;
@@ -77181,6 +77558,7 @@ exports.doActionSelectValue = doActionSelectValue;
 exports.doorbellCapability = doorbellCapability;
 exports.doorbellFeatureSources = doorbellFeatureSources;
 exports.droppedConditionsForKind = droppedConditionsForKind;
+exports.effectiveStepSettings = effectiveStepSettings;
 exports.egressTranscodeSharingKey = egressTranscodeSharingKey;
 exports.egressTransportFromRequest = egressTransportFromRequest;
 exports.electByShare = electByShare;
@@ -77201,8 +77579,6 @@ exports.enumerateInferenceDevices = enumerateInferenceDevices;
 exports.enumerateItemArrayFields = enumerateItemArrayFields;
 exports.enumerateSchemaFields = enumerateSchemaFields;
 exports.errMsg = require_err_msg.errMsg;
-exports.estimateDeviceDemand = estimateDeviceDemand;
-exports.estimatedConcurrentSessions = estimatedConcurrentSessions;
 exports.evaluateAst = require_composition.evaluateAst;
 exports.evaluateCompositionField = evaluateCompositionField;
 exports.evaluateCount = require_composition.evaluateCount;
@@ -77238,6 +77614,8 @@ exports.feederCustomizationExample = feederCustomizationExample;
 exports.feederExampleSources = feederExampleSources;
 exports.ffmpegRate = ffmpegRate;
 exports.fieldReads = require_composition.fieldReads;
+exports.fieldUnitKeys = fieldUnitKeys;
+exports.fieldsPinnedAtValueBelow = fieldsPinnedAtValueBelow;
 exports.filesystemBrowseCapability = filesystemBrowseCapability;
 exports.findCandidateCycles = findCandidateCycles;
 exports.findCompositionCycles = findCompositionCycles;
@@ -77289,6 +77667,7 @@ exports.isAudioChunkFormat = require_sleep.isAudioChunkFormat;
 exports.isAudioClassName = isAudioClassName;
 exports.isAudioLabelSelected = isAudioLabelSelected;
 exports.isAudioRule = isAudioRule;
+exports.isAutomaticShareSource = isAutomaticShareSource;
 exports.isBaseConditionKey = isBaseConditionKey;
 exports.isBatteryPresenceFault = isBatteryPresenceFault;
 exports.isClusterScopedStep = isClusterScopedStep;
@@ -77375,6 +77754,7 @@ exports.mayReadLocation = mayReadLocation;
 exports.mayWriteToLocation = mayWriteToLocation;
 exports.mediaPlayerCapability = mediaPlayerCapability;
 exports.memoizePinnedFfmpeg = memoizePinnedFfmpeg;
+exports.mergeSettingsBags = mergeSettingsBags;
 exports.mergeSourceInfo = mergeSourceInfo;
 exports.meshNetworkCapability = meshNetworkCapability;
 exports.method = require_sleep.method;
@@ -77435,6 +77815,7 @@ exports.parseProcStatus = parseProcStatus;
 exports.parseProfileBrokerId = require_sleep.parseProfileBrokerId;
 exports.parseRuleSection = parseRuleSection;
 exports.parseSessionPlacementPolicy = parseSessionPlacementPolicy;
+exports.parseShareSource = parseShareSource;
 exports.parseStreamParamsFormPatch = parseStreamParamsFormPatch;
 exports.patchAudio = patchAudio;
 exports.petFeederCapability = petFeederCapability;
@@ -77515,6 +77896,7 @@ exports.resolveCoreBlockFiles = resolveCoreBlockFiles;
 exports.resolveCreateExportSubject = resolveCreateExportSubject;
 exports.resolveDeviceControlKind = resolveDeviceControlKind;
 exports.resolveDeviceProfile = resolveDeviceProfile;
+exports.resolveEffectiveShares = resolveEffectiveShares;
 exports.resolveEgressDecodeHwAccel = resolveEgressDecodeHwAccel;
 exports.resolveExportProfiles = resolveExportProfiles;
 exports.resolveFormat = resolveFormat;
@@ -77579,6 +77961,8 @@ exports.sensorTransitionOffered = sensorTransitionOffered;
 exports.servedTemplateVars = servedTemplateVars;
 exports.serverManagementCapability = serverManagementCapability;
 exports.setByPath = setByPath;
+exports.settingValuesEqual = settingValuesEqual;
+exports.settingsBelow = settingsBelow;
 exports.settingsStoreCapability = settingsStoreCapability;
 exports.signalPercentFromBars = signalPercentFromBars;
 exports.signalPercentFromRssi = signalPercentFromRssi;
@@ -77595,6 +77979,7 @@ exports.startReachabilityPoll = startReachabilityPoll;
 exports.stateLabel = stateLabel;
 exports.stateVocabularyFor = stateVocabularyFor;
 exports.stepModelRunsOnFormat = stepModelRunsOnFormat;
+exports.stepSettingSource = stepSettingSource;
 exports.storageCapability = storageCapability;
 exports.storageEvictableCapability = storageEvictableCapability;
 exports.storageMigrationCapability = storageMigrationCapability;
@@ -77646,6 +78031,7 @@ exports.toAppLinkHubOrigin = toAppLinkHubOrigin;
 exports.toDeviceSummary = toDeviceSummary;
 exports.toExpressionValue = require_composition.toExpressionValue;
 exports.toNodeId = require_sleep.toNodeId;
+exports.toPercentShares = toPercentShares;
 exports.toStreamSourceEntry = toStreamSourceEntry;
 exports.toastCapability = toastCapability;
 exports.toggleAudioLabel = toggleAudioLabel;
@@ -77686,7 +78072,9 @@ exports.wiringHealthSnapshotSchema = wiringHealthSnapshotSchema;
 exports.wiringNodeHealthSchema = wiringNodeHealthSchema;
 exports.wiringProbeKindSchema = wiringProbeKindSchema;
 exports.wiringProbeResultSchema = wiringProbeResultSchema;
+exports.withFieldFrom = withFieldFrom;
 exports.withLocationMode = withLocationMode;
+exports.withoutField = withoutField;
 exports.writeModelBoundSetting = writeModelBoundSetting;
 exports.zodEntriesToConfigUI = zodEntriesToConfigUI;
 exports.zoneAnalyticsCapability = zoneAnalyticsCapability;