@fleetless/contracts 1.0.0

package/artifacts/schema/datapoint-config.schema.json

@@ -0,0 +1,366 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "type": "object",
+  "properties": {
+    "topic": {
+      "type": "string",
+      "maxLength": 255,
+      "pattern": "^\\/[A-Za-z_][A-Za-z0-9_]*(?:\\/[A-Za-z_][A-Za-z0-9_]*)*$",
+      "description": "The ROS topic this datapoint reads, as an absolute graph name. One datapoint reads **one** topic: a value assembled from two topics is not expressible here.",
+      "patternErrorMessage": "A ROS graph name is absolute: it begins with a slash, and each segment after a slash starts with a letter or an underscore and continues with letters, digits and underscores — `/camera/image_raw`. A relative name, a trailing slash, a dash or a dot is refused.",
+      "examples": [
+        "/battery"
+      ]
+    },
+    "type": {
+      "type": "string",
+      "maxLength": 255,
+      "pattern": "^[a-z][a-z0-9_]*\\/(?:msg|srv|action)\\/[A-Za-z][A-Za-z0-9]*$",
+      "description": "The message type carried by `topic`, spelled the way ROS 2 spells it, with the `msg` segment in the middle — `sensor_msgs/msg/BatteryState`, never `sensor_msgs/BatteryState`. It is declared here rather than discovered, so a configuration can be written for a robot that has never been connected; the cloud checks it against the robot's own message definitions only once one is there.",
+      "patternErrorMessage": "A ROS 2 type name has three segments: the package, then `msg`, `srv` or `action`, then the type — `sensor_msgs/msg/BatteryState`, `std_srvs/srv/Trigger`, `nav2_msgs/action/NavigateToPose`. The middle segment is the one usually left out. The package is lower-case with underscores; the type itself is letters and digits, conventionally CamelCase.",
+      "examples": [
+        "sensor_msgs/msg/BatteryState"
+      ]
+    },
+    "field": {
+      "type": "string",
+      "maxLength": 255,
+      "pattern": "^[a-z_][a-z0-9_]*(?:\\[\\d+\\])?(?:\\.[a-z_][a-z0-9_]*(?:\\[\\d+\\])?)*$",
+      "description": "A dotted path into the message naming the single value this datapoint carries, each segment indexing at most one array level — `ranges[0]`, never `ranges[0][1]`, because ROS 2 has no nested arrays. Without it the datapoint is the whole message, and `numeric`, `chart` and `alerts` are then refused.",
+      "patternErrorMessage": "A field path is dotted and lower-case, and each segment may index at most one array level — `voltage`, `pose.position.x`, `ranges[0]`. ROS 2 has no nested arrays, so a second index on one segment could name nothing that exists.",
+      "examples": [
+        "voltage",
+        "pose.position.x",
+        "ranges[0]"
+      ]
+    },
+    "rate_throttle_hz": {
+      "type": "number",
+      "minimum": 0,
+      "maximum": 20,
+      "description": "A ceiling on how often this datapoint is sent, in hertz. Omitted or `0` means no throttling. It is **a ceiling, not a clock**: a slow topic stays slow, a value is never repeated to manufacture a rate, and within a window the newest value wins. The bridge enforces it, so the robot's bandwidth is genuinely saved.",
+      "examples": [
+        2,
+        0.5
+      ]
+    },
+    "description": {
+      "description": "Prose about what this value is, for whoever meets it in the console later. It changes nothing the robot does, so a publish that touches only it pushes no configuration at all — but it is carried verbatim into `robot_describe`, where a model that has never seen this robot reads it. The datapoint is offered whenever the role grants it; without one it is offered with `description: null` and the model has less to go on, as for actions, services, publishers and cameras. Omission is the only way to say nothing; an empty string is refused, here and on all five.",
+      "examples": [
+        "What this value is, for whoever meets it in the console."
+      ],
+      "type": "string",
+      "minLength": 1,
+      "maxLength": 2000
+    },
+    "numeric": {
+      "type": "object",
+      "properties": {
+        "scale": {
+          "type": "number",
+          "description": "A factor the robot multiplies the raw value by before sending it (`value * scale + offset`). The arithmetic happens once, at the source, so REST, realtime and history can never disagree about a number.",
+          "examples": [
+            100
+          ]
+        },
+        "offset": {
+          "type": "number",
+          "description": "A constant the robot adds after `scale` (`value * scale + offset`), for a value whose zero sits in the wrong place. Like `scale` it is applied before sending, so history stores the converted value and a later correction cannot reach what is already stored.",
+          "examples": [
+            -273.15
+          ]
+        },
+        "unit": {
+          "type": "string",
+          "maxLength": 32,
+          "description": "The unit of the value **after** `scale` and `offset`, not the robot's own. It is shown beside the value and carried by `robot_describe` as its own field, so a model does not have to guess whether 15 means percent, volts or minutes.",
+          "examples": [
+            "%"
+          ]
+        },
+        "decimals": {
+          "type": "integer",
+          "minimum": 0,
+          "maximum": 6,
+          "description": "How many fraction digits the console shows the value with — value tile, chart axis and tooltip, and the datapoint detail page — and the number `robot_describe` reports as its own field, so a model formats the value the way the console does. Presentation only: the stored value keeps the precision it arrived with, and absent means the console's own default rather than zero.",
+          "examples": [
+            1
+          ]
+        }
+      },
+      "additionalProperties": false,
+      "description": "Arithmetic and formatting for a numeric value. `scale` and `offset` are applied **on the robot**, before sending, which is why REST, realtime and history all carry identical numbers. `unit` and `decimals` change nothing the robot does, so a publish that touches only those pushes no configuration.",
+      "defaultSnippets": [
+        {
+          "label": "a unit, and the arithmetic that produces it",
+          "description": "A 0..1 fraction sent as a percentage to one decimal. `scale` is applied on the robot before sending, so history stores the converted value and a later correction cannot reach what is already stored.",
+          "body": {
+            "scale": 100,
+            "unit": "\"%\"",
+            "decimals": 1
+          }
+        }
+      ]
+    },
+    "retention": {
+      "type": "object",
+      "properties": {
+        "enabled": {
+          "type": "boolean",
+          "description": "Whether values are written to the time series and become queryable. Off by default: without it the value is live only, and nobody who was not watching will ever see it."
+        },
+        "interval_seconds": {
+          "type": "integer",
+          "minimum": 1,
+          "maximum": 3600,
+          "description": "How often a value is written to history, in seconds; absent means `300`. **Not** how often it is sent — that is `rate_throttle_hz`. Stored points are billed, so this is the direct lever on what a robot costs, and a bumper that is true for 200 ms does not appear unless a write falls inside it.",
+          "examples": [
+            300,
+            60
+          ]
+        },
+        "max_buffer_values": {
+          "type": "integer",
+          "minimum": 1,
+          "maximum": 100000,
+          "description": "How many values the robot holds while the bridge is disconnected, to be pushed once it reconnects. The catch-up runs behind live telemetry and job results at a limited rate, so closing a gap never delays the present; without it the series simply has a gap, which is an honest answer.",
+          "examples": [
+            5000
+          ]
+        }
+      },
+      "additionalProperties": false,
+      "description": "What outlives the moment: whether this value is written to the time series, how often, and how many points the robot buffers while the bridge is away. Absent means no history at all — the value is live only.",
+      "defaultSnippets": [
+        {
+          "label": "history, on, with its interval and buffer",
+          "description": "Writes this value to the time series every 300 seconds and holds 5000 points on the robot while the bridge is away. Stored points are billed, so both numbers are worth choosing rather than inheriting.",
+          "body": {
+            "enabled": true,
+            "interval_seconds": 300,
+            "max_buffer_values": 5000
+          }
+        }
+      ]
+    },
+    "chart": {
+      "type": "object",
+      "properties": {
+        "y_min": {
+          "type": "number",
+          "description": "A fixed floor for the chart's y axis; omitted, the axis scales to the data. `0` is a real floor and is read as `0`, never as unset.",
+          "examples": [
+            0
+          ]
+        },
+        "y_max": {
+          "type": "number",
+          "description": "A fixed ceiling for the chart's y axis; omitted, the axis scales to the data. It may not sit below `y_min`: a reversed pair is refused here because nothing downstream catches it, and the chart would render empty.",
+          "examples": [
+            100
+          ]
+        },
+        "style": {
+          "type": "string",
+          "enum": [
+            "line",
+            "step"
+          ],
+          "description": "How the drawing joins two samples, which is not a matter of taste. `line` claims the value moved evenly between them, roughly true of a temperature or a charge; `step` holds and then jumps, the only honest drawing for a mode, a switch or a counter, where a straight line would show values that never existed.",
+          "enumDescriptions": [
+            "Straight lines between samples, so the drawing claims the value moved evenly from one to the next. Right for a quantity that really is continuous — a temperature, a charge level — where a reading taken between two samples would have landed somewhere on that line.",
+            "Each value is held until the next one arrives, then jumps to it. Right for anything that does not slide between its values — a mode, a state, a switch, a counter — where a sloped line would draw readings the robot never reported."
+          ]
+        },
+        "default_window_minutes": {
+          "type": "integer",
+          "minimum": 1,
+          "maximum": 43200,
+          "description": "How far back the chart reaches when it is first opened, in minutes; absent means `60`. Only the starting zoom: a viewer may look further, and nothing about what is stored follows from it.",
+          "examples": [
+            1440
+          ]
+        }
+      },
+      "additionalProperties": false,
+      "description": "How the console draws this value over time: axis bounds, whether the line interpolates or steps, and the window a chart opens on. **Display only** — it changes no stored value, no alert and nothing the robot does, so a publish that touches only it pushes no configuration.",
+      "defaultSnippets": [
+        {
+          "label": "axis bounds, and how two samples are joined",
+          "description": "A fixed 0..100 axis rather than one that scales to the data, and a choice between interpolating and stepping between samples — which is not a matter of taste.",
+          "body": {
+            "y_min": 0,
+            "y_max": 100,
+            "style": "${1|line,step|}"
+          }
+        }
+      ]
+    },
+    "alerts": {
+      "type": "object",
+      "propertyNames": {
+        "type": "string",
+        "minLength": 2,
+        "maxLength": 63,
+        "pattern": "^[a-z][a-z0-9]*(?:_[a-z0-9]+)*$",
+        "patternErrorMessage": "A name is lower-case: it starts with a letter, continues with letters and digits, and joins further words with a single underscore — `battery_voltage`. Capitals, dashes, dots, spaces, a leading digit and a doubled or trailing underscore are all refused."
+      },
+      "additionalProperties": {
+        "type": "object",
+        "properties": {
+          "condition": {
+            "type": "object",
+            "properties": {
+              "fire_at": {
+                "anyOf": [
+                  {
+                    "type": "number"
+                  },
+                  {
+                    "type": "string"
+                  },
+                  {
+                    "type": "boolean"
+                  }
+                ],
+                "description": "The value at which the alert starts firing. Alone it is an **equality**: it fires while the value equals `fire_at` and is ok again as soon as it differs, which is what makes a boolean or a string condition meaningful. Adding `resolve_at` turns it into a threshold instead.",
+                "examples": [
+                  15,
+                  true
+                ]
+              },
+              "resolve_at": {
+                "type": "number",
+                "description": "The value at which a firing alert becomes ok again — allowed only when `fire_at` is a number, and it **must differ from it**. That gap is the hysteresis, and it makes the condition a threshold whose direction follows from which of the two values is higher. Without a gap a value sitting on the line flips on every sample.",
+                "examples": [
+                  18
+                ]
+              }
+            },
+            "required": [
+              "fire_at"
+            ],
+            "additionalProperties": false,
+            "description": "When this alert fires and when it is ok again. It carries **no discriminator**: upper threshold, lower threshold or equality all follow from the two values in it. Editing it resets the alert to `ok` on the next publish, while a publish that leaves it untouched keeps the running state.",
+            "defaultSnippets": [
+              {
+                "label": "a threshold, with its hysteresis",
+                "description": "Fires below 15 and is ok again above 18. The gap is what keeps a value sitting on the line from flipping on every sample; the direction follows from which of the two is higher, and nothing else declares it.",
+                "body": {
+                  "fire_at": 15,
+                  "resolve_at": 18
+                }
+              },
+              {
+                "label": "an equality",
+                "description": "Fires while the value equals `fire_at` and is ok as soon as it differs — the only form a boolean or a string condition can take. No `resolve_at`: adding one would turn this into a threshold, and is refused unless `fire_at` is a number.",
+                "body": {
+                  "fire_at": true
+                }
+              }
+            ]
+          },
+          "severity": {
+            "type": "string",
+            "enum": [
+              "warning",
+              "error"
+            ],
+            "description": "How bad it is when this alert fires; absent means `warning`. It changes no behaviour — nothing is escalated, retried or delivered differently — it travels with the org event and colours the alert wherever it is shown.",
+            "enumDescriptions": [
+              "Worth seeing. This is what an alert that names no severity gets.",
+              "Worth acting on. The only difference from `warning` is how the alert is shown: the same event is written, at the same moment, to the same places."
+            ]
+          },
+          "name": {
+            "type": "string",
+            "minLength": 1,
+            "maxLength": 120,
+            "description": "A human-readable label shown wherever this alert appears, in place of its bare key. It is not the alert's identity — the key is — so the label can be reworded freely, while changing the key deletes one alert and creates another.",
+            "examples": [
+              "Battery low"
+            ]
+          },
+          "enabled": {
+            "type": "boolean",
+            "description": "Whether this alert is evaluated at all. Absent means on, the opposite of `retention.enabled`: an alert that is written down watches unless it is explicitly switched off, which is how one is silenced without losing the key that identifies it."
+          }
+        },
+        "required": [
+          "condition"
+        ],
+        "additionalProperties": false,
+        "defaultSnippets": [
+          {
+            "label": "an alert, with its condition",
+            "description": "One whole alert: the label shown in place of its key, and the threshold with the gap that keeps it from flipping on every sample.",
+            "body": {
+              "condition": {
+                "fire_at": 15,
+                "resolve_at": 18
+              },
+              "name": "${2:Battery low}"
+            }
+          }
+        ]
+      },
+      "description": "Alerts watching this value, keyed by slug; each moves between `ok` and `firing` and writes an org event on every transition. No mail is sent. **The key is the identity**, so renaming an alert is a delete plus a create: its runtime state is lost, and an alert that is still true fires again.",
+      "defaultSnippets": [
+        {
+          "label": "an alert, with its condition",
+          "description": "One whole alert: the label shown in place of its key, and the threshold with the gap that keeps it from flipping on every sample.",
+          "body": {
+            "${1:battery_low}": {
+              "condition": {
+                "fire_at": 15,
+                "resolve_at": 18
+              },
+              "name": "${2:Battery low}"
+            }
+          }
+        }
+      ]
+    }
+  },
+  "required": [
+    "topic",
+    "type"
+  ],
+  "additionalProperties": false,
+  "defaultSnippets": [
+    {
+      "label": "a datapoint",
+      "description": "One value the robot publishes: one field of one topic.",
+      "body": {
+        "topic": "${2:/battery}",
+        "type": "${3:sensor_msgs/msg/BatteryState}",
+        "field": "${4:voltage}",
+        "description": "${5:What this value is, for whoever meets it in the console.}"
+      }
+    },
+    {
+      "label": "a numeric datapoint, with history and a chart",
+      "description": "A number with its unit, what is kept of it and how it is drawn — the blocks a plain datapoint leaves out.",
+      "body": {
+        "topic": "${2:/battery}",
+        "type": "${3:sensor_msgs/msg/BatteryState}",
+        "field": "${4:percentage}",
+        "description": "${5:What this value is, for whoever meets it in the console.}",
+        "numeric": {
+          "scale": 100,
+          "unit": "\"%\"",
+          "decimals": 1
+        },
+        "retention": {
+          "enabled": true,
+          "interval_seconds": 300
+        },
+        "chart": {
+          "y_min": 0,
+          "y_max": 100,
+          "style": "line"
+        }
+      }
+    }
+  ]
+}

