@ggui-ai/protocol-conformance 0.6.3 → 0.8.0

package/dist/resolution-conformance/cases/resolve-default-host.json

@@ -6,7 +6,7 @@
         "version": "2.3.1"
     },
     "expect": {
-        "bundleUrl": "https://registry.ggui.ai/bundles/@acme/leaflet-wrapper/2.3.1/bundle.js",
-        "styleUrl": "https://registry.ggui.ai/bundles/@acme/leaflet-wrapper/2.3.1/style.css"
+        "bundleUrl": "https://registry.ggui.ai/bundles/public/@acme/leaflet-wrapper/2.3.1/bundle.js",
+        "styleUrl": "https://registry.ggui.ai/bundles/public/@acme/leaflet-wrapper/2.3.1/style.css"
     }
 }

package/dist/resolution-conformance/cases/resolve-loopback-host-http-scheme.json

@@ -7,7 +7,7 @@
         "bundleHost": "localhost:4873"
     },
     "expect": {
-        "bundleUrl": "http://localhost:4873/bundles/@acme/leaflet-wrapper/2.3.1/bundle.js",
-        "styleUrl": "http://localhost:4873/bundles/@acme/leaflet-wrapper/2.3.1/style.css"
+        "bundleUrl": "http://localhost:4873/bundles/public/@acme/leaflet-wrapper/2.3.1/bundle.js",
+        "styleUrl": "http://localhost:4873/bundles/public/@acme/leaflet-wrapper/2.3.1/style.css"
     }
 }

package/dist/resource-read-conformance/cases/all-ephemeral-substrate-fuses-like-none.json

@@ -0,0 +1,29 @@
+{
+    "name": "all-ephemeral-substrate-fuses-like-none",
+    "description": "A server binding the WHOLE substrate out of stores that declare ephemeral durability keeps no durable record — a restart erases everything — so it MUST fuse exactly like a substrate-less one (#457). Binding is not durability: deriving the NOT_SUPPORTED/NOT_FOUND split from mere binding lets an operator with three in-memory stores promise restorability the deployment cannot deliver, and the promise breaks silently, on the first restart, for every locator at once.",
+    "server": { "durableSubstrate": "all-ephemeral", "liveChannel": true },
+    "caller": "other",
+    "seeds": [{ "kind": "committed-render", "session": "6b2f8d13-4a5c-4e97-8f21-9d0c3b7a5e14" }],
+    "reads": [
+        {
+            "as": "refused",
+            "locator": { "kind": "render", "session": "6b2f8d13-4a5c-4e97-8f21-9d0c3b7a5e14" },
+            "expect": {
+                "kind": "typed-error",
+                "jsonRpcCode": -32006,
+                "dataCode": "NOT_SUPPORTED"
+            }
+        },
+        {
+            "as": "miss",
+            "locator": { "kind": "render", "session": "0c9e4f72-8b1d-4a63-95e8-2f6a7d3c1b58" },
+            "expect": {
+                "kind": "typed-error",
+                "jsonRpcCode": -32006,
+                "dataCode": "NOT_SUPPORTED"
+            }
+        }
+    ],
+    "indistinguishable": ["refused", "miss"],
+    "disclosesNothing": ["6b2f8d13-4a5c-4e97-8f21-9d0c3b7a5e14"]
+}

package/dist/resource-read-conformance/cases/channel-less-read-mounts-inline.json

@@ -0,0 +1,24 @@
+{
+    "name": "channel-less-read-mounts-inline",
+    "description": "The inline static channel makes a channel-less server mountable: no static component URL is wired, no live channel is wired, but the committed component fits the inline codeB64 cap — so the read returns a shell whose projected render meta declares the inline channel, not a typed failure. This is the success half of the size split whose failure half is read-without-a-delivery-channel-answers-not-mountable: the SAME server wiring answers by component size class, which is what makes the inline channel a real delivery channel rather than a serving detail.",
+    "server": { "durableSubstrate": "all" },
+    "caller": "owner",
+    "seeds": [
+        {
+            "kind": "committed-render",
+            "session": "3f1a9c22-7b4e-4d18-9a05-6c2e8b1d4f70",
+            "size": "under-inline-cap"
+        }
+    ],
+    "reads": [
+        {
+            "as": "inline",
+            "locator": {
+                "kind": "render",
+                "session": "3f1a9c22-7b4e-4d18-9a05-6c2e8b1d4f70",
+                "key": { "kind": "literal", "value": "fedcba9876543210" }
+            },
+            "expect": { "kind": "live-mount" }
+        }
+    ]
+}

