@ggui-ai/iframe-runtime 0.2.0-alpha.4 → 0.4.0-rc.0

package/dist/channel-transport.d.ts

@@ -15,7 +15,7 @@
  *
  *   - **Iframe polling** — fallback for every other channel. The
  *     router runs a setInterval that fires `tools/call` against
- *     the parent MCP host (Pattern α — direct, no bridge). Works
+ *     the parent MCP host (direct, no bridge). Works
  *     for any tool the agent has access to, including third-party
  *     MCP servers the local pod can't subscribe-for.
  *
@@ -33,10 +33,11 @@
  *      fallback (don't double-deliver).
  *
  * The WS-level exponential backoff (1s → 2s → 4s → ... cap 60s) lives
- * on the {@link RendererWebSocketManager}. The router only watches
- * status transitions; it doesn't own the reconnect schedule.
+ * on `@ggui-ai/live-channel`'s `WSTransport` (post-B3b owner of the
+ * reconnect ladder). The router only watches status transitions; it
+ * doesn't own the reconnect schedule.
  *
- * **Idempotence** — re-subscribing the same `(renderId, channelName)`
+ * **Idempotence** — re-subscribing the same `(sessionId, channelName)`
  * pair is server-side idempotent (the server's `ChannelSubscriptionState`
  * replaces in place). Clients can re-send on reconnect without bookkeeping
  * a "did we already subscribe?" gate.
@@ -53,20 +54,21 @@
  */
 import type { JsonObject, JsonValue, StreamSpec } from '@ggui-ai/protocol';
 import type { WebSocketMessage } from '@ggui-ai/protocol/transport/websocket';
