@fleetless/contracts 1.1.0 → 2.0.0

package/dist/protocol.js

@@ -7,18 +7,79 @@ import { rosGraph, typeDefinition } from './introspection.js';
 import { jobState } from './jobs.js';
 import { rosTypeName } from './common.js';
 /**
- * Bridge <-> cloud protocol, version 2.
+ * Bridge <-> cloud protocol, version 3.
  *
- * The version is exchanged in the hello handshake; the cloud refuses an
- * incompatible bridge: `protocol_mismatch`, which names both versions and
- * reaches the robot's detail view as `last_hello_error`.
+ * The version is exchanged in the hello handshake. Since 2026-09 the cloud
+ * serves a **window** of versions, not one: every entry of
+ * `PROTOCOL_VERSIONS` whose sunset has not passed. A version is deprecated
+ * by the cloud release that supersedes it and sunset `PROTOCOL_SUNSET_DAYS`
+ * later. Outside the window the cloud refuses with `protocol_mismatch`,
+ * which names the window and reaches the robot's detail view as
+ * `last_hello_error`.
+ *
+ * **3 (2026-09-22):** the ping carries `latency_ms` and `lag_ms`, the bridge
+ * sends `link_mode`, `bridge_state` gains `low_bandwidth`, and the
+ * `bridge_pressure` datapoint is gone. A protocol-2 bridge is served until
+ * its sunset, and the cloud's protocol-2 adapter owes it two translations on
+ * the way in: it drops its pressure datapoints, and it rewrites an
+ * `asset_progress` failure of kind `too_large` — a kind protocol 3 no longer
+ * has — to `refused` with `details: null`, because a 2.0.0 `bridgeAssetProgress`
+ * refuses the frame outright otherwise.
  *
  * **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.
+ * beside `message`.
+ */
+export const PROTOCOL_VERSION = 3;
+/** Days between a version's deprecation and its sunset. */
+export const PROTOCOL_SUNSET_DAYS = 90;
+/**
+ * Every protocol version the cloud has served, oldest first. A test keeps
+ * exactly one entry current and equal to `PROTOCOL_VERSION`; `test/changelog.test.ts`
+ * requires the CHANGELOG's current section to name the newest `bridge_from`
+ * and the previous entry's `sunsetOf(...)` date, and `scripts/verify-version-tag.mjs`
+ * requires a dated heading for the tag being released.
+ */
+export const PROTOCOL_VERSIONS = [
+    { version: 2, bridge_from: '3.0.0', deprecated_at: '2026-09-22' },
+    { version: 3, bridge_from: '4.0.0', deprecated_at: null },
+];
+/** The newest bridge package. The cloud mails organisations still below it. */
+export const LATEST_BRIDGE_VERSION = '4.0.0';
+const DAY_MS = 24 * 60 * 60 * 1000;
+function isoDate(date) {
+    return date.toISOString().slice(0, 10);
+}
+export function sunsetOf(entry) {
+    if (entry.deprecated_at === null)
+        return null;
+    return isoDate(new Date(Date.parse(entry.deprecated_at + 'T00:00:00Z') + PROTOCOL_SUNSET_DAYS * DAY_MS));
+}
+/**
+ * The window rule itself: `protocolStatus` and `minimumProtocolVersion` are
+ * this function over `PROTOCOL_VERSIONS`, and the cloud calls it directly.
+ *
+ * The table is a parameter because callers pass one with a deprecated entry —
+ * tests, and any caller reasoning about a sunset. The real table has none
+ * until the first bump, so a hard-coded `PROTOCOL_VERSIONS` would leave the
+ * deprecated and unsupported branches unreachable.
  */