package/dist/resource-read-conformance/cases/evicted-row-remints-from-the-durable-record.json

@@ -0,0 +1,26 @@
+{
+    "name": "evicted-row-remints-from-the-durable-record",
+    "description": "The success half on the path the durable substrate exists for. The render row is gone, but the record naming what it was survives, the blueprint it names is stored, and the component body behind that blueprint is still there — so the read restores it and hands back real mount material. Without this case the catalog would grade a server that answers every evicted locator with a typed error as fully conformant, which is the direction a broken re-mint fails in.",
+    "server": { "durableSubstrate": "all", "liveChannel": true },
+    "caller": "owner",
+    "seeds": [
+        {
+            "kind": "identity-record",
+            "session": "3f1a9c22-7b4e-4d18-9a05-6c2e8b1d4f70",
+            "key": "fedcba9876543210",
+            "blueprint": "named"
+        },
+        { "kind": "durable-blueprint", "componentRef": "present", "body": "stored" }
+    ],
+    "reads": [
+        {
+            "as": "reminted",
+            "locator": {
+                "kind": "render",
+                "session": "3f1a9c22-7b4e-4d18-9a05-6c2e8b1d4f70",
+                "key": { "kind": "literal", "value": "fedcba9876543210" }
+            },
+            "expect": { "kind": "live-mount" }
+        }
+    ]
+}

package/dist/resource-read-conformance/cases/half-wired-blueprints-only-substrate-fuses-like-none.json

@@ -0,0 +1,29 @@
+{
+    "name": "half-wired-blueprints-only-substrate-fuses-like-none",
+    "description": "The other half-wired shape: blueprint and component storage bound, no record of what any render was. Without the record there is nothing to look a blueprint up BY, so this server restores nothing either and owes the same fused answer as one wired for nothing at all.",
+    "server": { "durableSubstrate": "blueprints-only", "liveChannel": true },
+    "caller": "other",
+    "seeds": [{ "kind": "committed-render", "session": "3f1a9c22-7b4e-4d18-9a05-6c2e8b1d4f70" }],
+    "reads": [
+        {
+            "as": "refused",
+            "locator": { "kind": "render", "session": "3f1a9c22-7b4e-4d18-9a05-6c2e8b1d4f70" },
+            "expect": {
+                "kind": "typed-error",
+                "jsonRpcCode": -32006,
+                "dataCode": "NOT_SUPPORTED"
+            }
+        },
+        {
+            "as": "miss",
+            "locator": { "kind": "render", "session": "8d5b0e41-2c96-4a7f-b3d8-1e07f9a2c645" },
+            "expect": {
+                "kind": "typed-error",
+                "jsonRpcCode": -32006,
+                "dataCode": "NOT_SUPPORTED"
+            }
+        }
+    ],
+    "indistinguishable": ["refused", "miss"],
+    "disclosesNothing": ["3f1a9c22-7b4e-4d18-9a05-6c2e8b1d4f70"]
+}

package/dist/resource-read-conformance/cases/half-wired-identity-only-substrate-fuses-like-none.json

@@ -0,0 +1,29 @@
+{
+    "name": "half-wired-identity-only-substrate-fuses-like-none",
+    "description": "A server holding the record store and nothing else can restore no render, so it is as substrate-less as one holding nothing. This is where the fusion is easiest to get wrong: the re-mint is consulted only when the row is absent, so a verdict derived from a partial substrate check answers NOT_FOUND for a row that exists and NOT_SUPPORTED for one that never did — the existence oracle, rebuilt out of a provisioning mistake.",
+    "server": { "durableSubstrate": "identity-only", "liveChannel": true },
+    "caller": "other",
+    "seeds": [{ "kind": "committed-render", "session": "3f1a9c22-7b4e-4d18-9a05-6c2e8b1d4f70" }],
+    "reads": [
+        {
+            "as": "refused",
+            "locator": { "kind": "render", "session": "3f1a9c22-7b4e-4d18-9a05-6c2e8b1d4f70" },
+            "expect": {
+                "kind": "typed-error",
+                "jsonRpcCode": -32006,
+                "dataCode": "NOT_SUPPORTED"
+            }
+        },
+        {
+            "as": "miss",
+            "locator": { "kind": "render", "session": "8d5b0e41-2c96-4a7f-b3d8-1e07f9a2c645" },
+            "expect": {
+                "kind": "typed-error",
+                "jsonRpcCode": -32006,
+                "dataCode": "NOT_SUPPORTED"
+            }
+        }
+    ],
+    "indistinguishable": ["refused", "miss"],
+    "disclosesNothing": ["3f1a9c22-7b4e-4d18-9a05-6c2e8b1d4f70"]
+}

