@ggui-ai/protocol-reference-server 0.1.0-rc.1 → 0.2.0-alpha.1

package/README.md

@@ -12,7 +12,7 @@ kit grounds the claim empirically rather than by assertion.
 ## Scope
 
 - WebSocket transport matching the ggui live-channel wire.
-- In-memory session store (no persistence).
+- In-memory render store (no persistence).
 - `schemaVersion` handshake with `UPGRADE_REQUIRED` on mismatch.
 - A 4-handler wired-action registry:
   - `echo` — returns `{received: args}`.

package/dist/action-router.d.ts

@@ -1,34 +1,41 @@
-import type { Session } from './session.js';
+import type { Render } from './render.js';
 import type { ToolRegistry } from './tool-registry.js';
 /**
  * One inbound action frame shape. Matches the fixtures' authored
  * `inputEnvelope` for `wired-action-*` cases — the runner sends the
- * envelope verbatim.
+ * 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`).
  */
 interface IncomingActionFrame {
     readonly type: 'action';
     readonly channel?: number;
-    readonly sessionId: string;
+    readonly renderId: string;
     readonly action: {
         readonly name: string;
         readonly data?: unknown;
     };
 }
 /**
- * Type-guard the action frame shape before dispatching. Anything
- * malformed is dropped with a `no-op` warning — the matcher for
+ * Parse + validate an inbound action frame. Returns the normalized
+ * shape on success, `undefined` on any malformed input (matcher for
  * `no-op` fixtures expects silence, so loud rejection would break
- * them.
+ * 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`.
  */
-export declare function isActionFrame(frame: unknown): frame is IncomingActionFrame;
+export declare function parseActionFrame(frame: unknown): IncomingActionFrame | undefined;
 export interface DispatchContext {
-    readonly session: Session;
+    readonly render: Render;
     readonly tools: ToolRegistry;
 }
 /**
  * Dispatch one action frame. Runs asynchronously; contract-error
- * emissions are broadcast to every subscriber on the session via
- * `session.subscribers`.
+ * 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).

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

@@ -1 +1 @@
-{"version":3,"file":"action-router.d.ts","sourceRoot":"","sources":["../src/action-router.ts"],"names":[],"mappings":"AA2BA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAC5C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAMvD;;;;GAIG;AACH,UAAU,mBAAmB;IAC3B,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,MAAM,EAAE;QACf,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QACtB,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC;KACzB,CAAC;CACH;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,mBAAmB,CAS1E;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,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":"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"}

package/dist/action-router.js

@@ -22,35 +22,60 @@
  * `{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.
  */
 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;
 /**
- * Type-guard the action frame shape before dispatching. Anything
- * malformed is dropped with a `no-op` warning — the matcher for
+ * Parse + validate an inbound action frame. Returns the normalized
+ * shape on success, `undefined` on any malformed input (matcher for
  * `no-op` fixtures expects silence, so loud rejection would break
- * them.
+ * 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`.
  */
