Previous value: -"Machine-readable failure mode. Declared by this tool: `query_error`: Overpass returned HTTP 400 — malformed query syntax. `query_timeout`: The query exceeded its timeout. `result_too_large`: Overpass ran out of memory on this query. `rate_limited`: Every configured endpoint refused the query as throttled — HTTP 429, or a throttle document in place of JSON. `upstream_error`: Overpass reported a runtime error that is neither a timeout nor memory exhaustion. `overpass_gateway_timeout`: Overpass answered HTTP 504 — the query exceeded the endpoint's own time budget, not the [timeout:N] directive. `overpass_unavailable`: Overpass answered an HTTP 5xx other than 504 — the endpoint is down, restarting, or shedding load. `endpoints_exhausted`: No endpoint answered within its attempt window, or the total time budget ran out first. `endpoints_unavailable`: No configured endpoint would serve the call — connections refused, DNS failures, throttling, or instance faults, in some mix. Other values are possible when a failure originates below the handler."New value: +"Machine-readable failure mode. Declared by this tool: `query_error`: Overpass returned HTTP 400 — malformed query syntax. `query_timeout`: The query exceeded its timeout. `result_too_large`: Overpass ran out of memory on this query. `rate_limited`: Every configured endpoint refused the query as throttled — HTTP 429, or a throttle document in place of JSON. `upstream_error`: Overpass reported a runtime error that is neither a timeout nor memory exhaustion. `overpass_gateway_timeout`: Overpass answered HTTP 504 — the query exceeded the endpoint's own time budget, not the [timeout:N] directive. `overpass_unavailable`: Overpass answered an HTTP 5xx other than 504 — the endpoint is down, restarting, or shedding load. `endpoints_exhausted`: No endpoint answered within its attempt window, or the total time budget ran out first. `endpoints_unavailable`: No configured endpoint would serve the call — connections refused, DNS failures, HTTP refusals such as 401/403/404, throttling, or instance faults, in some mix. Other values are possible when a failure originates below the handler."

Previous value: -"Serialized-byte budget for one element, measured in UTF-8 bytes and applied to each element of the page independently after limit and offset. It bounds what limit cannot: a single relation or geometry-heavy way. An element over budget keeps every scalar and its tags but has its members, nodes and geometry arrays withheld whole — never truncated to a prefix — and lists each one under withheld_keys with its item count and byte size; withheldElements and withheldNotice then carry the offset and raised budget that fetch that element back whole in one more call. The withheld_keys disclosure the element gains is not counted back against the budget, so a bounded element runs a fixed ~60 bytes per withheld key above it."New value: +"Serialized-byte budget for one element, in UTF-8 bytes, applied per element after limit and offset — the dimension limit cannot bound, a single relation or geometry-heavy way. An over-budget element keeps every scalar and its tags but has its members, nodes and geometry arrays withheld whole, never truncated to a prefix, and lists each under withheld_keys with its item count and byte size; withheldElements and withheldNotice then give the offset and raised budget that fetch it back whole in one more call. That disclosure is not counted against the budget, so a bounded element runs ~60 bytes per withheld key above it."

Previous value: -"Number of matching elements to skip before applying limit, for paging through a large result set. The full match set is fetched and cached ~10 minutes keyed by the query, so re-paging at a new offset is deterministic and costs no extra upstream request; a result over 100000 elements is served but not cached, so paging that far re-queries and depends on the endpoint returning the same order. Pass the nextOffset value from a prior truncated response."New value: +"Elements to skip before applying limit, for paging a large result set. The full match set is cached ~10 minutes keyed by the query, so re-paging at a new offset is deterministic and costs no extra request; a result over 100000 elements is served uncached, so paging that far re-queries and depends on the endpoint returning the same order. Pass the nextOffset from a prior truncated response."