package/artifacts/schema/datapoint-display.schema.json

@@ -0,0 +1,31 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "type": "object",
+  "properties": {
+    "y_min": {
+      "anyOf": [
+        {
+          "type": "number"
+        },
+        {
+          "type": "null"
+        }
+      ]
+    },
+    "y_max": {
+      "anyOf": [
+        {
+          "type": "number"
+        },
+        {
+          "type": "null"
+        }
+      ]
+    }
+  },
+  "required": [
+    "y_min",
+    "y_max"
+  ],
+  "additionalProperties": false
+}

package/artifacts/schema/datapoint-event.schema.json

@@ -0,0 +1,34 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "type": "object",
+  "properties": {
+    "type": {
+      "type": "string",
+      "const": "datapoint"
+    },
+    "robot_id": {
+      "type": "string",
+      "format": "uuid",
+      "pattern": "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$"
+    },
+    "slug": {
+      "type": "string",
+      "minLength": 2,
+      "maxLength": 63,
+      "pattern": "^[a-z][a-z0-9]*(?:_[a-z0-9]+)*$"
+    },
+    "value": {},
+    "timestamp_ms": {
+      "type": "integer",
+      "minimum": 0,
+      "maximum": 9007199254740991
+    }
+  },
+  "required": [
+    "type",
+    "robot_id",
+    "slug",
+    "value",
+    "timestamp_ms"
+  ]
+}