-export const PROTOCOL_VERSION = 2;
+export function statusFromTable(table, version, today) {
+    const entry = table.find((candidate) => candidate.version === version);
+    if (!entry)
+        return { status: 'unsupported', sunset_at: null };
+    const sunset = sunsetOf(entry);
+    if (sunset === null)
+        return { status: 'current', sunset_at: null };
+    return { status: isoDate(today) < sunset ? 'deprecated' : 'unsupported', sunset_at: sunset };
+}
+export function protocolStatus(version, today = new Date()) {
+    return statusFromTable(PROTOCOL_VERSIONS, version, today);
+}
+/** The lowest version still inside its window today. */
+export function minimumProtocolVersion(today = new Date()) {
+    const alive = PROTOCOL_VERSIONS.filter((entry) => statusFromTable(PROTOCOL_VERSIONS, entry.version, today).status !== 'unsupported');
+    return alive[0]?.version ?? PROTOCOL_VERSION;
+}
 /**
  * The bridge socket close code for "this robot no longer exists".
  *
@@ -30,6 +91,20 @@ export const PROTOCOL_VERSION = 2;
  * more informative than "connection closed".
  */
 export const CLOSE_ROBOT_DELETED = 4004;
+/**
+ * The bridge socket close code for "the token you connected with is gone".
+ *
+ * The cloud closes a robot's live socket with this after the robot's token was
+ * rotated. A 4.0.0 bridge reads it the way it reads `invalid_token` — stop,
+ * exit 2 — because the secret it holds is no longer a secret anyone accepts,
+ * and no amount of reconnecting produces the new one. A 3.x bridge does not
+ * know the code, reconnects, and is refused at hello; that ends the same way,
+ * one round trip later.
+ *
+ * Its own code rather than `CLOSE_ROBOT_DELETED`, which would tell an operator
+ * their robot had been deleted when it very much still exists.
+ */
+export const CLOSE_TOKEN_ROTATED = 4005;
 /**
  * How long a command waits for its answer when the caller names no patience
  * of its own.
@@ -120,10 +195,35 @@ export const bridgeHello = z.object({
      */
     active_jobs: z.array(activeJob).max(500).default([]),
 });
