@ggui-ai/iframe-runtime 0.23.0 → 0.25.0

package/dist/runtime.js

@@ -42,7 +42,7 @@ import { RelayIncapableError } from './relay-incapability.js';
 import { ChannelRegistry } from '@ggui-ai/live-channel';
 import { createTelemetrySink, } from './runtime-telemetry.js';
 import { createChannelErrorHandler, createChannelPayloadHandler, createDataHandler, createDrainAckHandler, createPropsUpdateHandler, createRenderHandler, } from './channels/index.js';
-import { connectViaRegistry, } from './registry-subscribe.js';
+import { classifyChannelFrame, connectViaRegistry, } from './registry-subscribe.js';
 import { buildBridgePolling, buildEventsPolling, createSequenceCursor, } from './events-polling.js';
 import { unwrapCallToolResult } from './call-tool-unwrap.js';
 import { ensureStatusDom, setStatus, setConnectedStatus, retireShellLoadingIndicator, } from './status-dom.js';
@@ -185,12 +185,10 @@ let activeThemeUnsubscribe = null;
  * the spec's `'light' | 'dark'` literals (dropped, never guessed —
  * the same tolerant posture as `projectHostContext`).
  *
- * This is the INPUT leg of host-theme adaptation
- * (rnd/gen-ui/beauty/experiments/002-host-theme-adaptation.md, ggui#551):
+ * This is the INPUT leg of host-theme adaptation (ggui#551):
  * `hostContext.theme` alone reaches only `data-theme` +
  * `color-scheme` via `applyDocumentTheme` — nothing in the token
- * pipeline keys off it, so a dark host painted the light ladder
- * (host-fit 46.0 vs 87.7 with the dark ladder, probe `cc728a8eb`).
+ * pipeline keys off it, so a dark host painted the light ladder.
  * Under ggui#987 §4 the embedding host OWNS runtime mode: when it
  * announces one, `buildOpts` paints it over every stamped opinion; the
  * stamped layers decide only when the host is silent. Read live from
@@ -1045,6 +1043,7 @@ function createPlaceholderRegistry(params) {
                     : {}),
             },
         }),