+import type { ChannelTransportFallbackEvent, ChannelTransportPickedEvent, ChannelTransportResubscribedEvent } from './observability.js';
 import type { StreamBus } from './wire-config.js';
 /**
  * Default polling cadence for the iframe-polling transport (ms).
  * Mirrors the server-side default on
  * {@link DEFAULT_CHANNEL_POLL_DEFAULT_MS} in
- * `packages/mcp-server/src/session-channel.ts`. Conservative: 10s
+ * `packages/mcp-server/src/render-channel.ts`. Conservative: 10s
  * matches a "data is fresh enough" bar without burning the parent
  * host's `tools/call` quota.
  */
 export declare const DEFAULT_IFRAME_POLL_INTERVAL_MS = 10000;
 /**
- * Sender for outbound WS frames. The renderer's
- * {@link RendererWebSocketManager.send} fits structurally — pass
- * `manager.send.bind(manager)` or the buffered manager shim.
+ * Sender for outbound WS frames. Any structurally-fitting send fn
+ * works — post-B3b the registry wires the `@ggui-ai/live-channel`
+ * transport's send here.
  */
 export type WsSender = (msg: WebSocketMessage) => void;
 /**
@@ -83,9 +85,9 @@ export type ToolsCallInvoker = (args: {
  * Options for {@link createChannelTransportRouter}.
  */
 export interface ChannelTransportRouterOptions {
-    /** Render id the router scopes channel_subscribe frames against. */
-    readonly renderId: string;
-    /** App (tenant) id paired with renderId on the subscribe frame. */
+    /** GguiSession id the router scopes channel_subscribe frames against. */
+    readonly sessionId: string;
+    /** App (tenant) id paired with sessionId on the subscribe frame. */
     readonly appId: string;
     /**
      * Allowlist of `source.tool` names this server can subscribe-for
@@ -116,24 +118,12 @@ export interface ChannelTransportRouterOptions {
 /**
  * Observability events the router emits. Hosts that wire `onObserve`
  * see these alongside the renderer's other observability events
- * (`subscribe-failed`, `wired-tool-invoked`, …). The shape stays
- * narrow + non-breaking so future events can extend the union.
+ * (`subscribe-failed`, `auth-required`, …). The arm interfaces live in
+ * `observability.ts` (they are members of the exported
+ * `ObservabilityEvent` union); this alias is the router-scoped subset,
+ * so the two surfaces cannot drift.
  */
-export type ChannelTransportEvent = {
-    readonly kind: 'channel-transport-picked';
-    readonly renderId: string;
-    readonly channelName: string;
-    readonly transport: 'ws' | 'poll';
-} | {
-    readonly kind: 'channel-transport-fallback';
-    readonly renderId: string;
-    readonly channelName: string;
-    readonly reason: 'ws-disconnect' | 'channel-not-local';
-} | {
-    readonly kind: 'channel-transport-resubscribed';
-    readonly renderId: string;
-    readonly channelName: string;
-};
+export type ChannelTransportEvent = ChannelTransportPickedEvent | ChannelTransportFallbackEvent | ChannelTransportResubscribedEvent;
 /**
  * Router handle returned by {@link createChannelTransportRouter}.
  */
@@ -148,7 +138,7 @@ export interface ChannelTransportRouter {
      * the source-fed subset.
      */
     readonly applyRender: (render: {
-        readonly renderId: string;
+        readonly sessionId: string;
         readonly streamSpec?: StreamSpec;
     }) => void;
     /**
@@ -175,7 +165,7 @@ export interface ChannelTransportRouter {
 /**
  * Factory.
  *
- * Per-channel transport routing — owns the `(renderId, channelName)`
+ * Per-channel transport routing — owns the `(sessionId, channelName)`
  * registry, the WS-vs-poll decision per channel, and the cross-state
  * transitions (disconnect → poll fallback, reconnect → re-subscribe).
  */

package/dist/channel-transport.js

@@ -2,7 +2,7 @@
  * Default polling cadence for the iframe-polling transport (ms).
  * Mirrors the server-side default on
  * {@link DEFAULT_CHANNEL_POLL_DEFAULT_MS} in
- * `packages/mcp-server/src/session-channel.ts`. Conservative: 10s
+ * `packages/mcp-server/src/render-channel.ts`. Conservative: 10s
  * matches a "data is fresh enough" bar without burning the parent
  * host's `tools/call` quota.
  */
@@ -10,13 +10,13 @@ export const DEFAULT_IFRAME_POLL_INTERVAL_MS = 10_000;
 /**
  * Factory.
  *
- * Per-channel transport routing — owns the `(renderId, channelName)`
+ * Per-channel transport routing — owns the `(sessionId, channelName)`
  * registry, the WS-vs-poll decision per channel, and the cross-state
  * transitions (disconnect → poll fallback, reconnect → re-subscribe).
  */
 export function createChannelTransportRouter(opts) {
     /**
-     * Registry keyed by `${renderId}:${channelName}`. The composite
+     * Registry keyed by `${sessionId}:${channelName}`. The composite
      * key matches the server-side `channelSubs` map shape exactly, so
      * test snapshots line up.
      */
@@ -34,8 +34,8 @@ export function createChannelTransportRouter(opts) {
     let wsStatus = 'connected';
     let disposed = false;
     const observe = opts.onObserve ?? (() => { });
-    function keyOf(renderId, channelName) {
-        return `${renderId}:${channelName}`;
+    function keyOf(sessionId, channelName) {
+        return `${sessionId}:${channelName}`;
     }
     function stopPolling(state) {
         if (state.pollTimer !== null) {
@@ -45,7 +45,7 @@ export function createChannelTransportRouter(opts) {
     }
     function emitToBus(state, payload, complete) {
         const envelope = {
-            renderId: state.renderId,
+            sessionId: state.sessionId,
             channel: state.channelName,
             mode: state.mode,
             payload,
@@ -90,14 +90,14 @@ export function createChannelTransportRouter(opts) {
     }
     /**
      * Send a `channel_subscribe` WS frame. Server-side bookkeeping is
-     * idempotent on `(renderId, channelName)`, so re-sends on reconnect
+     * idempotent on `(sessionId, channelName)`, so re-sends on reconnect
      * are safe.
      */
     function sendSubscribe(state) {
         opts.send({
             type: 'channel_subscribe',
             payload: {
-                renderId: state.renderId,
+                sessionId: state.sessionId,
                 appId: opts.appId,
                 channelName: state.channelName,
                 ...(state.args !== undefined ? { args: { ...state.args } } : {}),
@@ -114,7 +114,7 @@ export function createChannelTransportRouter(opts) {
         opts.send({
             type: 'channel_unsubscribe',
             payload: {
-                renderId: state.renderId,
+                sessionId: state.sessionId,
                 appId: opts.appId,
                 channelName: state.channelName,
             },
@@ -137,7 +137,7 @@ export function createChannelTransportRouter(opts) {
                 sendSubscribe(state);
                 observe({
                     kind: 'channel-transport-picked',
-                    renderId: state.renderId,
+                    sessionId: state.sessionId,
                     channelName: state.channelName,
                     transport: 'ws',
                 });
@@ -148,7 +148,7 @@ export function createChannelTransportRouter(opts) {
             startPolling(state);
             observe({
                 kind: 'channel-transport-picked',
-                renderId: state.renderId,
+                sessionId: state.sessionId,
                 channelName: state.channelName,
                 transport: 'poll',
             });
@@ -157,7 +157,7 @@ export function createChannelTransportRouter(opts) {
         startPolling(state);
         observe({
             kind: 'channel-transport-picked',
-            renderId: state.renderId,
+            sessionId: state.sessionId,
             channelName: state.channelName,
             transport: 'poll',
         });
@@ -184,18 +184,18 @@ export function createChannelTransportRouter(opts) {
                 const channelArgs = source.args !== undefined && source.args !== null
                     ? source.args
                     : undefined;
-                const k = keyOf(render.renderId, channelName);
+                const k = keyOf(render.sessionId, channelName);
                 seenKeys.add(k);
                 const existing = channels.get(k);
                 if (existing !== undefined) {
-                    // Same (renderId, channelName) — leave the transport
+                    // Same (sessionId, channelName) — leave the transport
                     // bookkeeping alone. Spec changes that flip preferWs
                     // mid-render are out of 1c scope (would require
                     // re-handshake).
                     continue;
                 }
                 const state = {
-                    renderId: render.renderId,
+                    sessionId: render.sessionId,
                     channelName,
                     toolName,
                     ...(channelArgs !== undefined ? { args: channelArgs } : {}),
@@ -213,7 +213,7 @@ export function createChannelTransportRouter(opts) {
             // mounts that haven't been re-applied yet. Close-render paths
             // call `dispose()` for the wholesale teardown.
             for (const [k, state] of channels) {
-                if (state.renderId === render.renderId &&
+                if (state.sessionId === render.sessionId &&
                     !seenKeys.has(k)) {
                     stopPolling(state);
                     sendUnsubscribe(state);
@@ -226,7 +226,7 @@ export function createChannelTransportRouter(opts) {
                 return false;
             if (msg.type === 'channel_payload') {
                 const p = msg.payload;
-                const k = keyOf(p.renderId, p.channelName);
+                const k = keyOf(p.sessionId, p.channelName);
                 const state = channels.get(k);
                 if (state === undefined)
                     return false;
@@ -244,7 +244,7 @@ export function createChannelTransportRouter(opts) {
             if (msg.type === 'channel_error') {
                 const p = msg.payload;
                 // Locate by `channelName` only — the error payload doesn't
-                // carry `renderId`. We match by channel-name across active
+                // carry `sessionId`. We match by channel-name across active
                 // items and apply the permanent-fallback flag to the matching
                 // entries. Same channel name across renders is rare; the
                 // policy is conservative (fall back ALL matches rather than
@@ -254,12 +254,12 @@ export function createChannelTransportRouter(opts) {
                         continue;
                     if (p.code === 'CHANNEL_NOT_LOCAL' ||
                         p.code === 'CHANNEL_UNKNOWN' ||
-                        p.code === 'RENDER_NOT_FOUND') {
+                        p.code === 'SESSION_NOT_FOUND') {
                         state.permanentPollFallback = true;
                         startPolling(state);
                         observe({
                             kind: 'channel-transport-fallback',
-                            renderId: state.renderId,
+                            sessionId: state.sessionId,
                             channelName: state.channelName,
                             reason: 'channel-not-local',
                         });
@@ -298,7 +298,7 @@ export function createChannelTransportRouter(opts) {
                         startPolling(state);
                         observe({
                             kind: 'channel-transport-fallback',
-                            renderId: state.renderId,
+                            sessionId: state.sessionId,
                             channelName: state.channelName,
                             reason: 'ws-disconnect',
                         });
@@ -309,8 +309,8 @@ export function createChannelTransportRouter(opts) {
             if (status === 'connected' &&
                 (prevStatus === 'disconnected' || prevStatus === 'reconnecting')) {
                 // Reconnected. Re-send `channel_subscribe` for every
-                // WS-preferring channel. Server is idempotent on the (session,
-                // render, channel) tuple, so duplicates are safe. We
+                // WS-preferring channel. Server is idempotent on the
+                // (render, channel) tuple, so duplicates are safe. We
                 // intentionally LEAVE the polling fallback running until the
                 // first `channel_payload` lands — bridges the gap where the
                 // server's first post-reconnect poll cycle hasn't fired yet.
@@ -322,7 +322,7 @@ export function createChannelTransportRouter(opts) {
                     sendSubscribe(state);
                     observe({
                         kind: 'channel-transport-resubscribed',
-                        renderId: state.renderId,
+                        sessionId: state.sessionId,
                         channelName: state.channelName,
                     });
                 }

package/dist/channels/data.d.ts

@@ -2,24 +2,17 @@
  * `data` channel handler — validates inbound stream-envelope payloads
  * against the active render's `streamSpec`, then fans the validated
  * envelope out via `streamBus`. Invalid payloads drop silently
- * (matching `GguiSession.handleServerMessage`'s surfacing policy —
+ * (matching `GguiRender.handleServerMessage`'s surfacing policy —
  * the violation is already logged by the validator).
  *
- * Also fires `contract-error-emitted` on the optional observability
- * sink when the envelope arrives on the reserved
- * `CONTRACT_ERROR_CHANNEL`. Absorbed from `handleObservableMessage`
- * in `runtime.ts` as part of the B3b cleanup — the handler is now the
- * sole dispatch surface for `data` frames.
- *
  * Post-stack-removal (2026-05-27): the active render is read through
- * the caller-supplied `getCurrentRender` thunk instead of via a
+ * the caller-supplied `getCurrentGguiSession` thunk instead of via a
  * `StackModel.snapshot()` walk — the iframe holds exactly one mounted
  * render, so the lookup is direct.
  */
 import type { ChannelHandler } from '@ggui-ai/live-channel';
-import { type Render, type StreamEnvelope } from '@ggui-ai/protocol';
-import type { RenderSeedInput } from '../types.js';
-import type { ObservabilityEmitter } from '../observability.js';
+import type { GguiSession, StreamEnvelope } from '@ggui-ai/protocol';
+import type { GguiSessionSeedInput } from '../types.js';
 import { type RendererValidatorContext } from '../validation.js';
 import type { StreamBus } from '../wire-config.js';
 export interface DataHandlerDeps {
@@ -28,16 +21,8 @@ export interface DataHandlerDeps {
      * has been mounted yet — data frames received pre-mount have no
      * streamSpec to validate against and silently drop.
      */
-    readonly getCurrentRender: () => Render | RenderSeedInput | null;
+    readonly getCurrentGguiSession: () => GguiSession | GguiSessionSeedInput | null;
     readonly streamBus: StreamBus;
     readonly validatorCtx: RendererValidatorContext;
-    /**
-     * Optional observability sink. When present, every envelope on the
-     * reserved `_ggui:contract-error` channel fires a
-     * {@link ContractErrorEmittedEvent}. Absent = the observation skips
-     * silently (matches the pre-B3b posture when no `onObserve` is
-     * bound).
-     */
-    readonly onObserve?: ObservabilityEmitter;
 }
 export declare function createDataHandler(deps: DataHandlerDeps): ChannelHandler<StreamEnvelope>;

package/dist/channels/data.js

@@ -2,21 +2,14 @@
  * `data` channel handler — validates inbound stream-envelope payloads
  * against the active render's `streamSpec`, then fans the validated
  * envelope out via `streamBus`. Invalid payloads drop silently
- * (matching `GguiSession.handleServerMessage`'s surfacing policy —
+ * (matching `GguiRender.handleServerMessage`'s surfacing policy —
  * the violation is already logged by the validator).
  *
- * Also fires `contract-error-emitted` on the optional observability
- * sink when the envelope arrives on the reserved
- * `CONTRACT_ERROR_CHANNEL`. Absorbed from `handleObservableMessage`
- * in `runtime.ts` as part of the B3b cleanup — the handler is now the
- * sole dispatch surface for `data` frames.
- *
  * Post-stack-removal (2026-05-27): the active render is read through
- * the caller-supplied `getCurrentRender` thunk instead of via a
+ * the caller-supplied `getCurrentGguiSession` thunk instead of via a
  * `StackModel.snapshot()` walk — the iframe holds exactly one mounted
  * render, so the lookup is direct.
  */
-import { CONTRACT_ERROR_CHANNEL, } from '@ggui-ai/protocol';
 import { validateInboundStreamPayload, } from '../validation.js';
 export function createDataHandler(deps) {
     return {
@@ -27,19 +20,9 @@ export function createDataHandler(deps) {
                 typeof envelope.channel !== 'string') {
                 return;
             }
-            // Observability-axis emission for the reserved contract-error
-            // channel. Fires BEFORE validation because the envelope shape
-            // is owned by the server's reserved validator
-            // (`BUILTIN_RESERVED_VALIDATORS`) — invalid payloads at this
-            // boundary are server-side bugs the host inspector should still
-            // surface, not silently drop.
-            if (envelope.channel === CONTRACT_ERROR_CHANNEL &&
-                deps.onObserve !== undefined) {
-                emitContractErrorFromDataFrame(envelope, deps.onObserve);
-            }
             // Active render carries the streamSpec — mirrors
-            // `GguiSession.handleServerMessage`.
-            const activeRender = deps.getCurrentRender();
+            // `GguiRender.handleServerMessage`.
+            const activeRender = deps.getCurrentGguiSession();
             const streamSpec = activeRender !== null &&
                 activeRender.type !== 'mcpApps' &&
                 activeRender.type !== 'system'
@@ -52,34 +35,3 @@ export function createDataHandler(deps) {
         },
     };
 }
-/**
- * Narrow a contract-error envelope and emit
- * {@link ContractErrorEmittedEvent}. Malformed envelopes silently
- * skip (trust-boundary posture — host inspector gets a row only when
- * the wire payload carries the required discriminator fields).
- */
-function emitContractErrorFromDataFrame(envelope, emit) {
-    const payload = envelope.payload;
-    if (payload === null || typeof payload !== 'object' || Array.isArray(payload)) {
-        return;
-    }
-    const shaped = payload;
-    const code = shaped.error !== undefined &&
-        shaped.error !== null &&
-        typeof shaped.error === 'object' &&
-        typeof shaped.error.code === 'string'
-        ? shaped.error.code
-        : undefined;
-    const toolName = typeof shaped.toolName === 'string' ? shaped.toolName : undefined;
-    if (code === undefined || toolName === undefined)
-        return;
-    const event = {
-        kind: 'contract-error-emitted',
-        code,
-        toolName,
-        ...(typeof shaped.actionName === 'string'
-            ? { actionName: shaped.actionName }
-            : {}),
-    };
-    emit(event);
-}

package/dist/channels/index.d.ts

@@ -2,6 +2,5 @@ export { createPropsUpdateHandler, type PropsUpdateHandlerDeps, } from './props-
 export { createDrainAckHandler, type DrainAckHandlerDeps, } from './drain-ack.js';
 export { createRenderHandler, type RenderHandlerDeps } from './render-frame.js';
 export { createDataHandler, type DataHandlerDeps } from './data.js';
-export { createFeedbackHandler } from './feedback.js';
 export { createChannelPayloadHandler, createChannelErrorHandler, type ChannelRouterHandlerDeps, } from './channel-payload.js';
 export { createSystemHandler, type SystemHandlerDeps } from './system.js';

package/dist/channels/index.js

@@ -2,6 +2,5 @@ export { createPropsUpdateHandler, } from './props-update.js';
 export { createDrainAckHandler, } from './drain-ack.js';
 export { createRenderHandler } from './render-frame.js';
 export { createDataHandler } from './data.js';
-export { createFeedbackHandler } from './feedback.js';
 export { createChannelPayloadHandler, createChannelErrorHandler, } from './channel-payload.js';
 export { createSystemHandler } from './system.js';

package/dist/channels/props-update.d.ts

@@ -5,17 +5,17 @@
  *
  * Post-stack-removal (2026-05-27): each iframe holds exactly one
  * mounted render. The handler reads the current render via
- * `getCurrentRender()`, validates the inbound props against its
+ * `getCurrentGguiSession()`, validates the inbound props against its
  * cached `propsSpec`, and re-applies the patched render through
  * `applyRender` — the same callback the render handler uses, so the
  * React update surface is unified.
  *
  * Skips when:
- *   - `renderId` is empty or not a string.
+ *   - `sessionId` is empty or not a string.
  *   - `props` is null / not an object (defensive — server can't emit
  *     this shape, but the dispatcher routes the frame on type alone).
- *   - No render is currently mounted (`getCurrentRender` returns null).
- *   - The current render's id doesn't match `payload.renderId` —
+ *   - No render is currently mounted (`getCurrentGguiSession` returns null).
+ *   - The current render's id doesn't match `payload.sessionId` —
  *     the server may have raced ahead of an in-flight render swap.
  *   - The current render is `mcpApps` / `system` (no `propsSpec`;
  *     server should never emit `props_update` for these).
@@ -23,14 +23,14 @@
  *
  * R6 (2026-05-26) retired the per-handler polling descriptor. Polling
  * is now registry-level — the iframe-runtime composes the
- * `/api/renders/:id/state?wsToken=<token>` URL and a snapshot-parsing
+ * `/api/sessions/:id/state?wsToken=<token>` URL and a snapshot-parsing
  * function once at bind time (see `runtime.ts`); a single fetch per
  * tick projects the slice envelope into per-handler frames the
  * `PollingTransport` dispatches.
  */
 import type { ChannelHandler } from '@ggui-ai/live-channel';
-import type { PropsUpdatePayload, Render } from '@ggui-ai/protocol';
-import type { RenderSeedInput } from '../types.js';
+import type { PropsUpdatePayload, GguiSession } from '@ggui-ai/protocol';
+import type { GguiSessionSeedInput } from '../types.js';
 export interface PropsUpdateHandlerDeps {
     /**
      * Read the currently-mounted render. Returns `null` when no
@@ -39,11 +39,11 @@ export interface PropsUpdateHandlerDeps {
      * `props_update` before the first render frame has no React tree to
      * patch.
      */
-    readonly getCurrentRender: () => Render | RenderSeedInput | null;
+    readonly getCurrentGguiSession: () => GguiSession | GguiSessionSeedInput | null;
     /**
      * Re-apply the patched render to the single mount slot. Shared with
      * the render-frame handler so React updates flow through one path.
      */
-    readonly applyRender: (render: Render | RenderSeedInput) => Promise<void>;
+    readonly applyRender: (render: GguiSession | GguiSessionSeedInput) => Promise<void>;
 }
 export declare function createPropsUpdateHandler(deps: PropsUpdateHandlerDeps): ChannelHandler<PropsUpdatePayload>;

package/dist/channels/props-update.js

@@ -5,17 +5,17 @@
  *
  * Post-stack-removal (2026-05-27): each iframe holds exactly one
  * mounted render. The handler reads the current render via
- * `getCurrentRender()`, validates the inbound props against its
+ * `getCurrentGguiSession()`, validates the inbound props against its
  * cached `propsSpec`, and re-applies the patched render through
  * `applyRender` — the same callback the render handler uses, so the
  * React update surface is unified.
  *
  * Skips when:
- *   - `renderId` is empty or not a string.
+ *   - `sessionId` is empty or not a string.
  *   - `props` is null / not an object (defensive — server can't emit
  *     this shape, but the dispatcher routes the frame on type alone).
- *   - No render is currently mounted (`getCurrentRender` returns null).
- *   - The current render's id doesn't match `payload.renderId` —
+ *   - No render is currently mounted (`getCurrentGguiSession` returns null).
+ *   - The current render's id doesn't match `payload.sessionId` —
  *     the server may have raced ahead of an in-flight render swap.
  *   - The current render is `mcpApps` / `system` (no `propsSpec`;
  *     server should never emit `props_update` for these).
@@ -23,7 +23,7 @@
  *
  * R6 (2026-05-26) retired the per-handler polling descriptor. Polling
  * is now registry-level — the iframe-runtime composes the
- * `/api/renders/:id/state?wsToken=<token>` URL and a snapshot-parsing
+ * `/api/sessions/:id/state?wsToken=<token>` URL and a snapshot-parsing
  * function once at bind time (see `runtime.ts`); a single fetch per
  * tick projects the slice envelope into per-handler frames the
  * `PollingTransport` dispatches.
@@ -33,15 +33,15 @@ export function createPropsUpdateHandler(deps) {
     return {
         type: 'props_update',
         onMessage: async (payload) => {
-            const { renderId, props } = payload;
-            if (typeof renderId !== 'string' || renderId.length === 0)
+            const { sessionId, props } = payload;
+            if (typeof sessionId !== 'string' || sessionId.length === 0)
                 return;
             if (props === null || typeof props !== 'object')
                 return;
-            const current = deps.getCurrentRender();
+            const current = deps.getCurrentGguiSession();
             if (current === null)
                 return;
-            if (current.id !== renderId)
+            if (current.id !== sessionId)
                 return;
             if (current.type === 'mcpApps' || current.type === 'system')
                 return;

package/dist/channels/render-frame.d.ts

@@ -8,7 +8,7 @@
  * exactly one mounted render for its lifetime. The handler routes the
  * inbound `render` to a caller-supplied `applyRender` callback that
  * either mounts (first frame) or re-applies (subsequent frames to the
- * same id). Frames addressed to a different `renderId` are out-of-spec
+ * same id). Frames addressed to a different `sessionId` are out-of-spec
  * and drop with a console warning — the host spawns a fresh iframe
  * per unique render id.
  *
@@ -18,7 +18,7 @@
  * happens. The boot-without-renderer path remains testable.
  */
 import type { ChannelHandler } from '@ggui-ai/live-channel';
-import type { RenderPayload, Render } from '@ggui-ai/protocol';
+import type { RenderPayload, GguiSession } from '@ggui-ai/protocol';
 import type { ChannelTransportRouter } from '../channel-transport.js';
 import { type StatusRefs } from '../status-dom.js';
 export interface RenderHandlerDeps {
@@ -29,19 +29,19 @@ export interface RenderHandlerDeps {
      */
     readonly statusRefs: StatusRefs;
     /**
-     * Pin — when set, render frames with a different `renderId`
+     * Pin — when set, render frames with a different `sessionId`
      * are dropped with a console warning. Set by the renderer hook to
      * the render id the iframe was bootstrapped against (every
      * post-displayMode iframe is pinned to a single render).
      */
-    readonly pinnedRenderId?: string;
+    readonly pinnedSessionId?: string;
     /**
      * Apply the inbound render to the single mount slot. Absent in
      * placeholder mode (no React mount). When present, the handler
      * `await`s the apply before activating the per-channel transport
      * so the router targets the render React already mounted.
      */
-    readonly applyRender?: (render: Render) => Promise<void>;
+    readonly applyRender?: (render: GguiSession) => Promise<void>;
     /**
      * Renderer-mode hook — returns the per-channel transport router so
      * the render handler can activate `source.tool` channel subscriptions

package/dist/channels/render-frame.js

@@ -8,7 +8,7 @@
  * exactly one mounted render for its lifetime. The handler routes the
  * inbound `render` to a caller-supplied `applyRender` callback that
  * either mounts (first frame) or re-applies (subsequent frames to the
- * same id). Frames addressed to a different `renderId` are out-of-spec
+ * same id). Frames addressed to a different `sessionId` are out-of-spec
  * and drop with a console warning — the host spawns a fresh iframe
  * per unique render id.
  *
@@ -22,15 +22,15 @@ export function createRenderHandler(deps) {
     return {
         type: 'render',
         onMessage: async (payload) => {
-            const render = payload.render;
-            if (deps.pinnedRenderId !== undefined && render.id !== deps.pinnedRenderId) {
+            const render = payload.session;
+            if (deps.pinnedSessionId !== undefined && render.id !== deps.pinnedSessionId) {
                 // Out-of-spec: each iframe is pinned to exactly one render id
                 // post-displayMode-divergence; the host spawns a fresh iframe
                 // per render. A frame for some other id means the host wired
                 // the wrong render or the server is broadcasting cross-render
                 // frames.
                 // eslint-disable-next-line no-console
-                console.warn(`[ggui:render] ignoring render for ${render.id} — iframe pinned to ${deps.pinnedRenderId}`);
+                console.warn(`[ggui:render] ignoring render for ${render.id} — iframe pinned to ${deps.pinnedSessionId}`);
                 return;
             }
             if (deps.applyRender !== undefined) {
@@ -43,7 +43,7 @@ export function createRenderHandler(deps) {
             if (render.type === 'mcpApps' || render.type === 'system')
                 return;
             channelTransport.applyRender({
-                renderId: render.id,
+                sessionId: render.id,
                 ...(render.streamSpec !== undefined
                     ? { streamSpec: render.streamSpec }
                     : {}),

package/dist/compiled-validators.d.ts

@@ -14,7 +14,7 @@
 import type { CompiledContractValidators } from '@ggui-ai/protocol/integrations/mcp-apps';
 import type { ValidateFunction } from '@ggui-ai/protocol';
 /**
- * Precompiled validators for the active stack item's contract, keyed to
+ * Precompiled validators for the active render's contract, keyed to
  * match the four runtime-validated surfaces. `props` is a single
  * validator (the synthesized props wrapper); the other three are keyed
  * by action name / channel name / slot name.
@@ -49,7 +49,7 @@ export declare function loadCompiledValidators(meta: CompiledContractValidators
  * Response shape: an ES module whose `default` export is a
  * {@link CompiledContractValidators} object (produced server-side by
  * `bundleCompiledValidatorsAsModule`). `Cache-Control: immutable` so
- * repeat pushes with the same contract hit browser cache with no
+ * repeat renders with the same contract hit browser cache with no
  * round-trip.
  */
 export declare function loadCompiledValidatorsFromUrl(url: string | undefined, warn?: (message: string, detail: unknown) => void): Promise<CompiledValidatorSet>;

package/dist/compiled-validators.js

@@ -83,7 +83,7 @@ export async function loadCompiledValidators(meta, warn) {
  * Response shape: an ES module whose `default` export is a
  * {@link CompiledContractValidators} object (produced server-side by
  * `bundleCompiledValidatorsAsModule`). `Cache-Control: immutable` so
- * repeat pushes with the same contract hit browser cache with no
+ * repeat renders with the same contract hit browser cache with no
  * round-trip.
  */
 export async function loadCompiledValidatorsFromUrl(url, warn) {