@ggui-ai/iframe-runtime 0.17.0 → 0.19.0

package/dist/react-renderer.d.ts

@@ -129,6 +129,15 @@ export interface ReactRootMount {
     unmount(): void;
     /** Current component code (useful for tests + audit). */
     readonly currentCode: string | null;
+    /**
+     * Whether this mount HOLDS a component — i.e. whether the tree it renders
+     * is anything but its own stylesheet (ggui#1103). `applyRender` succeeding
+     * is not the same fact: a payload with no code, or a module that threw,
+     * leaves the scope element carrying only its `<style>`, and a caller that
+     * treats "a render was applied" as "something painted" retires the host's
+     * waiting indicator over a blank card.
+     */
+    readonly painted: boolean;
 }
 /**
  * Mount a React root inside `container` and render `render`'s

package/dist/react-renderer.js

@@ -443,6 +443,9 @@ export async function mountReactRoot(container, opts) {
     }
     await initialEvaluate();
     return {
+        get painted() {
+            return currentComponent !== null;
+        },
         get currentCode() {
             return currentCode;
         },

package/dist/render-item.d.ts

@@ -106,6 +106,14 @@ export interface RenderItemHandle {
     unmount(): void;
     /** Current render kind. Test-only — not load-bearing. */
     readonly kind: MountedKind;
+    /**
+     * Whether the active mount PAINTS something (ggui#1103). A provisional,
+     * system or MCP-app mount always does; a React mount does only while it
+     * holds a component. The runtime reads this to decide whether the served
+     * shell's waiting indicator has become a lie — "a render was applied" is
+     * not that fact.
+     */
+    readonly painted: boolean;
 }
 export declare function mountRender(container: HTMLElement, opts: RenderItemOptions): Promise<RenderItemHandle>;
 export {};

package/dist/render-item.js

