@camstack/types 1.2.318 → 1.2.320

package/dist/pipeline/{best-settings → auto-tune}/hardware-class.d.ts

@@ -1,5 +1,5 @@
 /**
- * Static hardware classification for the Best settings recommender (D745).
+ * Static hardware classification for the Auto tune recommender (D745).
  *
  * A node is classified from the facts its platform probe already reports —
  * `cpuModel`, `arch`, `gpu`, `npu` — never from a benchmark. The class picks a

package/dist/pipeline/auto-tune/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Auto tune (D745, D755): the static-hardware × measured-latency recommender
+ * of ONE detector family for the whole cluster, sized by a capacity floor
+ * (no load input), and the shapes of its plan. See `recommend.ts`.
+ */
+export * from './hardware-class.js';
+export * from './detector-performance.js';
+export * from './recommend.js';
+export * from './plan-schemas.js';

package/dist/pipeline/{best-settings → auto-tune}/plan-schemas.d.ts

@@ -1,10 +1,17 @@
 /**
- * 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.
  */
 import { z } from 'zod';
+/** Default least number of parallel sessions per device Auto tune keeps (D755). */
+export declare const DEFAULT_MIN_SESSIONS_PER_DEVICE = 2;
+/** The operator's range for it. */
+export declare const MIN_SESSIONS_PER_DEVICE_RANGE: {
+    readonly min: 1;
+    readonly max: 8;
+};
 export declare const HardwareClassIdSchema: z.ZodEnum<{
     unknown: "unknown";
     "intel-core-ultra": "intel-core-ultra";
@@ -21,8 +28,9 @@ export declare const AcceleratorKindSchema: z.ZodEnum<{
     coral: "coral";
 }>;
 export declare const RecommendationReasonSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    kind: z.ZodLiteral<"fits">;
-    utilisation: z.ZodNumber;
+    kind: z.ZodLiteral<"capacity">;
+    sessions: z.ZodNumber;
+    minSessions: z.ZodNumber;
 }, z.core.$strip>, z.ZodObject<{
     kind: z.ZodLiteral<"tie-faster">;
     over: z.ZodString;
@@ -34,13 +42,11 @@ export declare const RecommendationReasonSchema: z.ZodDiscriminatedUnion<[z.ZodO
     limitedBy: z.ZodString;
 }, z.core.$strip>, z.ZodObject<{
     kind: z.ZodLiteral<"no-fit-lightest">;
-    utilisation: z.ZodNumber;
+    sessions: z.ZodNumber;
+    minSessions: z.ZodNumber;
 }, z.core.$strip>, z.ZodObject<{
     kind: z.ZodLiteral<"derived-latency">;
     modelId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    kind: z.ZodLiteral<"estimated-load">;
-    observedForMs: z.ZodNullable<z.ZodNumber>;
 }, z.core.$strip>, z.ZodObject<{
     kind: z.ZodLiteral<"cpu-device">;
 }, z.core.$strip>, z.ZodObject<{
@@ -73,30 +79,12 @@ export declare const RecommendationReasonSchema: z.ZodDiscriminatedUnion<[z.ZodO
         gguf: "gguf";
     }>;
 }, z.core.$strip>], "kind">;
