@camstack/types 1.2.318 → 1.2.320

package/dist/addon.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_err_msg = require("./err-msg-Dx2Kor0g.js");
 //#region src/generated/cap-input-defaults.ts
@@ -156,14 +156,23 @@ var CAP_INPUT_DEFAULTS = Object.freeze({
 		"searchObjectEvents": { "limit": 50 }
 	},
 	"pipeline-orchestrator": {
-		"applyBestSettings": { "headroom": .4 },
+		"applyAutoTune": {
+			"headroom": .4,
+			"minSessionsPerDevice": 2
+		},
 		"getPlacementStats": { "windowMs": 36e5 },
-		"planBestSettings": { "headroom": .4 },
+		"planAutoTune": {
+			"headroom": .4,
+			"minSessionsPerDevice": 2
+		},
 		"setLoadBalancingShares": {
 			"nodes": {},
 			"devices": {}
 		},
-		"suggestShares": { "headroom": .4 }
+		"suggestShares": {
+			"headroom": .4,
+			"source": "hardware"
+		}
 	},
 	"pipeline-runner": {
 		"attachCamera": {

package/dist/addon.mjs

@@ -1,4 +1,4 @@
-import { At as normalizeAddonInitResult, B as nodePin, Ct as PEER_BYTES_STALL_MS, D as adminUiCapability, Et as DATAPLANE_SECRET_HEADER, N as expandCapMethods, Ot as DisposerChain, Pt as emitReadiness, S as DEVICE_CHILDREN_BATCH_MAX, St as PEER_BYTES_MAX_OUTSTANDING, T as describeCustomActions, U as ReadinessRegistry, V as readNodePin, W as ReadinessTimeoutError, a as asJsonObject, b as deviceOpsCapability, d as BOOT_RECOVERY_BACKOFF_MS, f as DEVICE_SCOPED_CAPS, h as createEventBusSliceSource, kt as BaseAddon, m as createDeviceProxy, p as isDeviceScopedCap, q as scopeKey, s as asString, t as sleep, u as parseJsonUnknown, wt as PEER_BYTES_TICKET_TTL_MS, x as viewerUiCapability, xt as PEER_BYTES_CHUNK_BYTES } from "./sleep-C16NCZR2.mjs";
+import { At as normalizeAddonInitResult, B as nodePin, Ct as PEER_BYTES_STALL_MS, D as adminUiCapability, Et as DATAPLANE_SECRET_HEADER, N as expandCapMethods, Ot as DisposerChain, Pt as emitReadiness, S as DEVICE_CHILDREN_BATCH_MAX, St as PEER_BYTES_MAX_OUTSTANDING, T as describeCustomActions, U as ReadinessRegistry, V as readNodePin, W as ReadinessTimeoutError, a as asJsonObject, b as deviceOpsCapability, d as BOOT_RECOVERY_BACKOFF_MS, f as DEVICE_SCOPED_CAPS, h as createEventBusSliceSource, kt as BaseAddon, m as createDeviceProxy, p as isDeviceScopedCap, q as scopeKey, s as asString, t as sleep, u as parseJsonUnknown, wt as PEER_BYTES_TICKET_TTL_MS, x as viewerUiCapability, xt as PEER_BYTES_CHUNK_BYTES } from "./sleep-DAJ9Er57.mjs";
 import { t as EventCategory } from "./event-category-BGmz_oxW.mjs";
 import { a as DeviceType, t as errMsg } from "./err-msg-DX6i_MY4.mjs";
 //#region src/generated/cap-input-defaults.ts
@@ -155,14 +155,23 @@ var CAP_INPUT_DEFAULTS = Object.freeze({
 		"searchObjectEvents": { "limit": 50 }
 	},
 	"pipeline-orchestrator": {
-		"applyBestSettings": { "headroom": .4 },
+		"applyAutoTune": {
+			"headroom": .4,
+			"minSessionsPerDevice": 2
+		},
 		"getPlacementStats": { "windowMs": 36e5 },
-		"planBestSettings": { "headroom": .4 },
+		"planAutoTune": {
+			"headroom": .4,
+			"minSessionsPerDevice": 2
+		},
 		"setLoadBalancingShares": {
 			"nodes": {},
 			"devices": {}
 		},
-		"suggestShares": { "headroom": .4 }
+		"suggestShares": {
+			"headroom": .4,
+			"source": "hardware"
+		}
 	},
 	"pipeline-runner": {
 		"attachCamera": {

package/dist/capabilities/pipeline-executor.cap.d.ts

@@ -822,7 +822,7 @@ export declare const pipelineExecutorCapability: {
             clearedDevices: z.ZodNumber;
         }, z.core.$strip>, "mutation">;
         /**
-         * 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

package/dist/capabilities/pipeline-orchestrator.cap.d.ts

@@ -1326,26 +1326,26 @@ export declare const pipelineOrchestratorCapability: {
             clearedCameraOverrides: z.ZodNumber;
         }, z.core.$strip>, "mutation">;
         /**
-         * 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.
          */
-        readonly planBestSettings: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+        readonly planAutoTune: import("./capability-definition.js").CapabilityMethodSchema<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>, 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;
@@ -1372,35 +1372,18 @@ export declare const pipelineOrchestratorCapability: {
                     }>>;
                     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;
@@ -1412,13 +1395,11 @@ export declare const pipelineOrchestratorCapability: {
                         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<{
@@ -1453,8 +1434,9 @@ export declare const pipelineOrchestratorCapability: {
                     }, 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;
@@ -1466,13 +1448,11 @@ export declare const pipelineOrchestratorCapability: {
                     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<{
@@ -1549,14 +1529,15 @@ export declare const pipelineOrchestratorCapability: {
             }, z.core.$strip>], "kind">>>;
         }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
         /**
-         * 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.
          */
-        readonly applyBestSettings: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+        readonly applyAutoTune: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             planHash: z.ZodString;
             headroom: z.ZodDefault<z.ZodNumber>;
+            minSessionsPerDevice: z.ZodDefault<z.ZodNumber>;
         }, z.core.$strip>, z.ZodDiscriminatedUnion<[z.ZodObject<{
             kind: z.ZodLiteral<"applied">;
             planHash: z.ZodString;
@@ -1590,7 +1571,8 @@ export declare const pipelineOrchestratorCapability: {
                 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;
@@ -1617,35 +1599,18 @@ export declare const pipelineOrchestratorCapability: {
                         }>>;
                         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;
@@ -1657,13 +1622,11 @@ export declare const pipelineOrchestratorCapability: {
                             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<{
@@ -1698,8 +1661,9 @@ export declare const pipelineOrchestratorCapability: {
                         }, 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;
@@ -1711,13 +1675,11 @@ export declare const pipelineOrchestratorCapability: {
                         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<{
@@ -1855,17 +1817,27 @@ export declare const pipelineOrchestratorCapability: {
             }, z.core.$strip>>>;
         }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
         /**
-         * 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.
          */
         readonly suggestShares: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             headroom: z.ZodDefault<z.ZodNumber>;
+            source: z.ZodDefault<z.ZodEnum<{
+                hardware: "hardware";
+                benchmark: "benchmark";
+            }>>;
         }, z.core.$strip>, z.ZodObject<{
             headroom: z.ZodNumber;
+            source: z.ZodEnum<{
+                hardware: "hardware";
+                benchmark: "benchmark";
+            }>;
             cameraFps: z.ZodNumber;
-            iterations: z.ZodNumber;
+            minSessionsPerDevice: z.ZodNumber;
             nodes: z.ZodReadonly<z.ZodArray<z.ZodObject<{
                 nodeId: z.ZodString;
                 share: z.ZodNullable<z.ZodNumber>;
@@ -1879,13 +1851,80 @@ export declare const pipelineOrchestratorCapability: {
                     suggestedMaxSessions: z.ZodNullable<z.ZodNumber>;
                 }, z.core.$strip>>>;
                 skippedReason: z.ZodNullable<z.ZodString>;
+                capacitySource: z.ZodNullable<z.ZodEnum<{
+                    hardware: "hardware";
+                    benchmark: "benchmark";
+                }>>;
+                capacityFallback: z.ZodNullable<z.ZodEnum<{
+                    "no-benchmark-results": "no-benchmark-results";
+                    "partial-benchmark-results": "partial-benchmark-results";
+                }>>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
+        /**
+         * 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.
+         */
+        readonly getEffectiveShares: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodObject<{
+            source: z.ZodEnum<{
+                manual: "manual";
+                hardware: "hardware";
+                benchmark: "benchmark";
+            }>;
+            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;
+                capacitySource: z.ZodNullable<z.ZodEnum<{
+                    hardware: "hardware";
+                    benchmark: "benchmark";
+                }>>;
+                capacityFallback: z.ZodNullable<z.ZodEnum<{
+                    "no-benchmark-results": "no-benchmark-results";
+                    "partial-benchmark-results": "partial-benchmark-results";
+                }>>;
+                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>, import("./capability-definition.js").CapabilityMethodKind>;
+        /**
+         * 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.
+         */
+        readonly setShareSource: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            source: z.ZodEnum<{
+                manual: "manual";
+                hardware: "hardware";
+                benchmark: "benchmark";
+            }>;
+        }, z.core.$strip>, z.ZodObject<{
+            success: z.ZodLiteral<true>;
+        }, z.core.$strip>, "mutation">;
         /** Read one camera's settings. Null when never touched (inherits agent defaults fully). */
         readonly getCameraSettings: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             deviceId: z.ZodNumber;
         }, z.core.$strip>, z.ZodNullable<z.ZodObject<{
             stepToggles: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
+            stepSettings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodUnknown>>>>;
             stepOverridesByDevice: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodObject<{
                 modelId: z.ZodOptional<z.ZodString>;
                 settings: z.ZodOptional<z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
@@ -1931,6 +1970,21 @@ export declare const pipelineOrchestratorCapability: {
         }, z.core.$strip>, z.ZodObject<{
             success: z.ZodLiteral<true>;
         }, z.core.$strip>, "mutation">;
+        /**
+         * 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.
+         */
+        readonly setCameraStepSettings: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            addonId: z.ZodString;
+            settings: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>, z.ZodObject<{
+            success: z.ZodLiteral<true>;
+        }, z.core.$strip>, "mutation">;
         /** Write or clear the wholesale per-agent pipeline override. Pass `pipeline: null` to drop the override. */
         readonly setCameraPipelineForAgent: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             deviceId: z.ZodNumber;

package/dist/client.js

@@ -6082,6 +6082,7 @@ function createDeviceProxy(api, binding, opts) {
 		setCameraStepToggle: (input) => dispatchSystem("pipelineOrchestrator", "setCameraStepToggle", "mutation", input),
 		getCameraStepOverrides: (input) => dispatchSystem("pipelineOrchestrator", "getCameraStepOverrides", "query", input),
 		setCameraStepOverride: (input) => dispatchSystem("pipelineOrchestrator", "setCameraStepOverride", "mutation", input),
+		setCameraStepSettings: (input) => dispatchSystem("pipelineOrchestrator", "setCameraStepSettings", "mutation", input),
 		setCameraPipelineForAgent: (input) => dispatchSystem("pipelineOrchestrator", "setCameraPipelineForAgent", "mutation", input),
 		resolvePipeline: (input) => dispatchSystem("pipelineOrchestrator", "resolvePipeline", "query", input),
 		getCameraSwitches: (input) => dispatchSystem("pipelineOrchestrator", "getCameraSwitches", "query", input),
@@ -7499,11 +7500,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),

package/dist/client.mjs

@@ -6081,6 +6081,7 @@ function createDeviceProxy(api, binding, opts) {
 		setCameraStepToggle: (input) => dispatchSystem("pipelineOrchestrator", "setCameraStepToggle", "mutation", input),
 		getCameraStepOverrides: (input) => dispatchSystem("pipelineOrchestrator", "getCameraStepOverrides", "query", input),
 		setCameraStepOverride: (input) => dispatchSystem("pipelineOrchestrator", "setCameraStepOverride", "mutation", input),
+		setCameraStepSettings: (input) => dispatchSystem("pipelineOrchestrator", "setCameraStepSettings", "mutation", input),
 		setCameraPipelineForAgent: (input) => dispatchSystem("pipelineOrchestrator", "setCameraPipelineForAgent", "mutation", input),
 		resolvePipeline: (input) => dispatchSystem("pipelineOrchestrator", "resolvePipeline", "query", input),
 		getCameraSwitches: (input) => dispatchSystem("pipelineOrchestrator", "getCameraSwitches", "query", input),
@@ -7498,11 +7499,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),

package/dist/generated/addon-api.d.ts

@@ -6595,18 +6595,18 @@ export type AppRouter = TrpcCoreRouter<{
             output: z.infer<typeof pipelineOrchestratorCapability.methods.resetNodePipelineDefaults.output>;
             meta: object;
         }>;
-        planBestSettings: TRPCQueryProcedure<{
+        planAutoTune: TRPCQueryProcedure<{
             input: {
                 [x: string]: unknown;
-            } & z.input<typeof pipelineOrchestratorCapability.methods.planBestSettings.input>;
-            output: z.infer<typeof pipelineOrchestratorCapability.methods.planBestSettings.output>;
+            } & z.input<typeof pipelineOrchestratorCapability.methods.planAutoTune.input>;
+            output: z.infer<typeof pipelineOrchestratorCapability.methods.planAutoTune.output>;
             meta: object;
         }>;
-        applyBestSettings: TRPCMutationProcedure<{
+        applyAutoTune: TRPCMutationProcedure<{
             input: {
                 [x: string]: unknown;
-            } & z.input<typeof pipelineOrchestratorCapability.methods.applyBestSettings.input>;
-            output: z.infer<typeof pipelineOrchestratorCapability.methods.applyBestSettings.output>;
+            } & z.input<typeof pipelineOrchestratorCapability.methods.applyAutoTune.input>;
+            output: z.infer<typeof pipelineOrchestratorCapability.methods.applyAutoTune.output>;
             meta: object;
         }>;
         setLoadBalancingShares: TRPCMutationProcedure<{
@@ -6630,6 +6630,20 @@ export type AppRouter = TrpcCoreRouter<{
             output: z.infer<typeof pipelineOrchestratorCapability.methods.suggestShares.output>;
             meta: object;
         }>;
+        getEffectiveShares: TRPCQueryProcedure<{
+            input: {
+                nodeId?: string | undefined;
+            } | undefined;
+            output: z.infer<typeof pipelineOrchestratorCapability.methods.getEffectiveShares.output>;
+            meta: object;
+        }>;
+        setShareSource: TRPCMutationProcedure<{
+            input: {
+                [x: string]: unknown;
+            } & z.input<typeof pipelineOrchestratorCapability.methods.setShareSource.input>;
+            output: z.infer<typeof pipelineOrchestratorCapability.methods.setShareSource.output>;
+            meta: object;
+        }>;
         getCameraSettings: TRPCQueryProcedure<{
             input: {
                 [x: string]: unknown;
@@ -6658,6 +6672,13 @@ export type AppRouter = TrpcCoreRouter<{
             output: z.infer<typeof pipelineOrchestratorCapability.methods.setCameraStepOverride.output>;
             meta: object;
         }>;
+        setCameraStepSettings: TRPCMutationProcedure<{
+            input: {
+                [x: string]: unknown;
+            } & z.input<typeof pipelineOrchestratorCapability.methods.setCameraStepSettings.input>;
+            output: z.infer<typeof pipelineOrchestratorCapability.methods.setCameraStepSettings.output>;
+            meta: object;
+        }>;
         setCameraPipelineForAgent: TRPCMutationProcedure<{
             input: {
                 [x: string]: unknown;

package/dist/generated/device-proxy.d.ts

@@ -300,7 +300,7 @@ export interface DeviceProxy {
     readonly notificationRules: Pick<InferDeviceProxyCap<typeof notificationRulesCapability>, 'setDeviceMuted'>;
     readonly osdManager: Pick<InferDeviceProxyCap<typeof osdManagerCapability>, 'getDeviceOsd' | 'getSourceCatalog' | 'setSlotBinding' | 'clearSlotBinding' | 'previewSlot' | 'renderDevice'>;
     readonly pipelineExecutor: Pick<InferDeviceProxyCap<typeof pipelineExecutorCapability>, 'runPipeline' | 'runPipelineBatch'>;
-    readonly pipelineOrchestrator: Pick<InferDeviceProxyCap<typeof pipelineOrchestratorCapability>, 'assignPipeline' | 'unassignPipeline' | 'setPipelineDevicePin' | 'getPipelineDevicePin' | 'getPipelineAssignment' | 'getCameraMetrics' | 'assignAudio' | 'unassignAudio' | 'getAudioAssignment' | 'getCameraSettings' | 'setCameraStepToggle' | 'getCameraStepOverrides' | 'setCameraStepOverride' | 'setCameraPipelineForAgent' | 'resolvePipeline' | 'getCameraSwitches' | 'setCameraSwitch' | 'getCameraStatus' | 'getDeviceSettingsContribution' | 'getDeviceLiveContribution' | 'applyDeviceSettingsPatch'>;
+    readonly pipelineOrchestrator: Pick<InferDeviceProxyCap<typeof pipelineOrchestratorCapability>, 'assignPipeline' | 'unassignPipeline' | 'setPipelineDevicePin' | 'getPipelineDevicePin' | 'getPipelineAssignment' | 'getCameraMetrics' | 'assignAudio' | 'unassignAudio' | 'getAudioAssignment' | 'getCameraSettings' | 'setCameraStepToggle' | 'getCameraStepOverrides' | 'setCameraStepOverride' | 'setCameraStepSettings' | 'setCameraPipelineForAgent' | 'resolvePipeline' | 'getCameraSwitches' | 'setCameraSwitch' | 'getCameraStatus' | 'getDeviceSettingsContribution' | 'getDeviceLiveContribution' | 'applyDeviceSettingsPatch'>;
     readonly pipelineRunner: Pick<InferDeviceProxyCap<typeof pipelineRunnerCapability>, 'detachCamera' | 'getCameraMetrics' | 'requestOccupancyBurst' | 'runDetailSubtree' | 'parkTrackFrame' | 'getParkedTrackFrame' | 'releaseParkedTrackFrames'>;
     readonly plateGallery: Pick<InferDeviceProxyCap<typeof plateGalleryCapability>, 'listPlates' | 'getPlateByTrack'>;
     readonly recordingArchive: Pick<InferDeviceProxyCap<typeof recordingArchiveCapability>, 'getDeviceConfig' | 'locateSegment' | 'readSegmentBytes' | 'readGopBytes' | 'readWindowBytes' | 'setDeviceConfig' | 'rescanStorage' | 'pruneFootage' | 'deleteFootprint' | 'renderGif' | 'renderClip' | 'getStatus' | 'getDeviceSettingsContribution' | 'getDeviceLiveContribution' | 'applyDeviceSettingsPatch'>;

package/dist/generated/method-access-map.d.ts

@@ -6,7 +6,7 @@
  * scope+access check inside `protectedProcedure` (see
  * `server/backend/src/api/trpc/trpc.middleware.ts`).
  *
- * Coverage: 1232 method paths across 165 capabilities.
+ * Coverage: 1235 method paths across 165 capabilities.
  */
 import type { CapabilityMethodAccess } from '../capabilities/capability-definition.js';
 export interface MethodAccessRecord {

package/dist/generated/method-device-selectors.d.ts

@@ -6,8 +6,8 @@
  * system-scope cap that takes a deviceId was previously never device-filtered
  * — see the generator header).
  *
- * Coverage: 511 methods carry a device reference, of which
- * 161 are on SYSTEM-scope caps.
+ * Coverage: 512 methods carry a device reference, of which
+ * 162 are on SYSTEM-scope caps.
  *
  * Top-level fields, number arrays, and one-level arrays of objects carrying
  * a numeric device field (targets[].deviceId) are all mapped; the matcher

package/dist/generated/system-proxy.d.ts

@@ -88,7 +88,7 @@ export interface SystemProxy {
     readonly notificationRules: Pick<InferProvider<typeof notificationRulesCapability>, 'listRules' | 'getRule' | 'createRule' | 'updateRule' | 'deleteRule' | 'setRuleEnabled' | 'listSequences' | 'getSequence' | 'createSequence' | 'updateSequence' | 'deleteSequence' | 'getClipRetentionAsks' | 'listDeviceMutes' | 'testRule' | 'previewStateSummary' | 'getConditionCatalog' | 'getTemplateCatalog' | 'previewTemplate' | 'getHistory' | 'getRuleLastRuns' | 'resolveArtifactUrl' | 'listSnoozes' | 'createSnooze' | 'cancelSnooze' | 'getAlarmConfig' | 'setAlarmConfig' | 'createAlarmProfile' | 'renameAlarmProfile' | 'deleteAlarmProfile' | 'activateAlarmProfile' | 'getAlarmSensors'>;
     readonly osdManager: Pick<InferProvider<typeof osdManagerCapability>, 'getConditionSupport' | 'copyDeviceConfiguration' | 'listTemplates' | 'upsertTemplate' | 'deleteTemplate'>;
     readonly pipelineExecutor: Pick<InferProvider<typeof pipelineExecutorCapability>, 'getAvailableEngines' | 'getSelectedEngine' | 'getDefaultSteps' | 'getEngineProvisioning' | 'getVideoPipelineSteps' | 'setVideoPipelineSteps' | 'clearDeviceOverrides' | 'clearModelBoundDeviceOverrides' | 'getInferenceDeviceHealth' | 'rearmInferenceDevice' | 'getSchema' | 'getGlobalSteps' | 'getGlobalPipelineConfig' | 'getOrchestratorConfigSchema' | 'validatePipeline' | 'listTemplates' | 'saveTemplate' | 'updateTemplate' | 'deleteTemplate' | 'getCapabilities' | 'getAddonModels' | 'downloadModel' | 'deleteModel' | 'cacheFrameInPool' | 'inferCached' | 'uncacheFrame' | 'getEffectiveTuning' | 'listLoadedEngines' | 'spinEngine' | 'killEngine' | 'listReferenceImages' | 'getReferenceImage' | 'getReferenceAudioFiles' | 'getReferenceAudio' | 'getAudioCapabilities' | 'runAudioTest' | 'getDetectionConfigSchema'>;
-    readonly pipelineOrchestrator: Pick<InferProvider<typeof pipelineOrchestratorCapability>, 'requestOccupancyLook' | 'pauseForStorageMigration' | 'resumeForStorageMigration' | 'rebalance' | 'getPipelineAssignments' | 'getAgentLoad' | 'getClusterModelChoice' | 'getGlobalMetrics' | 'getCapabilityBindings' | 'setCapabilityBinding' | 'getIngestOwner' | 'getAudioNodeLoad' | 'getAudioAssignments' | 'getAgentSettings' | 'listAgentSettings' | 'removeAgentSettings' | 'setAgentMaxCameras' | 'setAgentCapabilities' | 'setAgentDecodeLimits' | 'setAgentReachableHost' | 'setAgentInferenceDevices' | 'getNodeInferenceDevices' | 'resetNodePipelineDefaults' | 'planBestSettings' | 'applyBestSettings' | 'setLoadBalancingShares' | 'getPlacementStats' | 'suggestShares' | 'getCameraStatuses' | 'setCameraSensors' | 'reconcileFromDisk' | 'getReconcileFromDiskStatus' | 'listTemplates' | 'saveTemplate' | 'updateTemplate' | 'deleteTemplate'>;
+    readonly pipelineOrchestrator: Pick<InferProvider<typeof pipelineOrchestratorCapability>, 'requestOccupancyLook' | 'pauseForStorageMigration' | 'resumeForStorageMigration' | 'rebalance' | 'getPipelineAssignments' | 'getAgentLoad' | 'getClusterModelChoice' | 'getGlobalMetrics' | 'getCapabilityBindings' | 'setCapabilityBinding' | 'getIngestOwner' | 'getAudioNodeLoad' | 'getAudioAssignments' | 'getAgentSettings' | 'listAgentSettings' | 'removeAgentSettings' | 'setAgentMaxCameras' | 'setAgentCapabilities' | 'setAgentDecodeLimits' | 'setAgentReachableHost' | 'setAgentInferenceDevices' | 'getNodeInferenceDevices' | 'resetNodePipelineDefaults' | 'planAutoTune' | 'applyAutoTune' | 'setLoadBalancingShares' | 'getPlacementStats' | 'suggestShares' | 'getEffectiveShares' | 'setShareSource' | 'getCameraStatuses' | 'setCameraSensors' | 'reconcileFromDisk' | 'getReconcileFromDiskStatus' | 'listTemplates' | 'saveTemplate' | 'updateTemplate' | 'deleteTemplate'>;
     readonly pipelineRunner: Pick<InferProvider<typeof pipelineRunnerCapability>, 'attachCamera' | 'reportMotion' | 'getLocalLoad' | 'getLocalMetrics' | 'getAllCameraMetrics' | 'getLocalCameras' | 'getNativeCrop' | 'runStatelessStep'>;
     readonly plateGallery: Pick<InferProvider<typeof plateGalleryCapability>, 'getPlateMedia' | 'searchPlates' | 'suggestPlateClusters' | 'correctPlateText' | 'deletePlate' | 'listVehicles' | 'createVehicle' | 'renameVehicle' | 'deleteVehicle' | 'listVehicleSamples' | 'removeVehicleSample' | 'assignPlate' | 'unassignPlate' | 'assignPlates' | 'unassignPlates'>;
     readonly recordingArchive: Pick<InferProvider<typeof recordingArchiveCapability>, 'getAvailabilityBatch' | 'getDaysWithRecordingsBatch' | 'getStorageUsage' | 'listOpsLog' | 'pauseForStorageMigration' | 'resumeForStorageMigration' | 'refreshStorageLocationsForMigration' | 'startStorageMigrationMove' | 'getStorageMigrationMoveStatus' | 'cancelStorageMigrationMove' | 'relocateFootage' | 'listRelocateJobs' | 'getRelocateResidue' | 'reconcileLedgerAgainstDisk' | 'cancelRelocateJob' | 'planStorageRebalance' | 'startStorageRebalance' | 'getPlacement' | 'setDevicePlacement'>;

package/dist/index.d.ts

@@ -268,7 +268,8 @@ export { type ProviderMotionData, ProviderMotionDataSchema, providerMotionEvent,
 export { type FormatRunnableModel, stepModelRunsOnFormat, } from './pipeline/step-format-runnable.js';
 export { isRemovedModelId, REMOVED_MODEL_IDS } from './pipeline/removed-model-ids.js';
 export { applyModelBoundSettings, clearModelBoundOverrides, clearModelBoundSetting, collectModelBoundKeys, hasModelBoundOverrides, type InapplicableModelBoundOverride, modelBindingKey, type ModelBoundSettingsBag, type ModelBoundSettingSource, type ModelBoundSettingState, resolveModelBoundSetting, writeModelBoundSetting, } from './pipeline/model-bound-settings.js';
-export * from './pipeline/best-settings/index.js';
+export { diffStepSettings, effectiveStepSettings, fieldsPinnedAtValueBelow, fieldUnitKeys, mergeSettingsBags, settingsBelow, settingValuesEqual, type StepSettingSource, type StepSettingsBag, type StepSettingsLayers, stepSettingSource, withFieldFrom, withoutField, } from './pipeline/step-settings-layers.js';
+export * from './pipeline/auto-tune/index.js';
 export * from './pipeline/load-balancing/index.js';
 export { deriveRootFaceRefineRect, ROOT_FACE_REFINE_INPUT_PX, ROOT_FACE_REFINE_SCALE, } from './pipeline/root-face-crop.js';
 export { DEFAULT_DETAIL_CROP_CONVENTION, DETAIL_CROP_PADDING_FIELD, DETAIL_CROP_PADDING_KEY, DETAIL_CROP_SECTION_ID, DETAIL_CROP_SQUARE_KEY, type DetailCropConvention, DetailCropConventionSchema, type DetailCropRect, deriveDetailCropRect, FULL_IMAGE_BBOX, type HydratedSettingsSection, type HydratedSettingsView, pickDetailCropConvention, readDetailCropConvention, } from './pipeline/detail-crop.js';