-/** Cloud accepts the bridge: the robot is online from here on. */
+/**
+ * Cloud accepts the bridge: the robot is online from here on.
+ *
+ * `protocol` and `bridge` are optional so that a bridge parsing `hello_ok`
+ * strictly still parses one from an older cloud. `status` here is never
+ * `unsupported`: an unsupported version gets `hello_error`, not this frame.
+ */
 export const cloudHelloOk = z.object({
     type: z.literal('hello_ok'),
     robot_id: z.uuid(),
+    protocol: z
+        .object({
+        status: z.enum(['current', 'deprecated']).meta({
+            description: '`current` or `deprecated` — never `unsupported`, which is a `hello_error`.',
+        }),
+        sunset_at: z.iso.date().nullable().meta({
+            description: 'ISO date a deprecated version stops being served; `null` when current.',
+        }),
+    })
+        .optional()
+        .meta({ description: "The cloud's verdict on the announced protocol version; absent from an older cloud." }),
+    bridge: z
+        .object({
+        latest_version: z.string().min(1).meta({
+            description: "The newest published fleetless-bridge package version, for the bridge's own upgrade hint.",
+        }),
+    })
+        .optional()
+        .meta({ description: 'What the cloud knows about bridge packages; absent from an older cloud.' }),
 });
 /** Cloud refuses the bridge (bad token, incompatible protocol, ...). */
 export const cloudHelloError = z.object({
@@ -134,27 +234,57 @@ export const cloudHelloError = z.object({
 /**
  * One datapoint sample. `timestamp_ms` is the capture time at the bridge —
  * never the receive time — so clients compute age themselves.
+ *
+ * Which is exactly why `backfill` has to be on the frame. A replayed sample
+ * carries the capture time it had during the outage, so a cloud that measures
+ * lag from every arriving frame reads a two-hour disconnect as two hours of
+ * lag the moment the bridge reconnects — and reports a healthy link as the
+ * worst one it has ever seen. Only the bridge knows which frames came out of
+ * its buffer, so only the bridge can say.
  */
 export const datapointFrame = z.object({
     type: z.literal('datapoint'),
     slug,
     value: z.unknown(),
     timestamp_ms: z.number().int().nonnegative(),
+    backfill: z.boolean().optional().meta({ description: 'true when the sample was captured while the bridge was disconnected and is being replayed after the reconnect. The cloud keeps such a sample out of its lag measure; absent means live.' }),
 });
 /**
  * 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`.
+ *
+ * Sent every `pingIntervalMs`; the bridge answers with `pong`. Since protocol
+ * 3 it also carries what the cloud measured about this link, so the bridge
+ * can decide on its low-bandwidth mode with an end-to-end number: the
+ * round trip of the last pong, and the datapoint lag — the median over the
+ * last five seconds of (receive time − `timestamp_ms`) minus the minimum of
+ * the last ten minutes, which cancels the robot's clock offset. `null` until
+ * the cloud has a sample. A protocol-2 bridge reads only `ts_ms`.
  */
 export const cloudPing = z.object({
     type: z.literal('ping'),
     ts_ms: z.number().int().nonnegative(),
+    latency_ms: z.number().nonnegative().nullable().meta({ description: 'Round trip of the last pong in milliseconds; null before the first.' }),
+    lag_ms: z.number().nonnegative().nullable().meta({ description: 'Datapoint lag over the link: median of the last five seconds minus the ten-minute minimum, in milliseconds; null until a sample exists, and null again whenever no live sample arrived in the last five seconds, because a stale median would be a lie.' }),
 });
 /** Immediate bridge answer to a `CloudPing`, `ts_ms` echoed unchanged. */
 export const bridgePong = z.object({
     type: z.literal('pong'),
     ts_ms: z.number().int().nonnegative(),
 });
+/**
+ * The bridge's low-bandwidth mode changed. Sent on every transition and once
+ * after `hello_ok`, at tier 0 like the pong: the cloud folds it into
+ * `bridge_state.low_bandwidth`, and a frame that waited behind bulk would
+ * describe a state that is already over.
+ */
+export const bridgeLinkMode = z.object({
+    type: z.literal('link_mode'),
+    low_bandwidth: z.boolean().meta({ description: 'Whether the mode is active after this transition.' }),
+    reason: z.enum(['lag', 'dwell', 'forced', 'recovered']).meta({ description: '`lag`: the cloud-measured lag crossed the threshold; `dwell`: the bridge-measured queue dwell did; `forced`: `mode: on` or `off`; `recovered`: both measures stayed at or below the exit threshold.' }),
+    at_ms: z.number().int().nonnegative().meta({ description: 'Bridge time of the transition, epoch milliseconds.' }),
+});
 /**
  * The published configuration, cloud → bridge — the bridge applies the
  * published version. Sent right after `hello_ok` and again on every publish,
@@ -350,89 +480,16 @@ export const bridgeTypeDefinitions = z.object({
 /**
  * The built-in `bridge_state` datapoint every robot has: connection status
  * plus latency, the basis for offline-aware client UIs.
+ *
+ * `online` and `latency_ms` are cloud-observed (the socket, the pong);
+ * `low_bandwidth` is bridge-reported through `link_mode` and `false` for a
+ * bridge that never sends one.
  */
 export const bridgeState = z.object({
     online: z.boolean(),
     latency_ms: z.number().nonnegative().nullable(),
+    low_bandwidth: z.boolean().meta({ description: 'Whether the bridge is in its low-bandwidth mode: datapoints capped, cameras reduced or stopped. Bridge-reported.' }),
 });
-/** One tier's counters, `tiers` below carries six of these under string keys. */
-const bridgePressureTier = z.object({
-    sent: z.number().int().nonnegative(),
-    bytes: z.number().int().nonnegative(),
-    drops: z.number().int().nonnegative(),
-    high_water: z.number().int().nonnegative(),
-});
-/**
- * The built-in `bridge_pressure` datapoint: 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 const bridgePressure = z.object({
-    link: z.object({
-        /** bytes/s the socket demonstrably drains, from sends >= 64 KiB
-         *  only; null until the first large send of the session. */
-        rate_bps: z.number().nonnegative().nullable(),
-        /**
-         * the byte target snapshots are currently encoded to fit.
-         *
-         * `.nonnegative()`, not `.positive()`: the target is derived from
-         * `rate_bps`, and a link measured below 0.5 B/s floors to 0 here. A
-         * schema that rejects 0 does not prevent that link — it only makes the
-         * frame reporting it unparseable, and a console that cannot parse a
-         * pressure frame shows "no feed", i.e. reports a struggling robot as an
-         * *old* one. Zero is a legitimate reading and says something true.
-         */
-        snapshot_max_bytes: z.number().int().nonnegative(),
-    }),
-    /**
-     * String keys "0".."5" because JSON has no integer keys. Counters are
-     * cumulative per session and reset on reconnect; clients window by
-     * differencing two samples.
-     *
-     * **What this schema does not decide:** it does not guarantee all six
-     * keys are present (`z.record` over the six literals is exhaustive in
-     * zod 4 — tested here, it required every key and rejected none, the
-     * opposite of what a partial sample needs — so this is a
-     * `.strictObject().partial()` over the same six literal keys instead, a
-     * deliberate deviation from the originally sketched `z.record` shape with
-     * the same runtime behaviour). A missing tier key reads as zeros; the
-     * schema names what it cannot decide rather than implying a completeness
-     * it cannot check.
-     */
-    tiers: z
-        .strictObject({
-        '0': bridgePressureTier,
-        '1': bridgePressureTier,
-        '2': bridgePressureTier,
-        '3': bridgePressureTier,
-        '4': bridgePressureTier,
-        '5': bridgePressureTier,
-    })
-        .partial(),
-    video: z.object({
-        active_streams: z.number().int().nonnegative(),
-        bitrate_sum_kbps: z.number().int().nonnegative(),
-        /**
-         * The uplink budget the bridge was configured with
-         * (`FLEETLESS_UPLINK_KBPS`), or `null` when none was set.
-         *
-         * `.nonnegative()`, not `.positive()`: `FLEETLESS_UPLINK_KBPS=0` is a
-         * documented setting meaning "no video budget at all", and the bridge
-         * emits that 0 verbatim. `.positive()` made every frame from such a
-         * robot fail the console's `safeParse`, which renders an unparseable
-         * frame as "no pressure feed" — so the one robot that had *deliberately*
-         * turned video off was the one diagnosed as running a bridge too old to
-         * report pressure. A value the producer legitimately sends must parse;
-         * `null` is the only "not set" this field has.
-         */
-        uplink_kbps: z.number().int().nonnegative().nullable(),
-        override_kbps: z.number().int().nonnegative().nullable(),
-        video_budget_kbps: z.number().int().nonnegative().nullable(),
-        reserve_kbps: z.number().int().nonnegative(),
-    }),
-});
-export const PRESSURE_SLUG = 'bridge_pressure';
 /* ------------------------------------------------------------------------
  * Cameras.
  */

