@camstack/types 1.2.327 → 1.2.329

package/dist/pipeline/node-benchmark/schemas.d.ts

@@ -0,0 +1,848 @@
+/**
+ * Wire shapes of the node benchmark (D791): the operator's plan, the
+ * preflight the confirmation shows, the run the orchestrator owns, what the
+ * measuring runner reports, and the result rows Auto tune and the automatic
+ * shares read.
+ *
+ * ONE node at a time, owned by the pipeline orchestrator. While a run is
+ * active the cluster is in BENCHMARK MODE for that node: it is not a
+ * detection candidate, camera pins naming it are ignored so its sessions move
+ * elsewhere, and both come back when the mode ends — after a crash or a hub
+ * restart too (a persisted manifest, reconciled against the registry).
+ *
+ * Two measurements, both on the node, driven by its own runner (frames never
+ * cross a process at frame rate, D9):
+ *  - `device` — one accelerator × one candidate detector, root only, open
+ *    loop: how many streams at the camera rate it carries inside the frame
+ *    interval;
+ *  - `pipeline` — the chosen detector plus the operator's detail steps
+ *    (faces, plates, classifiers, CLIP…), on varied frames from the bench
+ *    clip: how many parallel sessions the node carries before latency, drops,
+ *    CPU, RAM or the event loop give out.
+ */
+import { z } from 'zod';
+/** Defaults and bounds, one place. */
+export declare const NODE_BENCHMARK_DEFAULTS: {
+    readonly fpsPerStream: 10;
+    readonly budgetMinutes: 45;
+    readonly minBudgetMinutes: 10;
+    readonly maxBudgetMinutes: 120;
+    /** A result older than this no longer beats the table. */
+    readonly staleAfterDays: 30;
+    /** Warm-in per ramp step (not accounted). */
+    readonly settleSec: 5;
+    /** Accounted window per ramp step. */
+    readonly measureSec: 20;
+    /** Longest the drain may take before the run is refused. */
+    readonly drainTimeoutSec: 120;
+    /** Candidate models per device in one run. */
+    readonly maxModelsPerDevice: 6;
+};
+/** The two measurements a run can make. */
+export declare const NodeBenchmarkPhaseSchema: z.ZodEnum<{
+    pipeline: "pipeline";
+    device: "device";
+}>;
+export type NodeBenchmarkPhase = z.infer<typeof NodeBenchmarkPhaseSchema>;
+export declare const NodeBenchmarkDevicePlanSchema: z.ZodObject<{
+    deviceKey: z.ZodString;
+    modelIds: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type NodeBenchmarkDevicePlan = z.infer<typeof NodeBenchmarkDevicePlanSchema>;
+/** What the operator confirmed. */
+export declare const NodeBenchmarkPlanSchema: 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>;
+export type NodeBenchmarkPlan = z.infer<typeof NodeBenchmarkPlanSchema>;
+export type NodeBenchmarkPlanInput = z.input<typeof NodeBenchmarkPlanSchema>;
+/** Why a run cannot start. `overridable` ones are lifted by a plan flag. */
+export declare const NodeBenchmarkRefusalKindSchema: z.ZodEnum<{
+    "unknown-device": "unknown-device";
+    "benchmark-active": "benchmark-active";
+    "node-offline": "node-offline";
+    "no-phase": "no-phase";
+    "insufficient-headroom": "insufficient-headroom";
+}>;
+export type NodeBenchmarkRefusalKind = z.infer<typeof NodeBenchmarkRefusalKindSchema>;
+export declare const NodeBenchmarkRefusalSchema: 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>;
+export type NodeBenchmarkRefusal = z.infer<typeof NodeBenchmarkRefusalSchema>;
+/** A camera whose detection leaves the node for the run. */
+export declare const NodeBenchmarkMovingCameraSchema: z.ZodObject<{
+    deviceId: z.ZodNumber;
+    placedOnNode: z.ZodBoolean;
+    pinnedToNode: z.ZodBoolean;
+}, z.core.$strip>;
+export type NodeBenchmarkMovingCamera = z.infer<typeof NodeBenchmarkMovingCameraSchema>;
+/** A camera that cannot leave: no other node can obtain its frames. */
+export declare const NodeBenchmarkStayingCameraSchema: z.ZodObject<{
+    deviceId: z.ZodNumber;
+    reason: z.ZodLiteral<"only-frame-source">;
+}, z.core.$strip>;
+export type NodeBenchmarkStayingCamera = z.infer<typeof NodeBenchmarkStayingCameraSchema>;
+export declare const NodeBenchmarkPreflightSchema: 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>;
+export type NodeBenchmarkPreflight = z.infer<typeof NodeBenchmarkPreflightSchema>;
+/** Where the measuring runner is. */
+export declare const NodeBenchProgressSchema: 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>;
+export type NodeBenchProgress = z.infer<typeof NodeBenchProgressSchema>;
+/** What limited a ramp. `none` = the ramp ran out of steps still passing. */
+export declare const NodeBenchLimitSchema: z.ZodEnum<{
+    errors: "errors";
+    none: "none";
+    cpu: "cpu";
+    p95: "p95";
+    drops: "drops";
+    stall: "stall";
+    ram: "ram";
+}>;
+export type NodeBenchLimit = z.infer<typeof NodeBenchLimitSchema>;
+export declare const NodeBenchRampStepSchema: 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>;
+export type NodeBenchRampStep = z.infer<typeof NodeBenchRampStepSchema>;
+/** One measured device × detector (the `device` measurement). */
+export declare const NodeBenchDeviceCellSchema: 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>;
+export type NodeBenchDeviceCell = z.infer<typeof NodeBenchDeviceCellSchema>;
+/** One measured pipeline (the `pipeline` measurement) on a device. */
+export declare const NodeBenchPipelineCellSchema: 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>;
+export type NodeBenchPipelineCell = z.infer<typeof NodeBenchPipelineCellSchema>;
+export declare const NodeBenchCellSchema: 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">;
+export type NodeBenchCell = z.infer<typeof NodeBenchCellSchema>;
+/**
+ * What a result was measured ON. A result whose fingerprint no longer matches
+ * the node no longer beats the table.
+ */
+export declare const NodeBenchFingerprintSchema: 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>;
+export type NodeBenchFingerprint = z.infer<typeof NodeBenchFingerprintSchema>;
+/** The frames the run used. */
+export declare const NodeBenchClipSchema: z.ZodObject<{
+    id: z.ZodString;
+    revision: z.ZodNullable<z.ZodString>;
+    frames: z.ZodNumber;
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+}, z.core.$strip>;
+export type NodeBenchClip = z.infer<typeof NodeBenchClipSchema>;
+export declare const NodeBenchRunnerInputSchema: 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>;
+export type NodeBenchRunnerInput = z.infer<typeof NodeBenchRunnerInputSchema>;
+export type NodeBenchRunnerInputRaw = z.input<typeof NodeBenchRunnerInputSchema>;
+export declare const NodeBenchRunnerStateSchema: z.ZodEnum<{
+    running: "running";
+    done: "done";
+    failed: "failed";
+    aborted: "aborted";
+}>;
+export type NodeBenchRunnerState = z.infer<typeof NodeBenchRunnerStateSchema>;
+export declare const NodeBenchRunnerStatusSchema: 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>;
+export type NodeBenchRunnerStatus = z.infer<typeof NodeBenchRunnerStatusSchema>;
+export declare const NodeBenchmarkStateSchema: z.ZodEnum<{
+    done: "done";
+    failed: "failed";
+    draining: "draining";
+    aborted: "aborted";
+    measuring: "measuring";
+    restoring: "restoring";
+}>;
+export type NodeBenchmarkState = z.infer<typeof NodeBenchmarkStateSchema>;
+/** Why a run ended. */
+export declare const NodeBenchmarkEndReasonSchema: 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";
+}>;
+export type NodeBenchmarkEndReason = z.infer<typeof NodeBenchmarkEndReasonSchema>;
+export declare const NodeBenchmarkRunSchema: 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>;
+export type NodeBenchmarkRun = z.infer<typeof NodeBenchmarkRunSchema>;
+/** `getNodeBenchmarkStatus`: the active run (or the last one), and whether benchmark mode is on. */
+export declare const NodeBenchmarkStatusSchema: 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>;
+export type NodeBenchmarkStatus = z.infer<typeof NodeBenchmarkStatusSchema>;
+/**
+ * One stored measurement — the only authority Auto tune and the automatic
+ * shares read measured capacity from. Written by the orchestrator when a run
+ * ends, never by anyone else.
+ */
+export declare const NodeBenchmarkResultSchema: 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;
+}, z.core.$strip>;
+export type NodeBenchmarkResult = z.infer<typeof NodeBenchmarkResultSchema>;
+export declare const ListNodeBenchmarkResultsInputSchema: z.ZodObject<{
+    nodeId: z.ZodOptional<z.ZodString>;
+    deviceKey: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ListNodeBenchmarkResultsInput = z.infer<typeof ListNodeBenchmarkResultsInputSchema>;
+/** A result with its standing today: does it still beat the table? */
+export declare const NodeBenchmarkResultViewSchema: 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>;
+export type NodeBenchmarkResultView = z.infer<typeof NodeBenchmarkResultViewSchema>;
+/** The manifest persisted BEFORE benchmark mode changes anything; its presence means "restore". */
+export declare const NodeBenchmarkManifestSchema: z.ZodObject<{
+    runId: z.ZodString;
+    nodeId: z.ZodString;
+    startedAtMs: z.ZodNumber;
+    deadlineAtMs: z.ZodNumber;
+    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>;
+    moved: z.ZodReadonly<z.ZodArray<z.ZodNumber>>;
+    staying: z.ZodReadonly<z.ZodArray<z.ZodNumber>>;
+}, z.core.$strip>;
+export type NodeBenchmarkManifest = z.infer<typeof NodeBenchmarkManifestSchema>;
+/** Candidate detectors per device, for the plan editor. */
+export declare const NodeBenchmarkCandidatesSchema: 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>;
+export type NodeBenchmarkCandidates = z.infer<typeof NodeBenchmarkCandidatesSchema>;