Previous value: -"Query timeout in seconds, bounding how long Overpass itself spends on the query. The [timeout:N] directive in the query string takes precedence if present. The client waits for what is requested here, up to 180s, so a long-running query is not cut off early — but the endpoint enforces its own budget and may answer HTTP 504 first."New value: +"How long Overpass may spend on the query. A [timeout:N] directive in the query string wins over this. The client waits the full value rather than cutting a long query off early, but the endpoint enforces its own budget and may answer HTTP 504 first."

Previous value: -"Raw Overpass API response elements for this page, up to the limit. Structure varies by query type — nodes have lat/lon, ways have nodes[], relations have members[]. An element over max_element_bytes carries a withheld_keys array instead of the heavy arrays it names, each entry giving the key, its item count, and its serialized byte size."New value: +"Raw Overpass elements for this page, up to the limit. Shape varies by type: nodes carry lat/lon, ways nodes[], relations members[]. An element over max_element_bytes swaps those heavy arrays for withheld_keys, each naming the key, its item count, and its byte size."

Previous value: -"Machine-readable failure mode. Declared by this tool: `query_error`: Overpass returned a 400 error — malformed query syntax. `query_timeout`: The query exceeded its timeout (Overpass runtime error in response body). `result_too_large`: Overpass runtime error: query ran out of memory — result set exceeds the server memory limit. `rate_limited`: Overpass refused the query as throttled — HTTP 429, or a throttle document instead of JSON — on every configured endpoint. With a list in OSM_OVERPASS_ENDPOINTS the call advances to the next entry first, so this surfaces only once all of them have refused it. `upstream_error`: Overpass reported a runtime error that is neither a timeout nor memory exhaustion — the message carries the remark verbatim. `overpass_gateway_timeout`: Overpass answered HTTP 504 — it accepted the query but its dispatcher gave up before producing a result, so the query exceeded the time budget the endpoint enforces rather than the [timeout:N] directive. `overpass_unavailable`: Overpass answered with an HTTP 5xx other than 504 (500, 501, 502, 503) — the endpoint is down, restarting, or shedding load. Every one of them surfaces as ServiceUnavailable. `endpoints_exhausted`: Every Overpass endpoint tried was still unanswered — each accepted the query and held the connection past its attempt window instead of failing outright, or the call ran out of its total time budget before another endpoint could be tried. The message names each endpoint and the window it was given. `endpoints_unavailable`: No configured Overpass endpoint could serve the call — the hosts refused the connection, could not be resolved, were throttled, or reported their own instance fault, in some mix. The message names each endpoint and what it did. Other values are possible when a failure originates below the handler."New value: +"Machine-readable failure mode. Declared by this tool: `query_error`: Overpass returned HTTP 400 — malformed query syntax. `query_timeout`: The query exceeded its timeout. `result_too_large`: Overpass ran out of memory on this query. `rate_limited`: Every configured endpoint refused the query as throttled — HTTP 429, or a throttle document in place of JSON. `upstream_error`: Overpass reported a runtime error that is neither a timeout nor memory exhaustion. `overpass_gateway_timeout`: Overpass answered HTTP 504 — the query exceeded the endpoint's own time budget, not the [timeout:N] directive. `overpass_unavailable`: Overpass answered an HTTP 5xx other than 504 — the endpoint is down, restarting, or shedding load. `endpoints_exhausted`: No endpoint answered within its attempt window, or the total time budget ran out first. `endpoints_unavailable`: No configured endpoint would serve the call — connections refused, DNS failures, throttling, or instance faults, in some mix. Other values are possible when a failure originates below the handler."

Previous value: -"Guidance when the page came back empty. Distinguishes a query that matched nothing (check syntax or broaden the filter) from an offset past the end of a non-empty result set (retry at a lower offset). Absent when results were returned."New value: +"Why this page is empty and what to try: nothing matched (check the query syntax or broaden the filter), or offset ran past the end (retry lower). Absent when results were returned."