package/dist/rest.d.ts

@@ -37,6 +37,39 @@ export declare const createRobotResponse: z.ZodObject<{
     token: z.ZodString;
 }, z.core.$strip>;
 export type CreateRobotResponse = z.infer<typeof createRobotResponse>;
+/**
+ * What a rotation hands back: the new token, once.
+ *
+ * The same shape as the creation response minus the robot, because nothing
+ * about the robot changed — only its credential. `createRobotResponse`'s own
+ * rule applies unchanged: the cloud stores a hash, so this is the only moment
+ * the raw token exists outside the caller's hands.
+ */
+export declare const robotTokenRotateResponse: z.ZodObject<{
+    token: z.ZodString;
+}, z.core.$strip>;
+export type RobotTokenRotateResponse = z.infer<typeof robotTokenRotateResponse>;
+/**
+ * Which datapoint drives the joints of this robot's URDF, or none.
+ *
+ * `null` is the clearing value, which is why `slug` is required rather than
+ * optional: an absent field and a cleared mapping would be the same request
+ * and mean different things, and the one a client sends by accident is the
+ * first.
+ *
+ * The cloud refuses a slug that is not a whole-message
+ * `sensor_msgs/msg/JointState` datapoint of the **published** document — a
+ * mapping that may point anywhere is a viewer animating a battery reading.
+ */
+export declare const jointStatePutRequest: z.ZodObject<{
+    slug: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type JointStatePutRequest = z.infer<typeof jointStatePutRequest>;
+/** The mapping as it now stands — the same field `GET /api/robots/:id/assets` reports. */
+export declare const jointStatePutResponse: z.ZodObject<{
+    joint_state_slug: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type JointStatePutResponse = z.infer<typeof jointStatePutResponse>;
 /**
  * How many things a robot exposes, per kind.
  *
@@ -46,18 +79,17 @@ export type CreateRobotResponse = z.infer<typeof createRobotResponse>;
  *
  * **Counted from the published configuration, and excluding the built-ins.**
  * `GET /api/robots/:id/exposures` answers *which* slugs and prepends the
- * three built-in datapoints — `bridge_state`, `robot_details` and
- * `bridge_pressure` — as `builtin: true`; this answers *how many* and counts
- * only what somebody configured. So a robot with an empty published config
- * reports `datapoints: 0` here and three entries there. That is intentional,
- * and it is written on both sides so the disagreement is never mistaken for a
- * bug.
- *
- * The number is "three" and not "two" as of `bridge_pressure`; the cloud
- * builds that prefix from `PLANE_BUILTIN_DATAPOINTS` rather than a literal,
- * so a further built-in moves this count again. Read the count off that set,
- * not off this sentence, before filing the bug this comment exists to
- * prevent.
+ * built-in datapoints — `bridge_state` and `robot_details` — as
+ * `builtin: true`; this answers *how many* and counts only what somebody
+ * configured. So a robot with an empty published config reports
+ * `datapoints: 0` here and two entries there. That is intentional, and it is
+ * written on both sides so the disagreement is never mistaken for a bug.
+ *
+ * The number was "three" while `bridge_pressure` existed and is "two" since
+ * protocol 3 dropped it; the cloud builds that prefix from its own built-in
+ * set rather than a literal, so the next built-in moves this count again.
+ * Read the count off that set, not off this sentence, before filing the bug
+ * this comment exists to prevent.
  */
 export declare const exposureCounts: z.ZodObject<{
     datapoints: z.ZodNumber;
@@ -67,11 +99,24 @@ export declare const exposureCounts: z.ZodObject<{
     cameras: z.ZodNumber;
 }, z.core.$strip>;
 export type ExposureCounts = z.infer<typeof exposureCounts>;
+/**
+ * Where a robot's bridge stands against the protocol window.
+ * `refused`: its last hello was refused for its version — it is offline
+ * until upgraded. Computed by the cloud from `protocol_version` and
+ * `last_hello_error`, never stored.
+ */
+export declare const protocolStatusValue: z.ZodEnum<{
+    deprecated: "deprecated";
+    refused: "refused";
+    current: "current";
+}>;
+export type ProtocolStatusValue = z.infer<typeof protocolStatusValue>;
 /** A robot as listed, with its current built-in `bridge_state`. */
 export declare const robotListItem: z.ZodObject<{
     bridge_state: z.ZodObject<{
         online: z.ZodBoolean;
         latency_ms: z.ZodNullable<z.ZodNumber>;
+        low_bandwidth: z.ZodBoolean;
     }, z.core.$strip>;
     exposes: z.ZodObject<{
         datapoints: z.ZodNumber;
@@ -80,6 +125,11 @@ export declare const robotListItem: z.ZodObject<{
         publishers: z.ZodNumber;
         cameras: z.ZodNumber;
     }, z.core.$strip>;
+    protocol_status: z.ZodOptional<z.ZodEnum<{
+        deprecated: "deprecated";
+        refused: "refused";
+        current: "current";
+    }>>;
     id: z.ZodUUID;
     name: z.ZodString;
     created_at: z.ZodISODateTime;
@@ -90,6 +140,7 @@ export declare const robotListResponse: z.ZodObject<{
         bridge_state: z.ZodObject<{
             online: z.ZodBoolean;
             latency_ms: z.ZodNullable<z.ZodNumber>;
+            low_bandwidth: z.ZodBoolean;
         }, z.core.$strip>;
         exposes: z.ZodObject<{
             datapoints: z.ZodNumber;
@@ -98,6 +149,11 @@ export declare const robotListResponse: z.ZodObject<{
             publishers: z.ZodNumber;
             cameras: z.ZodNumber;
         }, z.core.$strip>;
+        protocol_status: z.ZodOptional<z.ZodEnum<{
+            deprecated: "deprecated";
+            refused: "refused";
+            current: "current";
+        }>>;
         id: z.ZodUUID;
         name: z.ZodString;
         created_at: z.ZodISODateTime;
@@ -122,6 +178,15 @@ export type DatapointValue = z.infer<typeof datapointValue>;
  */
 export declare const robotDetailResponse: z.ZodObject<{
     bridge_version: z.ZodNullable<z.ZodString>;
+    protocol_version: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    protocol: z.ZodOptional<z.ZodObject<{
+        status: z.ZodEnum<{
+            deprecated: "deprecated";
+            refused: "refused";
+            current: "current";
+        }>;
+        sunset_at: z.ZodNullable<z.ZodISODate>;
+    }, z.core.$strip>>;
     last_hello_error: z.ZodNullable<z.ZodObject<{
         code: z.ZodString;
         message: z.ZodString;
@@ -141,6 +206,7 @@ export declare const robotDetailResponse: z.ZodObject<{
                 service: "service";
                 publisher: "publisher";
                 camera: "camera";
+                low_bandwidth: "low_bandwidth";
             }>;
             code: z.ZodString;
             message: z.ZodString;
@@ -150,6 +216,7 @@ export declare const robotDetailResponse: z.ZodObject<{
     bridge_state: z.ZodObject<{
         online: z.ZodBoolean;
         latency_ms: z.ZodNullable<z.ZodNumber>;
+        low_bandwidth: z.ZodBoolean;
     }, z.core.$strip>;
     exposes: z.ZodObject<{
         datapoints: z.ZodNumber;
@@ -158,6 +225,11 @@ export declare const robotDetailResponse: z.ZodObject<{
         publishers: z.ZodNumber;
         cameras: z.ZodNumber;
     }, z.core.$strip>;
+    protocol_status: z.ZodOptional<z.ZodEnum<{
+        deprecated: "deprecated";
+        refused: "refused";
+        current: "current";
+    }>>;
     id: z.ZodUUID;
     name: z.ZodString;
     created_at: z.ZodISODateTime;
@@ -203,6 +275,7 @@ export declare const configDraftResponse: z.ZodObject<{
             type: z.ZodString;
             field: z.ZodOptional<z.ZodString>;
             rate_throttle_hz: z.ZodOptional<z.ZodNumber>;
+            low_bandwidth: z.ZodOptional<z.ZodLiteral<"keep">>;
             description: z.ZodOptional<z.ZodString>;
             numeric: z.ZodOptional<z.ZodObject<{
                 scale: z.ZodOptional<z.ZodNumber>;
@@ -369,6 +442,23 @@ export declare const configDraftResponse: z.ZodObject<{
             snapshot_interval_seconds: z.ZodNumber;
             description: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>>>;
+        low_bandwidth: z.ZodOptional<z.ZodObject<{
+            mode: z.ZodOptional<z.ZodEnum<{
+                auto: "auto";
+                on: "on";
+                off: "off";
+            }>>;
+            enter_lag_ms: z.ZodOptional<z.ZodNumber>;
+            enter_after_s: z.ZodOptional<z.ZodNumber>;
+            exit_lag_ms: z.ZodOptional<z.ZodNumber>;
+            exit_after_s: z.ZodOptional<z.ZodNumber>;
+            datapoint_max_hz: z.ZodOptional<z.ZodNumber>;
+            camera: z.ZodOptional<z.ZodEnum<{
+                reduce: "reduce";
+                stop: "stop";
+            }>>;
+            camera_bitrate_kbps: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
     }, z.core.$strict>>;
     source: z.ZodString;
     updated_at: z.ZodNullable<z.ZodISODateTime>;
@@ -439,6 +529,7 @@ export declare const configVersionResponse: z.ZodObject<{
             type: z.ZodString;
             field: z.ZodOptional<z.ZodString>;
             rate_throttle_hz: z.ZodOptional<z.ZodNumber>;
+            low_bandwidth: z.ZodOptional<z.ZodLiteral<"keep">>;
             description: z.ZodOptional<z.ZodString>;
             numeric: z.ZodOptional<z.ZodObject<{
                 scale: z.ZodOptional<z.ZodNumber>;
@@ -605,6 +696,23 @@ export declare const configVersionResponse: z.ZodObject<{
             snapshot_interval_seconds: z.ZodNumber;
             description: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>>>;
+        low_bandwidth: z.ZodOptional<z.ZodObject<{
+            mode: z.ZodOptional<z.ZodEnum<{
+                auto: "auto";
+                on: "on";
+                off: "off";
+            }>>;
+            enter_lag_ms: z.ZodOptional<z.ZodNumber>;
+            enter_after_s: z.ZodOptional<z.ZodNumber>;
+            exit_lag_ms: z.ZodOptional<z.ZodNumber>;
+            exit_after_s: z.ZodOptional<z.ZodNumber>;
+            datapoint_max_hz: z.ZodOptional<z.ZodNumber>;
+            camera: z.ZodOptional<z.ZodEnum<{
+                reduce: "reduce";
+                stop: "stop";
+            }>>;
+            camera_bitrate_kbps: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
     }, z.core.$strict>;
     source: z.ZodString;
 }, z.core.$strip>;
@@ -1105,22 +1213,21 @@ export declare const ASSET_UPLOAD_HEADERS: {
     readonly nameEncoded: "x-fleetless-asset-name-encoded";
     readonly syncId: "x-fleetless-sync-id";
     /**
-     * **The announced size, and it is what makes `asset_too_large` reachable at
-     * all.**
+     * **The announced size, and it is what makes a structured store refusal
+     * reachable at all.**
      *
      * A server-side body limit is applied by the content-type parser, before the
-     * handler runs, so an oversized upload can only be refused with a bare
-     * `413` carrying neither `limit_bytes` nor `size_bytes` — and the structured
-     * refusal `assetTooLargeDetails` describes would have no producer.
+     * handler runs, so an upload with no room left can only be refused with a
+     * bare `413` carrying none of the three numbers — and the refusal
+     * `assetStoreRefusedDetails` describes would have no producer.
      *
-     * With the size announced in a header the refusal can be made where it can
-     * say something: before a byte is buffered, with both numbers. It also lets
-     * a producer discover its own limit without first reading the whole file
-     * into memory.
+     * With the size announced in a header the cloud can check `used + size`
+     * against `ROBOT_ASSET_STORE_BYTES` where it can still say something: before
+     * a byte is buffered, with all three numbers.
      *
      * The header is an **announcement, not a proof**: a sender can lie. The
-     * ceiling still applies to the body — this does not replace enforcement, it
-     * only makes the refusal answerable.
+     * store still applies to the bytes that arrive — this does not replace
+     * enforcement, it only makes the refusal answerable.
      */
     readonly size: "x-fleetless-asset-size";
 };
@@ -1248,8 +1355,8 @@ export declare const historySamplesResponse: z.ZodObject<{
     }, z.core.$strip>>;
     truncated: z.ZodBoolean;
     truncated_by: z.ZodNullable<z.ZodEnum<{
-        limit: "limit";
         bytes: "bytes";
+        limit: "limit";
     }>>;
 }, z.core.$strip>;
 export type HistorySamplesResponse = z.infer<typeof historySamplesResponse>;
@@ -1307,8 +1414,8 @@ export declare const historyResponse: z.ZodUnion<readonly [z.ZodObject<{
     }, z.core.$strip>>;
     truncated: z.ZodBoolean;
     truncated_by: z.ZodNullable<z.ZodEnum<{
-        limit: "limit";
         bytes: "bytes";
+        limit: "limit";
     }>>;
 }, z.core.$strip>, z.ZodObject<{
     slug: z.ZodString;
@@ -1519,7 +1626,6 @@ export declare const orgQuotas: z.ZodObject<{
     max_retention_bytes: z.ZodNumber;
     max_retention_writes_per_minute: z.ZodNumber;
     max_realtime_connections: z.ZodNumber;
-    max_asset_storage_bytes: z.ZodNumber;
 }, z.core.$strip>;
 export type OrgQuotas = z.infer<typeof orgQuotas>;
 /**
@@ -1542,7 +1648,6 @@ export declare const orgQuotaUsageCounts: z.ZodObject<{
     max_apps: z.ZodOptional<z.ZodNumber>;
     max_end_users: z.ZodOptional<z.ZodNumber>;
     max_retention_bytes: z.ZodOptional<z.ZodNumber>;
-    max_asset_storage_bytes: z.ZodOptional<z.ZodNumber>;
     max_retention_writes_per_minute: z.ZodOptional<z.ZodNumber>;
     max_realtime_connections: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
@@ -1556,14 +1661,12 @@ export declare const orgQuotaUsage: z.ZodObject<{
         max_retention_bytes: z.ZodNumber;
         max_retention_writes_per_minute: z.ZodNumber;
         max_realtime_connections: z.ZodNumber;
-        max_asset_storage_bytes: z.ZodNumber;
     }, z.core.$strip>;
     usage: z.ZodObject<{
         max_robots: z.ZodOptional<z.ZodNumber>;
         max_apps: z.ZodOptional<z.ZodNumber>;
         max_end_users: z.ZodOptional<z.ZodNumber>;
         max_retention_bytes: z.ZodOptional<z.ZodNumber>;
-        max_asset_storage_bytes: z.ZodOptional<z.ZodNumber>;
         max_retention_writes_per_minute: z.ZodOptional<z.ZodNumber>;
         max_realtime_connections: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>;
@@ -1699,8 +1802,8 @@ export declare const orgLatencyResponse: z.ZodObject<{
     to_ms: z.ZodNumber;
     truncated: z.ZodBoolean;
     truncated_by: z.ZodNullable<z.ZodEnum<{
-        limit: "limit";
         bytes: "bytes";
+        limit: "limit";
     }>>;
 }, z.core.$strip>;
 export type OrgLatencyResponse = z.infer<typeof orgLatencyResponse>;
@@ -1716,11 +1819,10 @@ export declare const USAGE_WINDOW_MAX_DAYS = 366;
 /**
  * The five things the meter records.
  *
- * Storage is two metrics and not one summed byte count, for
- * `org_quotas.max_asset_storage_bytes`'s own reason applied to billing: a sync
- * grows storage in jumps and time series grow steadily, and one number would
- * let the first crowd out the second on the invoice the same way it would on
- * the quota.
+ * Storage is two metrics and not one summed byte count: a sync grows storage
+ * in jumps and time series grow steadily, and one number would let the first
+ * crowd out the second on the invoice. The org that outgrew its bill would be
+ * told to look at the wrong thing.
  */
 export declare const usageMetric: z.ZodEnum<{
     api_calls: "api_calls";