@ggui-ai/protocol-conformance 0.7.0 → 0.9.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/index.d.ts

@@ -20,6 +20,8 @@ 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';

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;AAQ3C,OAAO,EACL,uBAAuB,EACvB,gBAAgB,EAChB,iBAAiB,EACjB,0BAA0B,EAC1B,wBAAwB,GACzB,MAAM,sCAAsC,CAAC;AAC9C,YAAY,EACV,sBAAsB,EACtB,iBAAiB,EACjB,4BAA4B,EAC5B,kBAAkB,EAClB,2BAA2B,EAC3B,8BAA8B,EAC9B,6BAA6B,EAC7B,2BAA2B,EAC3B,yBAAyB,EACzB,uBAAuB,EACvB,eAAe,EACf,mBAAmB,EACnB,mBAAmB,EACnB,iBAAiB,EACjB,sBAAsB,EACtB,oBAAoB,EACpB,0BAA0B,EAC1B,gBAAgB,EAChB,uBAAuB,EACvB,iCAAiC,GAClC,MAAM,sCAAsC,CAAC;AAG9C,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,11 @@ 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

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"
     }
 }

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/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/pin-past-the-head-answers-not-found.json

@@ -0,0 +1,29 @@
+{
+    "name": "pin-past-the-head-answers-not-found",
+    "description": "Epoch history (#483, SPEC §7.1.2.2): a pinned locator whose epoch exceeds the session's head names a record that does not exist — the same NOT_FOUND on -32002, detail-free, that a missing session answers. Nothing about the head's value may leak through the error shape: a caller must not be able to binary-search the history depth off error variance.",
+    "server": { "durableSubstrate": "all", "liveChannel": true },
+    "caller": "owner",
+    "seeds": [
+        {
+            "kind": "epoch-history",
+            "session": "7a4d9c15-8e2f-4b06-a3c9-5d1f8e0b2c47",
+            "records": [{ "props": { "count": 1 } }, { "props": { "count": 5 } }]
+        }
+    ],
+    "reads": [
+        {
+            "as": "past-head",
+            "locator": {
+                "kind": "render",
+                "session": "7a4d9c15-8e2f-4b06-a3c9-5d1f8e0b2c47",
+                "epoch": 7
+            },
+            "expect": {
+                "kind": "typed-error",
+                "jsonRpcCode": -32002,
+                "dataCode": "NOT_FOUND",
+                "detailAbsent": true
+            }
+        }
+    ]
+}

package/dist/resource-read-conformance/cases/pinned-superseded-record-serves-its-reign-immutably.json

@@ -0,0 +1,42 @@
+{
+    "name": "pinned-superseded-record-serves-its-reign-immutably",
+    "description": "Epoch history (#483, SPEC §7.1.2.2): a session whose head advanced to epoch 1 still serves its superseded epoch-0 record on the pinned locator — with the props of ITS reign (the amended mint state), never the successor's — and serves them byte-identically on a second read. The bare locator meanwhile tracks the live head. Immutability is graded on propsJson only: live-channel tokens on the same meta legitimately differ per read; the RECORD is what may not.",
+    "server": { "durableSubstrate": "all", "liveChannel": true },
+    "caller": "owner",
+    "seeds": [
+        {
+            "kind": "epoch-history",
+            "session": "5e2c7a90-4f1b-4c3d-8a67-9b0e2d4f6a81",
+            "records": [{ "props": { "count": 1 } }, { "props": { "count": 5 } }]
+        }
+    ],
+    "reads": [
+        {
+            "as": "pin0-first",
+            "locator": {
+                "kind": "render",
+                "session": "5e2c7a90-4f1b-4c3d-8a67-9b0e2d4f6a81",
+                "epoch": 0
+            },
+            "expect": { "kind": "pinned-mount", "propsInclude": { "count": 1 } }
+        },
+        {
+            "as": "pin0-second",
+            "locator": {
+                "kind": "render",
+                "session": "5e2c7a90-4f1b-4c3d-8a67-9b0e2d4f6a81",
+                "epoch": 0
+            },
+            "expect": { "kind": "pinned-mount", "propsInclude": { "count": 1 } }
+        },
+        {
+            "as": "head",
+            "locator": {
+                "kind": "render",
+                "session": "5e2c7a90-4f1b-4c3d-8a67-9b0e2d4f6a81"
+            },
+            "expect": { "kind": "pinned-mount", "propsInclude": { "count": 5 } }
+        }
+    ],
+    "identicalMounts": ["pin0-first", "pin0-second"]
+}

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

@@ -1,16 +1,27 @@
 {
     "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" },
+    "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" }],
+    "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" }
+                "key": {
+                    "kind": "literal",
+                    "value": "fedcba9876543210"
+                }
             },
             "expect": {
                 "kind": "typed-error",