+        classifyFrame: classifyChannelFrame,
     });
     registry.register(createRenderHandler({
         statusRefs: params.statusRefs,
@@ -1516,56 +1515,6 @@ function fnv1aHex(payload) {
     }
     return (hash >>> 0).toString(16).padStart(8, '0');
 }
-/**
- * Render a submit-action's `data` payload as a short inline string
- * for embedding in a `ui/message` consent prompt. Goal: human-
- * readable, not a JSON dump. Falls back to truncated JSON for
- * nested values so the prompt doesn't drop information silently.
- *
- * Exported for unit-testing — an earlier implementation returned `''`
- * for primitive payloads (strings/numbers/booleans), which silently
- * vaporised the chip's actual text from the consent prompt and made
- * the LLM think every dispatch was a contentless "Please proceed
- * with **<intent>**" request.
- */
-export function formatSubmitActionDataInline(data) {
-    if (data === null || data === undefined)
-        return '';
-    // Bare primitives: render verbatim. Strings unquoted (most legible
-    // in a "Please proceed with X (foo)" sentence). Numbers / booleans
-    // stringified.
-    if (typeof data === 'string')
-        return data;
-    if (typeof data === 'number' || typeof data === 'boolean')
-        return String(data);
-    // Arrays: short JSON, truncated. Length cap mirrors the per-entry
-    // cap below so the consent line stays a single human-readable phrase.
-    if (Array.isArray(data)) {
-        const json = JSON.stringify(data);
-        return json.length > 60 ? `${json.slice(0, 57)}…` : json;
-    }
-    if (typeof data !== 'object')
-        return '';
-    const entries = Object.entries(data);
-    if (entries.length === 0)
-        return '';
-    const parts = entries.map(([k, v]) => {
-        if (v === null)
-            return `${k}: null`;
-        if (v === undefined)
-            return `${k}: undefined`;
-        if (typeof v === 'string')
-            return `${k}: ${v}`;
-        if (typeof v === 'number' || typeof v === 'boolean')
-            return `${k}: ${v}`;
-        // `JSON.stringify` returns `undefined` for unrepresentable values
-        // (e.g. a `function` field on a form payload object) — guard so
-        // the subsequent `.length` access doesn't crash the dispatch path.
-        const json = JSON.stringify(v) ?? String(v);
-        return `${k}: ${json.length > 40 ? `${json.slice(0, 37)}…` : json}`;
-    });
-    return parts.join(', ');
-}
 /**
  * Post an arbitrary JSON-RPC envelope to the iframe's parent
  * window. Internal helper shared across {@link emitAudit} (the
@@ -2097,6 +2046,84 @@ function hideToast(el) {
 }
 /** The single action-toast element, reused for every message. */
 const ACTION_TOAST_ID = '__ggui-action-toast__';
+/**
+ * Lightweight toast UX surface for dispatched actions. Renders a
+ * fixed-position element at the bottom of the iframe so the user
+ * gets immediate visual feedback that their gesture was registered
+ * — "→ Sending action: archive" → "✓ Queued — agent will react"
+ * (or "💬 Sent to chat" on ui/message fallback).
+ *
+ * Without this, the iframe is silent during dispatch. User clicks
+ * and waits, with no way to distinguish "click was received but the
+ * agent is busy" from "click was lost". Especially load-bearing in
+ * the consume-pipe vs ui/message dual-path era — the toast tells
+ * the user which path the gesture actually took.
+ *
+ * Direct DOM (not React-managed) because:
+ *  - Works during boot before React mounts.
+ *  - Doesn't interfere with the component tree the generator owns.
+ *  - Survives React mount transitions inside the iframe.
+ *
+ * Single global toast (per iframe). Auto-dismisses after 2.5s on
+ * `success` / `fallback` outcomes. A successful dispatch draws nothing
+ * here (ggui#1444): its "sending" is spoken only (see
+ * {@link GESTURE_COPY}).
+ *
+ * The visible element is only half the surface (ggui#447). Every
+ * message is also spoken through {@link ensureToastAnnouncer}'s live
+ * regions, and the element itself is hidden from the accessibility
+ * tree so the sentence is not read twice. The one exception is
+ * `action_required`, the only toast the user must OPERATE: it re-enters
+ * the tree as a named button with a tab stop, because a dismissal that
+ * needs a mouse is a dismissal some users cannot perform.
+ *
+ * @internal — runtime-layer concern.
+ */
+/**
+ * The `label` an action declares on the render's `actionSpec`, trimmed, or
+ * `undefined` when the render declares none (or is a system / MCP-Apps
+ * render, which carries no actionSpec). By contract the label is the
+ * control's own copy, so it is the one name for a tap a visitor may read
+ * (see {@link GESTURE_COPY}).
+ *
+ * @internal — exported for unit tests.
+ */
+export function declaredActionLabel(render, actionName) {
+    if (render === null || render.type === 'mcpApps' || render.type === 'system')
+        return undefined;
+    const declared = render.actionSpec?.[actionName]?.label;
+    return typeof declared === 'string' && declared.trim() !== '' ? declared.trim() : undefined;
+}
+/**
+ * Everything the runtime says to a VISITOR about a gesture (ggui#1444).
+ *
+ * A card's action NAME and the data it sends are the author's and the
+ * agent's vocabulary, never the visitor's: a staging rehearsal drew
+ * "→ chooseReply (id: pricing)" over a card after a chip tap. So no text
+ * here names the action or carries its data. When the action declares a
+ * `label` (by contract the control's own copy, already on screen) the text
+ * names the tap by it, so two failed taps on different controls read as two
+ * different sentences to a screen reader (ggui#447); without one it says
+ * the same thing unnamed. Diagnostics keep the name and data (the
+ * `gesture.*` telemetry records); the screen and the live regions do not.
+ *
+ * `sending` and `sentToChat` are spoken, never drawn: a tap the relay
+ * accepted, or a wake-up the host took, needs no chrome over the card — the
+ * pending look belongs to the card's own control (`useActionPending`), and a
+ * host that takes a wake-up shows the conversation continuing in its own UI.
+ * The rest are drawn because each one tells the visitor something they have
+ * to know or do.
+ */
+const named = (label, rest, unnamed) => label === undefined ? unnamed : `${label} — ${rest}`;
+const GESTURE_COPY = {
+    sending: (label) => named(label, 'sending…', 'Sending…'),
+    notDelivered: (label) => `⚠ ${named(label, 'not delivered', 'Not delivered')}`,
+    transportError: (label) => `⚠ ${named(label, 'could not send, try again', 'Could not send — try again')}`,
+    unreachable: (label) => `⚠ ${named(label, 'could not reach the agent', 'Could not reach the agent')}`,
+    sentToChat: (label) => named(label, 'sent to the chat', 'Sent to the chat'),
+    sendToContinue: (label) => `💬 ${named(label, 'agent not listening. Send a message to continue.', 'Agent not listening. Send a message to continue.')}`,
+    chatRefused: (label) => `💬 ${named(label, 'the chat did not take the message. Send a message to continue.', 'The chat did not take the message. Send a message to continue.')}`,
+};
 function showActionToast(text, kind, onDismiss) {
     if (typeof document === 'undefined')
         return;
@@ -2338,9 +2365,14 @@ function emitUserActionDoorbell(args) {
     // `ai.ggui/userAction` to match our other protocol extensions
     // (`ai.ggui/render`, `ai.ggui/bootstrap`, etc.).
     currentTelemetrySink?.record('doorbell.ring', args.sessionId);
+    const doorbellId = Math.floor(Math.random() * 1e9);
+    watchDoorbellReply(doorbellId, (code) => {
+        currentTelemetrySink?.record('doorbell.refused', `${args.sessionId} code=${code}`);
+        args.onRefused();
+    });
     postToParent({
         jsonrpc: '2.0',
-        id: Math.floor(Math.random() * 1e9),
+        id: doorbellId,
         method: 'ui/message',
         params: {
             role: 'user',
@@ -2356,6 +2388,54 @@ function emitUserActionDoorbell(args) {
         },
     });
 }
+/**
+ * How long the view listens for the host's answer to a doorbell. A host
+ * may ask the user before sending the message, so the answer can take a
+ * while; past this the listener is removed and a late answer is ignored.
+ */
+const DOORBELL_REPLY_WAIT_MS = 5 * 60_000;
+/**
+ * Listen for the host's JSON-RPC reply to the doorbell `id` (ggui#1314).
+ * The doorbell is posted raw, outside the `App`'s request table, so no
+ * one else correlates it. Only a frame from `window.parent` carrying this
+ * `id` and a `result` or `error` counts; the first such frame ends the
+ * watch. An `error` is the host refusing the doorbell in-band (#1309:
+ * a host delivers a view's `ui/message` or answers it with an error,
+ * never a success), reported with its numeric code (`unknown` when the
+ * host sent none).
+ */
+function watchDoorbellReply(id, onRefused) {
+    if (typeof window === 'undefined')
+        return;
+    const onMessage = (ev) => {
+        if (ev.source !== window.parent)
+            return;
+        const frame = ev.data;
+        if (frame === null || typeof frame !== 'object')
+            return;
+        if (!('jsonrpc' in frame) || frame.jsonrpc !== '2.0')
+            return;
+        if (!('id' in frame) || frame.id !== id)
+            return;
+        const refused = 'error' in frame;
+        if (!refused && !('result' in frame))
+            return;
+        stop();
+        if (!refused)
+            return;
+        const error = frame.error;
+        const code = error !== null && typeof error === 'object' && 'code' in error && typeof error.code === 'number'
+            ? String(error.code)
+            : 'unknown';
+        onRefused(code);
+    };
+    const stop = () => {
+        window.removeEventListener('message', onMessage);
+        clearTimeout(timer);
+    };
+    window.addEventListener('message', onMessage);
+    const timer = setTimeout(stop, DOORBELL_REPLY_WAIT_MS);
+}
 /**
  * Latch for the relay-incapability notice (ggui#440). A host that
  * cannot relay fails EVERY gesture, so the explanation is stated once
@@ -2604,6 +2684,14 @@ function resetRelayCueThrottles() {
     cancelRelayCueRetraction();
 }
 /** @internal — exported for unit tests to reset module state. */
+/**
+ * Test-only: install the telemetry sink the runtime records into (normally
+ * set once at boot), so a test can observe the events a code path posts.
+ * `null` restores the no-sink state.
+ */
+export function __setTelemetrySinkForTest(sink) {
+    currentTelemetrySink = sink;
+}
 export function __resetRelayNoticeForTest() {
     relayIncapabilityAnnounced = false;
     runtimeConnectionWriter().set(true);
@@ -2687,7 +2775,7 @@ function resolveRelayCueTarget() {
  * the rest of the session is the same stale-announcement defect the
  * toast half avoids by clearing on hide.
  */
-function announceRelayCue(intent) {
+function announceRelayCue(intent, label) {
     const now = Date.now();
     if (intent === lastRelayCueAnnouncedIntent &&
         now - lastRelayCueAnnouncedAt < RELAY_CUE_THROTTLE_MS) {
@@ -2697,7 +2785,7 @@ function announceRelayCue(intent) {
     lastRelayCueAnnouncedIntent = intent;
     // `announceToast` cancels any retraction still pending, so the timer
     // armed here is always the only one in flight.
-    announceToast(`⚠ ${intent} — not delivered`, 'error');
+    announceToast(GESTURE_COPY.notDelivered(label), 'error');
     relayCueAnnounceTimer = window.setTimeout(() => {
         relayCueAnnounceTimer = undefined;
         retractRelayCueAnnouncement();
@@ -2738,7 +2826,7 @@ function retractRelayCueAnnouncement() {
  * (ggui#447) — the pulse via {@link announceRelayCue}, the fallback via
  * the toast primitive's own announcement.
  */
-function showDeadZoneCue(intent) {
+function showDeadZoneCue(intent, label) {
     if (typeof document === 'undefined')
         return;
     const target = resolveRelayCueTarget();
@@ -2751,7 +2839,7 @@ function showDeadZoneCue(intent) {
             return;
         ensureRelayCueStyle();
         target.classList.add(RELAY_CUE_CLASS);
-        announceRelayCue(intent);
+        announceRelayCue(intent, label);
         // Both cleanup routes cancel the other. Without the `clearTimeout`,
         // a pulse ended early by `animationend` leaves its timer armed, and
         // that timer later strips whatever class is on the element THEN —
@@ -2780,7 +2868,7 @@ function showDeadZoneCue(intent) {
     // a second explanation, so it must clear itself. Throttled because a
     // per-click toast on a host that fails every click is the #426
     // failure mode the latch exists to prevent.
-    showActionToast(`⚠ ${intent} — not delivered`, 'error');
+    showActionToast(GESTURE_COPY.notDelivered(label), 'error');
 }
 /**
  * Dispatch a submit-action via the empirically-validated bridge
@@ -2805,7 +2893,7 @@ export function dispatchSubmitAction(args) {
         currentTelemetrySink?.record('gesture.dropped_superseded', args.intent);
         return;
     }
-    const { toolName, intent, data, sessionId, appId } = args;
+    const { toolName, intent, data, sessionId, appId, label } = args;
     // Gesture-path telemetry — the click's own autopsy trail. #471
     // round 12 hit a frame whose channels + beacons were fully healthy
     // while clicks produced NOTHING observable; without a record at the
@@ -2814,8 +2902,6 @@ export function dispatchSubmitAction(args) {
     currentTelemetrySink?.record('gesture.dispatch', JSON.stringify({ intent, toolName }));
     const firedAt = new Date().toISOString();
     const actionId = fnv1aHex(`${intent}|${JSON.stringify(data ?? null)}|${firedAt}`);
-    const inlineData = formatSubmitActionDataInline(data);
-    const dataPart = inlineData === '' ? '' : ` (${inlineData})`;
     const uiContext = readLocalUiContext();
     // (1) Silent context update — fires FIRST and ALWAYS. Primes the
     // LLM's widget-context surface regardless of which downstream path
@@ -2857,10 +2943,13 @@ export function dispatchSubmitAction(args) {
     // the user has focused NOW; by the time the relay response settles,
     // focus may have moved on.
     if (!relayIncapabilityAnnounced) {
-        showActionToast(`→ ${intent}${dataPart}`, 'pending');
+        // No pill over the card (ggui#1444): the previous gesture's notice goes,
+        // and "sending" is spoken for assistive tech only.
+        dismissActionToast();
+        announceToast(GESTURE_COPY.sending(label), 'pending');
     }
     else if (!isRelayNoticeVisible()) {
-        showDeadZoneCue(intent);
+        showDeadZoneCue(intent, label);
     }
     // (2) Try submit_action via host relay. Spec-compliant hosts
     // forward the tools/call to the MCP server's submit_action handler;
@@ -2897,7 +2986,7 @@ export function dispatchSubmitAction(args) {
             });
         }
         catch {
-            showActionToast(`⚠ ${intent} — transport error`, 'error');
+            showActionToast(GESTURE_COPY.transportError(label), 'error');
             resp = null;
         }
         // Final hop of the gesture autopsy trail — what the relay
@@ -2940,7 +3029,7 @@ export function dispatchSubmitAction(args) {
             // through to the terminal "could not reach the agent" toast a
             // few lines down, which already replaces the stale notice.
             if (classifySubmitActionResponse(resp) === 'success') {
-                showActionToast(`→ ${intent}${dataPart}`, 'pending');
+                dismissActionToast();
             }
         }
         if (resp !== null && classifySubmitActionResponse(resp) === 'success') {
@@ -2964,14 +3053,29 @@ export function dispatchSubmitAction(args) {
                 // `ggui_consume`; servers that CAN answer always send an
                 // explicit `true` (the factory wires the registry
                 // unconditionally), so confirmed-consumer hosts stay quiet.
-                showActionToast(hostCanReceiveMessages()
-                    ? `💬 ${intent}${dataPart} — agent not listening, sent to chat`
-                    : `💬 ${intent}${dataPart} — agent not listening. Send a message to continue.`, 'action_required');
+                // A host that takes the wake-up carries it in its own UI (the
+                // conversation visibly continues, or a prepared message lands in
+                // its input), so nothing is drawn over the card (ggui#1444): the tap
+                // is spoken to assistive tech only. The card draws only when the
+                // visitor must act — this host cannot receive a message at all, or
+                // it refuses this one (`onRefused` below).
+                if (hostCanReceiveMessages()) {
+                    announceToast(GESTURE_COPY.sentToChat(label), 'pending');
+                }
+                else {
+                    showActionToast(GESTURE_COPY.sendToContinue(label), 'action_required');
+                }
                 emitUserActionDoorbell({
                     intent,
                     sessionId,
                     actionId,
                     submittedAt: firedAt,
+                    // The host refused the wake-up in-band (ggui#1314), so the
+                    // visitor has to act: say what. The gesture itself is safe on
+                    // the pipe; only the wake-up failed.
+                    onRefused: () => {
+                        showActionToast(GESTURE_COPY.chatRefused(label), 'action_required');
+                    },
                 });
                 return;
             }
@@ -3053,7 +3157,7 @@ export function dispatchSubmitAction(args) {
             announceRelayIncapability(confirmedRefusal ? 'confirmed-refusal' : 'advert-silent', { sessionId, appId });
             return;
         }
-        showActionToast(`⚠ ${intent} — could not reach the agent`, 'error');
+        showActionToast(GESTURE_COPY.unreachable(label), 'error');
     })();
 }
 /**
@@ -3170,13 +3274,14 @@ export function resolveDispatchToolName() {
  * @internal — exported for unit tests + production reuse.
  */
 export function routeDispatch(args) {
-    const { actionName, data, meta, dispatchToolName } = args;
+    const { actionName, data, meta, dispatchToolName, label } = args;
     dispatchSubmitAction({
         toolName: dispatchToolName,
         intent: actionName,
         data,
         sessionId: meta.sessionId,
         appId: meta.appId,
+        ...(label !== undefined ? { label } : {}),
     });
 }
 /**
@@ -3794,6 +3899,15 @@ async function bootProduction(opts) {
             // through `currentRender`-returning thunks so they always see the
             // latest snapshot without holding stale refs.
             let currentRender = null;
+            // ggui#1223 — who to tell when `currentRender` is replaced, so the card's
+            // spent state (read through `getCurrentGguiSession`) is re-read at once.
+            const renderListeners = new Set();
+            const onRenderChange = (listener) => {
+                renderListeners.add(listener);
+                return () => {
+                    renderListeners.delete(listener);
+                };
+            };
             let renderHandle = null;
             const dispatchToolName = resolveDispatchToolName();
             // Native-idiom interceptors — the replacement for the retired
@@ -3841,6 +3955,7 @@ async function bootProduction(opts) {
                 sessionId: meta.sessionId,
                 appId: meta.appId,
                 getCurrentGguiSession: () => currentRender,
+                renderChanges: onRenderChange,
                 manager,
                 streamBus,
                 onDispatchEnvelope: (envelope) => {
@@ -3856,6 +3971,8 @@ async function bootProduction(opts) {
                         || payload.action.length === 0) {
                         return;
                     }
+                    // The declared label names the tap in visitor copy (ggui#1444).
+                    const label = declaredActionLabel(currentRender, payload.action);
                     routeDispatch({
                         actionName: payload.action,
                         data: payload.data,
@@ -3864,6 +3981,7 @@ async function bootProduction(opts) {
                             appId: meta.appId,
                         },
                         dispatchToolName,
+                        ...(label !== undefined ? { label } : {}),
                     });
                 },
             });
@@ -3998,6 +4116,8 @@ async function bootProduction(opts) {
             };
             const applyRender = async (render) => {
                 currentRender = render;
+                for (const listener of [...renderListeners])
+                    listener();
                 if (renderHandle === null) {
                     renderHandle = await mountRender(renderInto, buildOpts(render));
                     return;
@@ -4099,6 +4219,7 @@ async function bootProduction(opts) {
                             : {}),
                     },
                 }),
+                classifyFrame: classifyChannelFrame,
             });
             channelRegistry.register(createRenderHandler({
                 statusRefs,

package/dist/shims/wire.js

@@ -1 +1 @@
-const w = globalThis.__ggui__.wire; export const useAction = w.useAction; export const useStream = w.useStream; export const useAuth = w.useAuth; export const useApp = w.useApp; export const useRender = w.useRender; export const useGguiContext = w.useGguiContext; export const useContract = w.useContract; export const useWireContext = w.useWireContext; export const GguiWireProvider = w.GguiWireProvider; export default w;
+const w = globalThis.__ggui__.wire; export const useAction = w.useAction; export const useStream = w.useStream; export const useAuth = w.useAuth; export const useApp = w.useApp; export const useRender = w.useRender; export const useGguiContext = w.useGguiContext; export const useContract = w.useContract; export const useWireContext = w.useWireContext; export const useActionSpent = w.useActionSpent; export const useActionPending = w.useActionPending; export const GguiWireProvider = w.GguiWireProvider; export default w;

package/dist/wire-config.d.ts

@@ -18,7 +18,7 @@
  */
 import type { ActionEnvelope, GguiSession } from '@ggui-ai/protocol/wire';
 import type { GguiSessionSeedInput } from './types.js';
-import { ClientContractViolationError, StreamBus, type WireConfig } from '@ggui-ai/wire';
+import { ClientContractViolationError, StreamBus, type BuiltWireConfig } from '@ggui-ai/wire';
 import type { WebSocketMessage } from '@ggui-ai/protocol/transport/websocket';
 /**
  * Outbound send surface — the minimal shape wire-config calls on the
@@ -48,6 +48,13 @@ export interface BuildRootWireConfigOptions {
      * WireConfig.
      */
     readonly getCurrentGguiSession: () => GguiSession | GguiSessionSeedInput | null;
+    /**
+     * The runtime's notice that the current render was replaced (a props
+     * update, a later live frame), so the card's spent state is re-read at
+     * once (ggui#1223), and the card's in-flight dispatches clear (ggui#1398).
+     * Passed through as wire's `spentInputsChanged` and `pendingInputsChanged`.
+     */
+    readonly renderChanges?: (listener: () => void) => () => void;
     /** Handle to the renderer's WS manager; used for outbound `action` frames. */
     readonly manager: RendererSendSurface;
     /** Shared bus for inbound stream deliveries. */
@@ -124,4 +131,4 @@ export interface BuildRootWireConfigOptions {
  * `RootWireConfigBundle` / `scopeWireConfig` / `buildScopedConfig`
  * indirection collapsed to a single `WireConfig`.
  */
-export declare function buildRootWireConfig(opts: BuildRootWireConfigOptions): WireConfig;
+export declare function buildRootWireConfig(opts: BuildRootWireConfigOptions): BuiltWireConfig;

package/dist/wire-config.js

@@ -87,6 +87,10 @@ export function buildRootWireConfig(opts) {
                 : undefined;
         },
         onActionSpecAbsent: nameUnenforceableOnce,
+        ...(opts.renderChanges !== undefined ? { spentInputsChanged: opts.renderChanges } : {}),
+        // ggui#1398 — a replaced render is the session's next frame: the agent's
+        // answer, so every in-flight dispatch stops reading pending.
+        ...(opts.renderChanges !== undefined ? { pendingInputsChanged: opts.renderChanges } : {}),
         // ggui#1223 — the card's persisted spent `oneShot` names. A re-served card
         // boots a new iframe, so the guard's in-memory set starts empty; the
         // render's record says what this card already spent. It counts only when

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ggui-ai/iframe-runtime",
-  "version": "0.23.0",
+  "version": "0.25.0",
   "description": "The iframe-local ggui runtime: a self-contained ESM bundle that boots inside an MCP Apps host iframe, runs the protocol-version handshake, opens the live-channel WebSocket, and mounts the rendered UI. Bundles React, ReactDOM, and the ggui design system so generated component code has a single seam to read from.",
   "keywords": [
     "ggui",
@@ -41,12 +41,12 @@
     "react": "^19.0.0",
     "react-dom": "^19.0.0",
     "zod": "^4.3.6",
-    "@ggui-ai/live-channel": "0.23.0",
-    "@ggui-ai/preview-a2ui": "0.23.0",
-    "@ggui-ai/protocol": "0.23.0",
-    "@ggui-ai/gadgets": "0.23.0",
-    "@ggui-ai/design": "0.23.0",
-    "@ggui-ai/wire": "0.23.0"
+    "@ggui-ai/gadgets": "0.25.0",
+    "@ggui-ai/design": "0.25.0",
+    "@ggui-ai/live-channel": "0.25.0",
+    "@ggui-ai/preview-a2ui": "0.25.0",
+    "@ggui-ai/protocol": "0.25.0",
+    "@ggui-ai/wire": "0.25.0"
   },
   "peerDependencies": {
     "@modelcontextprotocol/sdk": "^1.27.0"