@ggui-ai/protocol-conformance 0.6.3 → 0.7.0

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,22 @@
+{
+    "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 a component — neither a static component URL nor a live channel. 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" }],
+    "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"]
+}

package/dist/resource-read-conformance/index.d.ts

@@ -0,0 +1,371 @@
+/**
+ * The closed classification a typed read failure carries on
+ * `error.data.code`.
+ *
+ * The kit's decoupled copy, per the authoring posture in `../types`:
+ * fixtures compile against the kit's frozen vocabulary, never the live
+ * protocol types. CLOSED, not extensibly-closed — a fifth code is a kit
+ * version bump, because a catalog cannot grade a class it ships no case
+ * for.
+ */
+export type ResourceReadErrorCodeDecl = 'NOT_FOUND' | 'BLUEPRINT_UNRESOLVABLE' | 'NOT_SUPPORTED' | 'NOT_MOUNTABLE';
+/**
+ * How much of the record-keeping substrate a re-mint needs the server
+ * to have bound.
+ *
+ * Restoring an evicted render needs the whole set — the record naming
+ * what the render was, the blueprint it names, and the component body
+ * behind that blueprint. A server holding only part of it can restore
+ * nothing, so `identity-only` and `blueprints-only` are as
+ * substrate-less as `none`; they exist as separate arms because they
+ * are the shapes an operator actually reaches, by provisioning one
+ * store and forgetting the other.
+ *
+ * `all-ephemeral` (#457): every store bound, every store DECLARING
+ * ephemeral durability — binding is not durability, and a server whose
+ * records die with the process MUST fuse like one holding nothing.
+ * The arm an operator reaches by wiring three in-memory stores.
+ */
+export type DurableSubstrateWiring = 'all' | 'none' | 'identity-only' | 'blueprints-only' | 'all-ephemeral';
+/** The deployment shape a case needs the server under test to have. */
+export interface ResourceReadServerShape {
+    readonly durableSubstrate: DurableSubstrateWiring;
+    /** Bind the blueprint registry a read can fall back to. Default false. */
+    readonly blueprintRegistry?: boolean;
+    /** Bind static component delivery (a fetchable component URL). Default false. */
+    readonly staticDelivery?: boolean;
+    /** Bind the live delivery channel. Default false. */
+    readonly liveChannel?: boolean;
+}
+/**
+ * Whose read this is. `owner` holds the seeded renders; `other` is a
+ * caller with valid credentials and no claim to them — the identity
+ * every disclosure obligation is stated against.
+ */
+export type ResourceReadCaller = 'owner' | 'other';
+/**
+ * State the driver installs before the reads. CLOSED vocabulary: an
+ * unknown seed kind is a case-authoring error the runner throws on,
+ * never a skip and never a verdict on the server.
+ *
+ * Every seed belongs to the `owner` identity, whichever caller the case
+ * then reads as — that is what makes a refused read a read of something
+ * that really is there.
+ */
+export type ResourceReadSeed = {
+    /** A durable record of a render that has since been evicted. */
+    readonly kind: 'identity-record';
+    readonly session: string;
+    /**
+     * The contract key the record was stamped with — the
+     * `blueprintKey` segment a resume locator carries. Authored
+     * explicitly so nothing about which key resolves which record is
+     * implicit: a probe reading this record spells the same literal.
+     */
+    readonly key: string;
+    /** Whether the record names a blueprint at all. */
+    readonly blueprint: 'named' | 'unnamed';
+} | {
+    /** The durable blueprint an `identity-record` names. */
+    readonly kind: 'durable-blueprint';
+    /** Whether the blueprint stores a reference to a component body. */
+    readonly componentRef: 'present' | 'absent';
+    /** Whether the body behind that reference is still stored. */
+    readonly body: 'stored' | 'purged';
+} | {
+    /** A live render row that has committed a component. */
+    readonly kind: 'committed-render';
+    readonly session: string;
+} | {
+    /** A live render row whose generation has not committed yet. */
+    readonly kind: 'uncommitted-render';
+    readonly session: string;
+} | {
+    /**
+     * A blueprint published to the registry a read falls back to. The
+     * SERVER computes its key, so the driver reports the key back
+     * through {@link PreparedResourceReadScenario.registeredKeys}
+     * under this `as` name, and probes reference it there.
+     */
+    readonly kind: 'registered-blueprint';
+    readonly as: string;
+};
+/**
+ * The blueprint-key segment of a locator.
+ *
+ * `literal` is a value the case authors — the kit builds the URI from
+ * it, so the case pins the exact bytes read. `registered` defers to a
+ * key the server computed for a `registered-blueprint` seed, which is
+ * the one value a case cannot know in advance.
+ */
+export type ResourceReadKey = {
+    readonly kind: 'literal';
+    readonly value: string;
+} | {
+    readonly kind: 'registered';
+    readonly seed: string;
+};
+/**
+ * What gets read.
+ *
+ * `render` is the protocol's locator grammar and the kit builds the URI
+ * — a case never spells a well-formed locator out by hand, so the
+ * grammar has one owner. `raw` exists for the probes whose whole point
+ * is a URI that does NOT name a locator; there the exact string IS the
+ * input under test.
+ */
+export type ResourceReadLocator = {
+    readonly kind: 'render';
+    readonly session: string;
+    readonly key?: ResourceReadKey;
+} | {
+    readonly kind: 'raw';
+    readonly uri: string;
+};
+/**
+ * What one probe's read MUST produce. CLOSED vocabulary — see the
+ * module docstring for what each arm deliberately leaves ungraded.
+ */
+export type ResourceReadExpectation = {
+    readonly kind: 'typed-error';
+    /**
+     * The canonical number. `NOT_FOUND` rides on the resource-missing
+     * number; the other three ride on the mount-unavailable one. Both
+     * are pinned as literals in the case JSON so a rename that moved
+     * the wire fails here rather than passing against a constant.
+     */
+    readonly jsonRpcCode: number;
+    readonly dataCode: ResourceReadErrorCodeDecl;
+    /**
+     * Assert `error.data` carries NO `detail` key. Normative for
+     * `NOT_FOUND`, whose body must not vary; not authored elsewhere,
+     * because `detail` is optional context a conformant server may or
+     * may not attach.
+     */
+    readonly detailAbsent?: boolean;
+} | {
+    /**
+     * An error the resource-read classification does not reach:
+     * `data` carries no resource-read code.
+     *
+     * The NUMBER is deliberately not pinned — not even negatively.
+     * MCP assigns the resource-missing number to a `resources/read`
+     * of a URI the server does not serve, so a framework that maps
+     * every unrecognized URI onto it is correct, and banning that
+     * number here would fail it forever. The classification is what
+     * separates the two cases, and it is enough: a genuine miss
+     * carries one, a malformed URI carries none.
+     */
+    readonly kind: 'outside-typed-set';
+} | {
+    /** A result whose contents declare a delivery channel. */
+    readonly kind: 'live-mount';
+};
+/** One read within a case. */
+export interface ResourceReadProbe {
+    /** Name, unique within the case. Referenced by `indistinguishable`. */
+    readonly as: string;
+    readonly locator: ResourceReadLocator;
+    readonly expect: ResourceReadExpectation;
+}
+/**
+ * One resource-read conformance case. Authored as JSON under
+ * `./cases/`, consumed via {@link resourceReadCases}, graded by
+ * {@link runResourceReadConformance}.
+ *
+ * The shape IS the public API — additive changes only.
+ */
+export interface ResourceReadConformanceCase {
+    /** Unique case name. MUST match the JSON filename without `.json`. */
+    readonly name: string;
+    /** Which obligation this case proves. */
+    readonly description: string;
+    /** The deployment shape the driver brings up. */
+    readonly server: ResourceReadServerShape;
+    /** Whose read this is. */
+    readonly caller: ResourceReadCaller;
+    /** State installed before the reads. May be empty. */
+    readonly seeds: readonly ResourceReadSeed[];
+    /** The reads, dispatched in order against the one prepared server. */
+    readonly reads: readonly ResourceReadProbe[];
+    /**
+     * Probe names whose RAW error frames MUST be byte-identical.
+     *
+     * This is the disclosure obligation stated positively: a read of a
+     * locator the caller may not see and a read of one that never existed
+     * must be the same bytes, or the read is an existence oracle for
+     * other callers' renders. Compared on the serialized frames with only
+     * the session segments normalized away — a locator is caller-supplied
+     * and a server that echoes it back is caught by `disclosesNothing`,
+     * not excused here.
+     */
+    readonly indistinguishable?: readonly string[];
+    /**
+     * Literal substrings that MUST NOT appear anywhere in any error frame
+     * this case produces. The values a refusal would leak if a diagnostic
+     * escaped into `message` or `detail`.
+     */
+    readonly disclosesNothing?: readonly string[];
+}
+/** What the driver is asked to bring up. */
+export interface ResourceReadScenario {
+    /** The case being prepared — for the driver's own diagnostics. */
+    readonly caseName: string;
+    readonly server: ResourceReadServerShape;
+    readonly caller: ResourceReadCaller;
+    readonly seeds: readonly ResourceReadSeed[];
+}
+/**
+ * The delivery-channel fields of the render meta a successful read
+ * projects onto its contents.
+ *
+ * Narrowed to what the invariant needs: the kit asks "can this be
+ * mounted", not "what does it look like". A driver reports these off
+ * whatever its shell carries — the projection is protocol surface, the
+ * markup that transports it is not.
+ */
+export interface ResourceReadRenderMeta {
+    /** A fetchable component URL — the static delivery channel. */
+    readonly codeUrl?: string;
+    /** The live channel's endpoint. Only a channel WITH a token. */
+    readonly wsUrl?: string;
+    /** The live channel's token. Only a channel WITH an endpoint. */
+    readonly wsToken?: string;
+    /** A server-emitted system card, which carries its own content. */
+    readonly kind?: string;
+}
+/** The raw JSON-RPC error body a server put on the wire. */
+export interface JsonRpcErrorFrame {
+    readonly code: number;
+    readonly message: string;
+    readonly data?: unknown;
+}
+/** What one read produced. */
+export type ResourceReadOutcome = {
+    readonly kind: 'mount';
+    readonly renderMeta: ResourceReadRenderMeta;
+} | {
+    readonly kind: 'error';
+    readonly error: JsonRpcErrorFrame;
+};
+/** A server brought up in a declared shape, ready to be read. */
+export interface PreparedResourceReadScenario {
+    /**
+     * Read one locator. MUST resolve — a protocol-level failure is
+     * `{kind: 'error'}` carrying the RAW frame, not a throw. A throw is
+     * graded as a FAIL, since the read is the thing under test.
+     *
+     * Honest-grade contract: the reported outcome MUST be what the server
+     * really produced. A driver that fabricates a passing outcome is
+     * cheating its own conformance audit — the implementer's integrity to
+     * keep, exactly as with every other adapter the kit defines.
+     */
+    read(uri: string): Promise<ResourceReadOutcome>;
+    /**
+     * Keys the server computed for this case's `registered-blueprint`
+     * seeds, by their `as` name. Required whenever a probe references
+     * one; a case whose reference is unresolved SKIPS, because the kit
+     * cannot construct the locator it was supposed to read.
+     */
+    readonly registeredKeys?: Readonly<Record<string, string>>;
+    /** Tear the scenario down. Invoked after every case, pass or fail. */
+    dispose?(): Promise<void>;
+}
+/**
+ * Bring up a server in the declared shape. Throwing signals "I cannot
+ * express this scenario" and the runner records a SKIP with the
+ * message — never a pass.
+ */
+export type ResourceReadScenarioDriver = (scenario: ResourceReadScenario) => Promise<PreparedResourceReadScenario>;
+/**
+ * Every resource-read case the kit ships, in deterministic order: the
+ * four typed classes, then the disclosure fusions, then the boundary of
+ * the classification, then the two mount cases.
+ */
+export declare const resourceReadCases: readonly ResourceReadConformanceCase[];
+/** The resource URI every render locator hangs off. */
+export declare const GGUI_RENDER_RESOURCE_URI = "ui://ggui/render";
+/**
+ * Build the URI a probe reads. The kit owns the grammar so no case
+ * spells a well-formed locator out by hand; a `raw` locator passes
+ * through verbatim, which is the point of that arm.
+ */
+export declare function renderLocatorUri(locator: ResourceReadLocator, registeredKeys?: Readonly<Record<string, string>>): string;
+/**
+ * Does this render meta carry enough to paint something? One of the
+ * three delivery channels a runtime knows: a static component URL, a
+ * live channel, or a server-emitted system card.
+ *
+ * The live channel needs BOTH halves — an endpoint with no token cannot
+ * be opened, and a token with no endpoint has nowhere to go — so a
+ * half-declared one is not a channel.
+ */
+export declare function declaresDeliveryChannel(meta: ResourceReadRenderMeta): boolean;
+/** One obligation a server under test did not meet. */
+export interface ResourceReadConformanceFailure {
+    /** The case that failed. */
+    readonly name: string;
+    /** The probe whose read produced it, when the failure is probe-scoped. */
+    readonly probe?: string;
+    /** Which obligation was violated, in the catalog's own words. */
+    readonly obligation: string;
+    readonly expected: unknown;
+    readonly actual: unknown;
+    readonly message: string;
+}
+/** One case the kit could not grade, and why. */
+export interface ResourceReadConformanceSkip {
+    readonly name: string;
+    readonly reason: string;
+}
+/** Outcome of grading a server against the catalog. */
+export interface ResourceReadConformanceResult {
+    /** Names of cases the server satisfied. */
+    readonly passed: readonly string[];
+    /** Cases the server got wrong — at most one entry per case. */
+    readonly failed: readonly ResourceReadConformanceFailure[];
+    /** Cases the kit could not observe. Never a pass, never a fail. */
+    readonly skipped: readonly ResourceReadConformanceSkip[];
+}
+/** Options for {@link runResourceReadConformance}. */
+export interface RunResourceReadConformanceOptions {
+    /** Grade only these case names. Useful when debugging one obligation. */
+    readonly only?: readonly string[];
+}
+/**
+ * Grade a server against the catalog.
+ *
+ * One scenario is prepared per case, every probe is read against it in
+ * order, then the cross-probe obligations are checked. A case
+ * contributes at most one failure — the first obligation it broke —
+ * so the result reads as one verdict per case.
+ *
+ * A conformant server produces an empty `failed` array. An empty
+ * `passed` array is NOT success: a run where every case skipped proves
+ * nothing, and callers should treat it the way the WebSocket runner's
+ * consumers already do.
+ */
+export declare function runResourceReadConformance(drive: ResourceReadScenarioDriver, options?: RunResourceReadConformanceOptions): Promise<ResourceReadConformanceResult>;
+/**
+ * Validating parse of one authored case.
+ *
+ * The input is `unknown` BY DESIGN — this function IS the trust
+ * boundary, so it never leans on the static union it produces evidence
+ * for. The catalog's JSON enters the type system through a compile-time
+ * cast (tsc widens JSON-module string literals), which means the static
+ * type is the claim being checked here, not support for it. Same
+ * posture as the WebSocket runner's `parseSetupStep`.
+ *
+ * An unknown seed kind, locator kind, expectation kind or
+ * classification is a CASE-AUTHORING error: the runner throws, aborting
+ * the run loudly. It is never a skip and never a fail — those verdicts
+ * describe the server under test, not the catalog.
+ *
+ * Exported for the kit's own meta-tests and reachable from the
+ * `./resource-read-conformance` subpath, but NOT re-exported from the
+ * package root — the runner calls it for you, and a consumer needing it
+ * directly is authoring their own catalog rather than grading against
+ * this one.
+ */
+export declare function parseCase(input: unknown): ResourceReadConformanceCase;
+//# sourceMappingURL=index.d.ts.map

package/dist/resource-read-conformance/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/resource-read-conformance/index.ts"],"names":[],"mappings":"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"}