@fleetless/contracts 1.2.0 → 2.0.0

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";

package/dist/rest.js

@@ -38,6 +38,42 @@ export const createRobotResponse = z.object({
     robot,
     token: robotToken,
 });
+/**
+ * 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 const robotTokenRotateResponse = z.object({
+    token: robotToken.meta({
+        description: 'The robot\'s new bridge token. Returned exactly once; the previous token stops working at the bridge\'s next hello.',
+    }),
+});
+/**
+ * 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 const jointStatePutRequest = z.object({
+    slug: slug.nullable().meta({
+        description: 'The datapoint to read joint positions from, or `null` to choose none. It must name a whole-message `sensor_msgs/msg/JointState` datapoint of the published configuration; anything else is a `validation_error` naming the rule.',
+    }),
+});
+/** The mapping as it now stands — the same field `GET /api/robots/:id/assets` reports. */
+export const jointStatePutResponse = z.object({
+    joint_state_slug: slug.nullable().meta({
+        description: 'The stored mapping after the call, `null` when none is chosen. The same value `assetListResponse.joint_state_slug` carries.',
+    }),
+});
 /**
  * How many things a robot exposes, per kind.
  *
@@ -47,18 +83,17 @@ export const createRobotResponse = z.object({
  *
  * **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 const exposureCounts = z.object({
     datapoints: z.number().int().nonnegative(),
@@ -67,12 +102,22 @@ export const exposureCounts = z.object({
     publishers: z.number().int().nonnegative(),
     cameras: z.number().int().nonnegative(),
 });
+/**
+ * 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 const protocolStatusValue = z.enum(['current', 'deprecated', 'refused']);
 /** A robot as listed, with its current built-in `bridge_state`. */
 export const robotListItem = z.object({
     ...robot.shape,
     bridge_state: bridgeState,
     /** Required, not optional: "we did not look" and "it exposes nothing" must not render the same. */
     exposes: exposureCounts,
+    protocol_status: protocolStatusValue.optional().meta({
+        description: 'Where this robot\'s bridge stands against the protocol window: `current`, `deprecated` (still served, sunset date on the detail), or `refused` (its last hello was refused for its version; offline until upgraded). Absent from a cloud older than 0.21.0; read absence as `current`.',
+    }),
 });
 export const robotListResponse = z.object({
     robots: z.array(robotListItem),
@@ -103,6 +148,18 @@ export const datapointValue = z.object({
 export const robotDetailResponse = z.object({
     ...robotListItem.shape,
     bridge_version: z.string().min(1).nullable(),
+    protocol_version: z.number().int().positive().nullable().optional().meta({
+        description: 'The protocol version the bridge announced in its last accepted hello; `null` before the first. Absent from a cloud older than 0.21.0.',
+    }),
+    protocol: z
+        .object({
+        status: protocolStatusValue.meta({ description: 'Same values as `protocol_status`.' }),
+        sunset_at: z.iso.date().nullable().meta({
+            description: 'ISO date the announced version stops being served; `null` when current or unknown.',
+        }),
+    })
+        .optional()
+        .meta({ description: 'The window verdict for `protocol_version`.' }),
     /**
      * Cleared (set back to null) by the next successful hello from this
      * robot's bridge — a warning that outlives the condition it warns
@@ -232,7 +289,7 @@ export const fetchTypesResponse = z.object({
 export const datapointDescriptor = z.object({
     slug: slug.meta({ description: 'The name a client reads this datapoint by.' }),
     builtin: z.boolean().meta({
-        description: '`true` for the datapoints every robot has — `bridge_state`, `robot_details` and `bridge_pressure` — and `false` for everything the published configuration adds.',
+        description: '`true` for the datapoints every robot has — `bridge_state` and `robot_details` — and `false` for everything the published configuration adds.',
     }),
     unit: z.string().nullable().meta({
         description: 'The unit the value carries **after** any scale and offset, shown beside the number so nobody has to guess whether `15` means percent, volts or minutes. `null` when the configuration names none.',
@@ -250,7 +307,7 @@ export const datapointDescriptor = z.object({
 });
 export const datapointListResponse = z.object({
     datapoints: z.array(datapointDescriptor).meta({
-        description: 'Everything a client may read on this robot: the three built-ins, plus every datapoint the published configuration exposes and the caller\'s role grants.',
+        description: 'Everything a client may read on this robot: the two built-ins, plus every datapoint the published configuration exposes and the caller\'s role grants.',
     }),
 });
 /**
@@ -801,22 +858,21 @@ export const ASSET_UPLOAD_HEADERS = {
     nameEncoded: 'x-fleetless-asset-name-encoded',
     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.
      */
     size: 'x-fleetless-asset-size',
 };
@@ -1233,22 +1289,25 @@ export const robotDeletionSummary = z.object({
     bytes_freed: z.number().int().nonnegative(),
     cameras: z.array(slug),
     /**
-     * Assets destroyed with the robot, and **`asset_bytes_freed` is what
-     * this org actually gets back** — not the sum of the assets' sizes.
+     * Assets destroyed with the robot, and **`asset_bytes_freed` is what the
+     * robot's own store gives back** — every distinct mesh or texture blob it
+     * holds, counted once, URDF excluded.
      *
-     * Storage is content-addressed, so a mesh two robots share survives the
-     * deletion of one of them and frees nothing. Reporting the total would tell
-     * a developer they are about to recover 400 MB and hand back 4, on the one
-     * screen whose entire justification is naming what an irreversible click
-     * destroys. Same reasoning that keeps `cameras` out of `slug_count`: this
-     * summary is read aloud to a human, and a number that is nearly right is
-     * worse here than an absent one.
+     * Storage is content-addressed, but the store and its 1 GB ceiling are now
+     * per robot: a blob another robot also references stays in the object
+     * store but is still credited here, because each robot's counter carries
+     * it regardless of what else points at the same bytes. Same reasoning that
+     * keeps `cameras` out of `slug_count`: this summary is read aloud to a
+     * human, and a number that is nearly right is worse here than an absent
+     * one.
      *
      * `asset_count` is the plain count of the robot's asset rows, all of which
      * do go away.
      */
     asset_count: z.number().int().nonnegative(),
-    asset_bytes_freed: z.number().int().nonnegative(),
+    asset_bytes_freed: z.number().int().nonnegative().meta({
+        description: 'What the robot\'s store gives back: every distinct mesh or texture blob it holds, counted once, URDF excluded; a blob another robot also references stays in the object store but is still credited here, because each robot\'s counter carries it.',
+    }),
     /**
      * How many rows of run history go with the robot — every recorded
      * invocation of one of its actions or services, up to
@@ -1460,31 +1519,6 @@ export const orgQuotas = z.object({
     max_retention_bytes: z.number().int().nonnegative(),
     max_retention_writes_per_minute: z.number().int().nonnegative(),
     max_realtime_connections: z.number().int().positive(),
-    /**
-     * Asset storage — **its own dial, not part of `max_retention_bytes`.** A
-     * sync grows storage in jumps and time series grow steadily; one dial would
-     * let the first crowd out the second, and the org that hit its limit would be
-     * told to look at the wrong thing.
-     *
-     * **Counted per distinct blob *this org references* — not per asset row, and
-     * not per object the platform stores on its behalf.** The two readings are
-     * indistinguishable from the number alone and a customer is entitled to know
-     * which one they are being charged for.
-     *
-     * Within an org, sharing is free: two robots referencing the same mesh cost
-     * one copy, which is what dedup means to a customer, and anything else
-     * charges an org twice for a fleet of identical robots — the normal case.
-     *
-     * **Across orgs, sharing is not free.** Storage stays globally
-     * content-addressed (one object per sha256; that efficiency is real), but
-     * accounting is per-org: an org is charged for each distinct blob it
-     * references and credited when its own last reference goes, whether or not
-     * the blob survives for somebody else. Global refcounting would make the
-     * first org to sync a blob pay for it forever while every later org stored it
-     * free — a quota evadable by anyone whose mesh someone else had already
-     * uploaded, and an org's own number would depend on who got there first.
-     */
-    max_asset_storage_bytes: z.number().int().nonnegative(),
 });
 /**
  * What an org is **actually using**, per quota.
@@ -1506,7 +1540,6 @@ export const orgQuotaUsageCounts = z.object({
     max_apps: z.number().int().nonnegative(),
     max_end_users: z.number().int().nonnegative(),
     max_retention_bytes: z.number().int().nonnegative(),
-    max_asset_storage_bytes: z.number().int().nonnegative(),
     max_retention_writes_per_minute: z.number().int().nonnegative(),
     max_realtime_connections: z.number().int().nonnegative(),
 }).partial();
@@ -1685,11 +1718,10 @@ export 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 const usageMetric = z.enum(['api_calls', 'live_session_ms', 'retention_bytes', 'asset_bytes', 'robot_online_ms']);
 /**