@camstack/types 1.2.327 → 1.2.328

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

@@ -1318,9 +1318,19 @@ export declare const pipelineOrchestratorCapability: {
                         p50Ms: z.ZodNumber;
                         fps: z.ZodNumber;
                         measured: z.ZodBoolean;
+                        source: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                            kind: z.ZodLiteral<"table">;
+                        }, z.core.$strip>, z.ZodObject<{
+                            kind: z.ZodLiteral<"node-benchmark">;
+                            resultId: z.ZodString;
+                            measuredAtMs: z.ZodNumber;
+                        }, z.core.$strip>], "kind">>;
                         capacitySessions: z.ZodNumber;
                         personRecall: z.ZodNumber;
                     }, z.core.$strip>>;
+                    kept: z.ZodOptional<z.ZodEnum<{
+                        "custom-pin": "custom-pin";
+                    }>>;
                     reasons: z.ZodReadonly<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
                         kind: z.ZodLiteral<"capacity">;
                         sessions: z.ZodNumber;
@@ -1372,6 +1382,10 @@ export declare const pipelineOrchestratorCapability: {
                             pt: "pt";
                             gguf: "gguf";
                         }>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        kind: z.ZodLiteral<"kept-custom-pin">;
+                        modelId: z.ZodString;
+                        deviceKey: z.ZodString;
                     }, z.core.$strip>], "kind">>>;
                 }, z.core.$strip>>>;
                 reasons: z.ZodReadonly<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
@@ -1425,6 +1439,10 @@ export declare const pipelineOrchestratorCapability: {
                         pt: "pt";
                         gguf: "gguf";
                     }>;
