@ggui-ai/protocol-conformance 0.24.0 → 0.26.0

package/dist/host-helper-conformance/index.js

@@ -60,11 +60,279 @@
  *   reference validate is `@ggui-ai/design`'s `validateThemeCoverage`
  *   bound to the shipped `consumed-tokens.manifest.json` tokens.
  *
+ * - `M1-model-tool-set` — OPTIONAL like T1, graded when the host supplies
+ *   the filter it uses to derive the MODEL's tool list from a served
+ *   `tools/list` (ggui#1414): the result must withhold every tool whose
+ *   `_meta.ui.visibility` lacks `'model'` (ggui's six `ggui_runtime_*`
+ *   app-only tools) and keep every other tool. SEP-1865 assigns this door
+ *   to the host, and the server cannot observe a violation — a
+ *   view-issued and a model-issued call are indistinguishable on the wire
+ *   — so the kit is where a host proves it. Absent ⇒ `skip`.
+ *
+ * - `V1-view-material-withheld` — OPTIONAL (ggui#1415, SPEC §4.7): the
+ *   host keeps view-delivered material out of the model's context. The
+ *   kit feeds the host's own context rules a render result and a render
+ *   read body whose `_meta["ai.ggui/render"]` slice carries a unique
+ *   marker in every string value, and requires none of them (raw,
+ *   JSON-escaped, percent-encoded, or inside a base64 / base64url run) in
+ *   what the model sees, while the
+ *   model still sees the result's model-visible marker; and the host's
+ *   model-facing resource list, when it has one, must withhold
+ *   `ui://ggui/render/*` while keeping an ordinary resource. Absent ⇒
+ *   `skip`.
+ * - `L1-view-locator-binding` — OPTIONAL (ggui#1415, SPEC §4.7): the host
+ *   binds a view's calls and reads to its own locator. The kit feeds the
+ *   host's own relay decision a view mounted for one session, and reads
+ *   (every locator form) and every session-naming call a view may make,
+ *   for that session (relay) and another (refuse). Absent ⇒ `skip`.
+ *
+ * The three host-rule grades (M1, V1, L1) grade the host's RULE, fed
+ * fixtures: they prove the rule is right, not that a running host applies
+ * it (self-certification; the V1 and L1 pass details say so).
+ *
  * A helper that refuses the relay honestly is graded **tier
  * `read-only`** — a LEGAL grade, with the R cases skipped, never
  * failed. `nonconforming` means a dishonesty case failed.
  */
+import { toolVisibleToModel, } from '@ggui-ai/protocol/integrations/mcp-apps';
 import { renderLocatorUri } from '../resource-read-conformance/index.js';
+/**
+ * A served-equivalent shape the M1 grade feeds a host's filter (ggui#1414):
+ * agent tools as ggui declares them — `ggui_render` and `ggui_update` stamp
+ * `visibility: ['model']`, the others carry no marker (the spec's default)
+ * — and ggui's seven app-only `ggui_runtime_*` tools. The list is static and
+ * the names are the protocol's own, so it grades the FILTER a host applies,
+ * never the host's live `tools/list`: a host that filters by name rather
+ * than by visibility passes only as long as this list matches what its
+ * server lists, which is why the grade wants the filter and the SPEC
+ * points at the predicate.
+ */
+export const MODEL_TOOL_SET_FIXTURE = [
+    { name: 'ggui_handshake' },
+    { name: 'ggui_render', _meta: { ui: { visibility: ['model'] } } },
+    { name: 'ggui_update', _meta: { ui: { visibility: ['model'] } } },
+    { name: 'ggui_consume' },
+    { name: 'ggui_amend' },
+    { name: 'ggui_runtime_submit_action', _meta: { ui: { visibility: ['app'] } } },
+    { name: 'ggui_runtime_pull', _meta: { ui: { visibility: ['app'] } } },
+    { name: 'ggui_runtime_sync_context', _meta: { ui: { visibility: ['app'] } } },
+    { name: 'ggui_runtime_refresh_ws_token', _meta: { ui: { visibility: ['app'] } } },
+    { name: 'ggui_runtime_telemetry', _meta: { ui: { visibility: ['app'] } } },
+    { name: 'ggui_runtime_report_render_failure', _meta: { ui: { visibility: ['app'] } } },
+    { name: 'ggui_runtime_declare_tool_catalog', _meta: { ui: { visibility: ['app'] } } },
+];
+/**
+ * The render result V1 feeds a host's context builder (ggui#1415). Every
+ * string value in the `_meta["ai.ggui/render"]` slice is a unique marker
+ * ({@link VIEW_MATERIAL_CANARIES}); the model-visible parts carry values of
+ * their own, so a host that shows them cannot trip a canary, and one marker
+ * ({@link VIEW_MATERIAL_VISIBLE_MARKER}) the model must still see.
+ */
+export const VIEW_MATERIAL_RESULT_FIXTURE = {
+    structuredContent: { sessionId: 'vmx-visible-session-2a7d', status: 'rendered', note: 'vmx-visible-marker-5e1b' },
+    content: [{ type: 'text', text: 'Rendered the card (vmx-visible-marker-5e1b).' }],
+    _meta: {
+        'ai.ggui/render': {
+            sessionId: 'vmx-slice-session-3f9a1c',
+            appId: 'vmx-slice-app-8b2e',
+            runtimeUrl: 'https://vmx-slice-runtime.invalid/iframe-runtime.js',
+            wsUrl: 'wss://vmx-slice-wsurl-4c2d.invalid/ws',
+            wsToken: 'vmx-slice-wstoken-6d41e0a7',
+            viewKey: 'vmx-slice-viewkey-Q2FuYXJ5S2V5',
+            expiresAt: '2099-07-07T07:07:07.707Z',
+            propsJson: '{"vmxSliceProp":"vmx-slice-props-91c2"}',
+        },
+    },
+};
+/**
+ * The marker V1 requires in the model's context: the result itself is not
+ * withheld. Both model-visible parts carry it, so a host that shows either
+ * one passes.
+ */
+export const VIEW_MATERIAL_VISIBLE_MARKER = 'vmx-visible-marker-5e1b';
+/**
+ * Every string a value holds, walked deep: object values and keys, arrays,
+ * Map entries, Set members, and byte views read as UTF-8 text. Cycles are
+ * walked once.
+ */
+function stringValuesIn(value, out = [], seen = new Set()) {
+    if (typeof value === 'string') {
+        out.push(value);
+        return out;
+    }
+    if (typeof value !== 'object' || value === null || seen.has(value))
+        return out;
+    seen.add(value);
+    if (ArrayBuffer.isView(value)) {
+        out.push(new TextDecoder().decode(new Uint8Array(value.buffer, value.byteOffset, value.byteLength)));
+    }
+    else if (value instanceof ArrayBuffer) {
+        out.push(new TextDecoder().decode(new Uint8Array(value)));
+    }
+    else if (value instanceof Map) {
+        for (const [k, v] of value) {
+            stringValuesIn(k, out, seen);
+            stringValuesIn(v, out, seen);
+        }
+    }
+    else if (value instanceof Set || Array.isArray(value)) {
+        for (const item of value)
+            stringValuesIn(item, out, seen);
+    }
+    else {
+        for (const [k, v] of Object.entries(value)) {
+            out.push(k);
+            stringValuesIn(v, out, seen);
+        }
+    }
+    return out;
+}
+/**
+ * One canary per string value of the fixture's `ai.ggui/render` slice: the
+ * value's unique `vmx-slice-…` mark, which survives JSON escaping and
+ * encoding, or the whole value when it carries none. None may reach the model.
+ */
+export const VIEW_MATERIAL_CANARIES = Object.values(VIEW_MATERIAL_RESULT_FIXTURE._meta['ai.ggui/render'])
+    .filter((value) => typeof value === 'string')
+    .map((value) => /vmx-slice-[A-Za-z0-9-]+/.exec(value)?.[0] ?? value);
+/** The resources V1 feeds a host's model-facing resource list: the render template and one ordinary resource. */
+export const MODEL_RESOURCE_FIXTURE = [
+    { name: 'ggui render', uriTemplate: 'ui://ggui/render/{sessionId}' },
+    { name: 'notes', uri: 'file:///vmx-notes.md' },
+];
+/**
+ * A render locator's `resources/read` result as a server answers it: the
+ * self-contained shell, with the view's slice inlined, canaries included.
+ */
+export const VIEW_MATERIAL_READ_FIXTURE = {
+    contents: [
+        {
+            uri: 'ui://ggui/render/vmx-slice-session-3f9a1c',
+            mimeType: 'text/html;profile=mcp-app',
+            text: `<!doctype html><html><body><script>globalThis.__GGUI_META__ = ${JSON.stringify(VIEW_MATERIAL_RESULT_FIXTURE._meta)};</script></body></html>`,
+        },
+    ],
+};
+/** The view L1's requests come from. */
+export const VIEW_BINDING_MOUNT = { locator: 'ui://ggui/render/vmx-s1/bk-vmx1', sessionId: 'vmx-s1' };
+const OTHER_SESSION = 'vmx-s2';
+/**
+ * Every tool a view may call (no `model`-only marker) that names a session in
+ * its arguments, with arguments its input schema accepts. Left out:
+ * `ggui_runtime_declare_tool_catalog` (app-scoped, names none),
+ * `ggui_runtime_refresh_ws_token` (its session is inside the envelope, and
+ * the server admits the caller to it), `ggui_handshake` and
+ * `ggui_list_sessions` (name none), and `ggui_render` / `ggui_update`
+ * (model-only).
+ */
+export const VIEW_SESSION_BOUND_CALLS = [
+    {
+        name: 'ggui_runtime_submit_action',
+        args: (sessionId) => ({
+            kind: 'dispatch',
+            payload: { intent: 'confirm', actionData: null, uiContext: {} },
+            sessionId,
+            appId: 'vmx-app',
+            actionId: 'a3f2b1d4',
+            firedAt: '2026-09-29T00:00:00.000Z',
+        }),
+    },
+    { name: 'ggui_runtime_sync_context', args: (sessionId) => ({ sessionId, appId: 'vmx-app', snapshot: {} }) },
+    { name: 'ggui_runtime_pull', args: (sessionId) => ({ sessionId }) },
+    { name: 'ggui_runtime_telemetry', args: (sessionId) => ({ sessionId, events: [{ at: 0, kind: 'boot.path' }] }) },
+    {
+        name: 'ggui_runtime_report_render_failure',
+        args: (sessionId) => ({ sessionId, appId: 'vmx-app', phase: 'mount', errorName: 'TypeError', catches: 2 }),
+    },
+    { name: 'ggui_consume', args: (sessionId) => ({ sessionId }) },
+    { name: 'ggui_amend', args: (sessionId) => ({ sessionId, kind: 'merge', patch: { count: 1 } }) },
+    { name: 'ggui_emit', args: (sessionId) => ({ sessionId, channel: 'status', payload: { text: 'hi' } }) },
+    { name: 'ggui_get_session', args: (sessionId) => ({ sessionId }) },
+    { name: 'ggui_get_render_source', args: (sessionId) => ({ sessionId }) },
+];
+/**
+ * L1's requests and the decision each must get (ggui#1415). A view's own
+ * session relays and another's refuses, for a read of either locator form
+ * (`{sessionId}`, `{sessionId}/{blueprintKey}`, and an epoch pin `#N`) and
+ * for every call in {@link VIEW_SESSION_BOUND_CALLS}.
+ */
+export const VIEW_BINDING_CASES = [
+    { request: { kind: 'resources/read', uri: VIEW_BINDING_MOUNT.locator }, expect: 'relay' },
+    { request: { kind: 'resources/read', uri: `ui://ggui/render/${VIEW_BINDING_MOUNT.sessionId}` }, expect: 'relay' },
+    { request: { kind: 'resources/read', uri: `ui://ggui/render/${VIEW_BINDING_MOUNT.sessionId}#2` }, expect: 'relay' },
+    { request: { kind: 'resources/read', uri: `ui://ggui/render/${OTHER_SESSION}` }, expect: 'refuse' },
+    { request: { kind: 'resources/read', uri: `ui://ggui/render/${OTHER_SESSION}/bk-vmx2` }, expect: 'refuse' },
+    { request: { kind: 'resources/read', uri: `ui://ggui/render/${OTHER_SESSION}/bk-vmx2#1` }, expect: 'refuse' },
+    ...VIEW_SESSION_BOUND_CALLS.flatMap((call) => [
+        { request: { kind: 'tools/call', name: call.name, arguments: call.args(VIEW_BINDING_MOUNT.sessionId) }, expect: 'relay' },
+        { request: { kind: 'tools/call', name: call.name, arguments: call.args(OTHER_SESSION) }, expect: 'refuse' },
+    ]),
+];
+/** The base64 / base64url runs inside a string, decoded; a run that does not decode yields nothing. */
+function decodedBase64Runs(text) {
+    const runs = text.match(/[A-Za-z0-9+/_-]{16,}={0,2}/g) ?? [];
+    // A blob can start anywhere in a run (after a URL path, say), and base64
+    // decodes in 4-character groups, so each run is decoded from all four
+    // offsets: one of them lines up with the blob.
+    return runs.flatMap((run) => [0, 1, 2, 3].flatMap((offset) => {
+        const normal = run.slice(offset).replace(/-/g, '+').replace(/_/g, '/').replace(/=+$/, '');
+        const usable = normal.slice(0, normal.length - (normal.length % 4 === 1 ? 1 : 0));
+        try {
+            const binary = atob(usable + '==='.slice((usable.length + 3) % 4));
+            return [new TextDecoder().decode(Uint8Array.from(binary, (ch) => ch.charCodeAt(0)))];
+        }
+        catch {
+            // Not base64 from this offset: the run is searched raw already.
+            return [];
+        }
+    }));
+}
+/**
+ * A string with its `%XX` escapes decoded, where it carries any: the form
+ * state takes in a URL's query string. A malformed escape is left as is,
+ * one escape at a time, so a stray `%` never hides the rest.
+ */
+function percentDecoded(text) {
+    if (!/%[0-9A-Fa-f]{2}/.test(text))
+        return [];
+    try {
+        return [decodeURIComponent(text)];
+    }
+    catch {
+        // A malformed escape somewhere: decode the well-formed ones in place.
+        return [text.replace(/(?:%[0-9A-Fa-f]{2})+/g, (run) => {
+                try {
+                    return decodeURIComponent(run);
+                }
+                catch {
+                    // Bytes that are not UTF-8 stay escaped; the rest still decode.
+                    return run;
+                }
+            })];
+    }
+}
+/**
+ * Which canaries appear in a model context: raw (JSON-escaped values
+ * included, since every mark is escape-free), or inside a percent-encoded
+ * string or a base64 / base64url run, decoded (the first match per canary).
+ */
+function leakedCanaries(context) {
+    const strings = stringValuesIn(context);
+    const unescaped = strings.flatMap(percentDecoded);
+    const decoded = [...unescaped, ...[...strings, ...unescaped].flatMap(decodedBase64Runs)];
+    const raw = VIEW_MATERIAL_CANARIES.filter((c) => strings.some((s) => s.includes(c)));
+    const encoded = VIEW_MATERIAL_CANARIES.filter((c) => !raw.includes(c) && decoded.some((s) => s.includes(c)));
+    return { raw, encoded };
+}
+/** The slice field a canary is the value of, for a failure detail. */
+function canaryField(canary) {
+    const slice = VIEW_MATERIAL_RESULT_FIXTURE._meta['ai.ggui/render'];
+    const entry = typeof slice === 'object' && slice !== null
+        ? Object.entries(slice).find(([, v]) => typeof v === 'string' && /vmx-slice-[A-Za-z0-9-]+/.exec(v)?.[0] === canary) ??
+            Object.entries(slice).find(([, v]) => v === canary)
+        : undefined;
+    return entry !== undefined ? entry[0] : canary;
+}
 const METHOD_NOT_SUPPORTED = -32601;
 const DEFAULT_REFUSAL_TIMEOUT_MS = 2_000;
 /** A method no ggui helper answers — the honest-refusal probe. */
@@ -72,8 +340,7 @@ const UNSUPPORTED_PROBE_METHOD = 'ggui-conformance/unsupported-probe';
 /**
  * The `resources/read` probe's URI: a well-formed render locator naming
  * a render that does not exist, built with the kit's own locator grammar
- * (one owner, `resource-read-conformance`; the kit never compiles against
- * live protocol types). It is a locator on purpose, so a helper that
+ * (one owner, `resource-read-conformance`; the kit compiles against the protocol's published integrations only where a predicate IS the contract (`toolVisibleToModel`), never against live wire types). It is a locator on purpose, so a helper that
  * forwards only `ui://ggui/render/` reads still forwards it; a relaying
  * helper then hands back the server's own classification of the miss,
  * which is an answer (ggui#1304).
@@ -438,6 +705,120 @@ export async function runHostHelperConformance(port, options = {}) {
             });
         }
     }
+    // ── M1: the model's tool set withholds app-only tools ─────────────
+    if (options.modelToolSet === undefined) {
+        cases.push({
+            id: 'M1-model-tool-set',
+            outcome: 'skip',
+            detail: 'no model-facing filter supplied — the visibility door is still the host\'s obligation (SEP-1865), just not graded here (supply modelToolSet to grade)',
+        });
+    }
+    else {
+        const offered = new Set(options.modelToolSet.offeredToModel(MODEL_TOOL_SET_FIXTURE));
+        const leaked = MODEL_TOOL_SET_FIXTURE.filter((t) => !toolVisibleToModel(t._meta?.ui?.visibility) && offered.has(t.name)).map((t) => t.name);
+        const withheld = MODEL_TOOL_SET_FIXTURE.filter((t) => toolVisibleToModel(t._meta?.ui?.visibility) && !offered.has(t.name)).map((t) => t.name);
+        const served = new Set(MODEL_TOOL_SET_FIXTURE.map((t) => t.name));
+        const unknown = [...offered].filter((name) => !served.has(name));
+        if (leaked.length === 0 && withheld.length === 0 && unknown.length === 0) {
+            cases.push({
+                id: 'M1-model-tool-set',
+                outcome: 'pass',
+                detail: `the model's tool set withholds every app-only tool and keeps every model-visible one (${offered.size} offered)`,
+            });
+        }
+        else {
+            const parts = [
+                leaked.length > 0
+                    ? `app-only tools offered to the model (${leaked.length}): ${leaked.join(', ')} — a model holding the app credential can call them`
+                    : undefined,
+                withheld.length > 0
+                    ? `model-visible tools withheld (${withheld.length}): ${withheld.join(', ')} — the agent cannot run the loop without them`
+                    : undefined,
+                unknown.length > 0
+                    ? `names offered that the server never listed (${unknown.length}): ${unknown.join(', ')} — the list is not derived from tools/list`
+                    : undefined,
+            ].filter((part) => part !== undefined);
+            cases.push({
+                id: 'M1-model-tool-set',
+                outcome: 'fail',
+                detail: parts.join('; '),
+            });
+        }
+    }
+    // ── V1: view-delivered material stays out of the model's context ──
+    if (options.modelContext === undefined) {
+        cases.push({
+            id: 'V1-view-material-withheld',
+            outcome: 'skip',
+            detail: "no model-context rule supplied: keeping view material from the model is still the host's obligation (SPEC §4.7), just not graded here (supply modelContext to grade)",
+        });
+    }
+    else {
+        const rules = options.modelContext;
+        try {
+            const context = await rules.modelContextOf(VIEW_MATERIAL_RESULT_FIXTURE);
+            const readContext = await rules.modelContextOfRead(VIEW_MATERIAL_READ_FIXTURE);
+            const fromResult = leakedCanaries(context);
+            const fromRead = leakedCanaries(readContext);
+            const seesResult = stringValuesIn(context).some((s) => s.includes(VIEW_MATERIAL_VISIBLE_MARKER));
+            const offered = rules.resourcesOfferedToModel?.(MODEL_RESOURCE_FIXTURE);
+            const offersRender = (offered ?? []).filter((u) => u.startsWith('ui://ggui/render'));
+            const keepsOrdinary = offered === undefined || offered.includes('file:///vmx-notes.md');
+            const parts = [
+                fromResult.raw.length > 0 ? `view material from a tool result in the model's context: ${fromResult.raw.map(canaryField).join(', ')}` : undefined,
+                fromResult.encoded.length > 0 ? `view material from a tool result inside a percent-encoded or base64 run: ${fromResult.encoded.map(canaryField).join(', ')}` : undefined,
+                fromRead.raw.length > 0 ? `a render read body in the model's context: ${fromRead.raw.map(canaryField).join(', ')}` : undefined,
+                fromRead.encoded.length > 0 ? `a render read body inside a percent-encoded or base64 run: ${fromRead.encoded.map(canaryField).join(', ')}` : undefined,
+                seesResult ? undefined : `the model does not see the result's own marker ${VIEW_MATERIAL_VISIBLE_MARKER}: withholding the result is not withholding the view material`,
+                offersRender.length > 0 ? `a render read offered to the model: ${offersRender.join(', ')}` : undefined,
+                keepsOrdinary ? undefined : 'the ordinary resource was not offered: a list that hides everything is not a rule (omit resourcesOfferedToModel when the model reads no resources)',
+            ].filter((part) => part !== undefined);
+            cases.push(parts.length === 0
+                ? {
+                    id: 'V1-view-material-withheld',
+                    outcome: 'pass',
+                    detail: `none of the slice's ${VIEW_MATERIAL_CANARIES.length} values reaches the model from a tool result or a render read body, raw, JSON-escaped, percent-encoded, base64 or base64url; the result itself does; ${offered === undefined ? 'the host offers the model no resource reads' : 'no render read is offered'} (the host's rule, self-certified)`,
+                }
+                : { id: 'V1-view-material-withheld', outcome: 'fail', detail: parts.join('; ') });
+        }
+        catch (err) {
+            cases.push({ id: 'V1-view-material-withheld', outcome: 'fail', detail: `the host's rule threw: ${err instanceof Error ? err.message : String(err)}` });
+        }
+    }
+    // ── L1: a view's calls and reads are bound to its own locator ─────
+    if (options.viewBinding === undefined) {
+        cases.push({
+            id: 'L1-view-locator-binding',
+            outcome: 'skip',
+            detail: "no view-binding rule supplied: binding a view to its own locator is still the host's obligation (SPEC §4.7), just not graded here (supply viewBinding to grade)",
+        });
+    }
+    else {
+        const describe = (r) => r.kind === 'resources/read' ? `resources/read ${r.uri}` : `${r.name} for session ${String(r.arguments['sessionId'])}`;
+        const decide = options.viewBinding.decide;
+        const decided = VIEW_BINDING_CASES.map((c) => {
+            try {
+                return { ...c, got: decide(VIEW_BINDING_MOUNT, c.request) };
+            }
+            catch (err) {
+                // A rule that throws decides nothing: the request is neither relayed nor refused, and the case says so.
+                return { ...c, got: `threw: ${err instanceof Error ? err.message : String(err)}` };
+            }
+        });
+        const relayedForeign = decided.filter((c) => c.expect === 'refuse' && c.got !== 'refuse').map((c) => describe(c.request));
+        const refusedOwn = decided.filter((c) => c.expect === 'relay' && c.got !== 'relay').map((c) => describe(c.request));
+        const parts = [
+            relayedForeign.length > 0 ? `relayed another view's request (${relayedForeign.length}): ${relayedForeign.join('; ')}` : undefined,
+            refusedOwn.length > 0 ? `refused its own view's request (${refusedOwn.length}): ${refusedOwn.join('; ')}` : undefined,
+        ].filter((part) => part !== undefined);
+        cases.push(parts.length === 0
+            ? {
+                id: 'L1-view-locator-binding',
+                outcome: 'pass',
+                detail: `the view's own reads and session-bound calls relay and another session's refuse, ${VIEW_BINDING_CASES.length} requests (the host's rule, self-certified)`,
+            }
+            : { id: 'L1-view-locator-binding', outcome: 'fail', detail: parts.join('; ') });
+    }
     const failures = cases
         .filter((c) => c.outcome === 'fail')
         .map((c) => c.id);

package/dist/index.d.ts

@@ -12,7 +12,7 @@
  */
 export type { TransportConfig, WebSocketTransportConfig, UnknownTransportConfig, AuthConfig, TestCase, SubscribeFrameShaping, SetupStep, CreateGguiSessionStep, ActionSpecEntryDecl, JsonSchemaDecl, RendererUrlOverrideStep, ServerVersionOverrideStep, UiInitializeResponseOverrideStep, EmitEnvelopeStep, TeardownStep, ExpectedBehavior, ActionAckBehavior, ErrorFrameBehavior, StreamUpdateBehavior, BootstrapFailureBehavior, BootstrapSuccessBehavior, VersionMismatchBehavior, PropsUpdateBehavior, SessionStateBehavior, NoOpBehavior, UnknownBehavior, ProtocolError, BootstrapFailureReason, } from './types.js';
 export type { ConformanceHost, SetupStep as HostSetupStep, CreateGguiSessionSetup, RendererUrlOverrideSetup, ServerVersionOverrideSetup, UiInitializeResponseOverrideSetup, EmitEnvelopeSetup, TeardownStep as HostTeardownStep, } from './conformance-host.js';
-export { allFixtures, fixturesByContract, bootstrapProtocolFixtures, consumeBufferFixtures, hostContextFixtures, reservedChannelAuthorityFixtures, schemaVersionHandshakeFixtures, subscribeAppScopeFixtures, } from './fixtures/index.js';
+export { allFixtures, fixturesByContract, bootstrapProtocolFixtures, consumeBufferFixtures, hostContextFixtures, reservedChannelAuthorityFixtures, reservedChannelReplayFixtures, schemaVersionHandshakeFixtures, subscribeAppScopeFixtures, } from './fixtures/index.js';
 export type { ContractSlug } from './fixtures/index.js';
 export { gadgetWireSchemaCases, runSchemaConformance, } from './schema-conformance/index.js';
 export type { SchemaConformanceCase, SchemaConformanceMismatch, SchemaConformanceResult, } from './schema-conformance/index.js';
@@ -37,10 +37,12 @@ export type { PreparedReadPlaneOnlyScenario, ReadPlaneOnlyConformanceCase, ReadP
 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';
-export { createDefaultReporter, formatScorecard, formatSummary, formatFailures, formatSkips, } from './reporter.js';
+export { createDefaultReporter, formatScorecard, formatSummary, formatFailures, formatWarnings, formatSkips, } from './reporter.js';
 export type { DefaultReporterOptions } from './reporter.js';
 export { domainErrorCases, isRawToolCallResult, runDomainErrorConformance, } from './domain-error-conformance/index.js';
 export type { DomainErrorConformanceCase, DomainErrorConformanceResult, DomainErrorCriterion, DomainErrorMismatch, DomainErrorSkip, RawToolCallResult, RunDomainErrorConformanceOptions, ToolCallArgs, ToolCallContent, ToolCallDriver, ToolCallScenario, } from './domain-error-conformance/index.js';
+export { DISPATCH_IDEMPOTENCY_ACTION, DISPATCH_IDEMPOTENCY_ACTION_SPEC, runDispatchIdempotencyConformance, } from './dispatch-idempotency-conformance/index.js';
+export type { DispatchIdempotencyCaseName, DispatchIdempotencyCaseResult, DispatchIdempotencyHost, DispatchIdempotencyResult, DispatchIdempotencySession, } from './dispatch-idempotency-conformance/index.js';
 export { APP_THEME_CASES, OVERLAY_HASH_CASES, THEME_MODE_CASES, runThemeBindingConformance, } from './theme-binding-conformance/index.js';
 export type { AppThemeCase, OverlayHashCase, ThemeBindingResult, ThemeModeCase, } from './theme-binding-conformance/index.js';
 export { N1_COMPAT_CASES, N1_COMPAT_DIRECTIONS, N1_COMPAT_WIRES, runN1CompatConformance } from './n1-compat-conformance/index.js';

package/dist/index.d.ts.map

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

package/dist/index.js

@@ -13,7 +13,7 @@
 // Fixture catalog — every authored conformance case, classified by
 // contract. Third-party runners + the kit's own `runConformance()`
 // consume this surface.
-export { allFixtures, fixturesByContract, bootstrapProtocolFixtures, consumeBufferFixtures, hostContextFixtures, reservedChannelAuthorityFixtures, schemaVersionHandshakeFixtures, subscribeAppScopeFixtures, } from './fixtures/index.js';
+export { allFixtures, fixturesByContract, bootstrapProtocolFixtures, consumeBufferFixtures, hostContextFixtures, reservedChannelAuthorityFixtures, reservedChannelReplayFixtures, schemaVersionHandshakeFixtures, subscribeAppScopeFixtures, } from './fixtures/index.js';
 // Pure-function conformance catalogs — SPEC §7.7.2's gadget
 // obligations are deterministic validation functions, not transport-
 // observable behaviors. Each catalog grades a caller-supplied function
@@ -78,9 +78,11 @@ export { runConformance } from './run-conformance.js';
 // Default reporter — stdout-based bar-scorecard implementation +
 // formatters programmatic consumers can reuse when building their
 // own reporter (CI annotations, vitest integration, etc.).
-export { createDefaultReporter, formatScorecard, formatSummary, formatFailures, formatSkips, } from './reporter.js';
+export { createDefaultReporter, formatScorecard, formatSummary, formatFailures, formatWarnings, formatSkips, } from './reporter.js';
 // ── domain-error (SPEC §7.9 Plane 2 on the tools/call wire, ggui#880) ──
 export { domainErrorCases, isRawToolCallResult, runDomainErrorConformance, } from './domain-error-conformance/index.js';
+// ── dispatch-idempotency (SPEC §11.1 "A retried dispatch is one gesture", ggui#1519; SHOULD level) ──
+export { DISPATCH_IDEMPOTENCY_ACTION, DISPATCH_IDEMPOTENCY_ACTION_SPEC, runDispatchIdempotencyConformance, } from './dispatch-idempotency-conformance/index.js';
 // ── theme binding (ggui#987 — the theming wave's arbiter; guuey 1.3 judges against it) ──
 export { APP_THEME_CASES, OVERLAY_HASH_CASES, THEME_MODE_CASES, runThemeBindingConformance, } from './theme-binding-conformance/index.js';
 // ── n1-compat (ggui#1014 §3.6 — previous-release payloads against today's parsers; ggui#1093 — a later release's payload against today's READ door) ──

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

@@ -1 +1 @@
-{"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;AAqUD;;;;;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;AAkXD;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,OAAO,CAgBzD"}

package/dist/match-behavior.js

@@ -340,19 +340,21 @@ function matchContractViolationPayload(assertions, parsed, frames) {
  *     non-conformant envelope must not satisfy the assertion.
  */
 function matchStreamUpdate(behavior, frames) {
-    const envelopes = frames.flatMap((f) => {
-        if (f.kind !== 'frame' || f.parsed['type'] !== 'data')
-            return [];
-        const body = f.parsed['payload'];
-        return isStreamEnvelope(body) ? [body] : [];
-    });
     // `valueMatch: 'subset'` relaxes the value comparison to "every
     // declared key is present + matching; extra observed keys ignored".
     // Default ('exact' / absent) is the exact deep-equal.
     const subset = behavior.valueMatch === 'subset';
     const valueMatches = (observed) => subset ? deepMatchSubset(behavior.value, observed) : deepEqual(observed, behavior.value);
-    const match = envelopes.find((envelope) => envelope.channel === behavior.channel && valueMatches(envelope.payload));
-    if (match === undefined) {
+    // Every matching envelope, with where it arrived among the frames.
+    const matches = frames.flatMap((f, index) => {
+        if (f.kind !== 'frame' || f.parsed['type'] !== 'data')
+            return [];
+        const body = f.parsed['payload'];
+        return isStreamEnvelope(body) && body.channel === behavior.channel && valueMatches(body.payload)
+            ? [{ index, envelope: body }]
+            : [];
+    });
+    if (matches.length === 0) {
         return {
             kind: 'fail',
             expected: {
@@ -366,6 +368,43 @@ function matchStreamUpdate(behavior, frames) {
             message: `expected a \`data\` frame whose StreamEnvelope names channel '${behavior.channel}' and carries the declared value as its payload (${subset ? 'subset match — every declared key present + matching' : 'exact match'}); none matched.`,
         };
     }
+    if (behavior.replayAfterAck !== true)
+        return { kind: 'pass' };
+    return matchReplayPlacement(behavior.channel, frames, matches);
+}
+/**
+ * The replay placement a `stream-update` with `replayAfterAck` grades
+ * (SPEC §12.2.1, ggui#1526): a matching frame that arrives after the
+ * subscribe's `ack` and carries a `seq` at or below that ack's
+ * `streamSeq`. The first placement failure found names what is wrong.
+ */
+function matchReplayPlacement(channel, frames, matches) {
+    const ackIndex = frames.findIndex((f) => f.kind === 'frame' && f.parsed['type'] === 'ack');
+    const expected = { type: 'data', channel, after: 'the subscribe ack', seq: '<= ack.payload.streamSeq' };
+    const fail = (message) => ({
+        kind: 'fail',
+        expected,
+        received: frames.filter((f) => f.kind === 'frame').map((f) => (f.kind === 'frame' ? f.parsed : f)),
+        message,
+    });
+    if (ackIndex === -1) {
+        return fail(`a matching frame on '${channel}' was observed, but no subscribe \`ack\` was, so it cannot be shown to be the replay.`);
+    }
+    const ackFrame = frames[ackIndex];
+    const ackPayload = ackFrame !== undefined && ackFrame.kind === 'frame' ? ackFrame.parsed['payload'] : undefined;
+    const streamSeq = isRecord(ackPayload) ? ackPayload['streamSeq'] : undefined;
+    if (typeof streamSeq !== 'number') {
+        return fail(`the subscribe \`ack\` carries no numeric \`streamSeq\`, so a frame on '${channel}' cannot be shown to be at or below it.`);
+    }
+    const afterAck = matches.filter((m) => m.index > ackIndex);
+    if (afterAck.length === 0) {
+        return fail(`the only matching frames on '${channel}' arrived before the subscribe's \`ack\`; the replay belongs after it.`);
+    }
+    const replayed = afterAck.find((m) => typeof m.envelope.seq === 'number' && m.envelope.seq <= streamSeq);
+    if (replayed === undefined) {
+        const seqs = afterAck.map((m) => (typeof m.envelope.seq === 'number' ? m.envelope.seq : 'none')).join(', ');
+        return fail(`the matching frames on '${channel}' after the \`ack\` carry seq ${seqs}, none at or below the ack's \`streamSeq\` (${streamSeq}): each is above the ack's \`streamSeq\` (${streamSeq}) or unnumbered, so none is the replay.`);
+    }
     return { kind: 'pass' };
 }
 function matchNoOp(behavior, frames) {

package/dist/n1-compat-conformance/cases/forward-app-theme-carry-uninterpretable.json

@@ -0,0 +1,21 @@
+{
+    "name": "forward-app-theme-carry-uninterpretable",
+    "description": "FORWARD tolerance on the theme CARRY read (ggui#1175, VERSION-POLICY §3.6): a theme GET response for a stored document that fails the carry shape, as a door that names it returns it — `theme: null` beside `uninterpretable`, whose issues carry a path and a protocol-owned code and never a stored value. Today's response schema must accept it, and must read it as a document that is not a theme, never as \"no theme\".",
+    "direction": "forward",
+    "release": {
+        "label": "a later ggui release (synthetic): the theme GET naming an uninterpretable stored document",
+        "sha": "synthetic"
+    },
+    "wire": "app-theme-carry",
+    "payload": {
+        "theme": null,
+        "uninterpretable": {
+            "issueCount": 2,
+            "issues": [
+                { "path": ["overlays", "light", "not-a-ggui-var"], "code": "unknown_key" },
+                { "path": ["mode"], "code": "value_not_allowed" }
+            ]
+        }
+    },
+    "expect": "accepted"
+}