package/artifacts/schema/datapoint-frame.schema.json

@@ -0,0 +1,28 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "type": "object",
+  "properties": {
+    "type": {
+      "type": "string",
+      "const": "datapoint"
+    },
+    "slug": {
+      "type": "string",
+      "minLength": 2,
+      "maxLength": 63,
+      "pattern": "^[a-z][a-z0-9]*(?:_[a-z0-9]+)*$"
+    },
+    "value": {},
+    "timestamp_ms": {
+      "type": "integer",
+      "minimum": 0,
+      "maximum": 9007199254740991
+    }
+  },
+  "required": [
+    "type",
+    "slug",
+    "value",
+    "timestamp_ms"
+  ]
+}

package/artifacts/schema/datapoint-list-response.schema.json

@@ -0,0 +1,61 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "type": "object",
+  "properties": {
+    "datapoints": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "properties": {
+          "slug": {
+            "type": "string",
+            "minLength": 2,
+            "maxLength": 63,
+            "pattern": "^[a-z][a-z0-9]*(?:_[a-z0-9]+)*$",
+            "description": "The name a client reads this datapoint by."
+          },
+          "builtin": {
+            "type": "boolean",
+            "description": "`true` for the datapoints every robot has — `bridge_state`, `robot_details` and `bridge_pressure` — and `false` for everything the published configuration adds."
+          },
+          "unit": {
+            "anyOf": [
+              {
+                "type": "string"
+              },
+              {
+                "type": "null"
+              }
+            ],
+            "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."
+          },
+          "rate_throttle_hz": {
+            "anyOf": [
+              {
+                "type": "number",
+                "minimum": 0,
+                "maximum": 20
+              },
+              {
+                "type": "null"
+              }
+            ],
+            "description": "The ceiling on how often this datapoint is sent, in hertz. `null` means no ceiling is configured, which is also the answer for every built-in. A ceiling, not a clock: a slow topic stays slow and no value is repeated to manufacture a rate."
+          }
+        },
+        "required": [
+          "slug",
+          "builtin",
+          "unit",
+          "rate_throttle_hz"
+        ],
+        "additionalProperties": false
+      },
+      "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."
+    }
+  },
+  "required": [
+    "datapoints"
+  ],
+  "additionalProperties": false
+}