+                }, z.core.$strip>, z.ZodObject<{
+                    kind: z.ZodLiteral<"kept-custom-pin">;
+                    modelId: z.ZodString;
+                    deviceKey: z.ZodString;
                 }, z.core.$strip>], "kind">>>;
             }, z.core.$strip>>>;
             nodeChanges: z.ZodReadonly<z.ZodArray<z.ZodObject<{
@@ -1467,6 +1485,15 @@ export declare const pipelineOrchestratorCapability: {
                 kind: z.ZodLiteral<"coral-enabled">;
                 nodeId: z.ZodString;
                 deviceKey: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"custom-pin-kept">;
+                nodeId: z.ZodString;
+                deviceKey: z.ZodNullable<z.ZodString>;
+                deviceId: z.ZodNullable<z.ZodNumber>;
+                modelId: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"custom-registry-unreadable">;
+                error: z.ZodString;
             }, z.core.$strip>], "kind">>>;
         }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
         /**
@@ -1545,9 +1572,19 @@ export declare const pipelineOrchestratorCapability: {
                             p50Ms: z.ZodNumber;
                             fps: z.ZodNumber;
                             measured: z.ZodBoolean;
+                            source: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                                kind: z.ZodLiteral<"table">;
+                            }, z.core.$strip>, z.ZodObject<{
+                                kind: z.ZodLiteral<"node-benchmark">;
+                                resultId: z.ZodString;
+                                measuredAtMs: z.ZodNumber;
+                            }, z.core.$strip>], "kind">>;
                             capacitySessions: z.ZodNumber;
                             personRecall: z.ZodNumber;
                         }, z.core.$strip>>;
+                        kept: z.ZodOptional<z.ZodEnum<{
+                            "custom-pin": "custom-pin";
+                        }>>;
                         reasons: z.ZodReadonly<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
                             kind: z.ZodLiteral<"capacity">;
                             sessions: z.ZodNumber;
@@ -1599,6 +1636,10 @@ export declare const pipelineOrchestratorCapability: {
                                 pt: "pt";
                                 gguf: "gguf";
                             }>;
+                        }, z.core.$strip>, z.ZodObject<{
+                            kind: z.ZodLiteral<"kept-custom-pin">;
+                            modelId: z.ZodString;
+                            deviceKey: z.ZodString;
                         }, z.core.$strip>], "kind">>>;
                     }, z.core.$strip>>>;
                     reasons: z.ZodReadonly<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
@@ -1652,6 +1693,10 @@ export declare const pipelineOrchestratorCapability: {
                             pt: "pt";
                             gguf: "gguf";
                         }>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        kind: z.ZodLiteral<"kept-custom-pin">;
+                        modelId: z.ZodString;
+                        deviceKey: z.ZodString;
                     }, z.core.$strip>], "kind">>>;
                 }, z.core.$strip>>>;
                 nodeChanges: z.ZodReadonly<z.ZodArray<z.ZodObject<{
@@ -1694,6 +1739,15 @@ export declare const pipelineOrchestratorCapability: {
                     kind: z.ZodLiteral<"coral-enabled">;
                     nodeId: z.ZodString;
                     deviceKey: z.ZodString;
+                }, z.core.$strip>, z.ZodObject<{
+                    kind: z.ZodLiteral<"custom-pin-kept">;
+                    nodeId: z.ZodString;
+                    deviceKey: z.ZodNullable<z.ZodString>;
+                    deviceId: z.ZodNullable<z.ZodNumber>;
+                    modelId: z.ZodString;
+                }, z.core.$strip>, z.ZodObject<{
+                    kind: z.ZodLiteral<"custom-registry-unreadable">;
+                    error: z.ZodString;
                 }, z.core.$strip>], "kind">>>;
             }, z.core.$strip>;
         }, z.core.$strip>, z.ZodObject<{
@@ -1860,6 +1914,336 @@ export declare const pipelineOrchestratorCapability: {
         }, z.core.$strip>, z.ZodObject<{
             success: z.ZodLiteral<true>;
         }, z.core.$strip>, "mutation">;
+        /**
+         * Node benchmark — what a run of this plan would do, without doing it:
+         * the cameras that leave the node, those that cannot (the node is their
+         * only frame source; they stay and flag the run), the estimated duration
+         * and every reason it may not start. The confirmation shows this.
+         */
+        readonly getNodeBenchmarkPreflight: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            nodeId: z.ZodString;
+            devices: z.ZodArray<z.ZodObject<{
+                deviceKey: z.ZodString;
+                modelIds: z.ZodArray<z.ZodString>;
+            }, z.core.$strip>>;
+            phases: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+                pipeline: "pipeline";
+                device: "device";
+            }>>>;
+            steps: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            fpsPerStream: z.ZodDefault<z.ZodNumber>;
+            budgetMinutes: z.ZodDefault<z.ZodNumber>;
+            keepDownloadedModels: z.ZodDefault<z.ZodBoolean>;
+            acceptInsufficientHeadroom: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>, z.ZodObject<{
+            nodeId: z.ZodString;
+            online: z.ZodBoolean;
+            moving: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                deviceId: z.ZodNumber;
+                placedOnNode: z.ZodBoolean;
+                pinnedToNode: z.ZodBoolean;
+            }, z.core.$strip>>>;
+            staying: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                deviceId: z.ZodNumber;
+                reason: z.ZodLiteral<"only-frame-source">;
+            }, z.core.$strip>>>;
+            estimatedDurationMs: z.ZodNumber;
+            budgetMs: z.ZodNumber;
+            phases: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+                pipeline: "pipeline";
+                device: "device";
+            }>>>;
+            steps: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+            devices: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                deviceKey: z.ZodString;
+                modelIds: z.ZodArray<z.ZodString>;
+            }, z.core.$strip>>>;
+            headroom: z.ZodObject<{
+                sessionsNow: z.ZodNumber;
+                otherNodesCapacitySessions: z.ZodNullable<z.ZodNumber>;
+            }, z.core.$strip>;
+            refusals: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    "unknown-device": "unknown-device";
+                    "benchmark-active": "benchmark-active";
+                    "node-offline": "node-offline";
+                    "no-phase": "no-phase";
+                    "insufficient-headroom": "insufficient-headroom";
+                }>;
+                detail: z.ZodString;
+                overridable: z.ZodBoolean;
+            }, z.core.$strip>>>;
+            canStart: z.ZodBoolean;
+        }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
+        /**
+         * Node benchmark — start ONE run (cluster-wide lock). The orchestrator
+         * persists a restore manifest, enters benchmark mode for the node (out of
+         * placement, its camera pins ignored, nothing rewritten), drains it, drives
+         * the node's own runner, then restores — always, including after an
+         * abort, a lost node or a hub restart. Answers at once; poll
+         * `getNodeBenchmarkStatus`. Refused runs carry the preflight.
+         */
+        readonly startNodeBenchmark: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            nodeId: z.ZodString;
+            devices: z.ZodArray<z.ZodObject<{
+                deviceKey: z.ZodString;
+                modelIds: z.ZodArray<z.ZodString>;
+            }, z.core.$strip>>;
+            phases: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+                pipeline: "pipeline";
+                device: "device";
+            }>>>;
+            steps: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            fpsPerStream: z.ZodDefault<z.ZodNumber>;
+            budgetMinutes: z.ZodDefault<z.ZodNumber>;
+            keepDownloadedModels: z.ZodDefault<z.ZodBoolean>;
+            acceptInsufficientHeadroom: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>, z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"started">;
+            runId: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"refused">;
+            preflight: z.ZodObject<{
+                nodeId: z.ZodString;
+                online: z.ZodBoolean;
+                moving: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                    deviceId: z.ZodNumber;
+                    placedOnNode: z.ZodBoolean;
+                    pinnedToNode: z.ZodBoolean;
+                }, z.core.$strip>>>;
+                staying: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                    deviceId: z.ZodNumber;
+                    reason: z.ZodLiteral<"only-frame-source">;
+                }, z.core.$strip>>>;
+                estimatedDurationMs: z.ZodNumber;
+                budgetMs: z.ZodNumber;
+                phases: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+                    pipeline: "pipeline";
+                    device: "device";
+                }>>>;
+                steps: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+                devices: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                    deviceKey: z.ZodString;
+                    modelIds: z.ZodArray<z.ZodString>;
+                }, z.core.$strip>>>;
+                headroom: z.ZodObject<{
+                    sessionsNow: z.ZodNumber;
+                    otherNodesCapacitySessions: z.ZodNullable<z.ZodNumber>;
+                }, z.core.$strip>;
+                refusals: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                    kind: z.ZodEnum<{
+                        "unknown-device": "unknown-device";
+                        "benchmark-active": "benchmark-active";
+                        "node-offline": "node-offline";
+                        "no-phase": "no-phase";
+                        "insufficient-headroom": "insufficient-headroom";
+                    }>;
+                    detail: z.ZodString;
+                    overridable: z.ZodBoolean;
+                }, z.core.$strip>>>;
+                canStart: z.ZodBoolean;
+            }, z.core.$strip>;
+        }, z.core.$strip>], "kind">, "mutation">;
+        /** Node benchmark — the active run (or the last one) and the node in benchmark mode. */
+        readonly getNodeBenchmarkStatus: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodObject<{
+            modeNodeId: z.ZodNullable<z.ZodString>;
+            run: z.ZodNullable<z.ZodObject<{
+                runId: z.ZodString;
+                nodeId: z.ZodString;
+                state: z.ZodEnum<{
+                    done: "done";
+                    failed: "failed";
+                    draining: "draining";
+                    aborted: "aborted";
+                    measuring: "measuring";
+                    restoring: "restoring";
+                }>;
+                plan: z.ZodObject<{
+                    nodeId: z.ZodString;
+                    devices: z.ZodArray<z.ZodObject<{
+                        deviceKey: z.ZodString;
+                        modelIds: z.ZodArray<z.ZodString>;
+                    }, z.core.$strip>>;
+                    phases: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+                        pipeline: "pipeline";
+                        device: "device";
+                    }>>>;
+                    steps: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                    fpsPerStream: z.ZodDefault<z.ZodNumber>;
+                    budgetMinutes: z.ZodDefault<z.ZodNumber>;
+                    keepDownloadedModels: z.ZodDefault<z.ZodBoolean>;
+                    acceptInsufficientHeadroom: z.ZodDefault<z.ZodBoolean>;
+                }, z.core.$strip>;
+                startedAtMs: z.ZodNumber;
+                deadlineAtMs: z.ZodNumber;
+                finishedAtMs: z.ZodNullable<z.ZodNumber>;
+                endReason: z.ZodNullable<z.ZodEnum<{
+                    failed: "failed";
+                    completed: "completed";
+                    "operator-abort": "operator-abort";
+                    deadline: "deadline";
+                    "node-lost": "node-lost";
+                    "runner-lost": "runner-lost";
+                    "hub-restart": "hub-restart";
+                    "drain-timeout": "drain-timeout";
+                }>>;
+                error: z.ZodNullable<z.ZodString>;
+                moved: z.ZodReadonly<z.ZodArray<z.ZodNumber>>;
+                staying: z.ZodReadonly<z.ZodArray<z.ZodNumber>>;
+                contaminated: z.ZodBoolean;
+                progress: z.ZodNullable<z.ZodObject<{
+                    phase: z.ZodEnum<{
+                        pipeline: "pipeline";
+                        device: "device";
+                        preparing: "preparing";
+                        cleanup: "cleanup";
+                    }>;
+                    deviceKey: z.ZodNullable<z.ZodString>;
+                    modelId: z.ZodNullable<z.ZodString>;
+                    load: z.ZodNullable<z.ZodNumber>;
+                    cellsDone: z.ZodNumber;
+                    cellsTotal: z.ZodNumber;
+                    message: z.ZodString;
+                }, z.core.$strip>>;
+                resultIds: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
+        /** Node benchmark — stop the active run; the cluster is restored as it was. */
+        readonly abortNodeBenchmark: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            runId: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            aborted: z.ZodBoolean;
+        }, z.core.$strip>, "mutation">;
+        /**
+         * Node benchmark — root detector candidates per device (what Auto tune
+         * would pick first, then the family) and the detail steps the node's
+         * catalog offers, for the plan editor.
+         */
+        readonly getNodeBenchmarkCandidates: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            nodeId: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            nodeId: z.ZodString;
+            reachable: z.ZodBoolean;
+            devices: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                deviceKey: z.ZodString;
+                enabled: z.ZodBoolean;
+                available: z.ZodBoolean;
+                suggested: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+                all: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+                currentModelId: z.ZodNullable<z.ZodString>;
+            }, z.core.$strip>>>;
+            steps: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                name: z.ZodString;
+                slot: z.ZodString;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
+        /** Node benchmark — stored results, newest first, each with its standing today. */
+        readonly listNodeBenchmarkResults: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            nodeId: z.ZodOptional<z.ZodString>;
+            deviceKey: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            runId: z.ZodString;
+            nodeId: z.ZodString;
+            cell: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                phase: z.ZodLiteral<"device">;
+                deviceKey: z.ZodString;
+                modelId: z.ZodString;
+                p50Ms: z.ZodNumber;
+                p95Ms: z.ZodNumber;
+                p99Ms: z.ZodNumber;
+                fps: z.ZodNumber;
+                kMax: z.ZodNumber;
+                limitedBy: z.ZodEnum<{
+                    errors: "errors";
+                    none: "none";
+                    cpu: "cpu";
+                    p95: "p95";
+                    drops: "drops";
+                    stall: "stall";
+                    ram: "ram";
+                }>;
+                warmupMs: z.ZodNumber;
+                ramp: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                    load: z.ZodNumber;
+                    pass: z.ZodBoolean;
+                    p95Ms: z.ZodNumber;
+                    dropRatio: z.ZodNumber;
+                    fps: z.ZodNumber;
+                    cpuPct: z.ZodNullable<z.ZodNumber>;
+                    ramFreePct: z.ZodNullable<z.ZodNumber>;
+                    failReasons: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+                }, z.core.$strip>>>;
+            }, z.core.$strip>, z.ZodObject<{
+                phase: z.ZodLiteral<"pipeline">;
+                deviceKey: z.ZodString;
+                modelId: z.ZodString;
+                steps: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+                maxSessions: z.ZodNumber;
+                limitedBy: z.ZodEnum<{
+                    errors: "errors";
+                    none: "none";
+                    cpu: "cpu";
+                    p95: "p95";
+                    drops: "drops";
+                    stall: "stall";
+                    ram: "ram";
+                }>;
+                stepsFired: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+                warmupMs: z.ZodNumber;
+                ramp: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                    load: z.ZodNumber;
+                    pass: z.ZodBoolean;
+                    p95Ms: z.ZodNumber;
+                    dropRatio: z.ZodNumber;
+                    fps: z.ZodNumber;
+                    cpuPct: z.ZodNullable<z.ZodNumber>;
+                    ramFreePct: z.ZodNullable<z.ZodNumber>;
+                    failReasons: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+                }, z.core.$strip>>>;
+            }, z.core.$strip>], "phase">;
+            fpsPerStream: z.ZodNumber;
+            fingerprint: z.ZodNullable<z.ZodObject<{
+                pipelineVersion: z.ZodNullable<z.ZodString>;
+                cpuModel: z.ZodNullable<z.ZodString>;
+                ramGb: z.ZodNullable<z.ZodNumber>;
+                os: z.ZodNullable<z.ZodString>;
+                pools: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+                    runtime: z.ZodString;
+                    numWorkers: z.ZodNumber;
+                    concurrency: z.ZodNumber;
+                    batchMode: z.ZodString;
+                }, z.core.$strip>>>;
+            }, z.core.$strip>>;
+            clip: z.ZodNullable<z.ZodObject<{
+                id: z.ZodString;
+                revision: z.ZodNullable<z.ZodString>;
+                frames: z.ZodNumber;
+                width: z.ZodNumber;
+                height: z.ZodNumber;
+            }, z.core.$strip>>;
+            contaminated: z.ZodBoolean;
+            stayingCameras: z.ZodReadonly<z.ZodArray<z.ZodNumber>>;
+            partialRun: z.ZodBoolean;
+            measuredAtMs: z.ZodNumber;
+            standing: z.ZodEnum<{
+                superseded: "superseded";
+                stale: "stale";
+                fresh: "fresh";
+            }>;
+            staleWhy: z.ZodNullable<z.ZodEnum<{
+                runtime: "runtime";
+                age: "age";
+                "pool-tuning": "pool-tuning";
+            }>>;
+        }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
+        /** Node benchmark — delete one result; Auto tune and the shares stop reading it. */
+        readonly deleteNodeBenchmarkResult: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            id: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            deleted: z.ZodBoolean;
+        }, 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;

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