-export function isActionFrame(frame) {
+export function parseActionFrame(frame) {
     if (frame === null || typeof frame !== 'object')
-        return false;
+        return undefined;
     const f = frame;
     if (f['type'] !== 'action')
-        return false;
-    if (typeof f['sessionId'] !== 'string')
-        return false;
+        return undefined;
+    const renderId = typeof f['renderId'] === 'string'
+        ? f['renderId']
+        : typeof f['sessionId'] === 'string'
+            ? f['sessionId']
+            : undefined;
+    if (renderId === undefined)
+        return undefined;
     const action = f['action'];
     if (action === null || typeof action !== 'object')
-        return false;
+        return undefined;
     const a = action;
-    return typeof a['name'] === 'string';
+    const name = a['name'];
+    if (typeof name !== 'string')
+        return undefined;
+    const data = 'data' in a ? a['data'] : undefined;
+    const channelValue = f['channel'];
+    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 session via
- * `session.subscribers`.
+ * 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).
@@ -58,10 +83,10 @@ export function isActionFrame(frame) {
  * await ensures the kit's observation window captures the emission.
  */
 export async function dispatchAction(frame, context) {
-    const { session, tools } = context;
+    const { render, tools } = context;
     const actionName = frame.action.name;
     // Action → tool resolution, in priority order:
-    //   1. Explicit `register-actionspec` directive on this session.
+    //   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
@@ -71,13 +96,13 @@ export async function dispatchAction(frame, context) {
     // 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 = session.actionSpecs.get(actionName);
+    const actionSpec = render.actionSpecs.get(actionName);
     let toolName = actionSpec?.tool;
     if (toolName === undefined && tools.has(actionName)) {
         toolName = actionName;
     }
     if (toolName === undefined) {
-        emitContractError(session, {
+        emitContractError(render, {
             code: 'TOOL_NOT_FOUND',
             toolName: actionName,
             actionName,
@@ -87,7 +112,7 @@ export async function dispatchAction(frame, context) {
     }
     const tool = tools.get(toolName);
     if (tool === undefined) {
-        emitContractError(session, {
+        emitContractError(render, {
             code: 'TOOL_NOT_FOUND',
             toolName,
             actionName,
@@ -98,7 +123,7 @@ export async function dispatchAction(frame, context) {
     // Malformed handler is defined to return the wrong shape — emit
     // SCHEMA_VIOLATION instead of passing the bad return through.
     if (tool.kind === 'malformed') {
-        emitContractError(session, {
+        emitContractError(render, {
             code: 'SCHEMA_VIOLATION',
             toolName: tool.name,
             actionName,
@@ -131,7 +156,7 @@ export async function dispatchAction(frame, context) {
     }
     catch (err) {
         // Promise.race never rejects since we catch inside; defensive.
-        emitContractError(session, {
+        emitContractError(render, {
             code: 'TOOL_THREW',
             toolName: tool.name,
             actionName,
@@ -141,7 +166,7 @@ export async function dispatchAction(frame, context) {
         return;
     }
     if (handlerOutcome.kind === 'timeout') {
-        emitContractError(session, {
+        emitContractError(render, {
             code: 'TOOL_TIMEOUT',
             toolName: tool.name,
             actionName,
@@ -150,7 +175,7 @@ export async function dispatchAction(frame, context) {
         return;
     }
     if (handlerOutcome.kind === 'rejected') {
-        emitContractError(session, {
+        emitContractError(render, {
             code: 'TOOL_THREW',
             toolName: tool.name,
             actionName,
@@ -164,7 +189,7 @@ export async function dispatchAction(frame, context) {
     // `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(session, {
+    broadcast(render, {
         type: 'stream',
         payload: {
             channel: '_ggui:wired-tool-invoked',
@@ -173,7 +198,7 @@ export async function dispatchAction(frame, context) {
     });
     // Refresh-stream fan-out (SPEC §2.3 StreamSpec refresh triggers).
     // After a successful wired-action dispatch, every streamSpec
-    // declared on the session fires its refresh tool and emits a
+    // 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.
@@ -183,7 +208,7 @@ export async function dispatchAction(frame, context) {
     // 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(session, tools);
+    await dispatchRefreshStreams(render, tools);
 }
 /**
  * Run every streamSpec's refresh tool and broadcast the result on
@@ -194,11 +219,11 @@ export async function dispatchAction(frame, context) {
  * runtime emits in declaration order and the reference server
  * preserves that contract.
  */
-async function dispatchRefreshStreams(session, tools) {
-    for (const spec of session.streamSpecs.values()) {
+async function dispatchRefreshStreams(render, tools) {
+    for (const spec of render.streamSpecs.values()) {
         const refreshTool = tools.get(spec.tool);
         if (refreshTool === undefined) {
-            emitContractError(session, {
+            emitContractError(render, {
                 code: 'TOOL_NOT_FOUND',
                 toolName: spec.tool,
                 actionName: spec.channel,
@@ -208,7 +233,7 @@ async function dispatchRefreshStreams(session, tools) {
             continue;
         }
         if (refreshTool.kind === 'malformed' || refreshTool.kind === 'malformed-stream') {
-            emitContractError(session, {
+            emitContractError(render, {
                 code: 'SCHEMA_VIOLATION',
                 toolName: refreshTool.name,
                 actionName: spec.channel,
@@ -223,7 +248,7 @@ async function dispatchRefreshStreams(session, tools) {
         }
         catch (err) {
             const error = err instanceof Error ? err : new Error(String(err));
-            emitContractError(session, {
+            emitContractError(render, {
                 code: 'TOOL_THREW',
                 toolName: refreshTool.name,
                 actionName: spec.channel,
@@ -233,7 +258,7 @@ async function dispatchRefreshStreams(session, tools) {
             });
             continue;
         }
-        broadcast(session, {
+        broadcast(render, {
             type: 'stream',
             payload: {
                 channel: spec.channel,
@@ -242,7 +267,7 @@ async function dispatchRefreshStreams(session, tools) {
         });
     }
 }
-function emitContractError(session, input) {
+function emitContractError(render, input) {
     // Canonical SPEC §4.4 `ContractErrorPayload` via the central
     // builder. Nested `error: {code, message, causedBy}` alongside
     // flat `toolName` / `actionName` / `sourceAction` / `timestamp`.
@@ -262,7 +287,7 @@ function emitContractError(session, input) {
         },
         timestamp: new Date().toISOString(),
     });
-    broadcast(session, {
+    broadcast(render, {
         type: 'stream',
         payload: {
             channel: '_ggui:contract-error',
@@ -270,8 +295,8 @@ function emitContractError(session, input) {
         },
     });
 }
-function broadcast(session, frame) {
-    for (const subscriber of session.subscribers) {
+function broadcast(render, frame) {
+    for (const subscriber of render.subscribers) {
         try {
             subscriber.send(frame);
         }

package/dist/conformance-host.d.ts

@@ -6,13 +6,12 @@
  * Directives split into "implement" and "throw":
  *
  *   Implement:
- *     - create-session            → `sessions.create()`
+ *     - create-render             → `renders.create()`
  *     - register-tool             → `tools.register(name, handler)`
- *     - register-actionspec       → `sessions.registerActionSpec()`
- *     - register-streamspec       → `sessions.registerStreamSpec()`
- *     - server-version-override   → `sessions.setVersionOverride()`
- *     - emit-envelope             → `sessions.injectFrame()`
- *     - close-session             → `sessions.close()`
+ *     - 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):
@@ -24,6 +23,10 @@
  * 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';
@@ -36,8 +39,8 @@ export interface CreateReferenceConformanceHostInput {
  * drive the kit against the server.
  *
  * The server MUST be `start()`-ed before the first dispatch — the
- * kit calls `create-session` via `dispatchSetup` before any subscribe,
- * so the session store must be reachable. The caller owns the
+ * kit calls `create-render` via `dispatchSetup` before any subscribe,
+ * so the render 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;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,OAAO,KAAK,EAEV,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,CAwNvD"}
+{"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"}

package/dist/conformance-host.js

@@ -4,8 +4,8 @@
  * drive the kit against the server.
  *
  * The server MUST be `start()`-ed before the first dispatch — the
- * kit calls `create-session` via `dispatchSetup` before any subscribe,
- * so the session store must be reachable. The caller owns the
+ * kit calls `create-render` via `dispatchSetup` before any subscribe,
+ * so the render store must be reachable. The caller owns the
  * server lifecycle (`start()` + `stop()`).
  */
 export function createReferenceConformanceHost({ serverInstance, }) {
@@ -14,9 +14,9 @@ export function createReferenceConformanceHost({ serverInstance, }) {
             // Discriminant-narrow via explicit casts — the extensibly-closed
             // `HostUnknownSetupStep` arm (`kind: string & {}`) widens the
             // discriminant and blocks literal-narrowing on the union.
-            if (step.kind === 'create-session') {
+            if (step.kind === 'create-render') {
                 const s = step;
-                serverInstance.sessions.create(s.sessionId, s.appId ?? 'conformance');
+                serverInstance.renders.create(s.renderId, s.appId ?? 'conformance');
                 return;
             }
             if (step.kind === 'register-tool') {
@@ -35,16 +35,16 @@ export function createReferenceConformanceHost({ serverInstance, }) {
             }
             if (step.kind === 'register-actionspec') {
                 const s = step;
-                // register-actionspec doesn't carry a sessionId in the
+                // register-actionspec doesn't carry a renderId in the
                 // directive shape — it's scoped to the most-recently-created
-                // session, matching the fixture-authoring convention that
-                // create-session → register-tool → register-actionspec all
-                // land in order on the same session.
-                const lastSession = serverInstance.sessions.lastCreatedSessionId();
-                if (lastSession === undefined) {
-                    throw new Error('reference-server: register-actionspec invoked before create-session — no session scope to bind to');
+                // render, matching the fixture-authoring convention that
+                // create-render → register-tool → register-actionspec all
+                // land in order on the same render.
+                const lastRenderId = serverInstance.renders.lastCreatedRenderId();
+                if (lastRenderId === undefined) {
+                    throw new Error('reference-server: register-actionspec invoked before create-render — no render scope to bind to');
                 }
-                serverInstance.sessions.registerActionSpec(lastSession, {
+                serverInstance.renders.registerActionSpec(lastRenderId, {
                     name: s.name,
                     tool: s.tool,
                 });
@@ -58,7 +58,7 @@ export function createReferenceConformanceHost({ serverInstance, }) {
                 // Slice I refresh-stream support); the runtime shape is
                 // narrowed locally, matching the same convention as the
                 // pre-existing `register-tool` branch above. Same most-
-                // recently-created session scoping as register-actionspec.
+                // recently-created render scoping as register-actionspec.
                 const raw = step;
                 if (typeof raw.channel !== 'string' || raw.channel.length === 0) {
                     throw new Error(`register-streamspec directive missing channel: ${JSON.stringify(step)}`);
@@ -66,11 +66,11 @@ export function createReferenceConformanceHost({ serverInstance, }) {
                 if (typeof raw.tool !== 'string' || raw.tool.length === 0) {
                     throw new Error(`register-streamspec directive missing tool: ${JSON.stringify(step)}`);
                 }
-                const lastSession = serverInstance.sessions.lastCreatedSessionId();
-                if (lastSession === undefined) {
-                    throw new Error('reference-server: register-streamspec invoked before create-session — no session scope to bind to');
+                const lastRenderId = serverInstance.renders.lastCreatedRenderId();
+                if (lastRenderId === undefined) {
+                    throw new Error('reference-server: register-streamspec invoked before create-render — no render scope to bind to');
                 }
-                serverInstance.sessions.registerStreamSpec(lastSession, {
+                serverInstance.renders.registerStreamSpec(lastRenderId, {
                     channel: raw.channel,
                     tool: raw.tool,
                 });
@@ -78,11 +78,11 @@ export function createReferenceConformanceHost({ serverInstance, }) {
             }
             if (step.kind === 'emit-envelope') {
                 // The directive carries `channel` + `payload` but no
-                // sessionId — it's scoped to the most-recently-created
-                // session, matching the same fixture-authoring convention as
+                // renderId — it's scoped to the most-recently-created
+                // render, matching the same fixture-authoring convention as
                 // register-actionspec / register-streamspec / server-version-
                 // override (the kit's `narrowSetupStep` is a flat `type → kind`
-                // rename pass-through, so any sessionId on the directive JSON
+                // rename pass-through, so any renderId on the directive JSON
                 // would survive, but the canonical EmitEnvelopeSetup shape
                 // doesn't declare one).
                 //
@@ -98,11 +98,11 @@ export function createReferenceConformanceHost({ serverInstance, }) {
                 if (typeof s.channel !== 'string' || s.channel.length === 0) {
                     throw new Error(`emit-envelope directive missing channel: ${JSON.stringify(step)}`);
                 }
-                const lastSession = serverInstance.sessions.lastCreatedSessionId();
-                if (lastSession === undefined) {
-                    throw new Error('reference-server: emit-envelope invoked before create-session — no session scope to bind to');
+                const lastRenderId = serverInstance.renders.lastCreatedRenderId();
+                if (lastRenderId === undefined) {
+                    throw new Error('reference-server: emit-envelope invoked before create-render — no render scope to bind to');
                 }
-                const fanned = serverInstance.sessions.injectFrame(lastSession, {
+                const fanned = serverInstance.renders.injectFrame(lastRenderId, {
                     type: 'stream',
                     payload: {
                         channel: s.channel,
@@ -112,12 +112,12 @@ export function createReferenceConformanceHost({ serverInstance, }) {
                 if (!fanned) {
                     // No subscribers attached — the directive's emission is
                     // unobservable. Surface for fixture-authoring debuggability
-                    // (the canonical sequence is create-session → subscribe →
+                    // (the canonical sequence is create-render → subscribe →
                     // emit-envelope; fixtures that swap order silently lose the
                     // injection). Not a throw — the directive itself succeeded;
                     // the unobservability is a fixture concern.
                     // eslint-disable-next-line no-console
-                    console.warn(`[@ggui-ai/protocol-reference-server] emit-envelope on session '${lastSession}' channel '${s.channel}' had no subscribers — frame dropped`);
+                    console.warn(`[@ggui-ai/protocol-reference-server] emit-envelope on render '${lastRenderId}' channel '${s.channel}' had no subscribers — frame dropped`);
                 }
                 return;
             }
@@ -141,21 +141,21 @@ export function createReferenceConformanceHost({ serverInstance, }) {
                 if (typeof advertise !== 'string' || advertise.length === 0) {
                     throw new Error(`server-version-override directive missing advertiseVersion/version: ${JSON.stringify(step)}`);
                 }
-                // Same most-recently-created session scope as register-
+                // Same most-recently-created render scope as register-
                 // actionspec / register-streamspec — the fixture authoring
-                // convention is `create-session` immediately precedes this
+                // convention is `create-render` immediately precedes this
                 // directive, and the kit's narrowSetupStep doesn't surface a
-                // sessionId on the directive object even when the fixture
+                // renderId on the directive object even when the fixture
                 // JSON includes one (only `type → kind` is renamed; the rest
-                // is a flat passthrough, so a `sessionId` field WOULD survive
+                // is a flat passthrough, so a `renderId` field WOULD survive
                 // — but the canonical ServerVersionOverrideSetup type doesn't
                 // declare one, so fixtures may omit it. Falling back to
-                // `lastCreatedSessionId()` keeps the host robust to either.
-                const lastSession = serverInstance.sessions.lastCreatedSessionId();
-                if (lastSession === undefined) {
-                    throw new Error('reference-server: server-version-override invoked before create-session — no session scope to bind to');
+                // `lastCreatedRenderId()` keeps the host robust to either.
+                const lastRenderId = serverInstance.renders.lastCreatedRenderId();
+                if (lastRenderId === undefined) {
+                    throw new Error('reference-server: server-version-override invoked before create-render — no render scope to bind to');
                 }
-                serverInstance.sessions.setVersionOverride(lastSession, advertise);
+                serverInstance.renders.setVersionOverride(lastRenderId, advertise);
                 return;
             }
             // Unknown kind — extensibly-closed. Throw so the kit records
@@ -164,11 +164,6 @@ export function createReferenceConformanceHost({ serverInstance, }) {
             throw new Error(`reference server does not implement setup kind '${String(unknownKind)}'`);
         },
         async dispatchTeardown(step) {
-            if (step.kind === 'close-session') {
-                const s = step;
-                serverInstance.sessions.close(s.sessionId);
-                return;
-            }
             if (step.kind === 'unregister-tool') {
                 // Same toolName/name tolerance as register-tool.
                 const raw = step;

package/dist/{session.d.ts → render.d.ts}

@@ -1,14 +1,21 @@
 /**
- * In-memory session store for the reference server.
+ * In-memory render store for the reference server.
  *
- * Sessions are ephemeral and process-local — this is the whole
+ * Renders are ephemeral and process-local — this is the whole
  * point of the reference server. Persistence is explicitly out of
  * scope. Restart drops state; that's documented behavior, not a TODO.
  *
- * Each session carries an actionSpec map that the `register-actionspec`
+ * Each render carries an actionSpec map that the `register-actionspec`
  * ConformanceHost directive populates. The action router
  * (`./action-router.ts`) consults this map at dispatch time to
  * resolve action-name → tool-name → handler.
+ *
+ * Wire-shape note: the conformance kit drives the reference server
+ * over the SPEC §12.2 wire using the field name `sessionId` (its
+ * fixture catalog has not yet been migrated to the canonical
+ * `renderId`). The reference server READS that wire field and binds
+ * it to a `renderId` internally — the value is a render identity
+ * regardless of which spelling the consumer sends.
  */
 /**
  * Actionspec entry maps an action name (the value wired into DOM
@@ -31,7 +38,7 @@ export interface ActionSpecEntry {
  *
  * Reference-server scope: refresh-tool invocation is unconditional
  * — every successful wired-action dispatch fans out through every
- * registered streamSpec for the session. Real ggui servers may
+ * registered streamSpec for the render. Real ggui servers may
  * filter by which actions touch which channels; the reference
  * server's narrower contract is "any successful action triggers all
  * declared refreshes", which is sufficient for the kit's
@@ -42,14 +49,14 @@ export interface StreamSpecEntry {
     readonly channel: string;
     readonly tool: string;
 }
-export interface Session {
-    readonly sessionId: string;
+export interface Render {
+    readonly renderId: string;
     readonly appId: string;
     readonly actionSpecs: Map<string, ActionSpecEntry>;
     readonly streamSpecs: Map<string, StreamSpecEntry>;
     readonly subscribers: Set<Subscriber>;
     /**
-     * Per-session protocol-version override. When set, the WS subscribe
+     * Per-render protocol-version override. When set, the WS subscribe
      * + UPGRADE_REQUIRED paths advertise this value in place of the
      * server-instance-level `versionOverride`.
      *
@@ -58,9 +65,9 @@ export interface Session {
      * `server-version-override` setup directive in the conformance host
      * adapter — production code paths leave this `undefined`.
      *
-     * Why per-session, not per-instance: parallel kit fixtures share
+     * Why per-render, not per-instance: parallel kit fixtures share
      * one `ReferenceServer`. Mutating the instance-level override would
-     * leak across sessions; the per-session field scopes the mismatch
+     * leak across renders; the per-render field scopes the mismatch
      * to the one fixture that asked for it.
      */
     versionOverride?: string;
@@ -74,59 +81,59 @@ export interface Subscriber {
     send(frame: unknown): void;
 }
 /**
- * In-memory session store. Wraps a `Map<sessionId, Session>` with
+ * In-memory render store. Wraps a `Map<renderId, Render>` with
  * the operations the ConformanceHost adapter + WS subscribe handler
  * need. No locking — JS single-threaded; all calls originate from
  * the event loop.
  */
-export declare class SessionStore {
-    private readonly sessions;
+export declare class RenderStore {
+    private readonly renders;
     private lastCreated;
-    create(sessionId: string, appId: string): Session;
+    create(renderId: string, appId: string): Render;
     /**
-     * The sessionId most recently passed to `create()`. Used by the
+     * The renderId most recently passed to `create()`. Used by the
      * ConformanceHost's `register-actionspec` dispatcher — that
-     * directive doesn't carry a sessionId in its JSON shape, so the
+     * directive doesn't carry a renderId in its JSON shape, so the
      * adapter needs the "most recently created" scope to bind the
      * actionspec to. This matches the fixture-authoring convention that
-     * create-session always precedes register-actionspec.
+     * create-render always precedes register-actionspec.
      */
-    lastCreatedSessionId(): string | undefined;
-    get(sessionId: string): Session | undefined;
-    close(sessionId: string): boolean;
-    addSubscriber(sessionId: string, subscriber: Subscriber): Session;
-    removeSubscriber(sessionId: string, subscriber: Subscriber): void;
-    registerActionSpec(sessionId: string, entry: ActionSpecEntry): void;
+    lastCreatedRenderId(): string | undefined;
+    get(renderId: string): Render | undefined;
+    close(renderId: string): boolean;
+    addSubscriber(renderId: string, subscriber: Subscriber): Render;
+    removeSubscriber(renderId: string, subscriber: Subscriber): void;
+    registerActionSpec(renderId: string, entry: ActionSpecEntry): void;
     /**
      * Register a stream channel ↔ refresh-tool binding on the named
-     * session. Same "create-if-missing" semantics as
+     * render. Same "create-if-missing" semantics as
      * {@link registerActionSpec} so the ConformanceHost adapter can
      * dispatch this directive before subscribe lands. Keyed by
      * `entry.channel` — registering the same channel twice replaces
      * the prior binding, matching the action-spec map's behavior.
      */
-    registerStreamSpec(sessionId: string, entry: StreamSpecEntry): void;
+    registerStreamSpec(renderId: string, entry: StreamSpecEntry): void;
     /**
-     * Set the per-session protocol-version override. Used by the
+     * Set the per-render protocol-version override. Used by the
      * `server-version-override` ConformanceHost directive — populates
-     * {@link Session.versionOverride} so the WS subscribe handler
+     * {@link Render.versionOverride} so the WS subscribe handler
      * advertises this value (and emits UPGRADE_REQUIRED keyed off it)
-     * for THIS session only, leaving parallel sessions on the instance-
+     * for THIS render only, leaving parallel renders on the instance-
      * level default.
      *
      * Same "create-if-missing" semantics as the other register* setters
      * so directive ordering relative to subscribe doesn't matter.
      */
-    setVersionOverride(sessionId: string, version: string): void;
+    setVersionOverride(renderId: string, version: string): void;
     /**
-     * Fan out a frame to every subscriber on the named session. Used by
+     * Fan out a frame to every subscriber on the named render. Used by
      * the `emit-envelope` ConformanceHost directive — kit fixtures use
      * it to inject WS-observable side-effects (envelopes the server
      * would not normally emit on its own) so the kit can assert
      * downstream consequences (sequencing, fan-out, observability).
      *
-     * Returns `true` if the session existed and at least one subscriber
-     * received the frame; `false` if the session is unknown OR has no
+     * Returns `true` if the render existed and at least one subscriber
+     * received the frame; `false` if the render is unknown OR has no
      * subscribers attached. Caller may use the boolean to log a warning
      * when a fixture's directive-injection lands before any subscribe
      * — the directive then has no observable effect, which is usually
@@ -137,6 +144,6 @@ export declare class SessionStore {
      * `broadcast()` — one bad subscriber must not block fan-out to the
      * rest.
      */
-    injectFrame(sessionId: string, frame: unknown): boolean;
+    injectFrame(renderId: string, frame: unknown): boolean;
 }
-//# sourceMappingURL=session.d.ts.map
+//# sourceMappingURL=render.d.ts.map

package/dist/render.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"render.d.ts","sourceRoot":"","sources":["../src/render.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH;;;;;GAKG;AACH,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,MAAM;IACrB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;IACnD,QAAQ,CAAC,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;IACnD,QAAQ,CAAC,WAAW,EAAE,GAAG,CAAC,UAAU,CAAC,CAAC;IACtC;;;;;;;;;;;;;;OAcG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED;;;;GAIG;AACH,MAAM,WAAW,UAAU;IACzB,IAAI,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,CAAC;CAC5B;AAED;;;;;GAKG;AACH,qBAAa,WAAW;IACtB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA6B;IACrD,OAAO,CAAC,WAAW,CAAqB;IAExC,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM;IAkB/C;;;;;;;OAOG;IACH,mBAAmB,IAAI,MAAM,GAAG,SAAS;IAIzC,GAAG,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAIzC,KAAK,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAIhC,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,UAAU,GAAG,MAAM;IAM/D,gBAAgB,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,UAAU,GAAG,IAAI;IAMhE,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,eAAe,GAAG,IAAI;IAKlE;;;;;;;OAOG;IACH,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,eAAe,GAAG,IAAI;IAKlE;;;;;;;;;;OAUG;IACH,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI;IAK3D;;;;;;;;;;;;;;;;;;OAkBG;IACH,WAAW,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO;CAcvD"}

package/dist/{session.js → render.js}

@@ -1,109 +1,116 @@
 /**
- * In-memory session store for the reference server.
+ * In-memory render store for the reference server.
  *
- * Sessions are ephemeral and process-local — this is the whole
+ * Renders are ephemeral and process-local — this is the whole
  * point of the reference server. Persistence is explicitly out of
  * scope. Restart drops state; that's documented behavior, not a TODO.
  *
- * Each session carries an actionSpec map that the `register-actionspec`
+ * Each render carries an actionSpec map that the `register-actionspec`
  * ConformanceHost directive populates. The action router
  * (`./action-router.ts`) consults this map at dispatch time to
  * resolve action-name → tool-name → handler.
+ *
+ * Wire-shape note: the conformance kit drives the reference server
+ * over the SPEC §12.2 wire using the field name `sessionId` (its
+ * fixture catalog has not yet been migrated to the canonical
+ * `renderId`). The reference server READS that wire field and binds
+ * it to a `renderId` internally — the value is a render identity
+ * regardless of which spelling the consumer sends.
  */
 /**
- * In-memory session store. Wraps a `Map<sessionId, Session>` with
+ * In-memory render store. Wraps a `Map<renderId, Render>` with
  * the operations the ConformanceHost adapter + WS subscribe handler
  * need. No locking — JS single-threaded; all calls originate from
  * the event loop.
  */
-export class SessionStore {
-    sessions = new Map();
+export class RenderStore {
+    renders = new Map();
     lastCreated;
-    create(sessionId, appId) {
-        const existing = this.sessions.get(sessionId);
+    create(renderId, appId) {
+        const existing = this.renders.get(renderId);
         if (existing !== undefined) {
-            this.lastCreated = sessionId;
+            this.lastCreated = renderId;
             return existing;
         }
-        const session = {
-            sessionId,
+        const render = {
+            renderId,
             appId,
             actionSpecs: new Map(),
             streamSpecs: new Map(),
             subscribers: new Set(),
         };
-        this.sessions.set(sessionId, session);
-        this.lastCreated = sessionId;
-        return session;
+        this.renders.set(renderId, render);
+        this.lastCreated = renderId;
+        return render;
     }
     /**
-     * The sessionId most recently passed to `create()`. Used by the
+     * The renderId most recently passed to `create()`. Used by the
      * ConformanceHost's `register-actionspec` dispatcher — that
-     * directive doesn't carry a sessionId in its JSON shape, so the
+     * directive doesn't carry a renderId in its JSON shape, so the
      * adapter needs the "most recently created" scope to bind the
      * actionspec to. This matches the fixture-authoring convention that
-     * create-session always precedes register-actionspec.
+     * create-render always precedes register-actionspec.
      */
-    lastCreatedSessionId() {
+    lastCreatedRenderId() {
         return this.lastCreated;
     }
-    get(sessionId) {
-        return this.sessions.get(sessionId);
+    get(renderId) {
+        return this.renders.get(renderId);
     }
-    close(sessionId) {
-        return this.sessions.delete(sessionId);
+    close(renderId) {
+        return this.renders.delete(renderId);
     }
-    addSubscriber(sessionId, subscriber) {
-        const session = this.create(sessionId, 'conformance');
-        session.subscribers.add(subscriber);
-        return session;
+    addSubscriber(renderId, subscriber) {
+        const render = this.create(renderId, 'conformance');
+        render.subscribers.add(subscriber);
+        return render;
     }
-    removeSubscriber(sessionId, subscriber) {
-        const session = this.sessions.get(sessionId);
-        if (session === undefined)
+    removeSubscriber(renderId, subscriber) {
+        const render = this.renders.get(renderId);
+        if (render === undefined)
             return;
-        session.subscribers.delete(subscriber);
+        render.subscribers.delete(subscriber);
     }
-    registerActionSpec(sessionId, entry) {
-        const session = this.create(sessionId, 'conformance');
-        session.actionSpecs.set(entry.name, entry);
+    registerActionSpec(renderId, entry) {
+        const render = this.create(renderId, 'conformance');
+        render.actionSpecs.set(entry.name, entry);
     }
     /**
      * Register a stream channel ↔ refresh-tool binding on the named
-     * session. Same "create-if-missing" semantics as
+     * render. Same "create-if-missing" semantics as
      * {@link registerActionSpec} so the ConformanceHost adapter can
      * dispatch this directive before subscribe lands. Keyed by
      * `entry.channel` — registering the same channel twice replaces
      * the prior binding, matching the action-spec map's behavior.
      */
-    registerStreamSpec(sessionId, entry) {
-        const session = this.create(sessionId, 'conformance');
-        session.streamSpecs.set(entry.channel, entry);
+    registerStreamSpec(renderId, entry) {
+        const render = this.create(renderId, 'conformance');
+        render.streamSpecs.set(entry.channel, entry);
     }
     /**
-     * Set the per-session protocol-version override. Used by the
+     * Set the per-render protocol-version override. Used by the
      * `server-version-override` ConformanceHost directive — populates
-     * {@link Session.versionOverride} so the WS subscribe handler
+     * {@link Render.versionOverride} so the WS subscribe handler
      * advertises this value (and emits UPGRADE_REQUIRED keyed off it)
-     * for THIS session only, leaving parallel sessions on the instance-
+     * for THIS render only, leaving parallel renders on the instance-
      * level default.
      *
      * Same "create-if-missing" semantics as the other register* setters
      * so directive ordering relative to subscribe doesn't matter.
      */
-    setVersionOverride(sessionId, version) {
-        const session = this.create(sessionId, 'conformance');
-        session.versionOverride = version;
+    setVersionOverride(renderId, version) {
+        const render = this.create(renderId, 'conformance');
+        render.versionOverride = version;
     }
     /**
-     * Fan out a frame to every subscriber on the named session. Used by
+     * Fan out a frame to every subscriber on the named render. Used by
      * the `emit-envelope` ConformanceHost directive — kit fixtures use
      * it to inject WS-observable side-effects (envelopes the server
      * would not normally emit on its own) so the kit can assert
      * downstream consequences (sequencing, fan-out, observability).
      *
-     * Returns `true` if the session existed and at least one subscriber
-     * received the frame; `false` if the session is unknown OR has no
+     * Returns `true` if the render existed and at least one subscriber
+     * received the frame; `false` if the render is unknown OR has no
      * subscribers attached. Caller may use the boolean to log a warning
      * when a fixture's directive-injection lands before any subscribe
      * — the directive then has no observable effect, which is usually
@@ -114,13 +121,13 @@ export class SessionStore {
      * `broadcast()` — one bad subscriber must not block fan-out to the
      * rest.
      */
-    injectFrame(sessionId, frame) {
-        const session = this.sessions.get(sessionId);
-        if (session === undefined)
+    injectFrame(renderId, frame) {
+        const render = this.renders.get(renderId);
+        if (render === undefined)
             return false;
-        if (session.subscribers.size === 0)
+        if (render.subscribers.size === 0)
             return false;
-        for (const subscriber of session.subscribers) {
+        for (const subscriber of render.subscribers) {
             try {
                 subscriber.send(frame);
             }

package/dist/server.d.ts

@@ -1,4 +1,4 @@
-import { SessionStore } from './session.js';
+import { RenderStore } from './render.js';
 import { ToolRegistry } from './tool-registry.js';
 export interface ReferenceServerOptions {
     /** Port to bind. `0` = ephemeral — use {@link ReferenceServer.port}
@@ -31,7 +31,7 @@ export interface ReferenceServerOptions {
     readonly versionOverride?: string;
 }
 export declare class ReferenceServer {
-    readonly sessions: SessionStore;
+    readonly renders: RenderStore;
     readonly tools: ToolRegistry;
     private readonly options;
     private http;

package/dist/server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AAiBA,OAAO,EAAE,YAAY,EAAmB,MAAM,cAAc,CAAC;AAC7D,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAElD,MAAM,WAAW,sBAAsB;IACrC;iDAC6C;IAC7C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,2CAA2C;IAC3C,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB;;;;;;;;OAQG;IACH,QAAQ,CAAC,mBAAmB,CAAC,EAAE,OAAO,CAAC;IACvC;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAC;CACnC;AAED,qBAAa,eAAe;IAC1B,QAAQ,CAAC,QAAQ,eAAsB;IACvC,QAAQ,CAAC,KAAK,eAAsB;IAEpC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAmC;IAC3D,OAAO,CAAC,IAAI,CAA2B;IACvC,OAAO,CAAC,GAAG,CAAgC;IAC3C,OAAO,CAAC,SAAS,CAAuB;gBAE5B,OAAO,EAAE,sBAAsB;IAS3C;;;;;;OAMG;IACH,IAAI,iBAAiB,IAAI,MAAM,CAE9B;IAED,sDAAsD;IACtD,IAAI,IAAI,IAAI,MAAM,CAKjB;IAED,4DAA4D;IAC5D,IAAI,OAAO,IAAI,MAAM,CAEpB;IAEK,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IA+BtB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAkB3B,OAAO,CAAC,gBAAgB;YAoCV,aAAa;IAuC3B,OAAO,CAAC,eAAe;CAmExB"}
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AAwBA,OAAO,EAAE,WAAW,EAAmB,MAAM,aAAa,CAAC;AAC3D,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAElD,MAAM,WAAW,sBAAsB;IACrC;iDAC6C;IAC7C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,2CAA2C;IAC3C,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB;;;;;;;;OAQG;IACH,QAAQ,CAAC,mBAAmB,CAAC,EAAE,OAAO,CAAC;IACvC;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAC;CACnC;AAED,qBAAa,eAAe;IAC1B,QAAQ,CAAC,OAAO,cAAqB;IACrC,QAAQ,CAAC,KAAK,eAAsB;IAEpC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAmC;IAC3D,OAAO,CAAC,IAAI,CAA2B;IACvC,OAAO,CAAC,GAAG,CAAgC;IAC3C,OAAO,CAAC,SAAS,CAAuB;gBAE5B,OAAO,EAAE,sBAAsB;IAS3C;;;;;;OAMG;IACH,IAAI,iBAAiB,IAAI,MAAM,CAE9B;IAED,sDAAsD;IACtD,IAAI,IAAI,IAAI,MAAM,CAKjB;IAED,4DAA4D;IAC5D,IAAI,OAAO,IAAI,MAAM,CAEpB;IAEK,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IA+BtB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAkB3B,OAAO,CAAC,gBAAgB;YAoCV,aAAa;IAyC3B,OAAO,CAAC,eAAe;CA4ExB"}

package/dist/server.js

@@ -8,15 +8,22 @@
  * separation claim (Protocol #6) is empirically grounded — if this
  * server passes `@ggui-ai/protocol-conformance`, the protocol has
  * no implicit `@ggui-ai/mcp-server` coupling.
+ *
+ * Wire-field note: the consumer (`@ggui-ai/protocol-conformance`)
+ * still names the render identity field `sessionId` on the wire (its
+ * fixtures have not yet been renamed). The reference server honors
+ * the consumer contract by reading that field name verbatim, then
+ * binds the value to a `renderId` internally — see {@link Render}
+ * for the canonical identity name used throughout this package.
  */
 import { createServer } from 'node:http';
 import { PROTOCOL_SCHEMA_VERSION } from '@ggui-ai/protocol';
 import { WebSocketServer } from 'ws';
-import { dispatchAction, isActionFrame } from './action-router.js';
-import { SessionStore } from './session.js';
+import { dispatchAction, parseActionFrame } from './action-router.js';
+import { RenderStore } from './render.js';
 import { ToolRegistry } from './tool-registry.js';
 export class ReferenceServer {
-    sessions = new SessionStore();
+    renders = new RenderStore();
     tools = new ToolRegistry();
     options;
     http = null;
@@ -96,8 +103,8 @@ export class ReferenceServer {
     // ===========================================================================
     handleConnection(socket) {
         // Subscribe state is per-connection — one WS may subscribe to
-        // one session at a time. Re-subscribe overwrites.
-        let subscribedSessionId = null;
+        // one render at a time. Re-subscribe overwrites.
+        let subscribedRenderId = null;
         const subscriber = {
             send: (frame) => {
                 try {
@@ -112,19 +119,19 @@ export class ReferenceServer {
             void this.handleMessage(raw.toString('utf8'), {
                 socket,
                 subscriber,
-                onSubscribed: (sessionId) => {
-                    // If previously subscribed to a different session, unsub
+                onSubscribed: (renderId) => {
+                    // If previously subscribed to a different render, unsub
                     // from it first.
-                    if (subscribedSessionId !== null && subscribedSessionId !== sessionId) {
-                        this.sessions.removeSubscriber(subscribedSessionId, subscriber);
+                    if (subscribedRenderId !== null && subscribedRenderId !== renderId) {
+                        this.renders.removeSubscriber(subscribedRenderId, subscriber);
                     }
-                    subscribedSessionId = sessionId;
+                    subscribedRenderId = renderId;
                 },
             });
         });
         socket.on('close', () => {
-            if (subscribedSessionId !== null) {
-                this.sessions.removeSubscriber(subscribedSessionId, subscriber);
+            if (subscribedRenderId !== null) {
+                this.renders.removeSubscriber(subscribedRenderId, subscriber);
             }
         });
     }
@@ -150,11 +157,14 @@ export class ReferenceServer {
             });
             return;
         }
-        if (f['type'] === 'action' && isActionFrame(frame)) {
-            const session = this.sessions.get(frame.sessionId);
-            if (session === undefined)
-                return; // drop actions for unknown sessions
-            await dispatchAction(frame, { session, tools: this.tools });
+        if (f['type'] === 'action') {
+            const parsed = parseActionFrame(frame);
+            if (parsed === undefined)
+                return; // malformed — silently drop
+            const render = this.renders.get(parsed.renderId);
+            if (render === undefined)
+                return; // drop actions for unknown renders
+            await dispatchAction(parsed, { render, tools: this.tools });
             return;
         }
         // Unrecognized type — silently drop (extensibly-closed; third
@@ -165,8 +175,16 @@ export class ReferenceServer {
         if (payload === null || typeof payload !== 'object')
             return;
         const p = payload;
-        const sessionId = p['sessionId'];
-        if (typeof sessionId !== 'string')
+        // Wire-field acceptance: the conformance kit currently sends
+        // `sessionId`; the canonical SPEC field is `renderId`. Read both
+        // so the reference server is forward-compatible with the kit's
+        // eventual rename without breaking today's fixtures.
+        const renderId = typeof p['renderId'] === 'string'
+            ? p['renderId']
+            : typeof p['sessionId'] === 'string'
+                ? p['sessionId']
+                : undefined;
+        if (renderId === undefined)
             return;
         const appId = typeof p['appId'] === 'string' ? p['appId'] : 'conformance';
         const requestId = typeof frame['requestId'] === 'string' ? frame['requestId'] : undefined;
@@ -182,13 +200,13 @@ export class ReferenceServer {
         //   - `strictVersionPolicy: false` (advisory opt-out): emit +
         //     keep the connection open.
         //
-        // Per-session override precedence: if the `server-version-override`
-        // directive set a `versionOverride` on this session BEFORE the
+        // Per-render override precedence: if the `server-version-override`
+        // directive set a `versionOverride` on this render BEFORE the
         // subscribe landed, advertise that value instead of the instance-
         // level default. Lets parallel kit fixtures share one server while
-        // mismatching version on exactly one session.
-        const existingSession = this.sessions.get(sessionId);
-        const advertised = existingSession?.versionOverride ?? this.options.versionOverride;
+        // mismatching version on exactly one render.
+        const existingRender = this.renders.get(renderId);
+        const advertised = existingRender?.versionOverride ?? this.options.versionOverride;
         if (supportedVersions !== undefined && !supportedVersions.includes(advertised)) {
             ctx.subscriber.send({
                 type: 'error',
@@ -210,11 +228,11 @@ export class ReferenceServer {
             return;
         }
         // Add the subscriber + emit ack.
-        this.sessions.addSubscriber(sessionId, ctx.subscriber);
+        this.renders.addSubscriber(renderId, ctx.subscriber);
         // Preserve appId on first subscribe — create() is no-op if the
-        // session already exists from an earlier directive.
-        this.sessions.create(sessionId, appId);
-        ctx.onSubscribed(sessionId);
+        // render already exists from an earlier directive.
+        this.renders.create(renderId, appId);
+        ctx.onSubscribed(renderId);
         ctx.subscriber.send({
             type: 'ack',
             payload: { serverVersion: advertised },

package/dist/tool-registry.d.ts

@@ -45,9 +45,9 @@ export interface RegisteredTool {
  */
 export declare function buildHandler(kind: ToolHandlerKind): ToolHandler;
 /**
- * In-memory tool registry. Scoped to a session via the action router
+ * In-memory tool registry. Scoped to a render via the action router
  * (the plan's register-tool directive wires a handler under the
- * session's tool namespace). No-persistence by design.
+ * render's tool namespace). No-persistence by design.
  */
 export declare class ToolRegistry {
     private readonly tools;

package/dist/tool-registry.js

@@ -71,9 +71,9 @@ export function buildHandler(kind) {
     }
 }
 /**
- * In-memory tool registry. Scoped to a session via the action router
+ * In-memory tool registry. Scoped to a render via the action router
  * (the plan's register-tool directive wires a handler under the
- * session's tool namespace). No-persistence by design.
+ * render's tool namespace). No-persistence by design.
  */
 export class ToolRegistry {
     tools = new Map();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ggui-ai/protocol-reference-server",
-  "version": "0.1.0-rc.1",
+  "version": "0.2.0-alpha.1",
   "description": "Minimal reference implementation of the ggui protocol. Implements exactly enough of the live-channel WebSocket wire to pass the @ggui-ai/protocol-conformance kit. Not a production server — it exists to prove the protocol is vendor-neutral: an independent, from-scratch implementation passing the kit grounds that claim empirically.",
   "keywords": [
     "ggui",
@@ -29,14 +29,14 @@
   },
   "dependencies": {
     "ws": "^8.20.1",
-    "@ggui-ai/protocol": "0.1.0-rc.1"
+    "@ggui-ai/protocol": "0.2.0-alpha.1"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",
     "@types/ws": "^8.5.10",
     "typescript": "^5.0.0",
     "vitest": "^3.0.0",
-    "@ggui-ai/protocol-conformance": "0.1.0-rc.1"
+    "@ggui-ai/protocol-conformance": "0.2.0-alpha.1"
   },
   "repository": {
     "type": "git",

package/dist/session.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../src/session.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH;;;;;GAKG;AACH,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,OAAO;IACtB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;IACnD,QAAQ,CAAC,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;IACnD,QAAQ,CAAC,WAAW,EAAE,GAAG,CAAC,UAAU,CAAC,CAAC;IACtC;;;;;;;;;;;;;;OAcG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED;;;;GAIG;AACH,MAAM,WAAW,UAAU;IACzB,IAAI,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,CAAC;CAC5B;AAED;;;;;GAKG;AACH,qBAAa,YAAY;IACvB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA8B;IACvD,OAAO,CAAC,WAAW,CAAqB;IAExC,MAAM,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO;IAkBjD;;;;;;;OAOG;IACH,oBAAoB,IAAI,MAAM,GAAG,SAAS;IAI1C,GAAG,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS;IAI3C,KAAK,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO;IAIjC,aAAa,CAAC,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,UAAU,GAAG,OAAO;IAMjE,gBAAgB,CAAC,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,UAAU,GAAG,IAAI;IAMjE,kBAAkB,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,eAAe,GAAG,IAAI;IAKnE;;;;;;;OAOG;IACH,kBAAkB,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,eAAe,GAAG,IAAI;IAKnE;;;;;;;;;;OAUG;IACH,kBAAkB,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI;IAK5D;;;;;;;;;;;;;;;;;;OAkBG;IACH,WAAW,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO;CAcxD"}