Previous value: -"Overpass endpoint that produced this response, as origin and path. Differs from the first configured endpoint when a mirror answered after the primary failed, and names the endpoint that served a cached response rather than the one this call would have tried. Pair it with data_timestamp when a result looks unexpectedly slow, sparse, or stale."New value: +"Overpass endpoint that answered, as origin and path. May name a failover mirror, or the endpoint that originally served a cached response. Read with data_timestamp when a result looks slow, sparse, or stale."

Previous value: -"Machine-readable failure mode. Declared by this tool: `query_error`: Overpass returned a 400 error — malformed query syntax. `query_timeout`: The query exceeded its timeout (Overpass runtime error in response body). `result_too_large`: Overpass runtime error: query ran out of memory — result set exceeds the server memory limit. `rate_limited`: Overpass refused the query as throttled — HTTP 429, or a throttle document instead of JSON — on every configured endpoint. With a list in OSM_OVERPASS_ENDPOINTS the call advances to the next entry first, so this surfaces only once all of them have refused it. `upstream_error`: Overpass reported a runtime error that is neither a timeout nor memory exhaustion — the message carries the remark verbatim. `overpass_gateway_timeout`: Overpass answered HTTP 504 — it accepted the query but its dispatcher gave up before producing a result, so the query exceeded the time budget the endpoint enforces rather than the [timeout:N] directive. `overpass_unavailable`: Overpass answered with an HTTP 5xx other than 504 (500, 501, 502, 503) — the endpoint is down, restarting, or shedding load. Every one of them surfaces as ServiceUnavailable. `endpoints_exhausted`: Every Overpass endpoint tried was still unanswered when the call ran out of its total time budget — each accepted the query and held the connection instead of failing outright. Other values are possible when a failure originates below the handler."New value: +"Machine-readable failure mode. Declared by this tool: `query_error`: Overpass returned a 400 error — malformed query syntax. `query_timeout`: The query exceeded its timeout (Overpass runtime error in response body). `result_too_large`: Overpass runtime error: query ran out of memory — result set exceeds the server memory limit. `rate_limited`: Overpass refused the query as throttled — HTTP 429, or a throttle document instead of JSON — on every configured endpoint. With a list in OSM_OVERPASS_ENDPOINTS the call advances to the next entry first, so this surfaces only once all of them have refused it. `upstream_error`: Overpass reported a runtime error that is neither a timeout nor memory exhaustion — the message carries the remark verbatim. `overpass_gateway_timeout`: Overpass answered HTTP 504 — it accepted the query but its dispatcher gave up before producing a result, so the query exceeded the time budget the endpoint enforces rather than the [timeout:N] directive. `overpass_unavailable`: Overpass answered with an HTTP 5xx other than 504 (500, 501, 502, 503) — the endpoint is down, restarting, or shedding load. Every one of them surfaces as ServiceUnavailable. `endpoints_exhausted`: Every Overpass endpoint tried was still unanswered — each accepted the query and held the connection past its attempt window instead of failing outright, or the call ran out of its total time budget before another endpoint could be tried. The message names each endpoint and the window it was given. `endpoints_unavailable`: No configured Overpass endpoint could serve the call — the hosts refused the connection, could not be resolved, were throttled, or reported their own instance fault, in some mix. The message names each endpoint and what it did. Other values are possible when a failure originates below the handler."

Previous value: -[
-  "query_error",
-  "query_timeout",
-  "result_too_large",
-  "rate_limited",
-  "upstream_error",
-  "overpass_gateway_timeout",
-  "overpass_unavailable",
-  "endpoints_exhausted"
-]New value: +[
+  "query_error",
+  "query_timeout",
+  "result_too_large",
+  "rate_limited",
+  "upstream_error",
+  "overpass_gateway_timeout",
+  "overpass_unavailable",
+  "endpoints_exhausted",
+  "endpoints_unavailable"
+]

