@ggui-ai/protocol-reference-server 0.2.0-alpha.4 → 0.4.0-rc.0

package/README.md

@@ -12,14 +12,24 @@ kit grounds the claim empirically rather than by assertion.
 ## Scope
 
 - WebSocket transport matching the ggui live-channel wire.
-- In-memory render store (no persistence).
+- In-memory render store with a consume-buffer event ledger (no persistence).
 - `schemaVersion` handshake with `UPGRADE_REQUIRED` on mismatch.
-- A 4-handler wired-action registry:
-  - `echo` — returns `{received: args}`.
-  - `throw` — rejects → `TOOL_THREW` emitted on `_ggui:contract-error`.
-  - `timeout` — never resolves → `TOOL_TIMEOUT` after 500ms.
-  - `malformed` — shape-mismatched return → `SCHEMA_VIOLATION`.
-- `TOOL_NOT_FOUND` when an unregistered action is invoked.
+- Subscribe tenancy: the subscribe's `appId` must match the GguiSession's
+  bound `appId` or the subscribe is rejected with an `error` frame, code
+  `APP_MISMATCH` (an unknown session id still provisions on subscribe,
+  binding the subscribe's own `appId`).
+- `host_context_observed` persistence: the client-observed
+  `HostContextProjection` is validated against the protocol shape and
+  persisted onto `GguiSession.hostContext` (idempotent overwrite, no
+  response frame); the conformance host reads it back via
+  `readSessionField('hostContext')`.
+- The single action-routing model:
+  - a declared action appends to the GguiSession's consume buffer and the
+    ack carries `payload.sequence` (validate → append → ack);
+  - a `data:submit` action absent from the declared actionSpec is rejected
+    with an `error` frame, code `CONTRACT_VIOLATION` — nothing is appended.
+- The agent-side drain (`ggui_consume`) is an MCP surface this WS-only
+  server does not implement — a declared kit grading gap.
 
 ## Non-scope
 
@@ -40,6 +50,8 @@ Prints `READY ws://127.0.0.1:3100/ws` when bound. Ctrl-C to stop.
 
 `src/conformance.test.ts` boots this server and runs `@ggui-ai/protocol-conformance`
 against it through a `ConformanceHost` adapter. Every drivable conformance fixture must
-pass (bootstrap-success, wired-action-success, wired-action-tool-threw,
-stream-schema-violation); directives outside this server's scope (renderer-url-override,
-ui-initialize-response-override, and similar) skip cleanly per the kit's design.
+pass (bootstrap-success, action-ack-sequence, undeclared-action-rejected,
+action-payload-schema-violation, version-match, version-mismatch, app-mismatch,
+absent-appid-defaults, host-context-observed-persists); directives outside this server's scope
+(renderer-url-override, ui-initialize-response-override, and similar) skip cleanly per
+the kit's design.

package/dist/action-router.d.ts

@@ -1,47 +1,44 @@
-import type { Render } from './render.js';
-import type { ToolRegistry } from './tool-registry.js';
+import { type GguiSession, type Subscriber } from './render.js';
 /**
- * One inbound action frame shape. Matches the fixtures' authored
- * `inputEnvelope` for `wired-action-*` cases — the runner sends the
- * envelope verbatim. The wire spelling of the render-identity field
- * is normalized to `renderId` by {@link isActionFrame} (it accepts
- * either the canonical `renderId` or the kit's still-legacy
- * `sessionId`).
+ * One inbound action message — the canonical live-channel shape:
+ * `{type: 'action', payload: ActionEnvelope, requestId?}` where the
+ * envelope carries `{sessionId, type, payload?}` and, for
+ * `type: 'data:submit'`, `payload` is the ActionEventValue
+ * (`{action, data?, tool?}`).
  */