@@ -222,6 +222,11 @@ export async function mountRender(container, opts) {
         get kind() {
             return currentKind;
         },
+        get painted() {
+            if (currentKind === 'react')
+                return reactMount?.painted === true;
+            return currentKind !== 'none';
+        },
         async update(next) {
             const prevKind = currentKind;
             currentOpts = next;

package/dist/runtime.d.ts

@@ -421,6 +421,14 @@ export interface RendererHandle {
      * `propsSpec` / `streamSpec`.
      */
     getCurrentGguiSession(): GguiSession | GguiSessionSeedInput | null;
+    /**
+     * Whether the mounted render PAINTS something (ggui#1103) — false while no
+     * render has mounted, and false for a mount holding no component (a payload
+     * with no code, or a module that threw). Read by the boot to decide whether
+     * the served shell's waiting indicator has become a lie; "a render was
+     * applied" is a different fact and was the one being used.
+     */
+    painted(): boolean;
     readonly validatorCtx: RendererValidatorContext;
     /**
      * Send surface for outbound frames. Wired by `setup()` to the WS

package/dist/runtime.js

@@ -32,6 +32,7 @@ import { MCP_APP_BOOTSTRAP_FAILED_TYPE, MCP_APP_RENDERER_READY_TYPE, parseMcpApp
 import { effectiveThemeId, effectiveThemeMode, } from '@ggui-ai/protocol/integrations/theme-binding';
 import { extractLocatorFromToolResult, parseMetaFromGlobal, parseMetaFromToolResult, validateMeta, reportInvalidAppTheme, reportStrippedThemeMembers, } from './meta-parse.js';
 import { projectHostContext } from '@ggui-ai/protocol/wire';
+import { installDismissIntentListener } from './dismiss-intent.js';
 import { App, PostMessageTransport } from '@modelcontextprotocol/ext-apps';
 import { applyHostContextStyling, attachListener as attachHostContextListener, seed as seedHostContext, subscribeThemeChange as subscribeHostThemeChange, } from './host-context-emitter.js';
 import { mapHostPaletteToGguiVars } from './host-palette-bridge.js';
@@ -373,6 +374,13 @@ export async function bootSequence(opts) {
         onLifecycle?.(makeLifecycleEvent('error', { error: { code: reason, message } }));
     };
     const refs = ensureStatusDom(doc);
+    // ggui#1109: a key pressed inside the card's document never reaches the page
+    // around it, so a dismiss gesture died here — which is the moment a user who
+    // just clicked the card presses Escape. The card forwards the INTENT and
+    // never acts on it; the host owns what dismissal means, and ignoring is
+    // conformant. Installed before any mount, because the gesture can precede
+    // the first frame.
+    installDismissIntentListener(doc);
     // Live regions up BEFORE anything can announce through them
     // (ggui#447). A region created in the same tick as its first message
     // is a region no screen reader was watching yet, and that first
@@ -652,6 +660,7 @@ export async function bootSequence(opts) {
         mountedRender = target;
         if (renderer !== null) {
             await renderer.applyRender(target);
+            retireStandbyIfPainted();
             if (target.type !== 'mcpApps' && target.type !== 'system') {
                 renderer.channelTransport.applyRender({
                     sessionId: target.id,
@@ -671,11 +680,42 @@ export async function bootSequence(opts) {
         if (codeReadyEmitted)
             return;
         codeReadyEmitted = true;
-        // First real paint — the served shell's working-state mark (#667)
-        // becomes a lie the moment content lands.
-        retireShellLoadingIndicator(doc);
+        // The served shell's working-state mark (#667) is retired by PAINT, not by
+        // this event (ggui#1103): `code-ready` fires after a render was APPLIED,
+        // and applying succeeds when the mount holds no component — so retiring
+        // here left a blank box with no indicator, indistinguishable from a card
+        // still negotiating. `code-ready` itself keeps firing exactly where it did:
+        // hosts pin selectors on it (E2E specs, accessibility scanners).
+        retireStandbyIfPainted();
         onLifecycle?.(makeLifecycleEvent('code-ready', { sessionId: meta.sessionId }));
     };
+    /**
+     * Retire the shell's standby ONLY when the mount paints something, and say
+     * so when a boot reaches its end painting nothing (ggui#1103). Three states
+     * that looked alike — negotiating, empty, painted — now read apart: the
+     * standby means "still coming", its absence with content means the card,
+     * its absence with a said status means "nothing to show".
+     */
+    let saidNothingToShow = false;
+    function retireStandbyIfPainted() {
+        if (renderer !== null && renderer.painted()) {
+            retireShellLoadingIndicator(doc);
+            // A frame that lands after we said there was nothing withdraws the
+            // sentence — the card is the answer now.
+            if (saidNothingToShow) {
+                saidNothingToShow = false;
+                setConnectedStatus(refs);
+            }
+            return;
+        }
+        if (!codeReadyEmitted)
+            return; // still coming — the standby is honest
+        retireShellLoadingIndicator(doc);
+        if (!saidNothingToShow) {
+            saidNothingToShow = true;
+            setStatus(refs, 'Nothing to show for this card.', 'idle');
+        }
+    }
     // Mode discriminators. The mount surface is DECOUPLED from the live
     // channel: static content (codeUrl/codeB64/kind) paints immediately
     // with no WS; the live trio (wsUrl+wsToken) is an OPTIONAL
@@ -745,6 +785,7 @@ export async function bootSequence(opts) {
         if (seed !== null) {
             await renderer.applyRender(seed);
             mountedRender = seed;
+            retireStandbyIfPainted();
             emitCodeReadyOnce();
         }
     }
@@ -4084,6 +4125,7 @@ async function bootProduction(opts) {
                 getChannelTransport: () => channelTransport,
             }));
             return {
+                painted: () => renderHandle?.painted === true,
                 rootWireConfig: rootConfig,
                 streamBus,
                 applyRender,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ggui-ai/iframe-runtime",
-  "version": "0.17.0",
+  "version": "0.19.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/design": "0.17.0",
-    "@ggui-ai/gadgets": "0.17.0",
-    "@ggui-ai/live-channel": "0.17.0",
-    "@ggui-ai/preview-a2ui": "0.17.0",
-    "@ggui-ai/protocol": "0.17.0",
-    "@ggui-ai/wire": "0.17.0"
+    "@ggui-ai/design": "0.19.0",
+    "@ggui-ai/gadgets": "0.19.0",
+    "@ggui-ai/preview-a2ui": "0.19.0",
+    "@ggui-ai/protocol": "0.19.0",
+    "@ggui-ai/live-channel": "0.19.0",
+    "@ggui-ai/wire": "0.19.0"
   },
   "peerDependencies": {
     "@modelcontextprotocol/sdk": "^1.27.0"