Added value: +{
+  "default": 20000,
+  "description": "Serialized-byte budget for one element, measured in UTF-8 bytes and applied to each element of the page independently after limit and offset. It bounds what limit cannot: a single relation or geometry-heavy way. An element over budget keeps every scalar and its tags but has its members, nodes and geometry arrays withheld whole — never truncated to a prefix — and lists each one under withheld_keys with its item count and byte size; withheldElements and withheldNotice then carry the offset and raised budget that fetch that element back whole in one more call. The withheld_keys disclosure the element gains is not counted back against the budget, so a bounded element runs a fixed ~60 bytes per withheld key above it.",
+  "maximum": 10000000,
+  "minimum": 1000,
+  "type": "integer"
+}

Previous value: -"Raw Overpass API response elements for this page, up to the limit. Structure varies by query type — nodes have lat/lon, ways have nodes[], relations have members[]."New value: +"Raw Overpass API response elements for this page, up to the limit. Structure varies by query type — nodes have lat/lon, ways have nodes[], relations have members[]. An element over max_element_bytes carries a withheld_keys array instead of the heavy arrays it names, each entry giving the key, its item count, and its serialized byte size."

Added value: +{
+  "description": "Elements on this page that exceeded max_element_bytes, each with the arguments that fetch it back whole. Absent when every element fit.",
+  "items": {
+    "additionalProperties": false,
+    "properties": {
+      "id": {
+        "description": "OSM id of the bounded element.",
+        "type": "number"
+      },
+      "keys": {
+        "description": "Keys withheld whole from this element: members, nodes, or geometry.",
+        "items": {
+          "type": "string"
+        },
+        "type": "array"
+      },
+      "maxElementBytes": {
+        "description": "Serialized UTF-8 byte size of this element whole, which is the smallest max_element_bytes that returns it. Pass it on the retrieval call when it is at or below the 10000000 ceiling; above that no accepted budget returns the element whole and withheldNotice names the narrower query to use instead.",
+        "type": "number"
+      },
+      "offset": {
+        "description": "Absolute offset of this element in the full match set. Pass it with limit 1 to fetch this element alone.",
+        "type": "number"
+      },
+      "type": {
+        "description": "OSM element type of the bounded element.",
+        "type": "string"
+      }
+    },
+    "required": [
+      "type",
+      "id",
+      "keys",
+      "offset",
+      "maxElementBytes"
+    ],
+    "type": "object"
+  },
+  "type": "array"
+}

Added value: +{
+  "description": "How to retrieve the withheld arrays, one element per call. Absent when every element fit.",
+  "type": "string"
+}

Previous value: -"Machine-readable failure mode. Declared by this tool: `query_error`: Overpass returned a 400 error — malformed query syntax. `query_timeout`: The query exceeded its timeout (Overpass runtime error in response body). `result_too_large`: Overpass runtime error: query ran out of memory — result set exceeds the server memory limit. `rate_limited`: Overpass refused the query as throttled — HTTP 429, or a throttle document instead of JSON — on every configured endpoint. With a list in OSM_OVERPASS_ENDPOINTS the call advances to the next entry first, so this surfaces only once all of them have refused it. `upstream_error`: Overpass reported a runtime error that is neither a timeout nor memory exhaustion — the message carries the remark verbatim. `overpass_gateway_timeout`: Overpass answered HTTP 504 — it accepted the query but its dispatcher gave up before producing a result, so the query exceeded the time budget the endpoint enforces rather than the [timeout:N] directive. `overpass_unavailable`: Overpass answered with an HTTP 5xx other than 504 (500, 501, 502, 503) — the endpoint is down, restarting, or shedding load. The thrown code tracks the status: 500 and 501 surface as InternalError, every other 5xx as ServiceUnavailable. `endpoints_exhausted`: Every Overpass endpoint tried was still unanswered when the call ran out of its total time budget — each accepted the query and held the connection instead of failing outright. Other values are possible when a failure originates below the handler."New value: +"Machine-readable failure mode. Declared by this tool: `query_error`: Overpass returned a 400 error — malformed query syntax. `query_timeout`: The query exceeded its timeout (Overpass runtime error in response body). `result_too_large`: Overpass runtime error: query ran out of memory — result set exceeds the server memory limit. `rate_limited`: Overpass refused the query as throttled — HTTP 429, or a throttle document instead of JSON — on every configured endpoint. With a list in OSM_OVERPASS_ENDPOINTS the call advances to the next entry first, so this surfaces only once all of them have refused it. `upstream_error`: Overpass reported a runtime error that is neither a timeout nor memory exhaustion — the message carries the remark verbatim. `overpass_gateway_timeout`: Overpass answered HTTP 504 — it accepted the query but its dispatcher gave up before producing a result, so the query exceeded the time budget the endpoint enforces rather than the [timeout:N] directive. `overpass_unavailable`: Overpass answered with an HTTP 5xx other than 504 (500, 501, 502, 503) — the endpoint is down, restarting, or shedding load. Every one of them surfaces as ServiceUnavailable. `endpoints_exhausted`: Every Overpass endpoint tried was still unanswered when the call ran out of its total time budget — each accepted the query and held the connection instead of failing outright. Other values are possible when a failure originates below the handler."