package/dist/resource-read-conformance/cases/live-row-read-returns-mount-material.json

@@ -0,0 +1,18 @@
+{
+    "name": "live-row-read-returns-mount-material",
+    "description": "The success half of the invariant, on the simplest path: the render is still live and the caller owns it. The result's contents must declare a delivery channel — a component URL, a live channel carrying BOTH an endpoint and a token, or a server-emitted system card. Graded on the projected render meta, never on markup: what the shell looks like is a server's own presentation concern. Note the blueprintKey segment names nothing this server has ever stored, and the read succeeds anyway — that is deliberate, and it makes a second obligation graded here: when the row is present and readable, the ROW is what gets mounted and the supplied key is not consulted. A server that validated the key against its own records and refused the mismatch would fail this case, correctly, because a resume locator's key exists to resolve a render that is GONE.",
+    "server": { "durableSubstrate": "all", "liveChannel": true },
+    "caller": "owner",
+    "seeds": [{ "kind": "committed-render", "session": "3f1a9c22-7b4e-4d18-9a05-6c2e8b1d4f70" }],
+    "reads": [
+        {
+            "as": "live",
+            "locator": {
+                "kind": "render",
+                "session": "3f1a9c22-7b4e-4d18-9a05-6c2e8b1d4f70",
+                "key": { "kind": "literal", "value": "fedcba9876543210" }
+            },
+            "expect": { "kind": "live-mount" }
+        }
+    ]
+}

package/dist/resource-read-conformance/cases/malformed-locator-stays-outside-the-typed-set.json

@@ -0,0 +1,19 @@
+{
+    "name": "malformed-locator-stays-outside-the-typed-set",
+    "description": "A URI with an empty session segment names no render locator, so it is not a read of one and the four classifications do not apply. The graded law is exactly one negative: the error carries NO resource-read code on error.data.code. The NUMBER is not graded, not even negatively — MCP assigns the resource-missing number to a resources/read of a URI the server does not serve, so a framework mapping every unrecognized URI onto it is correct and must not fail here. The classification alone keeps the two apart: a genuine miss carries NOT_FOUND and the constant message, a malformed URI carries no classification at all.",
+    "server": { "durableSubstrate": "all", "liveChannel": true },
+    "caller": "owner",
+    "seeds": [],
+    "reads": [
+        {
+            "as": "empty-session",
+            "locator": { "kind": "raw", "uri": "ui://ggui/render/" },
+            "expect": { "kind": "outside-typed-set" }
+        },
+        {
+            "as": "empty-session-with-key",
+            "locator": { "kind": "raw", "uri": "ui://ggui/render//fedcba9876543210" },
+            "expect": { "kind": "outside-typed-set" }
+        }
+    ]
+}

package/dist/resource-read-conformance/cases/read-miss-answers-not-found.json

@@ -0,0 +1,23 @@
+{
+    "name": "read-miss-answers-not-found",
+    "description": "A read of a locator that never existed, on a server that keeps durable records and could have restored one, answers NOT_FOUND on -32002 with a body carrying no detail. -32002 is the number a missing resource already rides on, and for a locator keyed by session id a missing session and a missing resource are one condition. The absent detail is what keeps this answer identical to a refusal.",
+    "server": { "durableSubstrate": "all", "liveChannel": true },
+    "caller": "owner",
+    "seeds": [],
+    "reads": [
+        {
+            "as": "miss",
+            "locator": {
+                "kind": "render",
+                "session": "8d5b0e41-2c96-4a7f-b3d8-1e07f9a2c645",
+                "key": { "kind": "literal", "value": "fedcba9876543210" }
+            },
+            "expect": {
+                "kind": "typed-error",
+                "jsonRpcCode": -32002,
+                "dataCode": "NOT_FOUND",
+                "detailAbsent": true
+            }
+        }
+    ]
+}

package/dist/resource-read-conformance/cases/read-on-a-substrate-less-server-answers-not-supported.json

@@ -0,0 +1,22 @@
+{
+    "name": "read-on-a-substrate-less-server-answers-not-supported",
+    "description": "A server that keeps no durable record cannot restore an evicted render for anybody, so a read it cannot serve answers NOT_SUPPORTED on -32006. This is a property of the deployment, not of the locator — which is why the catalog does not grade WHEN the answer is produced. A substrate-less server may answer immediately, before any per-locator work.",
+    "server": { "durableSubstrate": "none", "liveChannel": true },
+    "caller": "owner",
+    "seeds": [],
+    "reads": [
+        {
+            "as": "evicted",
+            "locator": {
+                "kind": "render",
+                "session": "8d5b0e41-2c96-4a7f-b3d8-1e07f9a2c645",
+                "key": { "kind": "literal", "value": "fedcba9876543210" }
+            },
+            "expect": {
+                "kind": "typed-error",
+                "jsonRpcCode": -32006,
+                "dataCode": "NOT_SUPPORTED"
+            }
+        }
+    ]
+}

