@fleetless/contracts 1.0.0

package/dist/protocol.d.ts

@@ -0,0 +1,781 @@
+import { z } from 'zod';
+/**
+ * Bridge <-> cloud protocol, version 2.
+ *
+ * The version is exchanged in the hello handshake; the cloud refuses an
+ * incompatible bridge with a clear message (spec §5) — `ws/bridge.ts`'s
+ * `protocol_mismatch`, which names both versions and lands on the robot
+ * detail page as `last_hello_error`.
+ *
+ * **2 (2026-08-21):** `config_applied.errors` entries gained `kind` and `code`
+ * beside `message`. The check is `!==`, not a floor, so a bridge that is not
+ * exactly this version is refused entirely. That is deliberate: a cloud and a
+ * bridge that disagree about the wire should not pretend otherwise.
+ */
+export declare const PROTOCOL_VERSION = 2;
+/**
+ * The bridge socket close code for "this robot no longer exists" (W6a).
+ *
+ * Deliberately distinct from the auth failures: a deleted robot must **stop**,
+ * and a token that was valid a second ago is indistinguishable from one that
+ * was revoked unless the cloud says which. Without its own code the bridge
+ * reconnects forever against a robot that will never come back — a permanent
+ * load on the cloud, and a robot on someone's shelf whose logs say nothing
+ * more informative than "connection closed".
+ */
+export declare const CLOSE_ROBOT_DELETED = 4004;
+/**
+ * How long a command waits for its answer when the caller names no patience
+ * of its own (W6b).
+ *
+ * 15 s, which is what both halves already used independently: the cloud's
+ * `commandTimeoutMs` and the bridge's `GOAL_ACCEPT_TIMEOUT_S`. That they
+ * agreed was a coincidence of two separate decisions, and neither side could
+ * be told otherwise for a single call. Naming the number once, here, is what
+ * makes it one number rather than two that happen to match.
+ *
+ * A caller who knows their robot's work takes longer says so per call. A
+ * caller who says nothing gets exactly today's behaviour — which is the point
+ * of picking today's number as the default rather than a nicer one.
+ */
+export declare const DEFAULT_PATIENCE_MS = 15000;
+/**
+ * The longest patience a caller may ask for.
+ *
+ * A waiting REST request is a held-open connection, and there is **no rate
+ * limiting** on this platform until W8 — so an unbounded `patience_ms` is an
+ * unauthenticated way to pin the cloud's sockets open. Two minutes is long
+ * enough for the robot work anybody has described (a planner, a docking
+ * manoeuvre, an arm trajectory) and short enough that a thousand of them is
+ * still a bounded amount of cloud.
+ *
+ * Raising it is a W8 conversation, after rate limiting exists — not a
+ * one-line change here.
+ */
+export declare const MAX_PATIENCE_MS = 120000;
+/**
+ * The shortest patience a caller may ask for.
+ *
+ * A floor exists because **impatience reaches the robot**. Measured in W6b's
+ * review: `patience_ms: 1` on an action makes the bridge report `goal_timeout`
+ * and then issue a *corrective cancel* against a goal the action server
+ * accepts a moment later — so a caller who asks for an unreachable deadline
+ * does not merely get an error, they cause a cancellation on the machine.
+ * Repeatable, and on a platform with no rate limiting until W8.
+ *
+ * One second, because it has to be longer than a goal-acceptance round trip on
+ * a healthy robot and shorter than any wait a human would call patient. It is
+ * a guard against a number that cannot be satisfied, not a policy about how
+ * long work takes — `MAX_PATIENCE_MS` is the end that bounds the platform,
+ * this end bounds what the caller can do to the robot.
+ */
+export declare const MIN_PATIENCE_MS = 1000;
+/** Re-exported so consumers keep importing wire names from one place. */
+export { slug } from './common.js';
+/**
+ * One job the bridge still has, as reported in the handshake (W6b).
+ *
+ * It carries the **slug and the state**, not only the id, because the cloud's
+ * reconciliation needs both and had neither. Reading `active_job_ids` as bare
+ * uuids, a restarted cloud could answer exactly one question — "is this job
+ * still alive?" — for jobs it already knew about. It could not name what the
+ * robot is doing, could not tell a job that is still `running` from one that
+ * finished while the cloud was down, and had nothing at all to say about a
+ * job it never recorded because it crashed between minting the id and writing
+ * the row.
+ *
+ * `state` is the bridge's own current answer, not a history. A bridge that
+ * has a terminal result still in hand reports it here and the cloud writes it
+ * down, instead of publishing `lost` over a job that in fact succeeded.
+ */
+export declare const activeJob: z.ZodObject<{
+    job_id: z.ZodUUID;
+    slug: z.ZodString;
+    state: z.ZodEnum<{
+        failed: "failed";
+        running: "running";
+        succeeded: "succeeded";
+        cancelled: "cancelled";
+        lost: "lost";
+    }>;
+}, z.core.$strip>;
+export type ActiveJob = z.infer<typeof activeJob>;
+/** First frame a bridge sends after the socket opens. */
+export declare const bridgeHello: z.ZodObject<{
+    type: z.ZodLiteral<"hello">;
+    protocol_version: z.ZodNumber;
+    token: z.ZodString;
+    bridge_version: z.ZodString;
+    active_jobs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        job_id: z.ZodUUID;
+        slug: z.ZodString;
+        state: z.ZodEnum<{
+            failed: "failed";
+            running: "running";
+            succeeded: "succeeded";
+            cancelled: "cancelled";
+            lost: "lost";
+        }>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type BridgeHello = z.infer<typeof bridgeHello>;
+/** Cloud accepts the bridge: the robot is online from here on. */
+export declare const cloudHelloOk: z.ZodObject<{
+    type: z.ZodLiteral<"hello_ok">;
+    robot_id: z.ZodUUID;
+}, z.core.$strip>;
+export type CloudHelloOk = z.infer<typeof cloudHelloOk>;
+/** Cloud refuses the bridge (bad token, incompatible protocol, ...). */
+export declare const cloudHelloError: z.ZodObject<{
+    type: z.ZodLiteral<"hello_error">;
+    code: z.ZodString;
+    message: z.ZodString;
+}, z.core.$strip>;
+export type CloudHelloError = z.infer<typeof cloudHelloError>;
+/**
+ * One datapoint sample. `timestamp_ms` is the capture time at the bridge —
+ * never the receive time — so clients compute age themselves (spec §6.3).
+ */
+export declare const datapointFrame: z.ZodObject<{
+    type: z.ZodLiteral<"datapoint">;
+    slug: z.ZodString;
+    value: z.ZodUnknown;
+    timestamp_ms: z.ZodNumber;
+}, z.core.$strip>;
+export type DatapointFrame = z.infer<typeof datapointFrame>;
+/**
+ * Latency probe, cloud → bridge. The cloud sends its own clock in `ts_ms`;
+ * the bridge echoes it back untouched and the cloud derives the round-trip
+ * latency shown as `bridge_state.latency_ms`.
+ */
+export declare const cloudPing: z.ZodObject<{
+    type: z.ZodLiteral<"ping">;
+    ts_ms: z.ZodNumber;
+}, z.core.$strip>;
+export type CloudPing = z.infer<typeof cloudPing>;
+/** Immediate bridge answer to a `CloudPing`, `ts_ms` echoed unchanged. */
+export declare const bridgePong: z.ZodObject<{
+    type: z.ZodLiteral<"pong">;
+    ts_ms: z.ZodNumber;
+}, z.core.$strip>;
+export type BridgePong = z.infer<typeof bridgePong>;
+/**
+ * The published configuration, cloud → bridge (spec §4.1: the bridge applies
+ * the published version). Sent right after `hello_ok` and again on every
+ * publish, so a bridge never has to ask.
+ *
+ * `version: 0` with an empty document means *nothing published yet* — a fresh
+ * robot, not an error.
+ */
+/**
+ * Cloud → bridge: the configuration to apply.
+ *
+ * **`doc` is the whole of it.** Camera credentials travel inline in
+ * `doc.cameras[].source`, per `config.ts`'s `cameraCredentials` — there is no
+ * side channel any more. That was a deliberate, recorded trade-off: a
+ * password here is in every published version, and those are immutable. The
+ * bound on that decision is elsewhere and load-bearing — the publish audit
+ * event and the org event stream must not carry the document body.
+ *
+ * **The bridge does not persist configuration.** It holds this frame in
+ * memory and is sent it again on every reconnect, and that is the only thing
+ * keeping camera passwords off the robot's disk. The retired side channel
+ * carried this warning with an escape hatch attached — cache the config, just
+ * exclude the `credentials` field. There is no such field now: the secrets are
+ * inside `doc`, so caching the configuration caches the passwords, with
+ * nothing left to leave out. The warning survives its own mechanism, narrower
+ * and harder to satisfy than when it was written.
+ */
+export declare const cloudConfig: z.ZodObject<{
+    type: z.ZodLiteral<"config">;
+    version: z.ZodNumber;
+    doc: z.ZodObject<{
+        fleetless: z.ZodLiteral<1>;
+        messages: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        datapoints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            topic: z.ZodString;
+            type: z.ZodString;
+            field: z.ZodOptional<z.ZodString>;
+            rate_throttle_hz: z.ZodOptional<z.ZodNumber>;
+            description: z.ZodOptional<z.ZodString>;
+            numeric: z.ZodOptional<z.ZodObject<{
+                scale: z.ZodOptional<z.ZodNumber>;
+                offset: z.ZodOptional<z.ZodNumber>;
+                unit: z.ZodOptional<z.ZodString>;
+                decimals: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>>;
+            retention: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodOptional<z.ZodBoolean>;
+                interval_seconds: z.ZodOptional<z.ZodNumber>;
+                max_buffer_values: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>>;
+            chart: z.ZodOptional<z.ZodObject<{
+                y_min: z.ZodOptional<z.ZodNumber>;
+                y_max: z.ZodOptional<z.ZodNumber>;
+                style: z.ZodOptional<z.ZodEnum<{
+                    line: "line";
+                    step: "step";
+                }>>;
+                default_window_minutes: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>>;
+            alerts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                condition: z.ZodObject<{
+                    fire_at: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>;
+                    resolve_at: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strict>;
+                severity: z.ZodOptional<z.ZodEnum<{
+                    error: "error";
+                    warning: "warning";
+                }>>;
+                name: z.ZodOptional<z.ZodString>;
+                enabled: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>>>;
+        actions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            ros_name: z.ZodString;
+            type: z.ZodString;
+            message: z.ZodOptional<z.ZodUnknown>;
+            parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                type: z.ZodEnum<{
+                    string: "string";
+                    bool: "bool";
+                    byte: "byte";
+                    char: "char";
+                    int8: "int8";
+                    uint8: "uint8";
+                    int16: "int16";
+                    uint16: "uint16";
+                    int32: "int32";
+                    uint32: "uint32";
+                    int64: "int64";
+                    uint64: "uint64";
+                    float32: "float32";
+                    float64: "float64";
+                    wstring: "wstring";
+                }>;
+                default: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>>;
+                min_value: z.ZodOptional<z.ZodNumber>;
+                max_value: z.ZodOptional<z.ZodNumber>;
+                enum: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+                regex: z.ZodOptional<z.ZodString>;
+                description: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        services: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            ros_name: z.ZodString;
+            type: z.ZodString;
+            message: z.ZodOptional<z.ZodUnknown>;
+            parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                type: z.ZodEnum<{
+                    string: "string";
+                    bool: "bool";
+                    byte: "byte";
+                    char: "char";
+                    int8: "int8";
+                    uint8: "uint8";
+                    int16: "int16";
+                    uint16: "uint16";
+                    int32: "int32";
+                    uint32: "uint32";
+                    int64: "int64";
+                    uint64: "uint64";
+                    float32: "float32";
+                    float64: "float64";
+                    wstring: "wstring";
+                }>;
+                default: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>>;
+                min_value: z.ZodOptional<z.ZodNumber>;
+                max_value: z.ZodOptional<z.ZodNumber>;
+                enum: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+                regex: z.ZodOptional<z.ZodString>;
+                description: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        publishers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            topic: z.ZodString;
+            type: z.ZodString;
+            message: z.ZodUnknown;
+            parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                type: z.ZodEnum<{
+                    string: "string";
+                    bool: "bool";
+                    byte: "byte";
+                    char: "char";
+                    int8: "int8";
+                    uint8: "uint8";
+                    int16: "int16";
+                    uint16: "uint16";
+                    int32: "int32";
+                    uint32: "uint32";
+                    int64: "int64";
+                    uint64: "uint64";
+                    float32: "float32";
+                    float64: "float64";
+                    wstring: "wstring";
+                }>;
+                default: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>>;
+                min_value: z.ZodOptional<z.ZodNumber>;
+                max_value: z.ZodOptional<z.ZodNumber>;
+                enum: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+                regex: z.ZodOptional<z.ZodString>;
+                description: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+            failsafe: z.ZodObject<{
+                timeout_ms: z.ZodNumber;
+                message: z.ZodUnknown;
+            }, z.core.$strict>;
+            quiet_timeout_ms: z.ZodNumber;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        cameras: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            source: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"ros">;
+                topic: z.ZodString;
+                type: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"rtsp">;
+                url: z.ZodString;
+                transport: z.ZodOptional<z.ZodEnum<{
+                    tcp: "tcp";
+                    udp: "udp";
+                }>>;
+                credentials: z.ZodOptional<z.ZodObject<{
+                    username: z.ZodOptional<z.ZodString>;
+                    password: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"mjpeg">;
+                url: z.ZodString;
+                credentials: z.ZodOptional<z.ZodObject<{
+                    username: z.ZodOptional<z.ZodString>;
+                    password: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"v4l2">;
+                device: z.ZodString;
+            }, z.core.$strict>], "kind">;
+            width: z.ZodNumber;
+            height: z.ZodNumber;
+            fps: z.ZodNumber;
+            bitrate_kbps: z.ZodNumber;
+            snapshot_interval_seconds: z.ZodNumber;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>;
+}, z.core.$strip>;
+export type CloudConfig = z.infer<typeof cloudConfig>;
+/**
+ * What the bridge made of it. A single unusable entry must never stop the
+ * others: the bridge applies what it can, reports the rest per slug, and
+ * sets `ok: false`. The console shows this as "published v2 · applied v1".
+ */
+export declare const bridgeConfigApplied: z.ZodObject<{
+    type: z.ZodLiteral<"config_applied">;
+    version: z.ZodNumber;
+    ok: z.ZodBoolean;
+    errors: z.ZodArray<z.ZodObject<{
+        slug: z.ZodString;
+        kind: z.ZodEnum<{
+            datapoint: "datapoint";
+            action: "action";
+            service: "service";
+            publisher: "publisher";
+            camera: "camera";
+        }>;
+        code: z.ZodString;
+        message: z.ZodString;
+        details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type BridgeConfigApplied = z.infer<typeof bridgeConfigApplied>;
+/**
+ * Commands, cloud → bridge (spec §6.1, §11.3). The **cloud** mints the
+ * `job_id` before the bridge is asked to do anything, so a job exists —
+ * and can be reported `lost` — even if the answer never comes back.
+ */
+export declare const cloudInvoke: z.ZodObject<{
+    type: z.ZodLiteral<"invoke">;
+    job_id: z.ZodUUID;
+    slug: z.ZodString;
+    params: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    patience_ms: z.ZodNumber;
+}, z.core.$strip>;
+export type CloudInvoke = z.infer<typeof cloudInvoke>;
+/**
+ * Cancel — the bridge must issue a real ROS goal cancel (§11.3).
+ *
+ * `slug` stays, and stays required: it is how the bridge finds the tracker,
+ * and it is what a cancel with no id means.
+ *
+ * `job_id` is what W6b adds, and what makes a cancel say *which* job. Without
+ * it a cancel arriving a moment after one job ended and another began on the
+ * same slug stops the **new** one — the caller asked to stop something that
+ * had already finished and stopped a machine that had just started moving.
+ * That is not a race anybody had to lose: the caller knew the id, and the
+ * wire had nowhere to put it.
+ *
+ * `null` keeps today's meaning and must be read as exactly that: *cancel
+ * whatever is running on this slug*. It is a real request — an operator
+ * hitting stop wants the robot stopped, not a lecture about job identity —
+ * and it stays available for that. A bridge given an id that does not match
+ * what is running cancels **nothing** and says so; it must not fall back to
+ * the slug, because a caller who named an id has ruled that out.
+ */
+export declare const cloudCancel: z.ZodObject<{
+    type: z.ZodLiteral<"cancel">;
+    slug: z.ZodString;
+    job_id: z.ZodNullable<z.ZodUUID>;
+}, z.core.$strip>;
+export type CloudCancel = z.infer<typeof cloudCancel>;
+export declare const cloudPublish: z.ZodObject<{
+    type: z.ZodLiteral<"publish">;
+    slug: z.ZodString;
+    message: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>;
+export type CloudPublish = z.infer<typeof cloudPublish>;
+/**
+ * Progress on a job, bridge → cloud. `timestamp_ms` is capture time, so a
+ * burst delivered late after a reconnect is visibly late (§6.3).
+ */
+export declare const bridgeJobUpdate: z.ZodObject<{
+    type: z.ZodLiteral<"job_update">;
+    job_id: z.ZodUUID;
+    slug: z.ZodString;
+    state: z.ZodEnum<{
+        failed: "failed";
+        running: "running";
+        succeeded: "succeeded";
+        cancelled: "cancelled";
+        lost: "lost";
+    }>;
+    feedback: z.ZodNullable<z.ZodUnknown>;
+    progress: z.ZodNullable<z.ZodNumber>;
+    result: z.ZodNullable<z.ZodUnknown>;
+    error: z.ZodNullable<z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+        details: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$strip>>;
+    timestamp_ms: z.ZodNumber;
+}, z.core.$strip>;
+export type BridgeJobUpdate = z.infer<typeof bridgeJobUpdate>;
+/**
+ * Jobs the bridge can no longer account for **while connected** (§6.1) — a
+ * tracker dropped, an action server that vanished mid-goal, anything where
+ * the honest answer is "I lost this" rather than a state.
+ *
+ * The restart case is not this frame's job: a restarted bridge has nothing
+ * left to enumerate, so it is `hello.active_job_ids` that closes that gap.
+ * Both paths end in the same place — the cloud publishes `lost` rather than
+ * leaving a job reading "running" because nobody contradicted it.
+ */
+export declare const bridgeJobLost: z.ZodObject<{
+    type: z.ZodLiteral<"job_lost">;
+    job_ids: z.ZodArray<z.ZodUUID>;
+}, z.core.$strip>;
+export type BridgeJobLost = z.infer<typeof bridgeJobLost>;
+/** Cloud asks for a fresh ROS graph; `request_id` correlates the answer. */
+export declare const cloudIntrospectRequest: z.ZodObject<{
+    type: z.ZodLiteral<"introspect_request">;
+    request_id: z.ZodString;
+}, z.core.$strip>;
+export type CloudIntrospectRequest = z.infer<typeof cloudIntrospectRequest>;
+/** The graph snapshot, bridge → cloud. */
+export declare const bridgeIntrospect: z.ZodObject<{
+    type: z.ZodLiteral<"introspect">;
+    request_id: z.ZodString;
+    graph: z.ZodObject<{
+        topics: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            types: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>;
+        services: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            types: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>;
+        actions: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            types: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>;
+        captured_at_ms: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type BridgeIntrospect = z.infer<typeof bridgeIntrospect>;
+/**
+ * Field trees are fetched on demand, not shipped with the graph: a robot with
+ * hundreds of topics would otherwise push hundreds of kilobytes on every
+ * refresh, for types nobody opened.
+ */
+export declare const cloudTypeRequest: z.ZodObject<{
+    type: z.ZodLiteral<"type_request">;
+    request_id: z.ZodString;
+    type_names: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type CloudTypeRequest = z.infer<typeof cloudTypeRequest>;
+/**
+ * The resolved definitions. Names the bridge cannot resolve in its sourced
+ * workspace are listed in `unresolved` — an unknown type is an answer, not a
+ * failed frame.
+ */
+export declare const bridgeTypeDefinitions: z.ZodObject<{
+    type: z.ZodLiteral<"type_definitions">;
+    request_id: z.ZodString;
+    definitions: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        name: z.ZodString;
+        kind: z.ZodLiteral<"msg">;
+        fields: z.ZodArray<z.ZodType<import("./introspection.js").TypeField, unknown, z.core.$ZodTypeInternals<import("./introspection.js").TypeField, unknown>>>;
+    }, z.core.$strip>, z.ZodObject<{
+        name: z.ZodString;
+        kind: z.ZodLiteral<"srv">;
+        request: z.ZodArray<z.ZodType<import("./introspection.js").TypeField, unknown, z.core.$ZodTypeInternals<import("./introspection.js").TypeField, unknown>>>;
+        response: z.ZodArray<z.ZodType<import("./introspection.js").TypeField, unknown, z.core.$ZodTypeInternals<import("./introspection.js").TypeField, unknown>>>;
+    }, z.core.$strip>, z.ZodObject<{
+        name: z.ZodString;
+        kind: z.ZodLiteral<"action">;
+        goal: z.ZodArray<z.ZodType<import("./introspection.js").TypeField, unknown, z.core.$ZodTypeInternals<import("./introspection.js").TypeField, unknown>>>;
+        result: z.ZodArray<z.ZodType<import("./introspection.js").TypeField, unknown, z.core.$ZodTypeInternals<import("./introspection.js").TypeField, unknown>>>;
+        feedback: z.ZodArray<z.ZodType<import("./introspection.js").TypeField, unknown, z.core.$ZodTypeInternals<import("./introspection.js").TypeField, unknown>>>;
+    }, z.core.$strip>], "kind">>;
+    unresolved: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type BridgeTypeDefinitions = z.infer<typeof bridgeTypeDefinitions>;
+/**
+ * The built-in `bridge_state` datapoint every robot has (spec §4.3):
+ * connection status plus latency, the basis for offline-aware client UIs.
+ */
+export declare const bridgeState: z.ZodObject<{
+    online: z.ZodBoolean;
+    latency_ms: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strip>;
+export type BridgeState = z.infer<typeof bridgeState>;
+/**
+ * The built-in `bridge_pressure` datapoint (spec §4.3, the pressure-telemetry
+ * design's "The decision that shapes everything"): the bridge's own
+ * bandwidth-shaping state, sent on the same reserved-slug path as
+ * `bridge_state` so history, realtime, REST and MCP exposure fall out of the
+ * ordinary datapoint machinery for free.
+ */
+export declare const bridgePressure: z.ZodObject<{
+    link: z.ZodObject<{
+        rate_bps: z.ZodNullable<z.ZodNumber>;
+        snapshot_max_bytes: z.ZodNumber;
+    }, z.core.$strip>;
+    tiers: z.ZodObject<{
+        '0': z.ZodOptional<z.ZodObject<{
+            sent: z.ZodNumber;
+            bytes: z.ZodNumber;
+            drops: z.ZodNumber;
+            high_water: z.ZodNumber;
+        }, z.core.$strip>>;
+        '1': z.ZodOptional<z.ZodObject<{
+            sent: z.ZodNumber;
+            bytes: z.ZodNumber;
+            drops: z.ZodNumber;
+            high_water: z.ZodNumber;
+        }, z.core.$strip>>;
+        '2': z.ZodOptional<z.ZodObject<{
+            sent: z.ZodNumber;
+            bytes: z.ZodNumber;
+            drops: z.ZodNumber;
+            high_water: z.ZodNumber;
+        }, z.core.$strip>>;
+        '3': z.ZodOptional<z.ZodObject<{
+            sent: z.ZodNumber;
+            bytes: z.ZodNumber;
+            drops: z.ZodNumber;
+            high_water: z.ZodNumber;
+        }, z.core.$strip>>;
+        '4': z.ZodOptional<z.ZodObject<{
+            sent: z.ZodNumber;
+            bytes: z.ZodNumber;
+            drops: z.ZodNumber;
+            high_water: z.ZodNumber;
+        }, z.core.$strip>>;
+        '5': z.ZodOptional<z.ZodObject<{
+            sent: z.ZodNumber;
+            bytes: z.ZodNumber;
+            drops: z.ZodNumber;
+            high_water: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strict>;
+    video: z.ZodObject<{
+        active_streams: z.ZodNumber;
+        bitrate_sum_kbps: z.ZodNumber;
+        uplink_kbps: z.ZodNullable<z.ZodNumber>;
+        override_kbps: z.ZodNullable<z.ZodNumber>;
+        video_budget_kbps: z.ZodNullable<z.ZodNumber>;
+        reserve_kbps: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type BridgePressure = z.infer<typeof bridgePressure>;
+export declare const PRESSURE_SLUG: "bridge_pressure";
+/**
+ * The header of a **binary** snapshot frame, bridge → cloud.
+ *
+ * A snapshot frame is laid out as:
+ *
+ *   [4-byte big-endian header length][UTF-8 JSON header][image bytes]
+ *
+ * Binary rather than base64 in a text frame, because base64 costs a third of
+ * the robot's upstream for nothing. Self-contained rather than a JSON frame
+ * followed by a binary one, because that pairing would depend on frame
+ * ordering — and W4 established, at some cost, that ordering across a socket
+ * is not something to lean on.
+ *
+ * `timestamp_ms` is the bridge's **capture** time (§6.3), which is what lets
+ * every consumer state a snapshot's true age. A picture that lies about when
+ * it was taken is this wave's version of a job that reads "running" when
+ * nobody knows.
+ */
+/**
+ * The largest a snapshot frame — header and image bytes together — may be on
+ * the `/bridge` socket.
+ *
+ * This is a **byte** bound and not a pixel one, deliberately. A camera's
+ * `width`/`height` govern the *live* stream, which travels through LiveKit
+ * and never touches this socket, so capping resolution to protect the socket
+ * would cost live quality to solve a snapshot problem.
+ *
+ * The bound exists because exceeding it is not a dropped frame: `ws` enforces
+ * its payload limit before the frame is ever delivered and closes the
+ * connection with 1009 — taking datapoints, jobs, commands and configuration
+ * down with it. The bridge would then reconnect, receive the same
+ * configuration, capture the same frame and be closed again: a robot that
+ * will not stay online, from a configuration the platform accepted. Measured
+ * during the W5 review, a 4K JPEG of real camera content lands around
+ * 2.2 MiB and 1080p on a noisy scene within 40% of this number, so the margin
+ * is thinner than it looks.
+ *
+ * **The bridge must degrade rather than exceed it** — lower JPEG quality,
+ * then downscale, and if it still does not fit, skip the frame and say so.
+ * A missing snapshot is a gap, and this wave already established that a gap
+ * is an honest answer; a closed socket is not.
+ */
+export declare const SNAPSHOT_MAX_BYTES = 1572864;
+export declare const snapshotHeader: z.ZodObject<{
+    type: z.ZodLiteral<"snapshot">;
+    slug: z.ZodString;
+    mime: z.ZodString;
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+    timestamp_ms: z.ZodNumber;
+}, z.core.$strip>;
+export type SnapshotHeader = z.infer<typeof snapshotHeader>;
+/**
+ * Cloud → bridge: start publishing this camera live.
+ *
+ * The **cloud** mints the room and the publisher token, for the same reason
+ * it mints a `job_id` before asking anything (§6.1): the side that owns the
+ * refcount must own the identity of the stream, or a robot could end up
+ * publishing into a room nobody is watching.
+ */
+export declare const cloudCameraStart: z.ZodObject<{
+    type: z.ZodLiteral<"camera_start">;
+    slug: z.ZodString;
+    url: z.ZodString;
+    room: z.ZodString;
+    token: z.ZodString;
+    request_id: z.ZodString;
+}, z.core.$strip>;
+export type CloudCameraStart = z.infer<typeof cloudCameraStart>;
+/** Cloud → bridge: the last viewer left; stop publishing (§10 refcount). */
+/**
+ * Assets (spec §4.6, W7): the bridge **reports availability and transfers
+ * nothing** until asked.
+ *
+ * **The bytes never travel on this socket.** `server.ts` caps a frame at
+ * 2 MiB, a single mesh exceeds that routinely, and raising the cap is already
+ * tied to W8's rate limiting in the deferral register because it amplifies an
+ * unauthenticated path. So the socket carries the *conversation* — what exists,
+ * transfer this, here is how far I got — and the bytes go over HTTP with the
+ * robot's own credential.
+ *
+ * That split is the whole design: a 40 MB mesh cannot stall the frames that
+ * keep a robot answerable, and a failed upload cannot take the control channel
+ * down with it.
+ */
+export declare const bridgeAssetsAvailable: z.ZodObject<{
+    type: z.ZodLiteral<"assets_available">;
+    urdf: z.ZodBoolean;
+    meshes: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type BridgeAssetsAvailable = z.infer<typeof bridgeAssetsAvailable>;
+/**
+ * The explicit request §4.6 requires — nothing moves without it.
+ *
+ * The upload credential is minted per sync and travels here rather than being
+ * derived from the robot token: it is scoped to one robot's assets and one
+ * sync, so a bridge cannot be talked into uploading somewhere else, and an
+ * expired one fails a sync instead of failing a robot.
+ */
+export declare const cloudAssetRequest: z.ZodObject<{
+    type: z.ZodLiteral<"asset_request">;
+    sync_id: z.ZodUUID;
+    upload_url: z.ZodURL;
+    token: z.ZodString;
+    meshes: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type CloudAssetRequest = z.infer<typeof cloudAssetRequest>;
+/**
+ * How far a sync got, and — required, not optional — what it could not do.
+ *
+ * `failed` carries the URIs that did not resolve. A sync that quietly drops
+ * three meshes and reports success moves the failure into somebody else's
+ * renderer, where it appears as a robot with missing limbs and no cause.
+ */
+export declare const bridgeAssetProgress: z.ZodObject<{
+    type: z.ZodLiteral<"asset_progress">;
+    sync_id: z.ZodUUID;
+    done: z.ZodNumber;
+    total: z.ZodNumber;
+    failed: z.ZodArray<z.ZodObject<{
+        reference: z.ZodString;
+        kind: z.ZodEnum<{
+            unresolvable: "unresolvable";
+            upload_failed: "upload_failed";
+            refused: "refused";
+            too_large: "too_large";
+        }>;
+        details: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            limit_bytes: z.ZodNumber;
+            size_bytes: z.ZodNumber;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    state: z.ZodEnum<{
+        running: "running";
+        finished: "finished";
+        refused_busy: "refused_busy";
+    }>;
+}, z.core.$strip>;
+export type BridgeAssetProgress = z.infer<typeof bridgeAssetProgress>;
+export declare const cloudCameraStop: z.ZodObject<{
+    type: z.ZodLiteral<"camera_stop">;
+    slug: z.ZodString;
+    request_id: z.ZodString;
+}, z.core.$strip>;
+export type CloudCameraStop = z.infer<typeof cloudCameraStop>;
+/**
+ * What the bridge made of it. `publishing: false` with an `error` is how a
+ * camera that cannot start says so — the cloud must not leave a viewer
+ * watching a black rectangle while believing the stream is live.
+ */
+export declare const bridgeCameraState: z.ZodObject<{
+    type: z.ZodLiteral<"camera_state">;
+    slug: z.ZodString;
+    publishing: z.ZodBoolean;
+    error: z.ZodNullable<z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+    }, z.core.$strip>>;
+    cause: z.ZodEnum<{
+        source: "source";
+        command: "command";
+        config_change: "config_change";
+        live_lost: "live_lost";
+    }>;
+    observed_at_ms: z.ZodNumber;
+    request_id: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type BridgeCameraState = z.infer<typeof bridgeCameraState>;