-interface IncomingActionFrame {
+interface IncomingActionMessage {
     readonly type: 'action';
-    readonly channel?: number;
-    readonly renderId: string;
-    readonly action: {
-        readonly name: string;
-        readonly data?: unknown;
+    readonly requestId?: string;
+    readonly payload: {
+        readonly sessionId: string;
+        /** Event type, e.g. `'data:submit'`. */
+        readonly type: string;
+        /** ActionEventValue for `data:submit`; free-form otherwise. */
+        readonly payload?: unknown;
     };
 }
 /**
- * Parse + validate an inbound action frame. Returns the normalized
+ * Parse + validate an inbound action message. Returns the normalized
  * shape on success, `undefined` on any malformed input (matcher for
  * `no-op` fixtures expects silence, so loud rejection would break
  * them).
  *
- * Accepts both `renderId` (canonical) and `sessionId` (the kit's
- * legacy spelling that has not yet been migrated); the returned
- * shape always surfaces the value as `renderId`.
+ * Reads the canonical SPEC session-identity field `sessionId` from
+ * the envelope body.
  */
-export declare function parseActionFrame(frame: unknown): IncomingActionFrame | undefined;
-export interface DispatchContext {
-    readonly render: Render;
-    readonly tools: ToolRegistry;
+export declare function parseActionFrame(frame: unknown): IncomingActionMessage | undefined;
+export interface HandleActionContext {
+    readonly render: GguiSession;
+    /** Reply handle for the SENDING socket — acks and contract
+     *  rejections go to the dispatcher, not the broadcast set. */
+    readonly reply: Subscriber;
 }
 /**
- * Dispatch one action frame. Runs asynchronously; contract-error
- * emissions are broadcast to every subscriber on the render via
- * `render.subscribers`.
- *
- * Returns when the dispatch's observable outcome has been emitted
- * (either a happy-path observability frame or a contract-error).
- * The awaiting call site is the WS message handler — letting it
- * await ensures the kit's observation window captures the emission.
+ * Handle one parsed action message: enforce the declared-action
+ * contract, append, ack. Synchronous — the ledger is in-memory, so
+ * the ack ordering is deterministic relative to the inbound message
+ * stream.
  */
-export declare function dispatchAction(frame: IncomingActionFrame, context: DispatchContext): Promise<void>;
+export declare function handleAction(message: IncomingActionMessage, context: HandleActionContext): void;
 export {};
 //# sourceMappingURL=action-router.d.ts.map

package/dist/action-router.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"action-router.d.ts","sourceRoot":"","sources":["../src/action-router.ts"],"names":[],"mappings":"AAiCA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAC1C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAMvD;;;;;;;GAOG;AACH,UAAU,mBAAmB;IAC3B,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE;QACf,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QACtB,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC;KACzB,CAAC;CACH;AAED;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,mBAAmB,GAAG,SAAS,CAwBhF;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC;CAC9B;AAED;;;;;;;;;GASG;AACH,wBAAsB,cAAc,CAClC,KAAK,EAAE,mBAAmB,EAC1B,OAAO,EAAE,eAAe,GACvB,OAAO,CAAC,IAAI,CAAC,CAsIf"}
+{"version":3,"file":"action-router.d.ts","sourceRoot":"","sources":["../src/action-router.ts"],"names":[],"mappings":"AA+BA,OAAO,EAAe,KAAK,WAAW,EAAE,KAAK,UAAU,EAAE,MAAM,aAAa,CAAC;AAE7E;;;;;;GAMG;AACH,UAAU,qBAAqB;IAC7B,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,OAAO,EAAE;QAChB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;QAC3B,wCAAwC;QACxC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QACtB,+DAA+D;QAC/D,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;KAC5B,CAAC;CACH;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,qBAAqB,GAAG,SAAS,CAmBlF;AAED,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;IAC7B;kEAC8D;IAC9D,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC;CAC5B;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAC1B,OAAO,EAAE,qBAAqB,EAC9B,OAAO,EAAE,mBAAmB,GAC3B,IAAI,CAuCN"}

package/dist/action-router.js

@@ -1,308 +1,107 @@
 /**
- * Wired-action dispatcher — consumes an inbound `action` frame and
- * emits the matching `_ggui:contract-error` stream frame (plus happy-
- * path effects) per SPEC §4.4 + Contract #3.
+ * Inbound `action` frame handling — parse the canonical live-channel
+ * action message, enforce the declared actionSpec contract, append the
+ * envelope to the GguiSession's consume-buffer ledger, and ack with
+ * the assigned sequence.
  *
- * This file owns every ContractErrorCode emission path the
- * conformance kit's matcher asserts on:
+ * Ordering contract (mirrors the first-party server): validate →
+ * append → ack. The ack's `payload.sequence` is the wire-observable
+ * proof the action event persisted to the consume buffer — the kit's
+ * `action-ack-sequence` fixture grades exactly this. The retrieval
+ * half (the agent draining the buffer via `ggui_consume`) is an MCP
+ * tool call outside this WS-only server's scope.
  *
- *   - TOOL_NOT_FOUND   — dispatched action's tool is not registered
- *   - TOOL_THREW       — handler throws
- *   - TOOL_TIMEOUT     — handler exceeds `TIMEOUT_MS` (500ms)
- *   - SCHEMA_VIOLATION — handler returns shape not matching declared
- *                        channel schema (currently: `malformed` kind
- *                        always trips this path)
- *
- * Happy-path: echo handler's success return fires an observability
- * signal (kit's `wired-action-success` fixture asserts the router
- * dispatch observably happened). Since observability events are
- * unmatchable-on-ws per the conformance kit's matcher, the
- * happy-path emission here is best-effort: we emit a non-reserved
- * stream frame on `_ggui:wired-tool-invoked` carrying
- * `{toolName, actionName}` so an iframe-host kit can match the same
- * tool invocation signal from either side. Pure WS kit currently
- * treats this as SKIP.
- *
- * Wire-field note: the inbound action frame names the render
- * identity `sessionId` on the wire (consumer field name from
- * `@ggui-ai/protocol-conformance`, which has not yet renamed to
- * `renderId`). The type-guard accepts both spellings and surfaces
- * the value as `renderId` for the rest of the dispatcher.
+ * Contract enforcement: for `type: 'data:submit'` envelopes against a
+ * session WITH a declared actionSpec, the ActionEventValue's `action`
+ * MUST name a declared entry, and — when that entry declares a
+ * `schema` — its `data` MUST conform to it (SPEC §4.6 receipt
+ * validation). Both halves are graded by the protocol's own
+ * `validateActionData`, the same validator the first-party server's
+ * `assertActionContract` enforcement runs, so the two
+ * implementations can never drift on what counts as a violation.
+ * Violations reply an `error` frame with code `CONTRACT_VIOLATION`
+ * (echoing the message's `requestId`, carrying the structured
+ * violation list under `payload.details`) and the envelope is NOT
+ * appended — rejected actions never reach the buffer. Sessions
+ * without a declared actionSpec accept every action: no contract,
+ * nothing to enforce.
  */
-import { makeContractErrorPayload } from '@ggui-ai/protocol';
-/** Timeout the `timeout` handler exceeds; the kit's matcher
- *  recognizes TOOL_TIMEOUT within this window. */
-const TIMEOUT_MS = 500;
+import { ContractViolationError, validateActionData } from '@ggui-ai/protocol';
+import { isRecord } from '@ggui-ai/protocol';
+import { appendEvent } from './render.js';
 /**
- * Parse + validate an inbound action frame. Returns the normalized
+ * Parse + validate an inbound action message. Returns the normalized
  * shape on success, `undefined` on any malformed input (matcher for
  * `no-op` fixtures expects silence, so loud rejection would break
  * them).
  *
- * Accepts both `renderId` (canonical) and `sessionId` (the kit's
- * legacy spelling that has not yet been migrated); the returned
- * shape always surfaces the value as `renderId`.
+ * Reads the canonical SPEC session-identity field `sessionId` from
+ * the envelope body.
  */
 export function parseActionFrame(frame) {
-    if (frame === null || typeof frame !== 'object')
+    if (!isRecord(frame))
         return undefined;
-    const f = frame;
-    if (f['type'] !== 'action')
+    if (frame['type'] !== 'action')
         return undefined;
-    const renderId = typeof f['renderId'] === 'string'
-        ? f['renderId']
-        : typeof f['sessionId'] === 'string'
-            ? f['sessionId']
-            : undefined;
-    if (renderId === undefined)
+    const envelope = frame['payload'];
+    if (!isRecord(envelope))
         return undefined;
-    const action = f['action'];
-    if (action === null || typeof action !== 'object')
+    const sessionId = typeof envelope['sessionId'] === 'string' ? envelope['sessionId'] : undefined;
+    if (sessionId === undefined)
         return undefined;
-    const a = action;
-    const name = a['name'];
-    if (typeof name !== 'string')
+    const eventType = typeof envelope['type'] === 'string' ? envelope['type'] : undefined;
+    if (eventType === undefined)
         return undefined;
-    const data = 'data' in a ? a['data'] : undefined;
-    const channelValue = f['channel'];
+    const requestId = typeof frame['requestId'] === 'string' ? frame['requestId'] : undefined;
     return {
         type: 'action',
-        ...(typeof channelValue === 'number' ? { channel: channelValue } : {}),
-        renderId,
-        action: { name, ...(data !== undefined ? { data } : {}) },
-    };
-}
-/**
- * Dispatch one action frame. Runs asynchronously; contract-error
- * emissions are broadcast to every subscriber on the render via
- * `render.subscribers`.
- *
- * Returns when the dispatch's observable outcome has been emitted
- * (either a happy-path observability frame or a contract-error).
- * The awaiting call site is the WS message handler — letting it
- * await ensures the kit's observation window captures the emission.
- */
-export async function dispatchAction(frame, context) {
-    const { render, tools } = context;
-    const actionName = frame.action.name;
-    // Action → tool resolution, in priority order:
-    //   1. Explicit `register-actionspec` directive on this render.
-    //   2. Tool whose name equals the action name (1:1 convention).
-    //
-    // A real ggui server uses a blueprint's declared `actionSpec` to
-    // bind action names to tool names; the reference server honors the
-    // same binding via the fixture's explicit `register-actionspec`
-    // setup directive. If neither path resolves, emit TOOL_NOT_FOUND
-    // with `toolName = actionName` — the error payload names the
-    // missing tool by the identifier the dispatcher was asked to
-    // resolve, which is the action name itself.
-    const actionSpec = render.actionSpecs.get(actionName);
-    let toolName = actionSpec?.tool;
-    if (toolName === undefined && tools.has(actionName)) {
-        toolName = actionName;
-    }
-    if (toolName === undefined) {
-        emitContractError(render, {
-            code: 'TOOL_NOT_FOUND',
-            toolName: actionName,
-            actionName,
-            message: `no actionSpec bound action '${actionName}' and no tool of that name is registered`,
-        });
-        return;
-    }
-    const tool = tools.get(toolName);
-    if (tool === undefined) {
-        emitContractError(render, {
-            code: 'TOOL_NOT_FOUND',
-            toolName,
-            actionName,
-            message: `tool '${toolName}' is not registered`,
-        });
-        return;
-    }
-    // Malformed handler is defined to return the wrong shape — emit
-    // SCHEMA_VIOLATION instead of passing the bad return through.
-    if (tool.kind === 'malformed') {
-        emitContractError(render, {
-            code: 'SCHEMA_VIOLATION',
-            toolName: tool.name,
-            actionName,
-            message: `tool '${tool.name}' returned a shape that does not match the declared channel schema`,
-        });
-        return;
-    }
-    // Run the handler with a timeout bound. `timeout` kind wins the
-    // timeout race deliberately; other handlers should resolve or
-    // throw well before 500ms.
-    let handlerOutcome;
-    try {
-        handlerOutcome = await Promise.race([
-            (async () => {
-                try {
-                    const value = await tool.handler(frame.action.data);
-                    return { kind: 'resolved', value };
-                }
-                catch (err) {
-                    return {
-                        kind: 'rejected',
-                        error: err instanceof Error ? err : new Error(String(err)),
-                    };
-                }
-            })(),
-            new Promise((done) => {
-                setTimeout(() => done({ kind: 'timeout' }), TIMEOUT_MS);
-            }),
-        ]);
-    }
-    catch (err) {
-        // Promise.race never rejects since we catch inside; defensive.
-        emitContractError(render, {
-            code: 'TOOL_THREW',
-            toolName: tool.name,
-            actionName,
-            message: err.message ?? String(err),
-            causedBy: err.stack?.split('\n').slice(0, 3).join('\n'),
-        });
-        return;
-    }
-    if (handlerOutcome.kind === 'timeout') {
-        emitContractError(render, {
-            code: 'TOOL_TIMEOUT',
-            toolName: tool.name,
-            actionName,
-            message: `tool '${tool.name}' exceeded ${TIMEOUT_MS}ms`,
-        });
-        return;
-    }
-    if (handlerOutcome.kind === 'rejected') {
-        emitContractError(render, {
-            code: 'TOOL_THREW',
-            toolName: tool.name,
-            actionName,
-            message: handlerOutcome.error.message,
-            causedBy: handlerOutcome.error.stack?.split('\n').slice(0, 3).join('\n'),
-        });
-        return;
-    }
-    // Happy path — emit the observability signal so iframe-host kits
-    // can observe it. WS-only kit's matcher will return
-    // `unmatchable-on-ws` for `observability-event`, which the runner
-    // maps to SKIP (not FAIL). That's the intended behavior per the
-    // kit's design note at the top of `match-behavior.ts`.
-    broadcast(render, {
-        type: 'stream',
+        ...(requestId !== undefined ? { requestId } : {}),
         payload: {
-            channel: '_ggui:wired-tool-invoked',
-            value: { toolName: tool.name, actionName },
+            sessionId,
+            type: eventType,
+            ...('payload' in envelope ? { payload: envelope['payload'] } : {}),
         },
-    });
-    // Refresh-stream fan-out (SPEC §2.3 StreamSpec refresh triggers).
-    // After a successful wired-action dispatch, every streamSpec
-    // declared on the render fires its refresh tool and emits a
-    // stream-update on the bound channel. This is the wire-level
-    // proof of the refresh-after-action contract the kit's
-    // `stream-refresh-success` fixture asserts.
-    //
-    // Refresh-tool failures are emitted as contract-errors with
-    // `sourceAction: 'refresh-stream'` so the kit's matcher can
-    // distinguish action-path failures from refresh-path failures
-    // (and so `stream-schema-violation` has a path forward when its
-    // fixture flips off the known-failures list).
-    await dispatchRefreshStreams(render, tools);
+    };
 }
 /**
- * Run every streamSpec's refresh tool and broadcast the result on
- * its bound channel. Errors map to canonical `_ggui:contract-error`
- * envelopes with `sourceAction: 'refresh-stream'`. Sequential
- * dispatch keeps subscriber-frame ordering deterministic — the
- * kit's matcher doesn't depend on order today, but a real ggui
- * runtime emits in declaration order and the reference server
- * preserves that contract.
+ * Handle one parsed action message: enforce the declared-action
+ * contract, append, ack. Synchronous — the ledger is in-memory, so
+ * the ack ordering is deterministic relative to the inbound message
+ * stream.
  */
-async function dispatchRefreshStreams(render, tools) {
-    for (const spec of render.streamSpecs.values()) {
-        const refreshTool = tools.get(spec.tool);
-        if (refreshTool === undefined) {
-            emitContractError(render, {
-                code: 'TOOL_NOT_FOUND',
-                toolName: spec.tool,
-                actionName: spec.channel,
-                message: `streamSpec for channel '${spec.channel}' references tool '${spec.tool}', which is not registered`,
-                sourceActionType: 'refresh-stream',
-            });
-            continue;
-        }
-        if (refreshTool.kind === 'malformed' || refreshTool.kind === 'malformed-stream') {
-            emitContractError(render, {
-                code: 'SCHEMA_VIOLATION',
-                toolName: refreshTool.name,
-                actionName: spec.channel,
-                message: `refresh tool '${refreshTool.name}' returned a shape that does not match channel '${spec.channel}'`,
-                sourceActionType: 'refresh-stream',
+export function handleAction(message, context) {
+    const { render, reply } = context;
+    const requestIdProps = message.requestId !== undefined ? { requestId: message.requestId } : {};
+    if (message.payload.type === 'data:submit' && render.actionSpec !== undefined) {
+        const result = validateActionData(message.payload.payload, render.actionSpec);
+        if (!result.valid) {
+            // Same error construction as the first-party server's
+            // `assertActionContract` path: `ContractViolationError` formats
+            // the violation list into `message` and `toErrorData()` is the
+            // structured `details` payload its `sendError` attaches.
+            const violation = new ContractViolationError({
+                tool: 'ggui_event',
+                violations: result.violations,
             });
-            continue;
-        }
-        let value;
-        try {
-            value = await refreshTool.handler(undefined);
-        }
-        catch (err) {
-            const error = err instanceof Error ? err : new Error(String(err));
-            emitContractError(render, {
-                code: 'TOOL_THREW',
-                toolName: refreshTool.name,
-                actionName: spec.channel,
-                message: error.message,
-                causedBy: error.stack?.split('\n').slice(0, 3).join('\n'),
-                sourceActionType: 'refresh-stream',
+            reply.send({
+                type: 'error',
+                payload: {
+                    code: 'CONTRACT_VIOLATION',
+                    message: violation.message,
+                    details: violation.toErrorData(),
+                },
+                ...requestIdProps,
             });
-            continue;
+            return;
         }
-        broadcast(render, {
-            type: 'stream',
-            payload: {
-                channel: spec.channel,
-                value,
-            },
-        });
     }
-}
-function emitContractError(render, input) {
-    // Canonical SPEC §4.4 `ContractErrorPayload` via the central
-    // builder. Nested `error: {code, message, causedBy}` alongside
-    // flat `toolName` / `actionName` / `sourceAction` / `timestamp`.
-    // The conformance kit's matcher reads this canonical shape
-    // directly — no dual-shape workaround needed.
-    const value = makeContractErrorPayload({
-        toolName: input.toolName,
-        actionName: input.actionName,
-        sourceAction: {
-            type: input.sourceActionType ?? 'wired-action',
-            dispatchedAt: new Date().toISOString(),
-        },
-        error: {
-            code: input.code,
-            message: input.message,
-            ...(input.causedBy !== undefined ? { causedBy: input.causedBy } : {}),
-        },
-        timestamp: new Date().toISOString(),
+    const sequence = appendEvent(render, {
+        type: 'user.submitted',
+        data: message.payload,
     });
-    broadcast(render, {
-        type: 'stream',
-        payload: {
-            channel: '_ggui:contract-error',
-            value,
-        },
+    reply.send({
+        type: 'ack',
+        payload: { sequence, timestamp: Date.now() },
+        ...requestIdProps,
     });
 }
-function broadcast(render, frame) {
-    for (const subscriber of render.subscribers) {
-        try {
-            subscriber.send(frame);
-        }
-        catch {
-            // Subscriber lifecycle issues (closed socket, etc.) are the
-            // subscriber's problem — the router keeps broadcasting.
-        }
-    }
-}

package/dist/conformance-host.d.ts

@@ -1,33 +1,3 @@
-/**
- * `ConformanceHost` adapter — wires the `@ggui-ai/protocol-conformance`
- * setup/teardown directive dispatcher onto this package's
- * `ReferenceServer` instance.
- *
- * Directives split into "implement" and "throw":
- *
- *   Implement:
- *     - create-render             → `renders.create()`
- *     - register-tool             → `tools.register(name, handler)`
- *     - register-actionspec       → `renders.registerActionSpec()`
- *     - register-streamspec       → `renders.registerStreamSpec()`
- *     - server-version-override   → `renders.setVersionOverride()`
- *     - emit-envelope             → `renders.injectFrame()`
- *     - unregister-tool           → `tools.unregister()`
- *
- *   Throw (kit records SKIP, not FAIL):
- *     - seed-channel              — unimplemented
- *     - renderer-url-override     — unimplemented (browser-level)
- *     - ui-initialize-response-override — unimplemented
- *
- * The "throw" set matches the conformance kit's `unmatchable-on-ws`
- * skip expectations — browser-level fault injection that requires a
- * richer host harness. Throwing surfaces "directive not implemented"
- * with the error message as the skip reason.
- *
- * Note: render-termination directive (`close-render`) is intentionally
- * absent — render lifecycle is implicit (created → active → TTL-expired);
- * there is no agent-facing close tool, and no kit directive to invoke.
- */
 import type { ConformanceHost } from '@ggui-ai/protocol-conformance';
 import type { ReferenceServer } from './server.js';
 export interface CreateReferenceConformanceHostInput {
@@ -39,8 +9,8 @@ export interface CreateReferenceConformanceHostInput {
  * drive the kit against the server.
  *
  * The server MUST be `start()`-ed before the first dispatch — the
- * kit calls `create-render` via `dispatchSetup` before any subscribe,
- * so the render store must be reachable. The caller owns the
+ * kit calls `create-session` via `dispatchSetup` before any subscribe,
+ * so the GguiSession store must be reachable. The caller owns the
  * server lifecycle (`start()` + `stop()`).
  */
 export declare function createReferenceConformanceHost({ serverInstance, }: CreateReferenceConformanceHostInput): ConformanceHost;

package/dist/conformance-host.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"conformance-host.d.ts","sourceRoot":"","sources":["../src/conformance-host.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,OAAO,KAAK,EACV,eAAe,EAMhB,MAAM,+BAA+B,CAAC;AAEvC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAEnD,MAAM,WAAW,mCAAmC;IAClD,QAAQ,CAAC,cAAc,EAAE,eAAe,CAAC;CAC1C;AAED;;;;;;;;;GASG;AACH,wBAAgB,8BAA8B,CAAC,EAC7C,cAAc,GACf,EAAE,mCAAmC,GAAG,eAAe,CAmNvD"}
+{"version":3,"file":"conformance-host.d.ts","sourceRoot":"","sources":["../src/conformance-host.ts"],"names":[],"mappings":"AAmDA,OAAO,KAAK,EACV,eAAe,EAEhB,MAAM,+BAA+B,CAAC;AAGvC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAEnD,MAAM,WAAW,mCAAmC;IAClD,QAAQ,CAAC,cAAc,EAAE,eAAe,CAAC;CAC1C;AAED;;;;;;;;;GASG;AACH,wBAAgB,8BAA8B,CAAC,EAC7C,cAAc,GACf,EAAE,mCAAmC,GAAG,eAAe,CA0IvD"}