@ggui-ai/protocol-conformance 0.6.3 → 0.8.0

package/dist/binding-conformance/index.d.ts

@@ -0,0 +1,214 @@
+/**
+ * Binding-conformance catalog — MCP tool-binding resolution + search
+ * filter semantics (SPEC §7.7.4 — tool bindings & discovery).
+ *
+ * ## Why this is a pure-function catalog
+ *
+ * Two pure obligations connect a registry artifact to the MCP tools
+ * it renders:
+ *
+ *   1. RESOLUTION — given a manifest, which binding set is
+ *      effective? A declared `mcpTools` list wins entirely; a
+ *      blueprint without one derives bare tool names from its
+ *      contract's lineage fields
+ *      (`propsSpec.properties[*].sourceTool`,
+ *      `streamSpec[*].source.tool`); a schema-invalid list rejects
+ *      with the manifest-validation code. Bindings are search
+ *      metadata only — they never enter contract canonicalization
+ *      or any cache identity.
+ *   2. FILTERING — given an artifact's stored binding set and a
+ *      search query's `tool` / `server` params, does the artifact
+ *      match? Both dimensions are case-sensitive exact and must land
+ *      on a single entry; a bare entry never satisfies a server
+ *      dimension; no dimensions given passes everything.
+ *
+ * Both are deterministic functions — no render, transport, or wire
+ * frame — so they get the same treatment as the registry gate
+ * (`../registration-conformance`) and bundle-URL resolution
+ * (`../resolution-conformance`): catalogs of JSON cases graded
+ * against caller-supplied functions.
+ *
+ * ## Polyglot, decoupled
+ *
+ * Each case ships as raw JSON under `./cases/`.
+ * {@link runBindingResolutionCases} / {@link runBindingFilterCases}
+ * take the implementation as a callback — the kit never imports a
+ * concrete resolver or search filter, so adopters drive their OWN.
+ * The reference binding (`./binding-conformance.test.ts`) restates
+ * faithful minimal implementations in-test.
+ */
+import type { DataContract } from "@ggui-ai/protocol";
+/**
+ * One MCP tool binding as authored on a manifest / stored on search
+ * metadata. `server` carries `serverInfo.name` semantics; a bare
+ * entry (no `server`) is server-agnostic.
+ */
+export interface McpToolBindingDecl {
+    readonly server?: string;
+    readonly tool: string;
+}
+/**
+ * The binding-relevant subset of an artifact manifest the resolver
+ * reads. Authored kit-local — decoupled from any shipping manifest
+ * schema on purpose; `contract` reuses the protocol's
+ * {@link DataContract} type the way `../registration-conformance`
+ * does.
+ */
+export interface BindingManifestEntry {
+    /** Which manifest kind the entry models. Only blueprints derive. */
+    readonly kind: "gadget" | "blueprint";
+    /** The `mcpTools` list as authored — possibly invalid. */
+    readonly mcpTools?: readonly McpToolBindingDecl[];
+    /** The blueprint's contract, when it has one. */
+    readonly contract?: DataContract;
+}
+/**
+ * The code a schema-invalid `mcpTools` list classifies into.
+ * Extensibly-closed `(string & {})` tail so a later protocol
+ * revision's code rides through without a kit bump — same
+ * discipline as `GadgetGateRejectCode` in
+ * `../registration-conformance`.
+ */
+export type BindingRejectCode = "manifest_invalid" | (string & {});
+/**
+ * What resolving one manifest's bindings produces: accept with a
+ * `source` + `bindings` pair (declared or derived — present together
+ * or absent together), accept with NEITHER (the artifact has no
+ * bindings and is not findable by tool), or reject with the
+ * manifest-validation code.
+ */
+export type BindingResolutionOutcome = {
+    readonly outcome: "accept";
+    readonly source?: "declared" | "derived";
+    readonly bindings?: readonly McpToolBindingDecl[];
+} | {
+    readonly outcome: "reject";
+    readonly code: BindingRejectCode;
+};
+/**
+ * A search query's tool/server params as one filter input. Both
+ * optional — an absent dimension does not constrain. Matching is
+ * case-sensitive exact on both dimensions.
+ */
+export interface McpToolFilterDecl {
+    readonly tool?: string;
+    readonly server?: string;
+}
+/**
+ * One binding-resolution case. Authored as JSON under `./cases/`,
+ * consumed via {@link bindingResolutionCases}, graded by
+ * {@link runBindingResolutionCases}.
+ *
+ * The shape IS the public API — additive changes only.
+ */
+export interface BindingResolutionCase {
+    /** Unique case name. MUST match the JSON filename without `.json`. */
+    readonly name: string;
+    /** Which binding obligation this case proves. */
+    readonly description: string;
+    /** The manifest subset fed to the resolver. */
+    readonly entry: BindingManifestEntry;
+    /**
+     * The outcome a spec-conformant resolver MUST produce. Binding
+     * lists are compared order-sensitively: declared bindings carry
+     * authored order; derived bindings carry first-appearance order
+     * (props in declaration order, then stream channels), duplicates
+     * collapsed to the first occurrence.
+     */
+    readonly expect: BindingResolutionOutcome;
+}
+/**
+ * One filter-semantics case. Authored as JSON under `./cases/`,
+ * consumed via {@link bindingFilterCases}, graded by
+ * {@link runBindingFilterCases}.
+ *
+ * The shape IS the public API — additive changes only.
+ */
+export interface BindingFilterCase {
+    /** Unique case name. MUST match the JSON filename without `.json`. */
+    readonly name: string;
+    /** Which filter obligation this case proves. */
+    readonly description: string;
+    /** The artifact's stored binding set — absent models an unbound artifact. */
+    readonly bindings?: readonly McpToolBindingDecl[];
+    /** The query's tool/server params — `{}` models neither given. */
+    readonly filters: McpToolFilterDecl;
+    /** Whether a spec-conformant filter matches the artifact. */
+    readonly expect: boolean;
+}
+/**
+ * Every binding-resolution case the kit ships, in deterministic
+ * order — declared first, then derived, then the no-binding edges,
+ * then the schema rejects.
+ */
+export declare const bindingResolutionCases: readonly BindingResolutionCase[];
+/**
+ * Every filter-semantics case the kit ships, in deterministic
+ * order — tool-dimension, server-dimension, pair, no-filter
+ * passthrough, then case-sensitivity.
+ */
+export declare const bindingFilterCases: readonly BindingFilterCase[];
+/** One resolution case the resolver under test graded wrong. */
+export interface BindingResolutionMismatch {
+    readonly name: string;
+    /** The outcome the catalog says a conformant resolver MUST produce. */
+    readonly expected: BindingResolutionOutcome;
+    /** The outcome the resolver under test actually produced. */
+    readonly actual: BindingResolutionOutcome;
+}
+/** Outcome of grading a resolver against the resolution catalog. */
+export interface BindingResolutionResult {
+    /** Names of cases the resolver graded correctly. */
+    readonly passed: readonly string[];
+    /** Cases the resolver graded wrong — empty iff fully conformant. */
+    readonly failed: readonly BindingResolutionMismatch[];
+}
+/** One filter case the predicate under test graded wrong. */
+export interface BindingFilterMismatch {
+    readonly name: string;
+    /** Whether the catalog says a conformant filter matches. */
+    readonly expected: boolean;
+    /** What the predicate under test actually returned. */
+    readonly actual: boolean;
+}
+/** Outcome of grading a filter predicate against the filter catalog. */
+export interface BindingFilterResult {
+    /** Names of cases the predicate graded correctly. */
+    readonly passed: readonly string[];
+    /** Cases the predicate graded wrong — empty iff fully conformant. */
+    readonly failed: readonly BindingFilterMismatch[];
+}
+/**
+ * Grade a binding resolver against the resolution catalog.
+ *
+ * `resolve` MUST be a pure computation of `(entry) →
+ * BindingResolutionOutcome` — schema validation of a declared list
+ * plus declared-wins/derivation precedence, composed however the
+ * implementation likes. The kit deliberately does NOT import a
+ * concrete resolver — adopters pass their own (the reference
+ * binding uses a faithful in-test implementation; see
+ * `./binding-conformance.test.ts`). A conformant resolver produces
+ * an empty `failed` array.
+ *
+ * `resolve` is invoked exactly once per case, in
+ * {@link bindingResolutionCases} order; it MUST be pure and MUST
+ * NOT throw (a throwing resolver is itself non-conformant — wrap it
+ * so a classified rejection becomes a returned outcome).
+ */
+export declare function runBindingResolutionCases(resolve: (entry: BindingManifestEntry) => BindingResolutionOutcome): BindingResolutionResult;
+/**
+ * Grade a search filter predicate against the filter catalog.
+ *
+ * `matches` MUST be a pure computation of `(bindings, filters) →
+ * boolean` — the same predicate every storage implementation shares
+ * so `tool=` / `server=` behave identically everywhere. The kit
+ * deliberately does NOT import a concrete predicate — adopters pass
+ * their own. A conformant predicate produces an empty `failed`
+ * array.
+ *
+ * `matches` is invoked exactly once per case, in
+ * {@link bindingFilterCases} order; it MUST be pure and MUST NOT
+ * throw.
+ */
+export declare function runBindingFilterCases(matches: (bindings: readonly McpToolBindingDecl[] | undefined, filters: McpToolFilterDecl) => boolean): BindingFilterResult;
+//# sourceMappingURL=index.d.ts.map