Previous value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"

Added value: +false

Previous value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"

Added value: +[
+  {
+    "not": {
+      "required": [
+        "error"
+      ]
+    },
+    "required": [
+      "elements",
+      "total_elements",
+      "attribution",
+      "effectiveQuery",
+      "totalFound",
+      "truncated"
+    ]
+  },
+  {
+    "required": [
+      "error"
+    ]
+  }
+]

Added value: +{
+  "additionalProperties": {},
+  "description": "Present when the call failed. Absent on success.",
+  "properties": {
+    "code": {
+      "description": "JSON-RPC error code for this failure.",
+      "maximum": 9007199254740991,
+      "minimum": -9007199254740991,
+      "type": "integer"
+    },
+    "data": {
+      "additionalProperties": {},
+      "properties": {
+        "reason": {
+          "description": "Machine-readable failure mode. Declared by this tool: `query_error`: Overpass returned a 400 error — malformed query syntax. `query_timeout`: The query exceeded its timeout (Overpass runtime error in response body). `result_too_large`: Overpass runtime error: query ran out of memory — result set exceeds the server memory limit. `rate_limited`: Overpass refused the query as throttled — HTTP 429, or a throttle document instead of JSON — on every configured endpoint. With a list in OSM_OVERPASS_ENDPOINTS the call advances to the next entry first, so this surfaces only once all of them have refused it. `upstream_error`: Overpass reported a runtime error that is neither a timeout nor memory exhaustion — the message carries the remark verbatim. `overpass_gateway_timeout`: Overpass answered HTTP 504 — it accepted the query but its dispatcher gave up before producing a result, so the query exceeded the time budget the endpoint enforces rather than the [timeout:N] directive. `overpass_unavailable`: Overpass answered with an HTTP 5xx other than 504 (500, 501, 502, 503) — the endpoint is down, restarting, or shedding load. The thrown code tracks the status: 500 and 501 surface as InternalError, every other 5xx as ServiceUnavailable. `endpoints_exhausted`: Every Overpass endpoint tried was still unanswered when the call ran out of its total time budget — each accepted the query and held the connection instead of failing outright. Other values are possible when a failure originates below the handler.",
+          "examples": [
+            "query_error",
+            "query_timeout",
+            "result_too_large",
+            "rate_limited",
+            "upstream_error",
+            "overpass_gateway_timeout",
+            "overpass_unavailable",
+            "endpoints_exhausted"
+          ],
+          "type": "string"
+        },
+        "recovery": {
+          "additionalProperties": {},
+          "description": "Actionable next step for the caller.",
+          "properties": {
+            "hint": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "hint"
+          ],
+          "type": "object"
+        },
+        "retryable": {
+          "description": "Whether retrying may succeed.",
+          "type": "boolean"
+        }
+      },
+      "type": "object"
+    },
+    "message": {
+      "description": "Human-readable description of what went wrong.",
+      "type": "string"
+    }
+  },
+  "required": [
+    "code",
+    "message"
+  ],
+  "type": "object"
+}

