@camstack/addon-model-studio 1.1.209 → 1.1.211

package/dist/model-studio.addon.js

@@ -24293,7 +24293,143 @@ method(_void(), array(PipelineEngineChoiceSchema)), method(_void(), PipelineEngi
 	settings: record(string(), unknown()).optional()
 }), AudioTestResultSchema, { kind: "mutation" }), method(_void(), ConfigUISchemaNullableBridge);
 /**
-* The wire shapes of the Best settings plan and apply (D745), used by the
+* Wire shapes of the Load balancing surface (D748): the session placement
+* policy, the atomic share write, the observed placement statistics, the
+* hardware share suggestion and the stale device pins.
+*/
+/**
+* How a new detection session picks its node and device.
+*  - `least-loaded` — the historical rule: lowest `attached / weight`, a
+*    constant node order at a tie (D37). An idle node always ties at 0, so a
+*    weight only bites once a node already holds a session.
+*  - `share` — the share of PARALLEL sessions is held to the weights, and a
+*    full or drowning node yields to a free one (D748).
+*/
+var SessionPlacementPolicySchema = _enum(["least-loaded", "share"]);
+var LoadBalancingSharesInputSchema = object({
+	/** nodeId → share (> 0). A node left out keeps its weight. */
+	nodes: record(string(), number().positive()).default({}),
+	/** nodeId → deviceKey → share (> 0). A device left out keeps its weight. */
+	devices: record(string(), record(string(), number().positive())).default({})
+});
+var PlacementStatsInputSchema = object({ 
+/** Window the observed shares are averaged over (default 1 h, max 24 h). */
+windowMs: number().int().min(6e4).max(1440 * 60 * 1e3).default(3600 * 1e3) });
+var PlacementDeviceStatsSchema = object({
+	deviceKey: string(),
+	/** Sessions running on this device now. */
+	sessionsNow: number(),
+	/** Sessions started on this device inside the window. */
+	sessionsStarted: number(),
+	/** Time-weighted share of the node's parallel sessions over the window (0–1); null = no session ran. */
+	observedShare: number().nullable()
+});
+var PlacementNodeStatsSchema = object({
+	nodeId: string(),
+	sessionsNow: number(),
+	sessionsStarted: number(),
+	/** Time-weighted share of the cluster's parallel sessions over the window (0–1); null = none ran. */
+	observedShare: number().nullable(),
+	/** Most sessions this node ran at once inside the window. */
+	peakSessions: number(),
+	/** Sessions a share election handed elsewhere because this node was full or drowning. */
+	yieldsAway: number(),
+	devices: array(PlacementDeviceStatsSchema).readonly()
+});
+/** A camera's device pin that the session path cannot honour. */
+var StaleDevicePinSchema = object({
+	deviceId: number(),
+	deviceKey: string(),
+	/** `disabled` — the key exists on some node but is not enabled anywhere; `absent` — no node has it. */
+	reason: _enum(["disabled", "absent"])
+});
+var PlacementStatsSchema = object({
+	policy: SessionPlacementPolicySchema,
+	windowMs: number(),
+	/** How much of the window was actually observed (the hub keeps it in memory). */
+	observedForMs: number(),
+	sessionsNow: number(),
+	/** Most parallel sessions across the cluster inside the window. */
+	clusterPeakSessions: number(),
+	nodes: array(PlacementNodeStatsSchema).readonly(),
+	stalePins: array(StaleDevicePinSchema).readonly()
+});
+var SuggestSharesInputSchema = object({ headroom: number().min(.3).max(.5).default(.4) });
+var SuggestedDeviceShareSchema = object({
+	deviceKey: string(),
+	/** Share of the node (0–100, rounded). */
+	share: number(),
+	modelId: string().nullable(),
+	/** Inferences per second at that model, from the measured table. */
+	fps: number().nullable(),
+	measured: boolean(),
+	/** Advisory session cap: ⌊fps × (1 − headroom) / camera fps⌋. Never enforced. */
+	suggestedMaxSessions: number().nullable()
+});
+var SuggestedNodeShareSchema = object({
+	nodeId: string(),
+	/** Share of the cluster (0–100, rounded); null = node skipped (offline, unknown hardware). */
+	share: number().nullable(),
+	/** Parallel sessions the node sustains at the suggested models with the headroom kept free. */
+	capacitySessions: number(),
+	devices: array(SuggestedDeviceShareSchema).readonly(),
+	skippedReason: string().nullable()
+});
+var SuggestSharesResultSchema = object({
+	headroom: number(),
+	/** Camera detection rate the capacity is counted in (the fastest camera's fps). */
+	cameraFps: number(),
+	/** How many share → model → capacity rounds ran before the shares stopped moving (≤ 3). */
+	iterations: number(),
+	nodes: array(SuggestedNodeShareSchema).readonly()
+});
+/**
+* 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.
+*/
+var ShareSourceSchema = _enum(["auto", "manual"]);
+var SetShareSourceInputSchema = object({ source: ShareSourceSchema });
+object({
+	nodes: record(string(), number()),
+	devices: record(string(), record(string(), number()))
+});
+var EffectiveDeviceShareSchema = object({
+	deviceKey: string(),
+	/** Can take sessions now (enabled, available, can run the root). */
+	eligible: boolean(),
+	/** The share the source assigns, as a percentage of the node's devices. */
+	configuredPct: number(),
+	/** The share actually used, after an ineligible device's share went to the others. */
+	effectivePct: number()
+});
+var EffectiveNodeShareSchema = object({
+	nodeId: string(),
+	eligible: boolean(),
+	configuredPct: number(),
+	effectivePct: number(),
+	devices: array(EffectiveDeviceShareSchema).readonly()
+});
+var EffectiveSharesSchema = object({
+	source: ShareSourceSchema,
+	policy: SessionPlacementPolicySchema,
+	/** `auto` with no computed answer yet: the stored sliders are used meanwhile. */
+	autoPending: boolean(),
+	/** When the automatic shares were last computed (ms epoch); null = never. */
+	computedAt: number().nullable(),
+	/** What made the system recompute them last. */
+	trigger: string().nullable(),
+	nodes: array(EffectiveNodeShareSchema).readonly(),
+	/** The relative weights the election reads (before eligibility). */
+	nodeWeights: record(string(), number()),
+	deviceWeights: record(string(), record(string(), number()))
+});
+/**
+* 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.
@@ -24369,7 +24505,9 @@ var DeviceDemandSchema = object({
 		"estimate",
 		"none"
 	]),
-	observedForMs: number().nullable()
+	observedForMs: number().nullable(),
+	/** How on-motion sessions were charged: per-device observation, or split by share (D748). */
+	placement: SessionPlacementPolicySchema
 });
 var DeviceModelChoiceSchema = object({
 	modelId: string(),
@@ -24426,7 +24564,7 @@ var DetectorStoreClearSchema = object({
 	deviceId: number(),
 	keys: array(string()).readonly()
 });
-var BestSettingsWarningSchema = discriminatedUnion("kind", [
+var AutoTuneWarningSchema = discriminatedUnion("kind", [
 	object({
 		kind: literal("detector-store-cluster-wide"),
 		skippedNodes: array(string()).readonly()
@@ -24441,26 +24579,36 @@ var BestSettingsWarningSchema = discriminatedUnion("kind", [
 		deviceKey: string()
 	})
 ]);
-var BestSettingsOptionsSchema = object({ 
-/** Share of each accelerator's throughput kept free (0.3–0.5). */
-headroom: number().min(.3).max(.5).default(.4) });
-var BestSettingsPlanSchema = object({
+var AutoTuneOptionsSchema = object({
+	/** Share of each accelerator's throughput kept free (0.3–0.5). */
+	headroom: number().min(.3).max(.5).default(.4),
+	/**
+	* What-if shares (D748): plan as if these node/device shares were stored
+	* and the policy were `share`. Absent = the stored shares under the stored
+	* policy. A what-if plan is for display; apply always re-plans from what
+	* is stored.
+	*/
+	shares: LoadBalancingSharesInputSchema.optional()
+});
+var AutoTunePlanSchema = object({
 	/** Hash of everything the apply will write — the apply refuses a different one. */
 	planHash: string(),
 	family: literal("yolov9"),
 	headroom: number(),
+	/** Planned under what-if shares (D748): for display — apply refuses it as stale. */
+	whatIf: boolean(),
 	generatedAt: number(),
 	nodes: array(NodeRecommendationSchema).readonly(),
 	nodeChanges: array(NodeDeviceChangeSchema).readonly(),
 	cameraClears: array(CameraOverrideClearSchema).readonly(),
 	detectorStoreClears: array(DetectorStoreClearSchema).readonly(),
-	warnings: array(BestSettingsWarningSchema).readonly()
+	warnings: array(AutoTuneWarningSchema).readonly()
 });
-var BestSettingsApplyInputSchema = object({
+var AutoTuneApplyInputSchema = object({
 	planHash: string(),
 	headroom: number().min(.3).max(.5).default(.4)
 });
-var BestSettingsPhaseResultSchema = object({
+var AutoTunePhaseResultSchema = object({
 	phase: _enum([
 		"download",
 		"camera-overrides",
@@ -24471,19 +24619,19 @@ var BestSettingsPhaseResultSchema = object({
 	ok: boolean(),
 	detail: string()
 });
-var BestSettingsApplyResultSchema = discriminatedUnion("kind", [
+var AutoTuneApplyResultSchema = discriminatedUnion("kind", [
 	object({
 		kind: literal("applied"),
 		planHash: string(),
-		phases: array(BestSettingsPhaseResultSchema).readonly()
+		phases: array(AutoTunePhaseResultSchema).readonly()
 	}),
 	object({
 		kind: literal("aborted"),
-		phases: array(BestSettingsPhaseResultSchema).readonly()
+		phases: array(AutoTunePhaseResultSchema).readonly()
 	}),
 	object({
 		kind: literal("stale"),
-		plan: BestSettingsPlanSchema
+		plan: AutoTunePlanSchema
 	}),
 	object({
 		kind: literal("refused"),
@@ -25670,7 +25818,6 @@ var CameraStepOverridePatchSchema = object({
 	settings: record(string(), unknown()).readonly().optional()
 });
 var CameraPipelineSettingsSchema = object({
-	pinnedAgentNodeId: string().optional(),
 	stepToggles: record(string(), boolean()).optional(),
 	stepOverridesByDevice: record(string(), record(string(), record(string(), CameraStepOverridePatchSchema))).optional(),
 	pipelineByAgent: record(string(), CameraPipelineForAgentSchema).optional()
@@ -26169,12 +26316,6 @@ method(object({
 }), object({ success: literal(true) }), {
 	kind: "mutation",
 	auth: "admin"
-}), method(object({
-	agentNodeId: string(),
-	detectWeight: number().positive().nullable()
-}), object({ success: literal(true) }), {
-	kind: "mutation",
-	auth: "admin"
 }), method(object({
 	agentNodeId: string(),
 	detect: boolean().nullable().optional(),
@@ -26216,7 +26357,13 @@ method(object({
 }), {
 	kind: "mutation",
 	auth: "admin"
-}), method(BestSettingsOptionsSchema, BestSettingsPlanSchema, { auth: "admin" }), method(BestSettingsApplyInputSchema, BestSettingsApplyResultSchema, {
+}), method(AutoTuneOptionsSchema, AutoTunePlanSchema, { auth: "admin" }), method(AutoTuneApplyInputSchema, AutoTuneApplyResultSchema, {
+	kind: "mutation",
+	auth: "admin"
+}), method(LoadBalancingSharesInputSchema, object({ success: literal(true) }), {
+	kind: "mutation",
+	auth: "admin"
+}), method(PlacementStatsInputSchema, PlacementStatsSchema, { auth: "admin" }), method(SuggestSharesInputSchema, SuggestSharesResultSchema, { auth: "admin" }), method(_void(), EffectiveSharesSchema, { auth: "admin" }), method(SetShareSourceInputSchema, object({ success: literal(true) }), {
 	kind: "mutation",
 	auth: "admin"
 }), method(object({ deviceId: number() }), CameraPipelineSettingsSchema.nullable()), method(object({
@@ -42114,7 +42261,7 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
-	"pipelineOrchestrator.applyBestSettings": {
+	"pipelineOrchestrator.applyAutoTune": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
 		addonId: null,
@@ -42234,6 +42381,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"pipelineOrchestrator.getEffectiveShares": {
+		capName: "pipeline-orchestrator",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"pipelineOrchestrator.getGlobalMetrics": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
@@ -42270,6 +42423,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"pipelineOrchestrator.getPlacementStats": {
+		capName: "pipeline-orchestrator",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"pipelineOrchestrator.getReconcileFromDiskStatus": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
@@ -42294,7 +42453,7 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
-	"pipelineOrchestrator.planBestSettings": {
+	"pipelineOrchestrator.planAutoTune": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
 		addonId: null,
@@ -42360,12 +42519,6 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
-	"pipelineOrchestrator.setAgentDetectWeight": {
-		capName: "pipeline-orchestrator",
-		capScope: "system",
-		addonId: null,
-		access: "create"
-	},
 	"pipelineOrchestrator.setAgentInferenceDevices": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
@@ -42420,12 +42573,30 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"pipelineOrchestrator.setLoadBalancingShares": {
+		capName: "pipeline-orchestrator",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"pipelineOrchestrator.setPipelineDevicePin": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
 		addonId: null,
 		access: "create"
 	},
+	"pipelineOrchestrator.setShareSource": {
+		capName: "pipeline-orchestrator",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"pipelineOrchestrator.suggestShares": {
+		capName: "pipeline-orchestrator",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"pipelineOrchestrator.unassignAudio": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",