package/dist/binding-conformance/index.d.ts.map

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

package/dist/binding-conformance/index.js

@@ -0,0 +1,153 @@
+import bindBlueprintNoContractNone from "./cases/bind-blueprint-no-contract-none.json" with { type: "json" };
+import bindContractWithoutToolNamesNone from "./cases/bind-contract-without-tool-names-none.json" with { type: "json" };
+import bindDeclaredGadget from "./cases/bind-declared-gadget.json" with { type: "json" };
+import bindDeclaredWinsOverContract from "./cases/bind-declared-wins-over-contract.json" with { type: "json" };
+import bindDerivedCapsAtSixteen from "./cases/bind-derived-caps-at-sixteen.json" with { type: "json" };
+import bindDerivedPropsAndStream from "./cases/bind-derived-props-and-stream.json" with { type: "json" };
+import bindDerivedSkipsInvalidNames from "./cases/bind-derived-skips-invalid-names.json" with { type: "json" };
+import bindDerivedUnionDedupes from "./cases/bind-derived-union-dedupes.json" with { type: "json" };
+import bindGadgetUndeclaredNone from "./cases/bind-gadget-undeclared-none.json" with { type: "json" };
+import bindRejectCharset from "./cases/bind-reject-charset.json" with { type: "json" };
+import bindRejectDuplicatePair from "./cases/bind-reject-duplicate-pair.json" with { type: "json" };
+import bindRejectEmptyList from "./cases/bind-reject-empty-list.json" with { type: "json" };
+import bindRejectOverlongName from "./cases/bind-reject-overlong-name.json" with { type: "json" };
+import bindRejectServerCharset from "./cases/bind-reject-server-charset.json" with { type: "json" };
+import bindRejectTooManyEntries from "./cases/bind-reject-too-many-entries.json" with { type: "json" };
+import filterCaseSensitiveServer from "./cases/filter-case-sensitive-server.json" with { type: "json" };
+import filterCaseSensitiveTool from "./cases/filter-case-sensitive-tool.json" with { type: "json" };
+import filterNonePassesBound from "./cases/filter-none-passes-bound.json" with { type: "json" };
+import filterNonePassesUnbound from "./cases/filter-none-passes-unbound.json" with { type: "json" };
+import filterPairBareNeverMatches from "./cases/filter-pair-bare-never-matches.json" with { type: "json" };
+import filterPairExact from "./cases/filter-pair-exact.json" with { type: "json" };
+import filterPairNotCrossEntry from "./cases/filter-pair-not-cross-entry.json" with { type: "json" };
+import filterServerExcludesBare from "./cases/filter-server-excludes-bare.json" with { type: "json" };
+import filterServerMatch from "./cases/filter-server-match.json" with { type: "json" };
+import filterToolCrossServer from "./cases/filter-tool-cross-server.json" with { type: "json" };
+import filterToolExcludesUnbound from "./cases/filter-tool-excludes-unbound.json" with { type: "json" };
+import filterToolMatchesBareEntry from "./cases/filter-tool-matches-bare-entry.json" with { type: "json" };
+import filterToolNoMatch from "./cases/filter-tool-no-match.json" with { type: "json" };
+/**
+ * Every binding-resolution case the kit ships, in deterministic
+ * order — declared first, then derived, then the no-binding edges,
+ * then the schema rejects.
+ */
+export const bindingResolutionCases = [
+    bindDeclaredGadget,
+    bindDeclaredWinsOverContract,
+    bindDerivedPropsAndStream,
+    bindDerivedUnionDedupes,
+    bindDerivedSkipsInvalidNames,
+    bindDerivedCapsAtSixteen,
+    bindBlueprintNoContractNone,
+    bindContractWithoutToolNamesNone,
+    bindGadgetUndeclaredNone,
+    bindRejectCharset,
+    bindRejectServerCharset,
+    bindRejectDuplicatePair,
+    bindRejectOverlongName,
+    bindRejectTooManyEntries,
+    bindRejectEmptyList,
+];
+/**
+ * Every filter-semantics case the kit ships, in deterministic
+ * order — tool-dimension, server-dimension, pair, no-filter
+ * passthrough, then case-sensitivity.
+ */
+export const bindingFilterCases = [
+    filterToolCrossServer,
+    filterToolMatchesBareEntry,
+    filterToolNoMatch,
+    filterServerMatch,
+    filterServerExcludesBare,
+    filterPairExact,
+    filterPairNotCrossEntry,
+    filterPairBareNeverMatches,
+    filterNonePassesBound,
+    filterNonePassesUnbound,
+    filterToolExcludesUnbound,
+    filterCaseSensitiveTool,
+    filterCaseSensitiveServer,
+];
+function bindingListsEqual(a, b) {
+    if (a === undefined || b === undefined)
+        return a === b;
+    if (a.length !== b.length)
+        return false;
+    return a.every((entry, i) => {
+        const other = b[i];
+        return other !== undefined && entry.tool === other.tool && entry.server === other.server;
+    });
+}
+function resolutionOutcomeEquals(a, b) {
+    if (a.outcome === "reject" || b.outcome === "reject") {
+        return a.outcome === "reject" && b.outcome === "reject" && a.code === b.code;
+    }
+    return a.source === b.source && bindingListsEqual(a.bindings, b.bindings);
+}
+/**
+ * Grade a binding resolver against the resolution catalog.
+ *
+ * `resolve` MUST be a pure computation of `(entry) →
+ * BindingResolutionOutcome` — schema validation of a declared list
+ * plus declared-wins/derivation precedence, composed however the
+ * implementation likes. The kit deliberately does NOT import a
+ * concrete resolver — adopters pass their own (the reference
+ * binding uses a faithful in-test implementation; see
+ * `./binding-conformance.test.ts`). A conformant resolver produces
+ * an empty `failed` array.
+ *
+ * `resolve` is invoked exactly once per case, in
+ * {@link bindingResolutionCases} order; it MUST be pure and MUST
+ * NOT throw (a throwing resolver is itself non-conformant — wrap it
+ * so a classified rejection becomes a returned outcome).
+ */
+export function runBindingResolutionCases(resolve) {
+    const passed = [];
+    const failed = [];
+    for (const testCase of bindingResolutionCases) {
+        const actual = resolve(testCase.entry);
+        if (resolutionOutcomeEquals(actual, testCase.expect)) {
+            passed.push(testCase.name);
+        }
+        else {
+            failed.push({
+                name: testCase.name,
+                expected: testCase.expect,
+                actual,
+            });
+        }
+    }
+    return { passed, failed };
+}
+/**
+ * Grade a search filter predicate against the filter catalog.
+ *
+ * `matches` MUST be a pure computation of `(bindings, filters) →
+ * boolean` — the same predicate every storage implementation shares
+ * so `tool=` / `server=` behave identically everywhere. The kit
+ * deliberately does NOT import a concrete predicate — adopters pass
+ * their own. A conformant predicate produces an empty `failed`
+ * array.
+ *
+ * `matches` is invoked exactly once per case, in
+ * {@link bindingFilterCases} order; it MUST be pure and MUST NOT
+ * throw.
+ */
+export function runBindingFilterCases(matches) {
+    const passed = [];
+    const failed = [];
+    for (const testCase of bindingFilterCases) {
+        const actual = matches(testCase.bindings, testCase.filters);
+        if (actual === testCase.expect) {
+            passed.push(testCase.name);
+        }
+        else {
+            failed.push({
+                name: testCase.name,
+                expected: testCase.expect,
+                actual,
+            });
+        }
+    }
+    return { passed, failed };
+}