package/artifacts/schema/datapoint-value.schema.json

@@ -0,0 +1,28 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "type": "object",
+  "properties": {
+    "slug": {
+      "type": "string",
+      "minLength": 2,
+      "maxLength": 63,
+      "pattern": "^[a-z][a-z0-9]*(?:_[a-z0-9]+)*$",
+      "description": "The datapoint this value belongs to."
+    },
+    "value": {
+      "description": "The value itself, shaped by the datapoint: a number, a boolean, a string, or the whole ROS message where the configuration names no field inside it. Any `scale` and `offset` the configuration declares have already been applied, at the robot."
+    },
+    "timestamp_ms": {
+      "type": "integer",
+      "minimum": 0,
+      "maximum": 9007199254740991,
+      "description": "When the value was captured, as a unix timestamp in milliseconds. This is the **bridge's capture time**, never the time the cloud received it — the one exception is the built-in `bridge_state`, which the cloud observes by construction."
+    }
+  },
+  "required": [
+    "slug",
+    "value",
+    "timestamp_ms"
+  ],
+  "additionalProperties": false
+}

package/artifacts/schema/developer-login-request.schema.json

@@ -0,0 +1,19 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "type": "object",
+  "properties": {
+    "email": {
+      "type": "string",
+      "format": "email",
+      "pattern": "^(?!\\.)(?!.*\\.\\.)([A-Za-z0-9_'+\\-\\.]*)[A-Za-z0-9_+-]@([A-Za-z0-9][A-Za-z0-9\\-]*\\.)+[A-Za-z]{2,}$"
+    },
+    "password": {
+      "type": "string",
+      "minLength": 1
+    }
+  },
+  "required": [
+    "email",
+    "password"
+  ]
+}