Removed value: -[
-  "elements",
-  "total_elements",
-  "attribution",
-  "effectiveQuery",
-  "totalFound",
-  "truncated"
-]

Added value: +{
+  "default": 20,
+  "description": "Maximum elements to return. Applied after the Overpass query — if the query matched more, they are truncated.",
+  "maximum": 500,
+  "minimum": 1,
+  "type": "integer"
+}

Added value: +{
+  "default": 0,
+  "description": "Number of matching elements to skip before applying limit, for paging through a large result set. The full match set is fetched and cached ~10 minutes keyed by the query, so re-paging at a new offset is deterministic and costs no extra upstream request; a result over 100000 elements is served but not cached, so paging that far re-queries and depends on the endpoint returning the same order. Pass the nextOffset value from a prior truncated response.",
+  "maximum": 9007199254740991,
+  "minimum": 0,
+  "type": "integer"
+}

Previous value: -"Query timeout in seconds. The [timeout:N] directive in the query string takes precedence if present. Max 180s."New value: +"Query timeout in seconds, bounding how long Overpass itself spends on the query. The [timeout:N] directive in the query string takes precedence if present. The client waits for what is requested here, up to 180s, so a long-running query is not cut off early — but the endpoint enforces its own budget and may answer HTTP 504 first."

Previous value: -"Raw Overpass API response elements. Structure varies by query type — nodes have lat/lon, ways have nodes[], relations have members[]."New value: +"Raw Overpass API response elements for this page, up to the limit. Structure varies by query type — nodes have lat/lon, ways have nodes[], relations have members[]."

Added value: +{
+  "description": "Offset to pass on the next call to retrieve the following page of elements. Present only when more elements remain beyond this page.",
+  "type": "number"
+}

Previous value: -"Guidance when no elements were returned — e.g., check query syntax or broaden the filter. Absent when results were returned."New value: +"Guidance when the page came back empty. Distinguishes a query that matched nothing (check syntax or broaden the filter) from an offset past the end of a non-empty result set (retry at a lower offset). Absent when results were returned."

Added value: +{
+  "description": "Total elements returned by Overpass before limit truncation.",
+  "type": "number"
+}

Previous value: -"Number of elements returned."New value: +"Number of elements returned on this page. See totalFound for the full match count."

Added value: +{
+  "description": "True if elements were cut at the limit. Narrow the query, or page with offset to retrieve the rest.",
+  "type": "boolean"
+}

Previous value: -[
-  "elements",
-  "total_elements",
-  "attribution",
-  "effectiveQuery"
-]New value: +[
+  "elements",
+  "total_elements",
+  "attribution",
+  "effectiveQuery",
+  "totalFound",
+  "truncated"
+]

Added value: +{
+  "description": "Overpass endpoint that produced this response, as origin and path. Differs from the first configured endpoint when a mirror answered after the primary failed, and names the endpoint that served a cached response rather than the one this call would have tried. Pair it with data_timestamp when a result looks unexpectedly slow, sparse, or stale.",
+  "type": "string"
+}

Previous value: -"OSM data freshness timestamp from the Overpass response. Absent if not included in the response."New value: +"OSM data freshness timestamp from the Overpass response. Absent when the endpoint reported no freshness metadata."

Added value: +{
+  "description": "The Overpass QL string as sent to the API (after any timeout injection).",
+  "type": "string"
+}

Added value: +{
+  "description": "Guidance when no elements were returned — e.g., check query syntax or broaden the filter. Absent when results were returned.",
+  "type": "string"
+}

Previous value: -[
-  "elements",
-  "total_elements",
-  "attribution"
-]New value: +[
+  "elements",
+  "total_elements",
+  "attribution",
+  "effectiveQuery"
+]