@camstack/types 1.2.318 → 1.2.319

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

@@ -1,10 +1,10 @@
 import type { DeviceDemand } from './plan-schemas.js';
 /** How a camera's detection runs. `disabled` cameras charge nothing. */
-export type BestSettingsDetectionMode = 'always-on' | 'on-motion' | 'disabled';
+export type AutoTuneDetectionMode = 'always-on' | 'on-motion' | 'disabled';
 /** One camera's detection load. */
-export interface BestSettingsCameraLoad {
+export interface AutoTuneCameraLoad {
     readonly deviceId: number;
-    readonly mode: BestSettingsDetectionMode;
+    readonly mode: AutoTuneDetectionMode;
     /** Detection frames per second while a session runs. */
     readonly fps: number;
     /** False when only the camera's own (onboard) detector runs — no pipeline root. */
@@ -35,7 +35,7 @@ export interface DemandShares {
     readonly clusterPeak: ObservedClusterPeak | null;
 }
 /** A device the balancer may place a session on. */
-export interface BestSettingsEligibleDevice {
+export interface AutoTuneEligibleDevice {
     readonly nodeId: string;
     readonly deviceKey: string;
     readonly weight: number;
@@ -66,8 +66,8 @@ export declare function estimatedConcurrentSessions(cameraCount: number, options
  * Demand on every eligible device of the cluster.
  */
 export declare function estimateDeviceDemand(input: {
-    readonly cameras: readonly BestSettingsCameraLoad[];
-    readonly eligible: readonly BestSettingsEligibleDevice[];
+    readonly cameras: readonly AutoTuneCameraLoad[];
+    readonly eligible: readonly AutoTuneEligibleDevice[];
     readonly peaks: readonly ObservedDevicePeak[];
     readonly options?: DemandOptions;
     /** Present ⇒ share placement (D748); absent ⇒ least-loaded. */

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/{best-settings → auto-tune}/index.d.ts

@@ -1,5 +1,5 @@
 /**
- * Best settings (D745): the static-hardware × measured-latency × demand
+ * Auto tune (D745): the static-hardware × measured-latency × demand
  * recommender of ONE detector family for the whole cluster, and the shapes of
  * its plan. See `recommend.ts`.
  */

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

@@ -1,5 +1,5 @@
 /**
- * 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
  * schemas are what crosses the cap boundary.
@@ -385,7 +385,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,14 +396,14 @@ 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>>;
 }, 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;
@@ -610,11 +610,11 @@ 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>;
 }, 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 +625,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<{
@@ -867,15 +867,15 @@ 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>;

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

@@ -1,5 +1,5 @@
 /**
- * The Best settings recommender (D745): one detector per node, from ONE family
+ * The Auto tune 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.
  *
@@ -24,30 +24,30 @@ import type { ModelFormat } from '../../types/models.js';
 import { type DetectorPerfTable } from './detector-performance.js';
 import type { DeviceDemand, 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;
 /** 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 node: AutoTuneNodeInput;
     readonly demand: readonly DeviceDemand[];
     readonly headroom?: number;
     readonly perf?: DetectorPerfTable;

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

@@ -0,0 +1,28 @@
+/**
+ * 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,
+ * 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 { EffectiveShares, SessionPlacementPolicy, ShareSource, 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;
+    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,8 @@
 /**
- * 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): the share placement policy for detection
+ * sessions, where its shares come from, and the shapes of its admin surface.
+ * See `share-election.ts` and `effective-shares.ts`.
  */
 export * from './share-election.js';
 export * from './schemas.js';
+export * from './effective-shares.js';

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

@@ -17,10 +17,14 @@ export declare const SessionPlacementPolicySchema: z.ZodEnum<{
     share: "share";
 }>;
 export type SessionPlacementPolicy = z.infer<typeof SessionPlacementPolicySchema>;
+/**
+ * `share` since D750: the percentages are held by default. `least-loaded` stays
+ * selectable.
+ */
 export declare const DEFAULT_SESSION_PLACEMENT_POLICY: SessionPlacementPolicy;
 /** The global-settings key the policy is stored under (orchestrator `load` section). */
 export declare const SESSION_PLACEMENT_SETTING_KEY = "sessionPlacement";
-/** Parse a stored value; anything unknown is the default (nothing changes on deploy). */
+/** Parse a stored value; anything unknown is the default. */
 export declare function parseSessionPlacementPolicy(value: unknown): SessionPlacementPolicy;
 export declare const LoadBalancingSharesInputSchema: z.ZodObject<{
     nodes: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNumber>>;
@@ -144,3 +148,85 @@ export declare const SuggestSharesResultSchema: z.ZodObject<{
     }, z.core.$strip>>>;
 }, z.core.$strip>;
 export type SuggestSharesResult = z.infer<typeof SuggestSharesResultSchema>;
+/**
+ * Where the node and device shares come from (D750).
+ *  - `auto` — computed by the system from the cluster's measured capacity at
+ *    the Auto tune models, and recomputed whenever a node or device joins,
+ *    leaves, is switched on or off, or changes model.
+ *  - `manual` — the operator's stored sliders. A node or device that cannot
+ *    take sessions gives its share to the others in proportion; the stored
+ *    values are never rewritten for that.
+ */
+export declare const ShareSourceSchema: z.ZodEnum<{
+    manual: "manual";
+    auto: "auto";
+}>;
+export type ShareSource = z.infer<typeof ShareSourceSchema>;
+export declare const DEFAULT_SHARE_SOURCE: ShareSource;
+/** Headroom the automatic shares are computed at (Auto tune's default). */
+export declare const AUTO_SHARE_HEADROOM = 0.4;
+/** The global-settings key the share source is stored under (orchestrator `load` section). */
+export declare const SHARE_SOURCE_SETTING_KEY = "shareSource";
+/** Parse a stored value; anything unknown is the default. */
+export declare function parseShareSource(value: unknown): ShareSource;
+export declare const SetShareSourceInputSchema: z.ZodObject<{
+    source: z.ZodEnum<{
+        manual: "manual";
+        auto: "auto";
+    }>;
+}, z.core.$strip>;
+export type SetShareSourceInput = z.infer<typeof SetShareSourceInputSchema>;
+/** Raw relative weights (any scale) per node and per node's device. */
+export declare const ShareWeightsSchema: z.ZodObject<{
+    nodes: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    devices: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodNumber>>;
+}, z.core.$strip>;
+export type ShareWeights = z.infer<typeof ShareWeightsSchema>;
+export declare const EffectiveDeviceShareSchema: z.ZodObject<{
+    deviceKey: z.ZodString;
+    eligible: z.ZodBoolean;
+    configuredPct: z.ZodNumber;
+    effectivePct: z.ZodNumber;
+}, z.core.$strip>;
+export type EffectiveDeviceShare = z.infer<typeof EffectiveDeviceShareSchema>;
+export declare const EffectiveNodeShareSchema: z.ZodObject<{
+    nodeId: z.ZodString;
+    eligible: z.ZodBoolean;
+    configuredPct: z.ZodNumber;
+    effectivePct: z.ZodNumber;
+    devices: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        deviceKey: z.ZodString;
+        eligible: z.ZodBoolean;
+        configuredPct: z.ZodNumber;
+        effectivePct: z.ZodNumber;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type EffectiveNodeShare = z.infer<typeof EffectiveNodeShareSchema>;
+export declare const EffectiveSharesSchema: z.ZodObject<{
+    source: z.ZodEnum<{
+        manual: "manual";
+        auto: "auto";
+    }>;
+    policy: z.ZodEnum<{
+        "least-loaded": "least-loaded";
+        share: "share";
+    }>;
+    autoPending: z.ZodBoolean;
+    computedAt: z.ZodNullable<z.ZodNumber>;
+    trigger: z.ZodNullable<z.ZodString>;
+    nodes: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        nodeId: z.ZodString;
+        eligible: z.ZodBoolean;
+        configuredPct: z.ZodNumber;
+        effectivePct: z.ZodNumber;
+        devices: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            deviceKey: z.ZodString;
+            eligible: z.ZodBoolean;
+            configuredPct: z.ZodNumber;
+            effectivePct: z.ZodNumber;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>>;
+    nodeWeights: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    deviceWeights: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodNumber>>;
+}, z.core.$strip>;
+export type EffectiveShares = z.infer<typeof EffectiveSharesSchema>;

package/dist/pipeline/model-bound-settings.d.ts

@@ -84,6 +84,6 @@ export declare function clearModelBoundOverrides(settings: ModelBoundSettingsBag
 /**
  * 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).
  */
 export declare function collectModelBoundKeys(fields: readonly ConfigField[]): string[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camstack/types",
-  "version": "1.2.318",
+  "version": "1.2.319",
   "description": "Shared types, interfaces, and model catalogs for the CamStack detection ecosystem",
   "keywords": [
     "camstack",