-export declare const DeviceDemandSchema: z.ZodObject<{
-    nodeId: z.ZodString;
-    deviceKey: z.ZodString;
-    demandFps: z.ZodNumber;
-    maxCameraFps: z.ZodNumber;
-    alwaysOnCameras: z.ZodNumber;
-    onMotionSessions: z.ZodNumber;
-    onMotionSource: z.ZodEnum<{
-        none: "none";
-        "observed-24h": "observed-24h";
-        estimate: "estimate";
-    }>;
-    observedForMs: z.ZodNullable<z.ZodNumber>;
-    placement: z.ZodEnum<{
-        "least-loaded": "least-loaded";
-        share: "share";
-    }>;
-}, z.core.$strip>;
 export declare const DeviceModelChoiceSchema: z.ZodObject<{
     modelId: z.ZodString;
     p50Ms: z.ZodNumber;
     fps: z.ZodNumber;
     measured: z.ZodBoolean;
-    utilisation: z.ZodNumber;
+    capacitySessions: z.ZodNumber;
     personRecall: z.ZodNumber;
 }, z.core.$strip>;
 export declare const DeviceRecommendationSchema: z.ZodObject<{
@@ -111,35 +99,18 @@ export declare const DeviceRecommendationSchema: z.ZodObject<{
     }>>;
     enabled: z.ZodBoolean;
     available: z.ZodBoolean;
-    demand: z.ZodNullable<z.ZodObject<{
-        nodeId: z.ZodString;
-        deviceKey: z.ZodString;
-        demandFps: z.ZodNumber;
-        maxCameraFps: z.ZodNumber;
-        alwaysOnCameras: z.ZodNumber;
-        onMotionSessions: z.ZodNumber;
-        onMotionSource: z.ZodEnum<{
-            none: "none";
-            "observed-24h": "observed-24h";
-            estimate: "estimate";
-        }>;
-        observedForMs: z.ZodNullable<z.ZodNumber>;
-        placement: z.ZodEnum<{
-            "least-loaded": "least-loaded";
-            share: "share";
-        }>;
-    }, z.core.$strip>>;
     chosen: z.ZodNullable<z.ZodObject<{
         modelId: z.ZodString;
         p50Ms: z.ZodNumber;
         fps: z.ZodNumber;
         measured: z.ZodBoolean;
-        utilisation: z.ZodNumber;
+        capacitySessions: z.ZodNumber;
         personRecall: z.ZodNumber;
     }, z.core.$strip>>;
     reasons: z.ZodReadonly<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
-        kind: z.ZodLiteral<"fits">;
-        utilisation: z.ZodNumber;
+        kind: z.ZodLiteral<"capacity">;
+        sessions: z.ZodNumber;
+        minSessions: z.ZodNumber;
     }, z.core.$strip>, z.ZodObject<{
         kind: z.ZodLiteral<"tie-faster">;
         over: z.ZodString;
@@ -151,13 +122,11 @@ export declare const DeviceRecommendationSchema: z.ZodObject<{
         limitedBy: z.ZodString;
     }, z.core.$strip>, z.ZodObject<{
         kind: z.ZodLiteral<"no-fit-lightest">;
-        utilisation: z.ZodNumber;
+        sessions: z.ZodNumber;
+        minSessions: z.ZodNumber;
     }, z.core.$strip>, z.ZodObject<{
         kind: z.ZodLiteral<"derived-latency">;
         modelId: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{
-        kind: z.ZodLiteral<"estimated-load">;
-        observedForMs: z.ZodNullable<z.ZodNumber>;
     }, z.core.$strip>, z.ZodObject<{
         kind: z.ZodLiteral<"cpu-device">;
     }, z.core.$strip>, z.ZodObject<{
@@ -216,35 +185,18 @@ export declare const NodeRecommendationSchema: z.ZodObject<{
         }>>;
         enabled: z.ZodBoolean;
         available: z.ZodBoolean;
-        demand: z.ZodNullable<z.ZodObject<{
-            nodeId: z.ZodString;
-            deviceKey: z.ZodString;
-            demandFps: z.ZodNumber;
-            maxCameraFps: z.ZodNumber;
-            alwaysOnCameras: z.ZodNumber;
-            onMotionSessions: z.ZodNumber;
-            onMotionSource: z.ZodEnum<{
-                none: "none";
-                "observed-24h": "observed-24h";
-                estimate: "estimate";
-            }>;
-            observedForMs: z.ZodNullable<z.ZodNumber>;
-            placement: z.ZodEnum<{
-                "least-loaded": "least-loaded";
-                share: "share";
-            }>;
-        }, z.core.$strip>>;
         chosen: z.ZodNullable<z.ZodObject<{
             modelId: z.ZodString;
             p50Ms: z.ZodNumber;
             fps: z.ZodNumber;
             measured: z.ZodBoolean;
-            utilisation: z.ZodNumber;
+            capacitySessions: z.ZodNumber;
             personRecall: z.ZodNumber;
         }, z.core.$strip>>;
         reasons: z.ZodReadonly<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
-            kind: z.ZodLiteral<"fits">;
-            utilisation: z.ZodNumber;
+            kind: z.ZodLiteral<"capacity">;
+            sessions: z.ZodNumber;
+            minSessions: z.ZodNumber;
         }, z.core.$strip>, z.ZodObject<{
             kind: z.ZodLiteral<"tie-faster">;
             over: z.ZodString;
@@ -256,13 +208,11 @@ export declare const NodeRecommendationSchema: z.ZodObject<{
             limitedBy: z.ZodString;
         }, z.core.$strip>, z.ZodObject<{
             kind: z.ZodLiteral<"no-fit-lightest">;
-            utilisation: z.ZodNumber;
+            sessions: z.ZodNumber;
+            minSessions: z.ZodNumber;
         }, z.core.$strip>, z.ZodObject<{
             kind: z.ZodLiteral<"derived-latency">;
             modelId: z.ZodString;
-        }, z.core.$strip>, z.ZodObject<{
-            kind: z.ZodLiteral<"estimated-load">;
-            observedForMs: z.ZodNullable<z.ZodNumber>;
         }, z.core.$strip>, z.ZodObject<{
             kind: z.ZodLiteral<"cpu-device">;
         }, z.core.$strip>, z.ZodObject<{
@@ -297,8 +247,9 @@ export declare const NodeRecommendationSchema: z.ZodObject<{
         }, z.core.$strip>], "kind">>>;
     }, z.core.$strip>>>;
     reasons: z.ZodReadonly<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
-        kind: z.ZodLiteral<"fits">;
-        utilisation: z.ZodNumber;
+        kind: z.ZodLiteral<"capacity">;
+        sessions: z.ZodNumber;
+        minSessions: z.ZodNumber;
     }, z.core.$strip>, z.ZodObject<{
         kind: z.ZodLiteral<"tie-faster">;
         over: z.ZodString;
@@ -310,13 +261,11 @@ export declare const NodeRecommendationSchema: z.ZodObject<{
         limitedBy: z.ZodString;
     }, z.core.$strip>, z.ZodObject<{
         kind: z.ZodLiteral<"no-fit-lightest">;
-        utilisation: z.ZodNumber;
+        sessions: z.ZodNumber;
+        minSessions: z.ZodNumber;
     }, z.core.$strip>, z.ZodObject<{
         kind: z.ZodLiteral<"derived-latency">;
         modelId: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{
-        kind: z.ZodLiteral<"estimated-load">;
-        observedForMs: z.ZodNullable<z.ZodNumber>;
     }, z.core.$strip>, z.ZodObject<{
         kind: z.ZodLiteral<"cpu-device">;
     }, z.core.$strip>, z.ZodObject<{
@@ -385,7 +334,7 @@ export declare const DetectorStoreClearSchema: z.ZodObject<{
     deviceId: z.ZodNumber;
     keys: z.ZodReadonly<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>;
-export declare const BestSettingsWarningSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+export declare const AutoTuneWarningSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     kind: z.ZodLiteral<"detector-store-cluster-wide">;
     skippedNodes: z.ZodReadonly<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>, z.ZodObject<{
@@ -396,18 +345,16 @@ export declare const BestSettingsWarningSchema: z.ZodDiscriminatedUnion<[z.ZodOb
     nodeId: z.ZodString;
     deviceKey: z.ZodString;
 }, z.core.$strip>], "kind">;
-export declare const BestSettingsOptionsSchema: z.ZodObject<{
+export declare const AutoTuneOptionsSchema: z.ZodObject<{
     headroom: z.ZodDefault<z.ZodNumber>;
-    shares: z.ZodOptional<z.ZodObject<{
-        nodes: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNumber>>;
-        devices: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodNumber>>>;
-    }, z.core.$strip>>;
+    minSessionsPerDevice: z.ZodDefault<z.ZodNumber>;
 }, z.core.$strip>;
-export declare const BestSettingsPlanSchema: z.ZodObject<{
+export declare const AutoTunePlanSchema: z.ZodObject<{
     planHash: z.ZodString;
     family: z.ZodLiteral<"yolov9">;
     headroom: z.ZodNumber;
-    whatIf: z.ZodBoolean;
+    minSessionsPerDevice: z.ZodNumber;
+    cameraFps: z.ZodNumber;
     generatedAt: z.ZodNumber;
     nodes: z.ZodReadonly<z.ZodArray<z.ZodObject<{
         nodeId: z.ZodString;
@@ -434,35 +381,18 @@ export declare const BestSettingsPlanSchema: z.ZodObject<{
             }>>;
             enabled: z.ZodBoolean;
             available: z.ZodBoolean;
-            demand: z.ZodNullable<z.ZodObject<{
-                nodeId: z.ZodString;
-                deviceKey: z.ZodString;
-                demandFps: z.ZodNumber;
-                maxCameraFps: z.ZodNumber;
-                alwaysOnCameras: z.ZodNumber;
-                onMotionSessions: z.ZodNumber;
-                onMotionSource: z.ZodEnum<{
-                    none: "none";
-                    "observed-24h": "observed-24h";
-                    estimate: "estimate";
-                }>;
-                observedForMs: z.ZodNullable<z.ZodNumber>;
-                placement: z.ZodEnum<{
-                    "least-loaded": "least-loaded";
-                    share: "share";
-                }>;
-            }, z.core.$strip>>;
             chosen: z.ZodNullable<z.ZodObject<{
                 modelId: z.ZodString;
                 p50Ms: z.ZodNumber;
                 fps: z.ZodNumber;
                 measured: z.ZodBoolean;
-                utilisation: z.ZodNumber;
+                capacitySessions: z.ZodNumber;
                 personRecall: z.ZodNumber;
             }, z.core.$strip>>;
             reasons: z.ZodReadonly<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
-                kind: z.ZodLiteral<"fits">;
-                utilisation: z.ZodNumber;
+                kind: z.ZodLiteral<"capacity">;
+                sessions: z.ZodNumber;
+                minSessions: z.ZodNumber;
             }, z.core.$strip>, z.ZodObject<{
                 kind: z.ZodLiteral<"tie-faster">;
                 over: z.ZodString;
@@ -474,13 +404,11 @@ export declare const BestSettingsPlanSchema: z.ZodObject<{
                 limitedBy: z.ZodString;
             }, z.core.$strip>, z.ZodObject<{
                 kind: z.ZodLiteral<"no-fit-lightest">;
-                utilisation: z.ZodNumber;
+                sessions: z.ZodNumber;
+                minSessions: z.ZodNumber;
             }, z.core.$strip>, z.ZodObject<{
                 kind: z.ZodLiteral<"derived-latency">;
                 modelId: z.ZodString;
-            }, z.core.$strip>, z.ZodObject<{
-                kind: z.ZodLiteral<"estimated-load">;
-                observedForMs: z.ZodNullable<z.ZodNumber>;
             }, z.core.$strip>, z.ZodObject<{
                 kind: z.ZodLiteral<"cpu-device">;
             }, z.core.$strip>, z.ZodObject<{
@@ -515,8 +443,9 @@ export declare const BestSettingsPlanSchema: z.ZodObject<{
             }, z.core.$strip>], "kind">>>;
         }, z.core.$strip>>>;
         reasons: z.ZodReadonly<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
-            kind: z.ZodLiteral<"fits">;
-            utilisation: z.ZodNumber;
+            kind: z.ZodLiteral<"capacity">;
+            sessions: z.ZodNumber;
+            minSessions: z.ZodNumber;
         }, z.core.$strip>, z.ZodObject<{
             kind: z.ZodLiteral<"tie-faster">;
             over: z.ZodString;
@@ -528,13 +457,11 @@ export declare const BestSettingsPlanSchema: z.ZodObject<{
             limitedBy: z.ZodString;
         }, z.core.$strip>, z.ZodObject<{
             kind: z.ZodLiteral<"no-fit-lightest">;
-            utilisation: z.ZodNumber;
+            sessions: z.ZodNumber;
+            minSessions: z.ZodNumber;
         }, z.core.$strip>, z.ZodObject<{
             kind: z.ZodLiteral<"derived-latency">;
             modelId: z.ZodString;
-        }, z.core.$strip>, z.ZodObject<{
-            kind: z.ZodLiteral<"estimated-load">;
-            observedForMs: z.ZodNullable<z.ZodNumber>;
         }, z.core.$strip>, z.ZodObject<{
             kind: z.ZodLiteral<"cpu-device">;
         }, z.core.$strip>, z.ZodObject<{
@@ -610,11 +537,12 @@ export declare const BestSettingsPlanSchema: z.ZodObject<{
         deviceKey: z.ZodString;
     }, z.core.$strip>], "kind">>>;
 }, z.core.$strip>;
-export declare const BestSettingsApplyInputSchema: z.ZodObject<{
+export declare const AutoTuneApplyInputSchema: z.ZodObject<{
     planHash: z.ZodString;
     headroom: z.ZodDefault<z.ZodNumber>;
+    minSessionsPerDevice: z.ZodDefault<z.ZodNumber>;
 }, z.core.$strip>;
-export declare const BestSettingsPhaseResultSchema: z.ZodObject<{
+export declare const AutoTunePhaseResultSchema: z.ZodObject<{
     phase: z.ZodEnum<{
         download: "download";
         "camera-overrides": "camera-overrides";
@@ -625,7 +553,7 @@ export declare const BestSettingsPhaseResultSchema: z.ZodObject<{
     ok: z.ZodBoolean;
     detail: z.ZodString;
 }, z.core.$strip>;
-export declare const BestSettingsApplyResultSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+export declare const AutoTuneApplyResultSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     kind: z.ZodLiteral<"applied">;
     planHash: z.ZodString;
     phases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
@@ -658,7 +586,8 @@ export declare const BestSettingsApplyResultSchema: z.ZodDiscriminatedUnion<[z.Z
         planHash: z.ZodString;
         family: z.ZodLiteral<"yolov9">;
         headroom: z.ZodNumber;
-        whatIf: z.ZodBoolean;
+        minSessionsPerDevice: z.ZodNumber;
+        cameraFps: z.ZodNumber;
         generatedAt: z.ZodNumber;
         nodes: z.ZodReadonly<z.ZodArray<z.ZodObject<{
             nodeId: z.ZodString;
@@ -685,35 +614,18 @@ export declare const BestSettingsApplyResultSchema: z.ZodDiscriminatedUnion<[z.Z
                 }>>;
                 enabled: z.ZodBoolean;
                 available: z.ZodBoolean;
-                demand: z.ZodNullable<z.ZodObject<{
-                    nodeId: z.ZodString;
-                    deviceKey: z.ZodString;
-                    demandFps: z.ZodNumber;
-                    maxCameraFps: z.ZodNumber;
-                    alwaysOnCameras: z.ZodNumber;
-                    onMotionSessions: z.ZodNumber;
-                    onMotionSource: z.ZodEnum<{
-                        none: "none";
-                        "observed-24h": "observed-24h";
-                        estimate: "estimate";
-                    }>;
-                    observedForMs: z.ZodNullable<z.ZodNumber>;
-                    placement: z.ZodEnum<{
-                        "least-loaded": "least-loaded";
-                        share: "share";
-                    }>;
-                }, z.core.$strip>>;
                 chosen: z.ZodNullable<z.ZodObject<{
                     modelId: z.ZodString;
                     p50Ms: z.ZodNumber;
                     fps: z.ZodNumber;
                     measured: z.ZodBoolean;
-                    utilisation: z.ZodNumber;
+                    capacitySessions: z.ZodNumber;
                     personRecall: z.ZodNumber;
                 }, z.core.$strip>>;
                 reasons: z.ZodReadonly<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
-                    kind: z.ZodLiteral<"fits">;
-                    utilisation: z.ZodNumber;
+                    kind: z.ZodLiteral<"capacity">;
+                    sessions: z.ZodNumber;
+                    minSessions: z.ZodNumber;
                 }, z.core.$strip>, z.ZodObject<{
                     kind: z.ZodLiteral<"tie-faster">;
                     over: z.ZodString;
@@ -725,13 +637,11 @@ export declare const BestSettingsApplyResultSchema: z.ZodDiscriminatedUnion<[z.Z
                     limitedBy: z.ZodString;
                 }, z.core.$strip>, z.ZodObject<{
                     kind: z.ZodLiteral<"no-fit-lightest">;
-                    utilisation: z.ZodNumber;
+                    sessions: z.ZodNumber;
+                    minSessions: z.ZodNumber;
                 }, z.core.$strip>, z.ZodObject<{
                     kind: z.ZodLiteral<"derived-latency">;
                     modelId: z.ZodString;
-                }, z.core.$strip>, z.ZodObject<{
-                    kind: z.ZodLiteral<"estimated-load">;
-                    observedForMs: z.ZodNullable<z.ZodNumber>;
                 }, z.core.$strip>, z.ZodObject<{
                     kind: z.ZodLiteral<"cpu-device">;
                 }, z.core.$strip>, z.ZodObject<{
@@ -766,8 +676,9 @@ export declare const BestSettingsApplyResultSchema: z.ZodDiscriminatedUnion<[z.Z
                 }, z.core.$strip>], "kind">>>;
             }, z.core.$strip>>>;
             reasons: z.ZodReadonly<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
-                kind: z.ZodLiteral<"fits">;
-                utilisation: z.ZodNumber;
+                kind: z.ZodLiteral<"capacity">;
+                sessions: z.ZodNumber;
+                minSessions: z.ZodNumber;
             }, z.core.$strip>, z.ZodObject<{
                 kind: z.ZodLiteral<"tie-faster">;
                 over: z.ZodString;
@@ -779,13 +690,11 @@ export declare const BestSettingsApplyResultSchema: z.ZodDiscriminatedUnion<[z.Z
                 limitedBy: z.ZodString;
             }, z.core.$strip>, z.ZodObject<{
                 kind: z.ZodLiteral<"no-fit-lightest">;
-                utilisation: z.ZodNumber;
+                sessions: z.ZodNumber;
+                minSessions: z.ZodNumber;
             }, z.core.$strip>, z.ZodObject<{
                 kind: z.ZodLiteral<"derived-latency">;
                 modelId: z.ZodString;
-            }, z.core.$strip>, z.ZodObject<{
-                kind: z.ZodLiteral<"estimated-load">;
-                observedForMs: z.ZodNullable<z.ZodNumber>;
             }, z.core.$strip>, z.ZodObject<{
                 kind: z.ZodLiteral<"cpu-device">;
             }, z.core.$strip>, z.ZodObject<{
@@ -867,19 +776,18 @@ export declare const BestSettingsApplyResultSchema: z.ZodDiscriminatedUnion<[z.Z
         "apply-in-progress": "apply-in-progress";
     }>;
 }, z.core.$strip>], "kind">;
-export type BestSettingsPlan = z.infer<typeof BestSettingsPlanSchema>;
-export type BestSettingsOptions = z.infer<typeof BestSettingsOptionsSchema>;
-export type BestSettingsApplyInput = z.infer<typeof BestSettingsApplyInputSchema>;
-export type BestSettingsApplyResult = z.infer<typeof BestSettingsApplyResultSchema>;
-export type BestSettingsPhaseResult = z.infer<typeof BestSettingsPhaseResultSchema>;
-export type BestSettingsWarning = z.infer<typeof BestSettingsWarningSchema>;
+export type AutoTunePlan = z.infer<typeof AutoTunePlanSchema>;
+export type AutoTuneOptions = z.infer<typeof AutoTuneOptionsSchema>;
+export type AutoTuneApplyInput = z.infer<typeof AutoTuneApplyInputSchema>;
+export type AutoTuneApplyResult = z.infer<typeof AutoTuneApplyResultSchema>;
+export type AutoTunePhaseResult = z.infer<typeof AutoTunePhaseResultSchema>;
+export type AutoTuneWarning = z.infer<typeof AutoTuneWarningSchema>;
 export type DetectorStoreClear = z.infer<typeof DetectorStoreClearSchema>;
-export type BestSettingsCameraOverrideClear = z.infer<typeof CameraOverrideClearSchema>;
-export type BestSettingsNodeDeviceChange = z.infer<typeof NodeDeviceChangeSchema>;
+export type AutoTuneCameraOverrideClear = z.infer<typeof CameraOverrideClearSchema>;
+export type AutoTuneNodeDeviceChange = z.infer<typeof NodeDeviceChangeSchema>;
 export type HardwareClassId = z.infer<typeof HardwareClassIdSchema>;
 export type AcceleratorKind = z.infer<typeof AcceleratorKindSchema>;
 export type RecommendationReason = z.infer<typeof RecommendationReasonSchema>;
-export type DeviceDemand = z.infer<typeof DeviceDemandSchema>;
 export type DeviceModelChoice = z.infer<typeof DeviceModelChoiceSchema>;
 export type DeviceRecommendation = z.infer<typeof DeviceRecommendationSchema>;
 export type NodeRecommendation = z.infer<typeof NodeRecommendationSchema>;

package/dist/pipeline/{best-settings → auto-tune}/recommend.d.ts

@@ -1,7 +1,8 @@
 /**
- * The Best settings recommender (D745): one detector per node, from ONE family
- * (YOLOv9) for the whole cluster, chosen from static hardware facts × the
- * measured latency table × the node's detection demand. Pure; no benchmark.
+ * The Auto tune recommender (D745, D755): one detector per node, from ONE
+ * family (YOLOv9) for the whole cluster, chosen from static hardware facts ×
+ * the measured latency table × a capacity floor. Pure; no benchmark, and no
+ * load: nothing here depends on how many sessions ran yesterday.
  *
  * Per node:
  *  1. Classify the hardware (`classifyInferenceHardware`). An unknown class,
@@ -10,45 +11,54 @@
  *     available share ONE model — so a camera's floors never flip with the
  *     device the balancer rotated it onto. A candidate must have a build for
  *     every accelerator's format and a latency cell for each.
- *  3. A candidate FITS a device when its throughput, less the headroom, covers
- *     the device's demand and the single fastest camera that can land on it.
+ *  3. A candidate FITS a device when the device sustains at least
+ *     `minSessionsPerDevice` parallel sessions with it:
+ *     ⌊fps × (1 − headroom) / camera fps⌋ ≥ minSessionsPerDevice.
  *  4. Among candidates that fit everywhere, the most accurate wins (person
  *     recall at the shipped floor); within `RECALL_TIE` of the best, the
  *     fastest wins. That IS the step-down order the data gives: the first
- *     variant down from m-640 is s-640-int8, not m-320.
+ *     variant down from m-640 is s-640-int8, not m-320. When nothing fits,
+ *     the candidate with the most capacity is used and the plan says so.
  *  5. An enabled CPU device (the fallback pool) gets its own pick the same
  *     way; a Coral is never touched (no YOLOv9 build), only reported.
  */
 import type { HardwareInfo } from '../../interfaces/platform.js';
 import type { ModelFormat } from '../../types/models.js';
 import { type DetectorPerfTable } from './detector-performance.js';
-import type { DeviceDemand, NodeRecommendation } from './plan-schemas.js';
+import { type NodeRecommendation } from './plan-schemas.js';
 /** The family the cluster runs. */
-export declare const BEST_SETTINGS_FAMILY = "yolov9";
+export declare const AUTO_TUNE_FAMILY = "yolov9";
 /** Recall within this of the best counts as a tie — the faster one wins. */
 export declare const RECALL_TIE = 0.02;
 /** Default share of an accelerator's throughput kept free. */
 export declare const DEFAULT_HEADROOM = 0.4;
+/** Detection rate a session is counted at when no camera says otherwise. */
+export declare const DEFAULT_CAMERA_FPS = 10;
+/** Parallel sessions one device sustains at `fps` with `headroom` kept free. */
+export declare function capacitySessionsOf(fps: number, headroom: number, cameraFps: number): number;
 /** One device of a node, as the recommender reads it. */
-export interface BestSettingsDeviceInput {
+export interface AutoTuneDeviceInput {
     readonly key: string;
     readonly format: ModelFormat;
     readonly enabled: boolean;
     readonly available: boolean;
 }
 /** One node, as the recommender reads it. */
-export interface BestSettingsNodeInput {
+export interface AutoTuneNodeInput {
     readonly nodeId: string;
     readonly reachable: boolean;
     readonly hardware: HardwareInfo | null;
-    readonly devices: readonly BestSettingsDeviceInput[];
+    readonly devices: readonly AutoTuneDeviceInput[];
     /** Object-detection model id → the formats it has a build for, from the node's catalog. */
     readonly formatsByModel: Readonly<Record<string, readonly ModelFormat[]>>;
 }
 /** Recommend one node. See the module header. */
 export declare function recommendNode(input: {
-    readonly node: BestSettingsNodeInput;
-    readonly demand: readonly DeviceDemand[];
+    readonly node: AutoTuneNodeInput;
     readonly headroom?: number;
+    /** Least parallel sessions per device (default {@link DEFAULT_MIN_SESSIONS_PER_DEVICE}). */
+    readonly minSessionsPerDevice?: number;
+    /** The rate a session is counted at (default {@link DEFAULT_CAMERA_FPS}). */
+    readonly cameraFps?: number;
     readonly perf?: DetectorPerfTable;
 }): NodeRecommendation;

package/dist/pipeline/load-balancing/capacity-shares.d.ts

@@ -0,0 +1,37 @@
+import type { NodeRecommendation } from '../auto-tune/plan-schemas.js';
+import type { CapacitySource, SuggestSharesResult } from './schemas.js';
+/** One device's measured capacity (a node benchmark result, reduced to what shares need). */
+export interface DeviceMeasuredCapacity {
+    readonly deviceKey: string;
+    /** Parallel sessions the device sustained at the camera rate. */
+    readonly maxSessions: number;
+    readonly modelId: string | null;
+    readonly measuredAtMs: number;
+}
+/** One node's measured capacity. */
+export interface NodeMeasuredCapacity {
+    readonly nodeId: string;
+    readonly devices: readonly DeviceMeasuredCapacity[];
+}
+/**
+ * Where measured node capacity is read from. The node-benchmark results
+ * store implements it; until it exists the orchestrator wires one that
+ * answers nothing, and every node falls back to `hardware`.
+ */
+export interface NodeCapacitySource {
+    /** The usable (fresh) measured capacity of each asked node that has any. */
+    readMeasuredCapacity(nodeIds: readonly string[]): Promise<ReadonlyMap<string, NodeMeasuredCapacity>>;
+}
+/** A source that has no results — the benchmark store before it exists. */
+export declare const NO_MEASURED_CAPACITY: NodeCapacitySource;
+/** Integer shares summing to 100 (largest remainder); ties broken by key. */
+export declare function toPercentShares(weights: ReadonlyMap<string, number>): Map<string, number>;
+/** Shares proportional to capacity — the automatic shares and the suggestion are this. */
+export declare function computeCapacityShares(input: {
+    readonly recommendations: readonly NodeRecommendation[];
+    readonly source: CapacitySource;
+    readonly measured: ReadonlyMap<string, NodeMeasuredCapacity>;
+    readonly headroom: number;
+    readonly cameraFps: number;
+    readonly minSessionsPerDevice: number;
+}): SuggestSharesResult;

package/dist/pipeline/load-balancing/effective-shares.d.ts

@@ -0,0 +1,33 @@
+/**
+ * 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.
+ */
+import { type CapacityFallback, type CapacitySource, type EffectiveShares, type SessionPlacementPolicy, type ShareSource, type ShareWeights } from './schemas.js';
+export interface EffectiveSharesInput {
+    readonly source: ShareSource;
+    /** Every node the view covers, eligible or not. */
+    readonly nodeIds: readonly string[];
+    readonly stored: ShareWeights;
+    /** The last automatic computation; null = none yet. */
+    readonly auto: ShareWeights | null;
+    /** Per node, what the automatic answer was computed from. */
+    readonly autoCapacity?: Readonly<Record<string, {
+        readonly source: CapacitySource;
+        readonly fallback: CapacityFallback | null;
+    }>>;
+    readonly eligibleNodes: readonly string[];
+    /** nodeId → device keys that can take sessions; a node absent here lists none. */
+    readonly eligibleDevices: Readonly<Record<string, readonly string[]>>;
+    readonly policy?: SessionPlacementPolicy;
+    readonly computedAt?: number | null;
+    readonly trigger?: string | null;
+}
+export declare function resolveEffectiveShares(input: EffectiveSharesInput): EffectiveShares;

package/dist/pipeline/load-balancing/index.d.ts

@@ -1,6 +1,9 @@
 /**
- * Load balancing (D748): the share placement policy for detection sessions
- * and the shapes of its admin surface. See `share-election.ts`.
+ * Load balancing (D748, D750, D755): the share placement policy for detection
+ * sessions, where its shares come from, and the shapes of its admin surface.
+ * See `share-election.ts`, `effective-shares.ts` and `capacity-shares.ts`.
  */
 export * from './share-election.js';
 export * from './schemas.js';
+export * from './effective-shares.js';
+export * from './capacity-shares.js';