package/dist/fixtures/consume-buffer/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/fixtures/consume-buffer/index.ts"],"names":[],"mappings":"AAkCA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE/C;;gCAEgC;AAChC,eAAO,MAAM,qBAAqB,EAAE,SAAS,QAAQ,EAIpD,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/fixtures/consume-buffer/index.ts"],"names":[],"mappings":"AAqCA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE/C;;gCAEgC;AAChC,eAAO,MAAM,qBAAqB,EAAE,SAAS,QAAQ,EAIpD,CAAC"}

package/dist/fixtures/consume-buffer/index.js

@@ -20,7 +20,10 @@
  *
  * The retrieval half — the agent draining the buffer via
  * `ggui_consume` — is an MCP tool call a WS-only runner cannot drive;
- * that obligation belongs to an MCP-binding driver, not this catalog.
+ * that obligation belongs to a driver bound to `tools/call`, not this
+ * catalog. The kit's `resources/read` driver
+ * (`../../resource-read-conformance`) binds a different method and does
+ * not close it.
  * Same declared-gap posture for the schema-validity meta-check on the
  * DECLARED schema itself: a malformed authored schema is a fixture-
  * authoring error the runner throws on (validating parse), while a

package/dist/fixtures/index.d.ts

@@ -20,7 +20,7 @@
  *
  * ## Current coverage
  *
