@camstack/system 1.2.367 → 1.2.369

package/dist/{dist-BK15O90l.js → dist-BPFp08uY.js}

@@ -710,7 +710,7 @@ var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	return EventCategory;
 }({});
 //#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).
@@ -26294,7 +26294,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
@@ -26666,103 +26666,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 = zod.z.enum(["least-loaded", "share"]);
-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()
-});
-/**
-* 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);
+/** 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",
@@ -26780,8 +26694,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"),
@@ -26796,16 +26711,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") }),
@@ -26821,28 +26733,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({
@@ -26850,7 +26747,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()
 });
@@ -26892,7 +26788,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()
@@ -26907,36 +26803,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",
@@ -26947,25 +26844,196 @@ 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"),
 		reason: zod.z.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 = zod.z.enum(["least-loaded", "share"]);
+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 SetShareSourceInputSchema = zod.z.object({ source: ShareSourceSchema });
+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()))
+});
 zod.z.object({
 	activeCameras: zod.z.number(),
 	throttledCameras: zod.z.number(),
@@ -28377,8 +28445,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()
 });
@@ -29174,23 +29244,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"
 		}),
@@ -29215,12 +29287,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(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: 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: 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. */
@@ -29250,6 +29342,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(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: method(zod.z.object({
 			deviceId: zod.z.number(),
@@ -52403,7 +52511,7 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "view"
 	},
-	"pipelineOrchestrator.applyBestSettings": {
+	"pipelineOrchestrator.applyAutoTune": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
 		addonId: null,
@@ -52523,6 +52631,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",
@@ -52589,7 +52703,7 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "create"
 	},
-	"pipelineOrchestrator.planBestSettings": {
+	"pipelineOrchestrator.planAutoTune": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
 		addonId: null,
@@ -52691,6 +52805,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",
@@ -52721,6 +52841,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",
@@ -58388,6 +58514,11 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"pipelineOrchestrator.setCameraStepSettings": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"pipelineOrchestrator.setCameraStepToggle": [{
 		name: "deviceId",
 		form: "single",