{"items":[{"id":"NVI-00008871","kind":"vulnerability","title":"MCP TypeScript SDK: HTTP server transports and handlers did not limit request body size or JSON-RPC batch length","revision":2,"unknowns":["Customer inventory, deployment, reachability and exploitation have not been inspected."],"lifecycle":"active","identifiers":["GHSA-f897-62hf-6gxq"],"plain_summary":"GitHub lists this reviewed advisory for @modelcontextprotocol/sdk, @modelcontextprotocol/server, @modelcontextprotocol/node, @modelcontextprotocol/hono. Published version ranges and source prerequisites are shown below; this is not an inspection of a visitor’s application.","review_status":"source_listed","control_topics":[],"public_actions":[{"summary":"Identify the exact component and deployed version, examine the linked publisher’s conditions, and retain evidence of any mitigation.","source_ids":["sr-1282177666921e0afd4fa94a9a8d92d8"],"action_type":"investigate","limitations":"Confirm current vendor support, compatibility and deployment evidence. This report has not tested a fix in your system.","current_supported_target":null},{"summary":"The original advisory lists fixed boundaries 1.30.1 for @modelcontextprotocol/sdk. Confirm the publisher’s latest guidance.","source_ids":["sr-a7acd2628082690a7104457613733c2e"],"action_type":"vendor_patch","limitations":"Confirm current vendor support, compatibility and deployment evidence. This report has not tested a fix in your system.","current_supported_target":null},{"summary":"The original advisory lists fixed boundaries 2.1.0 for @modelcontextprotocol/server. Confirm the publisher’s latest guidance.","source_ids":["sr-a7acd2628082690a7104457613733c2e"],"action_type":"vendor_patch","limitations":"Confirm current vendor support, compatibility and deployment evidence. This report has not tested a fix in your system.","current_supported_target":null},{"summary":"The original advisory lists fixed boundaries 2.1.0 for @modelcontextprotocol/node. Confirm the publisher’s latest guidance.","source_ids":["sr-a7acd2628082690a7104457613733c2e"],"action_type":"vendor_patch","limitations":"Confirm current vendor support, compatibility and deployment evidence. This report has not tested a fix in your system.","current_supported_target":null},{"summary":"The original advisory lists fixed boundaries 2.0.1 for @modelcontextprotocol/hono. Confirm the publisher’s latest guidance.","source_ids":["sr-a7acd2628082690a7104457613733c2e"],"action_type":"vendor_patch","limitations":"Confirm current vendor support, compatibility and deployment evidence. This report has not tested a fix in your system.","current_supported_target":null}],"schema_version":"1.1.0","source_metrics":[{"kind":"CVSS","as_of":"2026-10-27T19:02:02.000Z","value":"7.5 high","meaning":"GitHub source severity; exploitability and local consequence require separate evidence.","source_id":"sr-1282177666921e0afd4fa94a9a8d92d8"}],"why_it_matters":"Published affected context helps an owner decide what evidence to gather. This report has not examined your application.","related_sources":[{"id":"sr-1282177666921e0afd4fa94a9a8d92d8","url":"https://github.com/advisories/GHSA-f897-62hf-6gxq","basis":"vendor_advisory","notes":"GitHub Advisory Database; CC-BY-4.0. Each advisory links its original attribution. Null normalizes fields.","title":"GHSA-f897-62hf-6gxq","publisher":"GitHub Advisory Database","observed_at":"2026-10-31T21:56:36.327Z"},{"id":"sr-a7acd2628082690a7104457613733c2e","url":"https://github.com/advisories/GHSA-f897-62hf-6gxq","basis":"vendor_advisory","notes":"GitHub-origin advisory, CC-BY-4.0; OSV is an aggregate copy, not independent corroboration.","title":"GHSA-f897-62hf-6gxq","publisher":"GitHub Advisory Database via OSV","observed_at":"2026-11-02T09:54:05.660Z"}],"affected_context":[{"certainty":"source_listed","source_ids":["sr-1282177666921e0afd4fa94a9a8d92d8"],"technology":"@modelcontextprotocol/sdk","known_exclusions":[],"conditions_summary":"### Summary\nIn affected versions, MCP servers reachable over HTTP put no limit on the size of a POST body or on the number of messages in a JSON-RPC batch. Large requests could exhaust the server's memory, and one long batch could block it from serving anyone else. No credentials were needed, unless your application authenticates requests before they reach the SDK.\n\n### Am I affected?\nYes, if clients you do not fully trust can reach your server over Streamable HTTP. A body parser such as `express.json()` does not protect you, because it does not limit batch length. Servers that only use stdio are not affected.\n\nAffected versions:\n\n- `@modelcontextprotocol/sdk` 1.10.0 through 1.30.0\n- `@modelcontextprotocol/server` 2.0.0\n- `@modelcontextprotocol/node` 2.0.0\n- `@modelcontextprotocol/hono` 2.0.0\n\n### Fix\nUpgrade to:\n\n- 1.x: `@modelcontextprotocol/sdk` 1.30.1 or later\n- 2.x: `@modelcontextprotocol/server` 2.1.0, `@modelcontextprotocol/node` 2.1.0 and `@modelcontextprotocol/hono` 2.0.1 or later. Upgrade every one you have installed.\n\nBodies over 4 MiB now get `413`, and batches over 100 messages get `400`. If your clients send larger bodies, raise the new `maxRequestBodySize` option.\n\nI","public_affected_ranges":[">= 1.10.0, < 1.30.1"]},{"certainty":"source_listed","source_ids":["sr-1282177666921e0afd4fa94a9a8d92d8"],"technology":"@modelcontextprotocol/server","known_exclusions":[],"conditions_summary":"### Summary\nIn affected versions, MCP servers reachable over HTTP put no limit on the size of a POST body or on the number of messages in a JSON-RPC batch. Large requests could exhaust the server's memory, and one long batch could block it from serving anyone else. No credentials were needed, unless your application authenticates requests before they reach the SDK.\n\n### Am I affected?\nYes, if clients you do not fully trust can reach your server over Streamable HTTP. A body parser such as `express.json()` does not protect you, because it does not limit batch length. Servers that only use stdio are not affected.\n\nAffected versions:\n\n- `@modelcontextprotocol/sdk` 1.10.0 through 1.30.0\n- `@modelcontextprotocol/server` 2.0.0\n- `@modelcontextprotocol/node` 2.0.0\n- `@modelcontextprotocol/hono` 2.0.0\n\n### Fix\nUpgrade to:\n\n- 1.x: `@modelcontextprotocol/sdk` 1.30.1 or later\n- 2.x: `@modelcontextprotocol/server` 2.1.0, `@modelcontextprotocol/node` 2.1.0 and `@modelcontextprotocol/hono` 2.0.1 or later. Upgrade every one you have installed.\n\nBodies over 4 MiB now get `413`, and batches over 100 messages get `400`. If your clients send larger bodies, raise the new `maxRequestBodySize` option.\n\nI","public_affected_ranges":[">= 2.0.0, < 2.1.0"]},{"certainty":"source_listed","source_ids":["sr-1282177666921e0afd4fa94a9a8d92d8"],"technology":"@modelcontextprotocol/node","known_exclusions":[],"conditions_summary":"### Summary\nIn affected versions, MCP servers reachable over HTTP put no limit on the size of a POST body or on the number of messages in a JSON-RPC batch. Large requests could exhaust the server's memory, and one long batch could block it from serving anyone else. No credentials were needed, unless your application authenticates requests before they reach the SDK.\n\n### Am I affected?\nYes, if clients you do not fully trust can reach your server over Streamable HTTP. A body parser such as `express.json()` does not protect you, because it does not limit batch length. Servers that only use stdio are not affected.\n\nAffected versions:\n\n- `@modelcontextprotocol/sdk` 1.10.0 through 1.30.0\n- `@modelcontextprotocol/server` 2.0.0\n- `@modelcontextprotocol/node` 2.0.0\n- `@modelcontextprotocol/hono` 2.0.0\n\n### Fix\nUpgrade to:\n\n- 1.x: `@modelcontextprotocol/sdk` 1.30.1 or later\n- 2.x: `@modelcontextprotocol/server` 2.1.0, `@modelcontextprotocol/node` 2.1.0 and `@modelcontextprotocol/hono` 2.0.1 or later. Upgrade every one you have installed.\n\nBodies over 4 MiB now get `413`, and batches over 100 messages get `400`. If your clients send larger bodies, raise the new `maxRequestBodySize` option.\n\nI","public_affected_ranges":[">= 2.0.0, < 2.1.0"]},{"certainty":"source_listed","source_ids":["sr-1282177666921e0afd4fa94a9a8d92d8"],"technology":"@modelcontextprotocol/hono","known_exclusions":[],"conditions_summary":"### Summary\nIn affected versions, MCP servers reachable over HTTP put no limit on the size of a POST body or on the number of messages in a JSON-RPC batch. Large requests could exhaust the server's memory, and one long batch could block it from serving anyone else. No credentials were needed, unless your application authenticates requests before they reach the SDK.\n\n### Am I affected?\nYes, if clients you do not fully trust can reach your server over Streamable HTTP. A body parser such as `express.json()` does not protect you, because it does not limit batch length. Servers that only use stdio are not affected.\n\nAffected versions:\n\n- `@modelcontextprotocol/sdk` 1.10.0 through 1.30.0\n- `@modelcontextprotocol/server` 2.0.0\n- `@modelcontextprotocol/node` 2.0.0\n- `@modelcontextprotocol/hono` 2.0.0\n\n### Fix\nUpgrade to:\n\n- 1.x: `@modelcontextprotocol/sdk` 1.30.1 or later\n- 2.x: `@modelcontextprotocol/server` 2.1.0, `@modelcontextprotocol/node` 2.1.0 and `@modelcontextprotocol/hono` 2.0.1 or later. Upgrade every one you have installed.\n\nBodies over 4 MiB now get `413`, and batches over 100 messages get `400`. If your clients send larger bodies, raise the new `maxRequestBodySize` option.\n\nI","public_affected_ranges":[">= 2.0.0, < 2.0.1"]},{"certainty":"source_listed","source_ids":["sr-a7acd2628082690a7104457613733c2e"],"technology":"@modelcontextprotocol/sdk","known_exclusions":[],"conditions_summary":"### Summary\nIn affected versions, MCP servers reachable over HTTP put no limit on the size of a POST body or on the number of messages in a JSON-RPC batch. Large requests could exhaust the server's memory, and one long batch could block it from serving anyone else. No credentials were needed, unless your application authenticates requests before they reach the SDK.\n\n### Am I affected?\nYes, if clients you do not fully trust can reach your server over Streamable HTTP. A body parser such as `express.json()` does not protect you, because it does not limit batch length. Servers that only use stdio are not affected.\n\nAffected versions:\n\n- `@modelcontextprotocol/sdk` 1.10.0 through 1.30.0\n- `@modelcontextprotocol/server` 2.0.0\n- `@modelcontextprotocol/node` 2.0.0\n- `@modelcontextprotocol/hono` 2.0.0\n\n### Fix\nUpgrade to:\n\n- 1.x: `@modelcontextprotocol/sdk` 1.30.1 or later\n- 2.x: `@modelcontextprotocol/server` 2.1.0, `@modelcontextprotocol/node` 2.1.0 and `@modelcontextprotocol/hono` 2.0.1 or later. Upgrade every one you have installed.\n\nBodies over 4 MiB now get `413`, and batches over 100 messages get `400`. If your clients send larger bodies, raise the new `maxRequestBodySize` option.\n\nI","public_affected_ranges":["SEMVER: introduced 1.10.0; fixed 1.30.1"]},{"certainty":"source_listed","source_ids":["sr-a7acd2628082690a7104457613733c2e"],"technology":"@modelcontextprotocol/server","known_exclusions":[],"conditions_summary":"### Summary\nIn affected versions, MCP servers reachable over HTTP put no limit on the size of a POST body or on the number of messages in a JSON-RPC batch. Large requests could exhaust the server's memory, and one long batch could block it from serving anyone else. No credentials were needed, unless your application authenticates requests before they reach the SDK.\n\n### Am I affected?\nYes, if clients you do not fully trust can reach your server over Streamable HTTP. A body parser such as `express.json()` does not protect you, because it does not limit batch length. Servers that only use stdio are not affected.\n\nAffected versions:\n\n- `@modelcontextprotocol/sdk` 1.10.0 through 1.30.0\n- `@modelcontextprotocol/server` 2.0.0\n- `@modelcontextprotocol/node` 2.0.0\n- `@modelcontextprotocol/hono` 2.0.0\n\n### Fix\nUpgrade to:\n\n- 1.x: `@modelcontextprotocol/sdk` 1.30.1 or later\n- 2.x: `@modelcontextprotocol/server` 2.1.0, `@modelcontextprotocol/node` 2.1.0 and `@modelcontextprotocol/hono` 2.0.1 or later. Upgrade every one you have installed.\n\nBodies over 4 MiB now get `413`, and batches over 100 messages get `400`. If your clients send larger bodies, raise the new `maxRequestBodySize` option.\n\nI","public_affected_ranges":["SEMVER: introduced 2.0.0; fixed 2.1.0"]},{"certainty":"source_listed","source_ids":["sr-a7acd2628082690a7104457613733c2e"],"technology":"@modelcontextprotocol/node","known_exclusions":[],"conditions_summary":"### Summary\nIn affected versions, MCP servers reachable over HTTP put no limit on the size of a POST body or on the number of messages in a JSON-RPC batch. Large requests could exhaust the server's memory, and one long batch could block it from serving anyone else. No credentials were needed, unless your application authenticates requests before they reach the SDK.\n\n### Am I affected?\nYes, if clients you do not fully trust can reach your server over Streamable HTTP. A body parser such as `express.json()` does not protect you, because it does not limit batch length. Servers that only use stdio are not affected.\n\nAffected versions:\n\n- `@modelcontextprotocol/sdk` 1.10.0 through 1.30.0\n- `@modelcontextprotocol/server` 2.0.0\n- `@modelcontextprotocol/node` 2.0.0\n- `@modelcontextprotocol/hono` 2.0.0\n\n### Fix\nUpgrade to:\n\n- 1.x: `@modelcontextprotocol/sdk` 1.30.1 or later\n- 2.x: `@modelcontextprotocol/server` 2.1.0, `@modelcontextprotocol/node` 2.1.0 and `@modelcontextprotocol/hono` 2.0.1 or later. Upgrade every one you have installed.\n\nBodies over 4 MiB now get `413`, and batches over 100 messages get `400`. If your clients send larger bodies, raise the new `maxRequestBodySize` option.\n\nI","public_affected_ranges":["SEMVER: introduced 2.0.0; fixed 2.1.0"]},{"certainty":"source_listed","source_ids":["sr-a7acd2628082690a7104457613733c2e"],"technology":"@modelcontextprotocol/hono","known_exclusions":[],"conditions_summary":"### Summary\nIn affected versions, MCP servers reachable over HTTP put no limit on the size of a POST body or on the number of messages in a JSON-RPC batch. Large requests could exhaust the server's memory, and one long batch could block it from serving anyone else. No credentials were needed, unless your application authenticates requests before they reach the SDK.\n\n### Am I affected?\nYes, if clients you do not fully trust can reach your server over Streamable HTTP. A body parser such as `express.json()` does not protect you, because it does not limit batch length. Servers that only use stdio are not affected.\n\nAffected versions:\n\n- `@modelcontextprotocol/sdk` 1.10.0 through 1.30.0\n- `@modelcontextprotocol/server` 2.0.0\n- `@modelcontextprotocol/node` 2.0.0\n- `@modelcontextprotocol/hono` 2.0.0\n\n### Fix\nUpgrade to:\n\n- 1.x: `@modelcontextprotocol/sdk` 1.30.1 or later\n- 2.x: `@modelcontextprotocol/server` 2.1.0, `@modelcontextprotocol/node` 2.1.0 and `@modelcontextprotocol/hono` 2.0.1 or later. Upgrade every one you have installed.\n\nBodies over 4 MiB now get `413`, and batches over 100 messages get `400`. If your clients send larger bodies, raise the new `maxRequestBodySize` option.\n\nI","public_affected_ranges":["SEMVER: introduced 2.0.0; fixed 2.0.1"]}],"null_published_at":"2026-11-02T20:21:10.347Z","source_updated_at":"2026-10-27T19:02:02.000Z","source_disclosed_at":"2026-10-27T19:02:00.000Z","is_synthetic_fixture":false,"null_last_reviewed_at":null,"public_change_summary":"Source facts changed; compare the preserved prior revision.","null_first_observed_at":"2026-10-31T21:56:36.327Z"},{"id":"NVI-00008871","kind":"vulnerability","title":"MCP TypeScript SDK: HTTP server transports and handlers did not limit request body size or JSON-RPC batch length","revision":1,"unknowns":["Customer inventory, deployment, reachability and exploitation have not been inspected."],"lifecycle":"active","identifiers":["GHSA-f897-62hf-6gxq"],"plain_summary":"GitHub lists this reviewed advisory for @modelcontextprotocol/sdk, @modelcontextprotocol/server, @modelcontextprotocol/node, @modelcontextprotocol/hono. Published version ranges and source prerequisites are shown below; this is not an inspection of a visitor’s application.","review_status":"source_listed","control_topics":[],"public_actions":[{"summary":"Identify the exact component and deployed version, examine the linked publisher’s conditions, and retain evidence of any mitigation.","source_ids":["sr-1282177666921e0afd4fa94a9a8d92d8"],"action_type":"investigate","limitations":"Confirm current vendor support, compatibility and deployment evidence. This report has not tested a fix in your system.","current_supported_target":null}],"schema_version":"1.1.0","source_metrics":[{"kind":"CVSS","as_of":"2026-10-27T19:02:02.000Z","value":"7.5 high","meaning":"GitHub source severity; exploitability and local consequence require separate evidence.","source_id":"sr-1282177666921e0afd4fa94a9a8d92d8"}],"why_it_matters":"Published affected context helps an owner decide what evidence to gather. This report has not examined your application.","related_sources":[{"id":"sr-1282177666921e0afd4fa94a9a8d92d8","url":"https://github.com/advisories/GHSA-f897-62hf-6gxq","basis":"vendor_advisory","notes":"GitHub Advisory Database; CC-BY-4.0. Each advisory links its original attribution. Null normalizes fields.","title":"GHSA-f897-62hf-6gxq","publisher":"GitHub Advisory Database","observed_at":"2026-10-31T21:56:36.327Z"}],"affected_context":[{"certainty":"source_listed","source_ids":["sr-1282177666921e0afd4fa94a9a8d92d8"],"technology":"@modelcontextprotocol/sdk","known_exclusions":[],"conditions_summary":"### Summary\nIn affected versions, MCP servers reachable over HTTP put no limit on the size of a POST body or on the number of messages in a JSON-RPC batch. Large requests could exhaust the server's memory, and one long batch could block it from serving anyone else. No credentials were needed, unless your application authenticates requests before they reach the SDK.\n\n### Am I affected?\nYes, if clients you do not fully trust can reach your server over Streamable HTTP. A body parser such as `express.json()` does not protect you, because it does not limit batch length. Servers that only use stdio are not affected.\n\nAffected versions:\n\n- `@modelcontextprotocol/sdk` 1.10.0 through 1.30.0\n- `@modelcontextprotocol/server` 2.0.0\n- `@modelcontextprotocol/node` 2.0.0\n- `@modelcontextprotocol/hono` 2.0.0\n\n### Fix\nUpgrade to:\n\n- 1.x: `@modelcontextprotocol/sdk` 1.30.1 or later\n- 2.x: `@modelcontextprotocol/server` 2.1.0, `@modelcontextprotocol/node` 2.1.0 and `@modelcontextprotocol/hono` 2.0.1 or later. Upgrade every one you have installed.\n\nBodies over 4 MiB now get `413`, and batches over 100 messages get `400`. If your clients send larger bodies, raise the new `maxRequestBodySize` option.\n\nI","public_affected_ranges":[">= 1.10.0, < 1.30.1"]},{"certainty":"source_listed","source_ids":["sr-1282177666921e0afd4fa94a9a8d92d8"],"technology":"@modelcontextprotocol/server","known_exclusions":[],"conditions_summary":"### Summary\nIn affected versions, MCP servers reachable over HTTP put no limit on the size of a POST body or on the number of messages in a JSON-RPC batch. Large requests could exhaust the server's memory, and one long batch could block it from serving anyone else. No credentials were needed, unless your application authenticates requests before they reach the SDK.\n\n### Am I affected?\nYes, if clients you do not fully trust can reach your server over Streamable HTTP. A body parser such as `express.json()` does not protect you, because it does not limit batch length. Servers that only use stdio are not affected.\n\nAffected versions:\n\n- `@modelcontextprotocol/sdk` 1.10.0 through 1.30.0\n- `@modelcontextprotocol/server` 2.0.0\n- `@modelcontextprotocol/node` 2.0.0\n- `@modelcontextprotocol/hono` 2.0.0\n\n### Fix\nUpgrade to:\n\n- 1.x: `@modelcontextprotocol/sdk` 1.30.1 or later\n- 2.x: `@modelcontextprotocol/server` 2.1.0, `@modelcontextprotocol/node` 2.1.0 and `@modelcontextprotocol/hono` 2.0.1 or later. Upgrade every one you have installed.\n\nBodies over 4 MiB now get `413`, and batches over 100 messages get `400`. If your clients send larger bodies, raise the new `maxRequestBodySize` option.\n\nI","public_affected_ranges":[">= 2.0.0, < 2.1.0"]},{"certainty":"source_listed","source_ids":["sr-1282177666921e0afd4fa94a9a8d92d8"],"technology":"@modelcontextprotocol/node","known_exclusions":[],"conditions_summary":"### Summary\nIn affected versions, MCP servers reachable over HTTP put no limit on the size of a POST body or on the number of messages in a JSON-RPC batch. Large requests could exhaust the server's memory, and one long batch could block it from serving anyone else. No credentials were needed, unless your application authenticates requests before they reach the SDK.\n\n### Am I affected?\nYes, if clients you do not fully trust can reach your server over Streamable HTTP. A body parser such as `express.json()` does not protect you, because it does not limit batch length. Servers that only use stdio are not affected.\n\nAffected versions:\n\n- `@modelcontextprotocol/sdk` 1.10.0 through 1.30.0\n- `@modelcontextprotocol/server` 2.0.0\n- `@modelcontextprotocol/node` 2.0.0\n- `@modelcontextprotocol/hono` 2.0.0\n\n### Fix\nUpgrade to:\n\n- 1.x: `@modelcontextprotocol/sdk` 1.30.1 or later\n- 2.x: `@modelcontextprotocol/server` 2.1.0, `@modelcontextprotocol/node` 2.1.0 and `@modelcontextprotocol/hono` 2.0.1 or later. Upgrade every one you have installed.\n\nBodies over 4 MiB now get `413`, and batches over 100 messages get `400`. If your clients send larger bodies, raise the new `maxRequestBodySize` option.\n\nI","public_affected_ranges":[">= 2.0.0, < 2.1.0"]},{"certainty":"source_listed","source_ids":["sr-1282177666921e0afd4fa94a9a8d92d8"],"technology":"@modelcontextprotocol/hono","known_exclusions":[],"conditions_summary":"### Summary\nIn affected versions, MCP servers reachable over HTTP put no limit on the size of a POST body or on the number of messages in a JSON-RPC batch. Large requests could exhaust the server's memory, and one long batch could block it from serving anyone else. No credentials were needed, unless your application authenticates requests before they reach the SDK.\n\n### Am I affected?\nYes, if clients you do not fully trust can reach your server over Streamable HTTP. A body parser such as `express.json()` does not protect you, because it does not limit batch length. Servers that only use stdio are not affected.\n\nAffected versions:\n\n- `@modelcontextprotocol/sdk` 1.10.0 through 1.30.0\n- `@modelcontextprotocol/server` 2.0.0\n- `@modelcontextprotocol/node` 2.0.0\n- `@modelcontextprotocol/hono` 2.0.0\n\n### Fix\nUpgrade to:\n\n- 1.x: `@modelcontextprotocol/sdk` 1.30.1 or later\n- 2.x: `@modelcontextprotocol/server` 2.1.0, `@modelcontextprotocol/node` 2.1.0 and `@modelcontextprotocol/hono` 2.0.1 or later. Upgrade every one you have installed.\n\nBodies over 4 MiB now get `413`, and batches over 100 messages get `400`. If your clients send larger bodies, raise the new `maxRequestBodySize` option.\n\nI","public_affected_ranges":[">= 2.0.0, < 2.0.1"]}],"null_published_at":"2026-10-31T22:13:27.120Z","source_updated_at":"2026-10-27T19:02:02.000Z","source_disclosed_at":"2026-10-27T19:02:00.000Z","is_synthetic_fixture":false,"null_last_reviewed_at":null,"public_change_summary":"First indexed by Null; source disclosure date is shown separately.","null_first_observed_at":"2026-10-31T21:56:36.327Z"}],"next_cursor":null,"snapshot_revision":"42594"}