- * Six sub-modules with content (12 fixtures). Additional sub-modules
+ * Six WebSocket sub-modules with content (12 fixtures). Additional sub-modules
  * (`data-contract`, `tool-name-uniqueness`)
  * are reserved for additive fixture expansion and not yet
  * materialized — adding fixtures there is a kit minor version.
@@ -36,6 +36,43 @@
  * frame to drive — so they do NOT belong in this behavioral fixture
  * catalog.
  *
+ * ## An MCP-binding driver EXISTS for `resources/read` — `../resource-read-conformance`
+ *
+ * This catalog used to declare the MCP-binding driver as missing. It is
+ * no longer missing. `../resource-read-conformance` ships a driver
+ * bound to the MCP **`resources/read`** method, with its own case
+ * shape, its own runner (`runResourceReadConformance`) and its own
+ * scenario-driver seam. It grades the typed-failure contract for a
+ * render locator (`ui://ggui/render/{sessionId}[/{blueprintKey}]`): the
+ * four failure classes on their canonical numbers, the constant
+ * `NOT_FOUND` body, the deny-equals-miss byte-identity obligation, and
+ * the invariant that any successful result declares a delivery channel.
+ *
+ * Its cases are NOT registered in the map below, and that is
+ * deliberate. Every entry here is driven by `runConformance()` over a
+ * live channel, so an MCP case landing in this catalog would be a
+ * permanent skip on every WebSocket run — a skip that can never become
+ * a pass on that transport, which is exactly the false gate this kit's
+ * exact skip-set pinning exists to prevent.
+ *
+ * ### Precisely what that driver does NOT close
+ *
+ * It binds ONE MCP method. `tools/call` has no driver, so both of these
+ * remain open and neither is addressed by it:
+ *
+ *   - **`stream-delivery-roundtrip`** — see the next section. Needs
+ *     `ggui_emit`.
+ *   - **The `ggui_consume` retrieval half of the action loop** —
+ *     `action-ack-sequence` proves the append half; draining the buffer
+ *     is `ggui_consume`.
+ *
+ * `resources/read` and `tools/call` are different methods with
+ * different seams: the former is a stateless read of a URI the kit can
+ * construct, the latter is an invocation whose arguments and effects
+ * are the agent's vocabulary. A driver for one is not a driver for the
+ * other, and saying "the kit now has an MCP driver" without that
+ * qualifier would read as closing gaps it does not touch.
+ *
  * ## What is NOT here — declared Path-A sequencing gap
  *
  * A `stream-delivery-roundtrip` fixture (an `emit-envelope`'d payload
@@ -52,9 +89,10 @@
  * transport, while emission is server-side (the agent's `ggui_emit`
  * MCP tool) — routing a host directive through the wire-frame slot
  * would conflate the two vocabularies. Honest grading needs either a
- * post-subscribe host-directive phase (a runner-mechanism change) or
- * an MCP-binding driver. Declared here rather than papered over with
- * a fixture that fails conformant servers on sequencing alone.
+ * post-subscribe host-directive phase (a runner-mechanism change) or a
+ * driver bound to `tools/call`. The `resources/read` driver above is
+ * NOT that driver. Declared here rather than papered over with a
+ * fixture that fails conformant servers on sequencing alone.
  */
 export { bootstrapProtocolFixtures } from './bootstrap-protocol/index.js';
 export { consumeBufferFixtures } from './consume-buffer/index.js';

package/dist/fixtures/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/fixtures/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AAEH,OAAO,EAAE,yBAAyB,EAAE,MAAM,+BAA+B,CAAC;AAC1E,OAAO,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AAClE,OAAO,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAC9D,OAAO,EAAE,gCAAgC,EAAE,MAAM,uCAAuC,CAAC;AACzF,OAAO,EAAE,8BAA8B,EAAE,MAAM,qCAAqC,CAAC;AACrF,OAAO,EAAE,wBAAwB,EAAE,MAAM,8BAA8B,CAAC;AAExE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAQ5C;;;;;GAKG;AACH,MAAM,MAAM,YAAY,GACpB,oBAAoB,GACpB,gBAAgB,GAChB,cAAc,GACd,4BAA4B,GAC5B,0BAA0B,GAC1B,mBAAmB,GACnB,CAAC,MAAM,GAAG,EAAE,CAAC,CAAC;AAElB;;;;;;;GAOG;AACH,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,MAAM,CAAC,YAAY,EAAE,SAAS,QAAQ,EAAE,CAAC,CAOlF,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,WAAW,EAAE,SAAS,QAAQ,EAGwB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/fixtures/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+FG;AAEH,OAAO,EAAE,yBAAyB,EAAE,MAAM,+BAA+B,CAAC;AAC1E,OAAO,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AAClE,OAAO,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAC9D,OAAO,EAAE,gCAAgC,EAAE,MAAM,uCAAuC,CAAC;AACzF,OAAO,EAAE,8BAA8B,EAAE,MAAM,qCAAqC,CAAC;AACrF,OAAO,EAAE,wBAAwB,EAAE,MAAM,8BAA8B,CAAC;AAExE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAQ5C;;;;;GAKG;AACH,MAAM,MAAM,YAAY,GACpB,oBAAoB,GACpB,gBAAgB,GAChB,cAAc,GACd,4BAA4B,GAC5B,0BAA0B,GAC1B,mBAAmB,GACnB,CAAC,MAAM,GAAG,EAAE,CAAC,CAAC;AAElB;;;;;;;GAOG;AACH,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,MAAM,CAAC,YAAY,EAAE,SAAS,QAAQ,EAAE,CAAC,CAOlF,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,WAAW,EAAE,SAAS,QAAQ,EAGwB,CAAC"}

package/dist/fixtures/index.js

@@ -20,7 +20,7 @@
  *
  * ## Current coverage
  *
- * Six sub-modules with content (12 fixtures). Additional sub-modules
+ * Six WebSocket sub-modules with content (12 fixtures). Additional sub-modules
  * (`data-contract`, `tool-name-uniqueness`)
  * are reserved for additive fixture expansion and not yet
  * materialized — adding fixtures there is a kit minor version.
@@ -36,6 +36,43 @@
  * frame to drive — so they do NOT belong in this behavioral fixture
  * catalog.
  *
+ * ## An MCP-binding driver EXISTS for `resources/read` — `../resource-read-conformance`
+ *
+ * This catalog used to declare the MCP-binding driver as missing. It is
+ * no longer missing. `../resource-read-conformance` ships a driver
+ * bound to the MCP **`resources/read`** method, with its own case
+ * shape, its own runner (`runResourceReadConformance`) and its own
+ * scenario-driver seam. It grades the typed-failure contract for a
+ * render locator (`ui://ggui/render/{sessionId}[/{blueprintKey}]`): the
+ * four failure classes on their canonical numbers, the constant
+ * `NOT_FOUND` body, the deny-equals-miss byte-identity obligation, and
+ * the invariant that any successful result declares a delivery channel.
+ *
+ * Its cases are NOT registered in the map below, and that is
+ * deliberate. Every entry here is driven by `runConformance()` over a
+ * live channel, so an MCP case landing in this catalog would be a
+ * permanent skip on every WebSocket run — a skip that can never become
+ * a pass on that transport, which is exactly the false gate this kit's
+ * exact skip-set pinning exists to prevent.
+ *
+ * ### Precisely what that driver does NOT close
+ *
+ * It binds ONE MCP method. `tools/call` has no driver, so both of these
+ * remain open and neither is addressed by it:
+ *
+ *   - **`stream-delivery-roundtrip`** — see the next section. Needs
+ *     `ggui_emit`.
+ *   - **The `ggui_consume` retrieval half of the action loop** —
+ *     `action-ack-sequence` proves the append half; draining the buffer
+ *     is `ggui_consume`.
+ *
+ * `resources/read` and `tools/call` are different methods with
+ * different seams: the former is a stateless read of a URI the kit can
+ * construct, the latter is an invocation whose arguments and effects
+ * are the agent's vocabulary. A driver for one is not a driver for the
+ * other, and saying "the kit now has an MCP driver" without that
+ * qualifier would read as closing gaps it does not touch.
+ *
  * ## What is NOT here — declared Path-A sequencing gap
  *
  * A `stream-delivery-roundtrip` fixture (an `emit-envelope`'d payload
@@ -52,9 +89,10 @@
  * transport, while emission is server-side (the agent's `ggui_emit`
  * MCP tool) — routing a host directive through the wire-frame slot
  * would conflate the two vocabularies. Honest grading needs either a
- * post-subscribe host-directive phase (a runner-mechanism change) or
- * an MCP-binding driver. Declared here rather than papered over with
- * a fixture that fails conformant servers on sequencing alone.
+ * post-subscribe host-directive phase (a runner-mechanism change) or a
+ * driver bound to `tools/call`. The `resources/read` driver above is
+ * NOT that driver. Declared here rather than papered over with a
+ * fixture that fails conformant servers on sequencing alone.
  */
 export { bootstrapProtocolFixtures } from './bootstrap-protocol/index.js';
 export { consumeBufferFixtures } from './consume-buffer/index.js';

package/dist/fixtures/reserved-channel-authority/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/fixtures/reserved-channel-authority/index.ts"],"names":[],"mappings":"AA4BA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE/C,qEAAqE;AACrE,eAAO,MAAM,gCAAgC,EAAE,SAAS,QAAQ,EAE/D,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/fixtures/reserved-channel-authority/index.ts"],"names":[],"mappings":"AA8BA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE/C,qEAAqE;AACrE,eAAO,MAAM,gCAAgC,EAAE,SAAS,QAAQ,EAE/D,CAAC"}

package/dist/fixtures/reserved-channel-authority/index.js

@@ -21,8 +21,10 @@
  * are Server→Client only). Agent emission enters through the
  * `ggui_emit` MCP tool, so both the violation and the rejection that
  * grades it are observable only on the MCP binding. That fixture
- * belongs to a future MCP-binding driver — the gap is declared here
- * rather than faked with a frame the wire cannot carry.
+ * belongs to a future driver bound to `tools/call` — the kit's
+ * `resources/read` driver (`../../resource-read-conformance`) binds a
+ * different method and does not reach `ggui_emit`. The gap is declared
+ * here rather than faked with a frame the wire cannot carry.
  */
 import propsUpdateRoundtrip from './props-update-roundtrip.json' with { type: 'json' };
 /** All fixtures asserting reserved-channel authority (SPEC §4.4). */

package/dist/index.d.ts

@@ -20,6 +20,10 @@ export { gadgetRegistrationCases, runRegistrationConformance, } from './registra
 export type { GadgetGateRejectCode, GateOutcome, RegistrationConformanceCase, RegistrationConformanceMismatch, RegistrationConformanceResult, } from './registration-conformance/index.js';
 export { gadgetResolutionCases, runResolutionConformance, } from './resolution-conformance/index.js';
 export type { GadgetUrlEntry, ResolvedGadgetUrls, ResolutionConformanceCase, ResolutionConformanceMismatch, ResolutionConformanceResult, } from './resolution-conformance/index.js';
+export { bindingFilterCases, bindingResolutionCases, runBindingFilterCases, runBindingResolutionCases, } from './binding-conformance/index.js';
+export type { BindingFilterCase, BindingFilterMismatch, BindingFilterResult, BindingManifestEntry, BindingRejectCode, BindingResolutionCase, BindingResolutionMismatch, BindingResolutionOutcome, BindingResolutionResult, McpToolBindingDecl, McpToolFilterDecl, } from './binding-conformance/index.js';
+export { declaresDeliveryChannel, renderLocatorUri, resourceReadCases, runResourceReadConformance, GGUI_RENDER_RESOURCE_URI, } from './resource-read-conformance/index.js';
+export type { DurableSubstrateWiring, JsonRpcErrorFrame, PreparedResourceReadScenario, ResourceReadCaller, ResourceReadConformanceCase, ResourceReadConformanceFailure, ResourceReadConformanceResult, ResourceReadConformanceSkip, ResourceReadErrorCodeDecl, ResourceReadExpectation, ResourceReadKey, ResourceReadLocator, ResourceReadOutcome, ResourceReadProbe, ResourceReadRenderMeta, ResourceReadScenario, ResourceReadScenarioDriver, ResourceReadSeed, ResourceReadServerShape, RunResourceReadConformanceOptions, } from './resource-read-conformance/index.js';
 export { loadFixture, listFixtures, loadAllFixtures } from './loader.js';
 export { runConformance } from './run-conformance.js';
 export type { RunConformanceConfig, ConformanceResult, ConformanceFailure, SkippedFixture, ConformanceReporter, InputEnvelopeDispatch, HostContextObservedInputEnvelope, } from './run-conformance.js';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAKH,YAAY,EAEV,eAAe,EACf,wBAAwB,EACxB,sBAAsB,EACtB,UAAU,EAEV,QAAQ,EACR,qBAAqB,EAErB,SAAS,EACT,qBAAqB,EACrB,mBAAmB,EACnB,cAAc,EACd,uBAAuB,EACvB,yBAAyB,EACzB,gCAAgC,EAChC,gBAAgB,EAEhB,YAAY,EAEZ,gBAAgB,EAChB,iBAAiB,EACjB,kBAAkB,EAClB,oBAAoB,EACpB,wBAAwB,EACxB,wBAAwB,EACxB,uBAAuB,EACvB,mBAAmB,EACnB,oBAAoB,EACpB,YAAY,EACZ,eAAe,EAEf,aAAa,EACb,sBAAsB,GACvB,MAAM,YAAY,CAAC;AAMpB,YAAY,EACV,eAAe,EAEf,SAAS,IAAI,aAAa,EAC1B,sBAAsB,EACtB,wBAAwB,EACxB,0BAA0B,EAC1B,iCAAiC,EACjC,iBAAiB,EAEjB,YAAY,IAAI,gBAAgB,GACjC,MAAM,uBAAuB,CAAC;AAK/B,OAAO,EACL,WAAW,EACX,kBAAkB,EAClB,yBAAyB,EACzB,qBAAqB,EACrB,mBAAmB,EACnB,gCAAgC,EAChC,8BAA8B,EAC9B,wBAAwB,GACzB,MAAM,qBAAqB,CAAC;AAC7B,YAAY,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AASxD,OAAO,EACL,qBAAqB,EACrB,oBAAoB,GACrB,MAAM,+BAA+B,CAAC;AACvC,YAAY,EACV,qBAAqB,EACrB,yBAAyB,EACzB,uBAAuB,GACxB,MAAM,+BAA+B,CAAC;AAKvC,OAAO,EACL,uBAAuB,EACvB,0BAA0B,GAC3B,MAAM,qCAAqC,CAAC;AAC7C,YAAY,EACV,oBAAoB,EACpB,WAAW,EACX,2BAA2B,EAC3B,+BAA+B,EAC/B,6BAA6B,GAC9B,MAAM,qCAAqC,CAAC;AAK7C,OAAO,EACL,qBAAqB,EACrB,wBAAwB,GACzB,MAAM,mCAAmC,CAAC;AAC3C,YAAY,EACV,cAAc,EACd,kBAAkB,EAClB,yBAAyB,EACzB,6BAA6B,EAC7B,2BAA2B,GAC5B,MAAM,mCAAmC,CAAC;AAG3C,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAGzE,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AACtD,YAAY,EACV,oBAAoB,EACpB,iBAAiB,EACjB,kBAAkB,EAClB,cAAc,EACd,mBAAmB,EAInB,qBAAqB,EACrB,gCAAgC,GACjC,MAAM,sBAAsB,CAAC;AAK9B,OAAO,EACL,qBAAqB,EACrB,eAAe,EACf,aAAa,EACb,cAAc,EACd,WAAW,GACZ,MAAM,eAAe,CAAC;AACvB,YAAY,EAAE,sBAAsB,EAAE,MAAM,eAAe,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/index.js

@@ -30,6 +30,18 @@ export { gadgetRegistrationCases, runRegistrationConformance, } from './registra
 // compute for a gadget descriptor's transport fields (`bundleHost`
 // precedence, default host, loopback scheme).
 export { gadgetResolutionCases, runResolutionConformance, } from './resolution-conformance/index.js';
+// Binding-conformance — MCP tool-binding resolution (declared wins,
+// contract-lineage derivation, schema-invalid rejects) + the search
+// filter semantics (`tool=` / `server=` case-sensitive exact,
+// AND-composed per entry).
+export { bindingFilterCases, bindingResolutionCases, runBindingFilterCases, runBindingResolutionCases, } from './binding-conformance/index.js';
+// Resource-read conformance — the kit's first MCP-binding driver, and
+// it binds `resources/read` ONLY (`tools/call` has none). A read of a
+// render locator has exactly two exits: a result whose contents
+// declare a delivery channel, or one typed JSON-RPC error.
+// Unlike the three catalogs above this one drives a live server, so
+// the caller supplies a scenario driver rather than a pure function.
+export { declaresDeliveryChannel, renderLocatorUri, resourceReadCases, runResourceReadConformance, GGUI_RENDER_RESOURCE_URI, } from './resource-read-conformance/index.js';
 // Runtime loader — look up a fixture by name from the inlined catalog.
 export { loadFixture, listFixtures, loadAllFixtures } from './loader.js';
 // Runner — drive the catalog against a live implementation.

package/dist/match-behavior.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"match-behavior.d.ts","sourceRoot":"","sources":["../src/match-behavior.ts"],"names":[],"mappings":"AA6FA,OAAO,KAAK,EAIV,gBAAgB,EAIjB,MAAM,YAAY,CAAC;AACpB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAEvD;;;;;GAKG;AACH,MAAM,MAAM,WAAW,GACnB;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GACzB;IACE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B,GACD;IAAE,QAAQ,CAAC,IAAI,EAAE,mBAAmB,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAEpE;;;;;;;;GAQG;AACH,wBAAgB,UAAU,CAAC,CAAC,SAAS,gBAAgB,CAAC,MAAM,CAAC,EAC3D,QAAQ,EAAE,gBAAgB,EAC1B,IAAI,EAAE,CAAC,GACN,QAAQ,IAAI,OAAO,CAAC,gBAAgB,EAAE;IAAE,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAA;CAAE,CAAC,CAE7D;AAED,wBAAgB,aAAa,CAC3B,QAAQ,EAAE,gBAAgB,EAC1B,MAAM,EAAE,SAAS,aAAa,EAAE,GAC/B,WAAW,CAkDb;AAgRD;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,OAAO,CAgBzD"}
+{"version":3,"file":"match-behavior.d.ts","sourceRoot":"","sources":["../src/match-behavior.ts"],"names":[],"mappings":"AA+FA,OAAO,KAAK,EAIV,gBAAgB,EAIjB,MAAM,YAAY,CAAC;AACpB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAEvD;;;;;GAKG;AACH,MAAM,MAAM,WAAW,GACnB;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GACzB;IACE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B,GACD;IAAE,QAAQ,CAAC,IAAI,EAAE,mBAAmB,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAEpE;;;;;;;;GAQG;AACH,wBAAgB,UAAU,CAAC,CAAC,SAAS,gBAAgB,CAAC,MAAM,CAAC,EAC3D,QAAQ,EAAE,gBAAgB,EAC1B,IAAI,EAAE,CAAC,GACN,QAAQ,IAAI,OAAO,CAAC,gBAAgB,EAAE;IAAE,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAA;CAAE,CAAC,CAE7D;AAED,wBAAgB,aAAa,CAC3B,QAAQ,EAAE,gBAAgB,EAC1B,MAAM,EAAE,SAAS,aAAa,EAAE,GAC/B,WAAW,CAkDb;AAgRD;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,OAAO,CAgBzD"}