package/dist/resource-read-conformance/cases/read-record-with-purged-blueprint-answers-blueprint-unresolvable.json

@@ -0,0 +1,29 @@
+{
+    "name": "read-record-with-purged-blueprint-answers-blueprint-unresolvable",
+    "description": "A durable record survives its render and names a blueprint, but the blueprint is gone. The read answers BLUEPRINT_UNRESOLVABLE on -32006 — not an internal error. Nothing malfunctioned: the record kept its promise and the thing it pointed at was reaped. A host reading -32006 knows a retry of this locator cannot succeed, which -32603 would have told it the opposite of.",
+    "server": { "durableSubstrate": "all", "liveChannel": true },
+    "caller": "owner",
+    "seeds": [
+        {
+            "kind": "identity-record",
+            "session": "3f1a9c22-7b4e-4d18-9a05-6c2e8b1d4f70",
+            "key": "fedcba9876543210",
+            "blueprint": "named"
+        }
+    ],
+    "reads": [
+        {
+            "as": "evicted",
+            "locator": {
+                "kind": "render",
+                "session": "3f1a9c22-7b4e-4d18-9a05-6c2e8b1d4f70",
+                "key": { "kind": "literal", "value": "fedcba9876543210" }
+            },
+            "expect": {
+                "kind": "typed-error",
+                "jsonRpcCode": -32006,
+                "dataCode": "BLUEPRINT_UNRESOLVABLE"
+            }
+        }
+    ]
+}

package/dist/resource-read-conformance/cases/read-refusal-is-indistinguishable-from-a-miss.json

@@ -0,0 +1,47 @@
+{
+    "name": "read-refusal-is-indistinguishable-from-a-miss",
+    "description": "The core disclosure obligation. A caller with no claim to a render reads a locator that fully resolves for its owner, and reads one that never existed. Both answers must be the same bytes. Anything that varies — a message naming the session, a detail explaining the refusal, a different code because the access check ran late — answers 'does this render exist?' for someone with no right to ask.",
+    "server": { "durableSubstrate": "all", "liveChannel": true },
+    "caller": "other",
+    "seeds": [
+        {
+            "kind": "identity-record",
+            "session": "3f1a9c22-7b4e-4d18-9a05-6c2e8b1d4f70",
+            "key": "fedcba9876543210",
+            "blueprint": "named"
+        },
+        { "kind": "durable-blueprint", "componentRef": "present", "body": "stored" }
+    ],
+    "reads": [
+        {
+            "as": "refused",
+            "locator": {
+                "kind": "render",
+                "session": "3f1a9c22-7b4e-4d18-9a05-6c2e8b1d4f70",
+                "key": { "kind": "literal", "value": "fedcba9876543210" }
+            },
+            "expect": {
+                "kind": "typed-error",
+                "jsonRpcCode": -32002,
+                "dataCode": "NOT_FOUND",
+                "detailAbsent": true
+            }
+        },
+        {
+            "as": "miss",
+            "locator": {
+                "kind": "render",
+                "session": "8d5b0e41-2c96-4a7f-b3d8-1e07f9a2c645",
+                "key": { "kind": "literal", "value": "fedcba9876543210" }
+            },
+            "expect": {
+                "kind": "typed-error",
+                "jsonRpcCode": -32002,
+                "dataCode": "NOT_FOUND",
+                "detailAbsent": true
+            }
+        }
+    ],
+    "indistinguishable": ["refused", "miss"],
+    "disclosesNothing": ["3f1a9c22-7b4e-4d18-9a05-6c2e8b1d4f70"]
+}

package/dist/resource-read-conformance/cases/read-without-a-delivery-channel-answers-not-mountable.json