package/artifacts/schema/dynamic-client-registration-request.schema.json

@@ -0,0 +1,60 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "type": "object",
+  "properties": {
+    "redirect_uris": {
+      "minItems": 1,
+      "maxItems": 5,
+      "type": "array",
+      "items": {
+        "type": "string",
+        "minLength": 1,
+        "maxLength": 2000
+      },
+      "description": "Where the authorization code may be returned, and the one field a registration cannot omit. Each must be an `https` URL, or `http` on an explicit loopback address for a native app that cannot hold a certificate, and none may carry a fragment. There must be between `1` and `5` of them; duplicates are collapsed rather than counted twice. Matched **exactly** at the authorize step against what was registered here."
+    },
+    "client_name": {
+      "description": "The name the client calls itself. Optional — a registration without one is recorded under a default name, per RFC 7591's making every metadata field optional. It is **not** vouched for by Fleetless and must never be rendered as if it were: a self-registered client chooses this string, and one has called itself *\"Fleetless Official Helper\"*.",
+      "type": "string",
+      "minLength": 1,
+      "maxLength": 200
+    },
+    "token_endpoint_auth_method": {
+      "description": "`none`, RFC 7591's value for a public client, and the only value either server registers. Any other value is **refused rather than silently downgraded**: a client that believes it holds a secret and does not has a wrong mental model of its own security. There is no client secret to hold — mandatory PKCE (`S256`) is the defence.",
+      "type": "string",
+      "enum": [
+        "none"
+      ]
+    },
+    "grant_types": {
+      "description": "Accepted for conformance with RFC 7591 and then **ignored**. What comes back is what was actually granted, which §3.2.1 permits a server to substitute: `authorization_code` and nothing else, so a client that asks for `refresh_token` is registered and told plainly that it did not get one.",
+      "type": "array",
+      "items": {
+        "type": "string",
+        "enum": [
+          "authorization_code",
+          "refresh_token"
+        ]
+      }
+    },
+    "response_types": {
+      "description": "Accepted for conformance and then **ignored**; the response names `code`, which is the only response type OAuth 2.1 leaves, the implicit grant having been removed.",
+      "type": "array",
+      "items": {
+        "type": "string",
+        "enum": [
+          "code"
+        ]
+      }
+    },
+    "scope": {
+      "description": "Accepted for conformance and then **ignored**. This authorization server issues no scopes at all, which is why the registration answer carries no `scope` field to echo one back in.",
+      "type": "string",
+      "maxLength": 500
+    }
+  },
+  "required": [
+    "redirect_uris"
+  ],
+  "description": "What an MCP client sends to register itself, per RFC 7591. Unknown metadata is ignored rather than refused (§3.1), and the answer states what was actually granted rather than what was asked for (§3.2.1)."
+}