package/dist/match-behavior.js

@@ -84,8 +84,10 @@
  * `action-ack` proves the append half of the consume-buffer contract.
  * The retrieval half — the agent draining the buffer via
  * `ggui_consume({sessionId})` — is an MCP tool call a WS-only runner
- * cannot drive. Grading it needs an MCP-binding driver; that gap is
- * declared here rather than papered over with a weaker assertion.
+ * cannot drive. Grading it needs a driver bound to `tools/call`. The
+ * kit's `resources/read` driver (`../resource-read-conformance`) does
+ * NOT reach it: different method, different seam. That gap is declared
+ * here rather than papered over with a weaker assertion.
  */
 import { PROTOCOL_SCHEMA_VERSION } from '@ggui-ai/protocol';
 import { isRecord } from '@ggui-ai/protocol';

package/dist/resolution-conformance/cases/resolve-bundle-host-computed.json

@@ -1,13 +1,13 @@
 {
     "name": "resolve-bundle-host-computed",
-    "description": "A descriptor with a hostname-only `bundleHost` (no scheme, no path) and no explicit `bundleUrl`. The resolver MUST compute both the bundle and style URLs as `https://<bundleHost>/bundles/<package>/<version>/<file>` — the path layout matching `@ggui-ai/registry-core`'s `BundleStorage` so a bundle published to one registry resolves cleanly from the other.",
+    "description": "A descriptor with a hostname-only `bundleHost` (no scheme, no path) and no explicit `bundleUrl`. The resolver MUST compute both the bundle and style URLs as `https://<bundleHost>/bundles/public/<package>/<version>/<file>` — the PUBLIC prefix of `@ggui-ai/registry-core`'s visibility-split `BundleStorage` layout (H1). bundleHost-tier composition is anonymous render-time fetching, which only the public prefix serves; private artifacts reach the iframe via an explicit presigned `bundleUrl`, never via host composition. Keeping the shapes aligned means a bundle published to one registry resolves cleanly from the other.",
     "entry": {
         "package": "@acme/leaflet-wrapper",
         "version": "2.3.1",
         "bundleHost": "cdn.example.com"
     },
     "expect": {
-        "bundleUrl": "https://cdn.example.com/bundles/@acme/leaflet-wrapper/2.3.1/bundle.js",
-        "styleUrl": "https://cdn.example.com/bundles/@acme/leaflet-wrapper/2.3.1/style.css"
+        "bundleUrl": "https://cdn.example.com/bundles/public/@acme/leaflet-wrapper/2.3.1/bundle.js",
+        "styleUrl": "https://cdn.example.com/bundles/public/@acme/leaflet-wrapper/2.3.1/style.css"
     }
 }