@@ -0,0 +1,33 @@
+{
+    "name": "read-without-a-delivery-channel-answers-not-mountable",
+    "description": "The locator resolves and the caller owns it, but the server wires no way to deliver the component \u2014 neither a static component URL nor a live channel, and the committed component is too large for the inline codeB64 channel (an under-cap component would mount inline; that arm has its own case). The read answers NOT_MOUNTABLE on -32006 rather than handing back a shell with nothing to mount. This is the branch that proves the invariant is about the RESULT, not the lookup: the lookup succeeded.",
+    "server": {
+        "durableSubstrate": "all"
+    },
+    "caller": "owner",
+    "seeds": [
+        {
+            "kind": "committed-render",
+            "session": "3f1a9c22-7b4e-4d18-9a05-6c2e8b1d4f70",
+            "size": "over-inline-cap"
+        }
+    ],
+    "reads": [
+        {
+            "as": "resolvable",
+            "locator": {
+                "kind": "render",
+                "session": "3f1a9c22-7b4e-4d18-9a05-6c2e8b1d4f70",
+                "key": {
+                    "kind": "literal",
+                    "value": "fedcba9876543210"
+                }
+            },
+            "expect": {
+                "kind": "typed-error",
+                "jsonRpcCode": -32006,
+                "dataCode": "NOT_MOUNTABLE"
+            }
+        }
+    ]
+}

package/dist/resource-read-conformance/cases/registry-match-fuses-on-not-mountable.json

@@ -0,0 +1,40 @@
+{
+    "name": "registry-match-fuses-on-not-mountable",
+    "description": "The one place a server keeping no durable record answers something other than NOT_SUPPORTED for a read it cannot mount: the blueprint registry MATCHED the caller's key, so what the read found is a component it has no channel to deliver. The answer is NOT_MOUNTABLE — and because the match depends on the key rather than on the row, it is still identical for a refused read and a miss. This server wires NO delivery channel at all, which is what makes undeliverability follow from the declared shape rather than from any one implementation's choice about how it serves a registry match.",
+    "server": { "durableSubstrate": "none", "blueprintRegistry": true },
+    "caller": "other",
+    "seeds": [
+        { "kind": "registered-blueprint", "as": "fallback" },
+        { "kind": "committed-render", "session": "3f1a9c22-7b4e-4d18-9a05-6c2e8b1d4f70" }
+    ],
+    "reads": [
+        {
+            "as": "refused",
+            "locator": {
+                "kind": "render",
+                "session": "3f1a9c22-7b4e-4d18-9a05-6c2e8b1d4f70",
+                "key": { "kind": "registered", "seed": "fallback" }
+            },
+            "expect": {
+                "kind": "typed-error",
+                "jsonRpcCode": -32006,
+                "dataCode": "NOT_MOUNTABLE"
+            }
+        },
+        {
+            "as": "miss",
+            "locator": {
+                "kind": "render",
+                "session": "8d5b0e41-2c96-4a7f-b3d8-1e07f9a2c645",
+                "key": { "kind": "registered", "seed": "fallback" }
+            },
+            "expect": {
+                "kind": "typed-error",
+                "jsonRpcCode": -32006,
+                "dataCode": "NOT_MOUNTABLE"
+            }
+        }
+    ],
+    "indistinguishable": ["refused", "miss"],
+    "disclosesNothing": ["3f1a9c22-7b4e-4d18-9a05-6c2e8b1d4f70"]
+}

package/dist/resource-read-conformance/cases/substrate-less-fusion-of-refusal-and-miss.json

@@ -0,0 +1,29 @@
+{
+    "name": "substrate-less-fusion-of-refusal-and-miss",
+    "description": "The disclosure obligation restated for a server that keeps no durable record. NOT_SUPPORTED describes the server, so it must answer for a refused row too. A deployment that reported NOT_FOUND for rows that exist and NOT_SUPPORTED for ones that never did would have rebuilt the existence oracle out of its own wiring.",
+    "server": { "durableSubstrate": "none", "liveChannel": true },
+    "caller": "other",
+    "seeds": [{ "kind": "committed-render", "session": "3f1a9c22-7b4e-4d18-9a05-6c2e8b1d4f70" }],
+    "reads": [
+        {
+            "as": "refused",
+            "locator": { "kind": "render", "session": "3f1a9c22-7b4e-4d18-9a05-6c2e8b1d4f70" },
+            "expect": {
+                "kind": "typed-error",
+                "jsonRpcCode": -32006,
+                "dataCode": "NOT_SUPPORTED"
+            }
+        },
+        {
+            "as": "miss",
+            "locator": { "kind": "render", "session": "8d5b0e41-2c96-4a7f-b3d8-1e07f9a2c645" },
+            "expect": {
+                "kind": "typed-error",
+                "jsonRpcCode": -32006,
+                "dataCode": "NOT_SUPPORTED"
+            }
+        }
+    ],
+    "indistinguishable": ["refused", "miss"],
+    "disclosesNothing": ["3f1a9c22-7b4e-4d18-9a05-6c2e8b1d4f70"]
+}