@@ -146,9 +146,9 @@ export type DetailResult = z.infer<typeof DetailResultSchema>;
  *   spread the same failure.
  */
 declare const StatelessStepRefusalSchema: z.ZodEnum<{
+    "unreadable-frame": "unreadable-frame";
     "unknown-step": "unknown-step";
     "model-not-servable": "model-not-servable";
-    "unreadable-frame": "unreadable-frame";
     "execution-failed": "execution-failed";
 }>;
 export type StatelessStepRefusal = z.infer<typeof StatelessStepRefusalSchema>;
@@ -1208,9 +1208,9 @@ export declare const pipelineRunnerCapability: {
             kind: z.ZodLiteral<"refused">;
             nodeId: z.ZodString;
             reason: z.ZodEnum<{
+                "unreadable-frame": "unreadable-frame";
                 "unknown-step": "unknown-step";
                 "model-not-servable": "model-not-servable";
-                "unreadable-frame": "unreadable-frame";
                 "execution-failed": "execution-failed";
             }>;
             detail: z.ZodString;
@@ -1318,6 +1318,149 @@ export declare const pipelineRunnerCapability: {
         }, z.core.$strip>, z.ZodObject<{
             released: z.ZodNumber;
         }, z.core.$strip>, "mutation">;
+        /**
+         * Start measuring THIS node for the orchestrator's node benchmark: the
+         * bench clip decoded once into RAM, each device × candidate detector on an
+         * open-loop ramp (`device`), then the chosen pipeline with the requested
+         * detail steps (`pipeline`). Everything runs in-process with the executor
+         * — no frame crosses a node (D9) — and writes nothing: no track, event,
+         * media or notification. Reached by `nodePin(nodeId)`. Answers at once;
+         * one run per node; the run stops itself at `deadlineAtMs`.
+         */
+        readonly startNodeBench: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            runId: z.ZodString;
+            devices: z.ZodArray<z.ZodObject<{
+                deviceKey: z.ZodString;
+                modelIds: z.ZodArray<z.ZodString>;
+            }, z.core.$strip>>;
+            phases: z.ZodArray<z.ZodEnum<{
+                pipeline: "pipeline";
+                device: "device";
+            }>>;
+            steps: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            fpsPerStream: z.ZodNumber;
+            deadlineAtMs: z.ZodNumber;
+            settleSec: z.ZodDefault<z.ZodNumber>;
+            measureSec: z.ZodDefault<z.ZodNumber>;
+            keepDownloadedModels: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>, z.ZodObject<{
+            accepted: z.ZodLiteral<true>;
+            runId: z.ZodString;
+        }, z.core.$strip>, "mutation">;
+        /** The run's progress and every finished cell; null when this runner does not know `runId`. */
+        readonly getNodeBenchStatus: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            runId: z.ZodString;
+        }, z.core.$strip>, z.ZodNullable<z.ZodObject<{
+            runId: z.ZodString;
+            nodeId: z.ZodString;
+            state: z.ZodEnum<{
+                running: "running";
+                done: "done";
+                failed: "failed";
+                aborted: "aborted";
+            }>;
+            progress: z.ZodNullable<z.ZodObject<{
+                phase: z.ZodEnum<{
+                    pipeline: "pipeline";
+                    device: "device";
+                    preparing: "preparing";
+                    cleanup: "cleanup";
+                }>;
+                deviceKey: z.ZodNullable<z.ZodString>;
+                modelId: z.ZodNullable<z.ZodString>;
+                load: z.ZodNullable<z.ZodNumber>;
+                cellsDone: z.ZodNumber;
+                cellsTotal: z.ZodNumber;
+                message: z.ZodString;
+            }, z.core.$strip>>;
+            cells: z.ZodReadonly<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                phase: z.ZodLiteral<"device">;
+                deviceKey: z.ZodString;
+                modelId: z.ZodString;
+                p50Ms: z.ZodNumber;
+                p95Ms: z.ZodNumber;
+                p99Ms: z.ZodNumber;
+                fps: z.ZodNumber;
+                kMax: z.ZodNumber;
+                limitedBy: z.ZodEnum<{
+                    errors: "errors";
+                    none: "none";
+                    cpu: "cpu";
+                    p95: "p95";
+                    drops: "drops";
+                    stall: "stall";
+                    ram: "ram";
+                }>;
+                warmupMs: z.ZodNumber;
+                ramp: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                    load: z.ZodNumber;
+                    pass: z.ZodBoolean;
+                    p95Ms: z.ZodNumber;
+                    dropRatio: z.ZodNumber;
+                    fps: z.ZodNumber;
+                    cpuPct: z.ZodNullable<z.ZodNumber>;
+                    ramFreePct: z.ZodNullable<z.ZodNumber>;
+                    failReasons: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+                }, z.core.$strip>>>;
+            }, z.core.$strip>, z.ZodObject<{
+                phase: z.ZodLiteral<"pipeline">;
+                deviceKey: z.ZodString;
+                modelId: z.ZodString;
+                steps: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+                maxSessions: z.ZodNumber;
+                limitedBy: z.ZodEnum<{
+                    errors: "errors";
+                    none: "none";
+                    cpu: "cpu";
+                    p95: "p95";
+                    drops: "drops";
+                    stall: "stall";
+                    ram: "ram";
+                }>;
+                stepsFired: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+                warmupMs: z.ZodNumber;
+                ramp: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                    load: z.ZodNumber;
+                    pass: z.ZodBoolean;
+                    p95Ms: z.ZodNumber;
+                    dropRatio: z.ZodNumber;
+                    fps: z.ZodNumber;
+                    cpuPct: z.ZodNullable<z.ZodNumber>;
+                    ramFreePct: z.ZodNullable<z.ZodNumber>;
+                    failReasons: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+                }, z.core.$strip>>>;
+            }, z.core.$strip>], "phase">>>;
+            fingerprint: z.ZodNullable<z.ZodObject<{
+                pipelineVersion: z.ZodNullable<z.ZodString>;
+                cpuModel: z.ZodNullable<z.ZodString>;
+                ramGb: z.ZodNullable<z.ZodNumber>;
+                os: z.ZodNullable<z.ZodString>;
+                pools: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+                    runtime: z.ZodString;
+                    numWorkers: z.ZodNumber;
+                    concurrency: z.ZodNumber;
+                    batchMode: z.ZodString;
+                }, z.core.$strip>>>;
+            }, z.core.$strip>>;
+            clip: z.ZodNullable<z.ZodObject<{
+                id: z.ZodString;
+                revision: z.ZodNullable<z.ZodString>;
+                frames: z.ZodNumber;
+                width: z.ZodNumber;
+                height: z.ZodNumber;
+            }, z.core.$strip>>;
+            activeCameraIds: z.ZodReadonly<z.ZodArray<z.ZodNumber>>;
+            deletedModels: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+            error: z.ZodNullable<z.ZodString>;
+            startedAtMs: z.ZodNumber;
+            finishedAtMs: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strip>>, import("./capability-definition.js").CapabilityMethodKind>;
+        /** Stop the run; what it finished is kept. */
+        readonly abortNodeBench: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            runId: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            aborted: z.ZodBoolean;
+        }, z.core.$strip>, "mutation">;
     };
 };
 export type IPipelineRunnerProvider = InferProvider<typeof pipelineRunnerCapability>;

package/dist/capabilities/storage.cap.d.ts

@@ -133,8 +133,8 @@ export declare const storageCapability: {
             }>>;
         }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
         readonly upsertLocation: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
-            id: z.ZodString;
             type: z.ZodString;
+            id: z.ZodString;
             nodeId: z.ZodOptional<z.ZodString>;
             mode: z.ZodOptional<z.ZodEnum<{
                 readonly: "readonly";