@ggui-ai/iframe-runtime 0.1.0-rc.3 → 0.2.0-alpha.1

package/dist/runtime.js

@@ -1,15 +1,17 @@
-import { parseBootstrap, parseBootstrapFromGlobal, parseBootstrapFromToolResult, } from './bootstrap.js';
-import { StackModel } from './stack.js';
-import { attachListener as attachHostContextListener, seed as seedHostContext, subscribeLocal as subscribeHostContextLocal, } from './host-context-emitter.js';
+import { parseMetaFromGlobal, parseMetaFromToolResult, } from './meta-parse.js';
+import { projectHostContext } from '@ggui-ai/protocol';
+import { App, PostMessageTransport } from '@modelcontextprotocol/ext-apps';
+import { applyHostContextStyling, attachListener as attachHostContextListener, seed as seedHostContext, } from './host-context-emitter.js';
 import { buildRootWireConfig, StreamBus, } from './wire-config.js';
 import { createChannelTransportRouter, } from './channel-transport.js';
-import { ChannelRegistry } from '@ggui-ai/channel-client';
-import { createChannelErrorHandler, createChannelPayloadHandler, createDataHandler, createDrainAckHandler, createFeedbackHandler, createPropsUpdateHandler, createPushHandler, createSystemHandler, } from './channels/index.js';
+import { ChannelRegistry } from '@ggui-ai/live-channel';
+import { createChannelErrorHandler, createChannelPayloadHandler, createDataHandler, createDrainAckHandler, createFeedbackHandler, createPropsUpdateHandler, createRenderHandler, createSystemHandler, } from './channels/index.js';
 import { connectViaRegistry, } from './registry-subscribe.js';
-import { ensureStatusDom, refreshStackDom, setStatus, setConnectedStatus, } from './status-dom.js';
+import { buildEventsPolling } from './events-polling.js';
+import { ensureStatusDom, setStatus, setConnectedStatus, } from './status-dom.js';
 import { mergeReservedValidators, setActiveValidatorSet, } from './validation.js';
-import { loadCompiledValidators } from './compiled-validators.js';
-import { StackRenderer, } from './stack-item-renderer.js';
+import { loadCompiledValidatorsFromUrl } from './compiled-validators.js';
+import { mountRender, } from './render-item.js';
 import { fromBootstrapFailure, } from './protocol-error.js';
 import { postObservabilityToParent, } from './observability.js';
 import { makeLifecycleEvent, postLifecycleToParent, } from './lifecycle.js';
@@ -23,6 +25,19 @@ import { contextSlotLastValues, createContextStateHost, installContextRegistry,
 // substitute via esbuild `define` if a non-package value is wanted.
 // =============================================================================
 const RENDERER_VERSION = '0.1.0';
+/**
+ * How long the spec-canonical postMessage tier (Tier 3 in
+ * `bootSequence`'s resolver chain + the autostart resolver's race
+ * against `bootProduction`) waits for an inbound
+ * `ui/notifications/tool-result` notification before falling through.
+ *
+ * 30 seconds chosen to span the slowest spec-compliant hosts that
+ * post the tool result LATE (after their `ui/initialize` response
+ * resolves + after the tool call round-trips through the LLM
+ * provider). Faster hosts return immediately on arrival; the timeout
+ * only fires when the host never posts at all.
+ */
+const POSTMESSAGE_BOOT_TIMEOUT_MS = 30_000;
 const drainAckListeners = new Set();
 export function subscribeDrainAck(listener) {
     drainAckListeners.add(listener);
@@ -41,56 +56,106 @@ function dispatchDrainAck(payload) {
         }
     }
 }
+// =============================================================================
+// App-class plumbing (Phase 1.19b.3). The renderer used to roll its own
+// JSON-RPC pump (a closure-scoped `makeJsonRpcCaller` for the single
+// `ui/initialize` request + a module-level `ensurePostRpcToParentListener`
+// for `tools/call` and a `installPostMountListener` for inbound
+// `ui/notifications/tool-result`). Every one of those was a hand-rolled
+// reimplementation of a primitive `@modelcontextprotocol/ext-apps`'s
+// `App` class already ships — drift across them produced the Reading-B
+// vs spec-canonical schism we spent the postMessage tier-3 resolver
+// patching around. Post-1.19b.3 every host-iframe message hops through
+// one `App` instance.
+//
+// Two-piece construction:
+//   - `createDefaultApp` builds an `App` + `PostMessageTransport` against
+//     `window.parent`. Production wires this; tests inject their own.
+//   - `connectApp` runs `App.connect(transport)` and surfaces failures
+//     as the typed `ConnectAppResult` discriminated union (since App
+//     throws and we want bootSequence's `UI_INITIALIZE_FAILED` envelope
+//     to surface a string `message` without `instanceof` gymnastics).
+// =============================================================================
+const APP_INFO = { name: 'ggui-iframe-runtime', version: RENDERER_VERSION };
+/**
+ * Available display modes the iframe-runtime supports — declared on
+ * `ui/initialize` so spec-compliant hosts know `ui/request-display-mode`
+ * requests for these values are honored. The runtime emits
+ * `ui/request-display-mode` from the `Element.requestFullscreen`
+ * interceptor + the canvas-mode display-mode escalation policy; both
+ * target this enum.
+ */
+const APP_CAPABILITIES = {
+    availableDisplayModes: ['inline', 'fullscreen', 'pip'],
+};
+/**
+ * Build the default production `App` + `PostMessageTransport` pair
+ * targeting `window.parent`. Tests inject their own; production calls
+ * this lazily so test files that import this module without running
+ * the autostart side-effect don't construct an iframe-bound App.
+ */
+function createDefaultApp() {
+    const app = new App(APP_INFO, APP_CAPABILITIES, { autoResize: true });
+    const transport = new PostMessageTransport(window.parent, window.parent);
+    return { app, transport };
+}
 /**
- * Post a JSON-RPC request to `window.parent` and resolve with the
- * matching response. The host MUST echo the request `id` on its
- * response per the MCP Apps lifecycle. Pending requests are tracked
- * by id in a module-private map; responses without a matching id are
- * dropped (per the adapter-boundary rule the shell already enforces).
+ * Module-level connected App handle. Set by `bootProduction` /
+ * `bootSelfContained` once `app.connect()` resolves; consumed by the
+ * outbound dispatch path (`tools/call` via `app.callServerTool`) so
+ * spec-compliant frame routing is used in place of the legacy
+ * hand-rolled JSON-RPC pump.
  *
- * Hosts have no obligation to respond (a misbehaving host can hang the
- * call) — `bootSequence` enforces a timeout at the orchestration layer
- * because the runtime's whole-flow deadline is what matters, not
- * per-call.
+ * `null` between the moment the module loads and the moment one of
+ * the boot paths assigns it — `dispatchWiredAction`'s callsites are
+ * gated on this, so calls fired pre-boot drop with a console warning.
  */
-function makeJsonRpcCaller() {
-    let nextId = 1;
-    const pending = new Map();
-    window.addEventListener('message', (event) => {
-        const data = event.data;
-        if (data === null || typeof data !== 'object')
-            return;
-        const id = data.id;
-        if (typeof id !== 'number')
-            return;
-        // Filter for RESPONSES — must carry `result` or `error`. Bare
-        // requests with `method` set are not responses (see the matching
-        // filter in `ensurePostRpcToParentListener` for the same reason).
-        if (!('result' in data) && !('error' in data))
-            return;
-        const resolver = pending.get(id);
-        if (resolver === undefined)
-            return;
-        pending.delete(id);
-        resolver(data);
-    });
-    return (method, params) => new Promise((resolve) => {
-        const id = nextId;
-        nextId += 1;
-        pending.set(id, resolve);
-        try {
-            window.parent.postMessage({
-                jsonrpc: '2.0',
-                id,
-                method,
-                params: params ?? {},
-            }, '*');
-        }
-        catch (err) {
-            pending.delete(id);
-            resolve({ error: { message: err instanceof Error ? err.message : String(err) } });
-        }
-    });
+let currentApp = null;
+/**
+ * Assign the module-level App handle. Replaces any previous handle —
+ * production runs bootSequence exactly once per iframe lifecycle, so
+ * a replace only happens in tests that reuse the module across
+ * scenarios (and want each spec to bind its own App).
+ *
+ * @internal — production callers are the boot paths
+ *   (`bootProduction`, `bootSelfContained`); tests inject directly to
+ *   drive outbound `tools/call` through a `MockTransport`-bound App
+ *   without invoking the full boot pipeline.
+ */
+export function setCurrentApp(app) {
+    currentApp = app;
+}
+/**
+ * Read the connected App handle. Returns `null` when neither boot
+ * path has run yet. Outbound dispatch sites that depend on it MUST
+ * handle the null case (typically by logging + dropping the call).
+ */
+function getCurrentApp() {
+    return currentApp;
+}
+/**
+ * @internal — exported for unit tests to reset module state between
+ * scenarios.
+ */
+export function __resetAppForTest() {
+    currentApp = null;
+}
+/**
+ * Connect an App over its transport; map any thrown error to the
+ * `ConnectAppResult` shape so callers don't need an `instanceof Error`
+ * dance to fill `UI_INITIALIZE_FAILED`.
+ */
+async function connectApp(app, transport) {
+    try {
+        await app.connect(transport);
+        return { ok: true };
+    }
+    catch (err) {
+        return {
+            ok: false,
+            message: err instanceof Error ? err.message : String(err),
+        };
+    }
 }
 /**
  * Notify the parent that the renderer is alive + ready to receive
@@ -123,8 +188,9 @@ function postBootFailure(reason, message) {
     }
 }
 export async function bootSequence(opts) {
-    const { doc, callUiInitialize, notifyParent, triadWiring, onProtocolError, onObserve, onLifecycle } = opts;
+    const { doc, app, transport, notifyParent, renderer: rendererHooks, onProtocolError, onObserve, onLifecycle } = opts;
     const connectFn = opts.connectFn ?? connectViaRegistry;
+    const toolResultTimeoutMs = opts.toolResultTimeoutMs ?? POSTMESSAGE_BOOT_TIMEOUT_MS;
     // Emit typed {@link ProtocolError} for every bootstrap-failure site
     // that surfaces a `RendererBootFailedMessage`. The narrow
     // postMessage envelope stays (parent compatibility); the typed
@@ -150,16 +216,12 @@ export async function bootSequence(opts) {
         onLifecycle?.(makeLifecycleEvent('error', { error: { code: reason, message } }));
     };
     const refs = ensureStatusDom(doc);
-    // Construct the model empty + unfiltered so the initial "empty
-    // placeholder" render + any early-return-on-failure path uses a
-    // consistent instance. If the bootstrap parse below succeeds AND
-    // pins a `stackItemId`, we swap to a filtered model before any
-    // setAll / upsert runs — the filter is immutable per-instance, so
-    // swap-then-reassign is the only way to lock the pin.
-    let stackModel = new StackModel();
-    // Initial empty-placeholder render via the canonical helper.
-    // `refreshStackDom` is the public seam handlers use after fold.
-    refreshStackDom(refs, stackModel);
+    // The mounted render is established after the first ack lands —
+    // populated by `applyAck` below + read back by every channel handler
+    // that needs `propsSpec` / `streamSpec`. Tracked as a closure-scoped
+    // ref so the failure-path returns can carry the same value through
+    // `BootSequenceResult`.
+    let mountedRender = null;
     setStatus(refs, 'Negotiating with host…', 'connecting');
     notifyParent({ type: 'ggui:renderer-ready', version: RENDERER_VERSION });
     // Lifecycle `mounting` — the renderer is alive + status DOM is up,
@@ -168,223 +230,303 @@ export async function bootSequence(opts) {
     // re-emission is the host's concern (per protocol, host treats
     // duplicate same-state envelopes as a no-op).
     onLifecycle?.(makeLifecycleEvent('mounting'));
-    const initResp = await callUiInitialize();
-    if (initResp.error !== undefined || initResp.result === undefined) {
-        const message = initResp.error?.message ?? 'ui/initialize returned no result';
-        setStatus(refs, `ui/initialize failed: ${message}`, 'error');
-        emitBootFailure('UI_INITIALIZE_FAILED', message);
-        return { ok: false, stack: stackModel };
+    // Install the spec-canonical toolresult listener on App BEFORE
+    // calling `app.connect(transport)`. App's `_assertHandlerTiming`
+    // warns if the first handler for a one-shot event registers AFTER
+    // the `ui/initialize`→`ui/notifications/initialized` handshake
+    // completes (the host may have already fired the notification by
+    // then). Registering early is the spec-canonical answer.
+    //
+    // The Promise resolves on the FIRST inbound `ui/notifications/tool-result`
+    // notification carrying valid `_meta["ai.ggui/render"]`. The race
+    // versus the synchronous `__GGUI_META__` tier is resolved AFTER the
+    // App handshake settles — whichever yields first wins; the listener
+    // is removed on resolve.
+    //
+    // Skipped entirely when `preResolvedMeta` is set (autostart caught
+    // the toolresult or read the global early) — no listener installed,
+    // no race to run.
+    const toolResultPromise = opts.preResolvedMeta !== undefined
+        ? Promise.resolve(null)
+        : awaitToolResultMetaFromApp(app, toolResultTimeoutMs);
+    const initResult = await connectApp(app, transport);
+    if (!initResult.ok) {
+        setStatus(refs, `ui/initialize failed: ${initResult.message}`, 'error');
+        emitBootFailure('UI_INITIALIZE_FAILED', initResult.message);
+        return { ok: false, mountedRender };
+    }
+    // Connected — expose the App on the module-level slot so outbound
+    // `tools/call` (dispatchWiredAction, channel-transport router)
+    // routes through `app.callServerTool` instead of the legacy raw
+    // postMessage pump. Idempotent: re-boot with the same App is a
+    // no-op; a different App throws (the iframe is single-tenant).
+    setCurrentApp(app);
+    // Slice-meta resolution — spec-canonical primary, no in-house
+    // Reading-B (retired Phase 1.19b.3 with the App-class swap; the
+    // McpUiInitializeResult schema doesn't define `toolOutput`).
+    //
+    //   Tier 0  preResolvedMeta — autostart-layer pre-resolution. When
+    //           the autostart's own toolresult race or inline `__GGUI_META__`
+    //           parse caught the meta before bootSequence ran, it threads
+    //           the parsed slice meta here so we don't re-await the same
+    //           delivery. Skips every tier below.
+    //
+    //   Tier 1  parseMetaFromGlobal — synchronous `__GGUI_META__` inline
+    //           global. Self-contained shells (`buildSelfContainedHtml`,
+    //           per-session resource shells) populate this before this
+    //           bundle's `<script type="module">` evaluates.
+    //           Opportunistic — its absence (the common case for
+    //           postMessage-delivered hosts) never surfaces as a parse
+    //           failure to the caller.
+    //
+    //   Tier 2  spec-canonical `ui/notifications/tool-result` — observed
+    //           by App via `addEventListener('toolresult', …)`. The ONLY
+    //           remaining post-handshake path, used by every spec-strict
+    //           host (`<AppRenderer>`, ChatGPT MCP-Apps connector,
+    //           claude.ai post-spec, and any future host that issues
+    //           `ui/initialize` without echoing `toolOutput`).
+    //
+    // When both tiers fail, we surface the Tier 2 timeout/failure reason
+    // (`MISSING_META_GGUI_BOOTSTRAP`) — it's the spec-canonical channel
+    // and its absence is the diagnostic worth showing.
+    let parsed;
+    if (opts.preResolvedMeta !== undefined) {
+        parsed = { ok: true, meta: opts.preResolvedMeta };
+    }
+    else {
+        const inline = parseMetaFromGlobal();
+        if (inline.ok) {
+            parsed = inline;
+        }
+        else {
+            const fromToolResult = await toolResultPromise;
+            if (fromToolResult !== null) {
+                parsed = { ok: true, meta: fromToolResult };
+            }
+            else {
+                parsed = {
+                    ok: false,
+                    reason: 'MISSING_META_GGUI_BOOTSTRAP',
+                };
+            }
+        }
+    }
+    // hostContext is captured opportunistically from
+    // `app.getHostContext()` — populated by App's `ui/initialize`
+    // response capture + kept fresh by the `hostcontextchanged`
+    // notification handler App ships internally. Apply the RAW context
+    // to the iframe DOM via the spec-canonical ext-apps helpers (theme
+    // + style variables + fonts) regardless of whether projection
+    // picked up new fields. Projection drops theme / styles (they live
+    // in ggui's own theming pipeline); the DOM-apply path is what
+    // surfaces them to LLM-generated UI so host-native primitives
+    // render consistently with the rest of chat.
+    const rawHostContext = app.getHostContext();
+    if (rawHostContext !== undefined) {
+        applyHostContextStyling(rawHostContext);
+    }
+    if (parsed.ok && parsed.hostContext === undefined) {
+        const hostContext = projectHostContext(rawHostContext);
+        if (hostContext !== undefined) {
+            parsed = { ...parsed, hostContext };
+        }
     }
-    const parsed = parseBootstrap(initResp.result);
     if (!parsed.ok) {
-        const message = `bootstrap parse failed: ${parsed.reason}`;
+        const message = `slice-meta parse failed: ${parsed.reason}`;
         setStatus(refs, message, 'error');
         emitBootFailure(parsed.reason, message);
-        return { ok: false, stack: stackModel };
+        return { ok: false, mountedRender };
     }
+    // Single render slice — post-Phase-B the wire merged the
+    // `ai.ggui/session` + `ai.ggui/stack-item` pair into one
+    // `ai.ggui/render` slice. The parser surfaces it directly on
+    // `parsed.meta`.
+    const meta = parsed.meta;
     // Install the precompiled, eval-free contract validators shipped on
     // the bootstrap BEFORE any wire traffic is validated. Self-contained
     // ESM modules — no `__ggui__` dependency, so this need not wait for
     // `installGlobalRegistry`. A failed load leaves the validation seam
     // to fall back to in-iframe compilation (CSP-blocked, but no worse
     // than pre-A4).
-    setActiveValidatorSet(await loadCompiledValidators(parsed.bootstrap.compiledValidators));
-    // Single-item mode. When a per-item resource route served this
-    // resource, the bootstrap carries `stackItemId` and the renderer
-    // binds to just that stack entry. Absent (whole-session resource)
-    // → multi-item render path. The swap happens BEFORE any setAll /
-    // upsert so filter semantics apply to the first-frame stack the
-    // ack delivers.
-    if (parsed.bootstrap.stackItemId !== undefined) {
-        stackModel = new StackModel({ filterToItemId: parsed.bootstrap.stackItemId });
-    }
-    // Canvas mode: when bootstrap.canvasMode
-    // AND a canvasMount hook is wired, mount CanvasShell as a React
-    // tree into refs.stack BEFORE triadWiring.setup so the triad's
-    // renderer writes into the canvas's content slot. The canvas's
-    // NavStackModel is kept in sync with stackModel on every applyAck.
-    // No canvasMount hook OR canvasMode !== true ⇒ legacy inline path.
-    let canvasMountHandle = null;
-    let renderIntoEl = refs.stack;
-    // Late-bound send surface for canvas's
-    // outbound `canvas_navigated` envelopes. The triad's `manager`
-    // (constructed inside triadWiring.setup below) is the producer; we
-    // capture it here so the canvas callbacks — installed at mount time
-    // BEFORE setup — can dispatch through the buffered shim once the
-    // WS is up. Calls during the bind gap silently no-op (the user
-    // can't physically click back-arrow before the canvas is rendered).
-    let canvasOutboundSend = null;
-    if (parsed.bootstrap.canvasMode === true && opts.canvasMount !== undefined) {
-        canvasMountHandle = opts.canvasMount({
-            mountTarget: refs.stack,
-            callbacks: {
-                // Back-gesture → live-channel
-                // `canvas_navigated` outbound. The server updates
-                // `session.activeStackItemId` so ggui_consume's active-pipe
-                // resolution stays aligned with the user's nav focus.
-                onBackGesture: ({ previousActiveItemId, activeItemId }) => {
-                    canvasOutboundSend?.({
-                        type: 'canvas_navigated',
-                        payload: {
-                            sessionId: parsed.bootstrap.sessionId,
-                            previousActiveItemId,
-                            activeItemId,
-                        },
-                    });
-                },
-                // Display-mode escalation → spec
-                // postMessage to the host. The escalation policy decides
-                // which mode to request based on host capabilities + content
-                // state;
-                // this just forwards the decision via the existing
-                // `requestDisplayModeInParent` helper (paired audit
-                // envelope fires automatically). Hosts that don't speak the
-                // spec drop the postMessage silently, so the request is
-                // safe to fire unconditionally — the policy already gates
-                // on `availableDisplayModes`.
-                onRequestDisplayMode: (mode) => {
-                    requestDisplayModeInParent({
-                        toolName: 'ggui_canvas_shell',
-                        mode,
-                        sessionId: parsed.bootstrap.sessionId,
-                        appId: parsed.bootstrap.appId,
-                    });
-                },
-            },
-        });
-        renderIntoEl = canvasMountHandle.contentEl;
-    }
-    // Triad wiring — when supplied, the handler routes frames through
-    // StackRenderer + WireConfig + StreamBus. When absent, the placeholder
-    // path runs (boot.test.ts relies on the latter to keep its import
-    // graph tiny). The triad's channelRegistry is the dispatch surface
-    // for every WS frame; `connectFn` registers handshake handlers on
-    // top of the existing registry then binds the transport.
-    // When canvas-mode is active, build the
-    // lifecycle-payload sink that translates wire-shape
-    // `CanvasLifecyclePayload` envelopes into the animator-event
-    // shape and publishes on the mount's event bus. The triad's `data`
-    // channel handler invokes this for every envelope on the reserved
-    // `_ggui:lifecycle` channel.
-    const canvasLifecycleSink = canvasMountHandle !== null
-        ? canvasMountHandle.events.publishLifecycle.bind(canvasMountHandle.events)
-        : undefined;
-    const triad = triadWiring !== undefined
-        ? triadWiring.setup({
-            bootstrap: parsed.bootstrap,
-            stackModel,
-            renderInto: renderIntoEl,
+    setActiveValidatorSet(await loadCompiledValidatorsFromUrl(meta.validatorsUrl));
+    // Pin — this iframe binds to exactly one render id for its lifetime
+    // (post-render-identity-collapse each iframe = one mounted render,
+    // per [[kill-displaymode-divergence]]). The bootstrap's `renderId`
+    // is the pin; the render handler drops any frame addressed
+    // elsewhere.
+    const pinnedRenderId = meta.renderId;
+    // Renderer wiring — when supplied, the handler routes frames through
+    // the single-render mount surface + WireConfig + StreamBus. When
+    // absent, the placeholder path runs (boot.test.ts relies on the
+    // latter to keep its import graph tiny). The renderer's
+    // channelRegistry is the dispatch surface for every WS frame;
+    // `connectFn` registers handshake handlers on top of the existing
+    // registry then binds the transport.
+    const renderer = rendererHooks !== undefined
+        ? rendererHooks.setup({
+            meta,
+            renderInto: refs.stack,
             statusRefs: refs,
             ...(onObserve !== undefined ? { onObserve } : {}),
-            ...(canvasLifecycleSink !== undefined
-                ? { onCanvasLifecycle: canvasLifecycleSink }
-                : {}),
         })
         : null;
-    setStatus(refs, `Connecting to ${parsed.bootstrap.sessionId}…`, 'connecting');
-    // Boot-without-triad path: we still need a ChannelRegistry to
+    setStatus(refs, `Connecting to ${meta.renderId}…`, 'connecting');
+    // Boot-without-renderer path: we still need a ChannelRegistry to
     // receive frames, because the registry is the only dispatch
-    // surface. Build a minimal one with just the `push` placeholder
-    // handler so non-triad consumers (boot.test.ts) see the
-    // `data-ggui-stack-item` upserts.
-    const placeholderRegistry = triad === null
+    // surface. Build a minimal one with just the `render` placeholder
+    // handler so non-renderer consumers (boot.test.ts) can observe
+    // bootstrap-orchestration outcomes without paying React import
+    // cost. The handler logs status but does not mount React.
+    const placeholderRegistry = renderer === null
         ? createPlaceholderRegistry({
-            bootstrap: parsed.bootstrap,
-            stackModel,
+            meta,
             statusRefs: refs,
+            pinnedRenderId,
         })
         : null;
-    const activeRegistry = triad?.channelRegistry ?? placeholderRegistry;
-    // Bind the canvas's outbound send surface to
-    // the triad's buffered-send shim. The shim queues frames pre-WS;
-    // they flush automatically once `attachManager` swaps in the real
-    // socket. No need to await — the canvas's back-arrow won't fire
-    // until the user can physically click, which requires render +
-    // layout that always come after this binding.
-    if (canvasMountHandle !== null && triad !== null) {
-        canvasOutboundSend = (msg) => triad.manager.send(msg);
-    }
-    // Subscribe the canvas mount to local
-    // host-context-emitter updates so the display-mode escalation
-    // policy reconciles against the latest host capabilities. Fires
-    // once on
-    // subscribe with the seeded projection (if any) AND on every
-    // `host-context-changed` notification. Captures the local handle
-    // so the subscription is scoped to this boot pass — re-mounts
-    // would re-subscribe.
-    if (canvasMountHandle !== null) {
-        const localHandle = canvasMountHandle;
-        const unsubscribeHostContext = subscribeHostContextLocal((projection) => {
-            localHandle.setAvailableDisplayModes(projection.availableDisplayModes);
-            localHandle.setDisplayMode(projection.currentDisplayMode);
-        });
-        localHandle.registerCleanup(unsubscribeHostContext);
-    }
+    const activeRegistry = renderer?.channelRegistry ?? placeholderRegistry;
     /**
-     * Apply an ack's stack snapshot to the runtime — populates the model,
-     * refreshes status DOM, and (when triad is wired) re-renders the
-     * stack + re-activates the top item's channel-transport entry. Used
-     * by:
+     * Apply an ack's render snapshot to the runtime — when the ack
+     * carries a render matching `pinnedRenderId`, mount it through the
+     * renderer. Used by:
      *
      *   - The initial bootSequence path (first ack after subscribe).
      *   - The WS reconnect-with-rebootstrap path (every subsequent ack
      *     when the underlying WSTransport reconnects + re-fires
-     *     subscribe). A push or update that landed during the dropout
-     *     window flows back through here.
+     *     subscribe). A render or update that landed during the
+     *     dropout window flows back through here.
      *
-     * Idempotent on identical inputs — `stackModel.setAll` is a snapshot
-     * replace; `applyStack` + `applyStackItem` are server-side idempotent
-     * on the (stackItemId, channelName) tuple.
+     * Idempotent on identical inputs — `applyRender` patches in place
+     * via {@link RenderItemHandle.update} when called with the same
+     * render id; `channelTransport.applyRender` is server-side
+     * idempotent on the (renderId, channelName) tuple.
      */
-    const applyAckStack = async (ackPayload) => {
-        if (ackPayload.stack === undefined)
+    const applyAck = async (ackPayload) => {
+        const target = ackPayload.render;
+        if (target === undefined)
+            return;
+        if (target.id !== pinnedRenderId) {
+            // Server's snapshot is for a different render — likely a stale
+            // re-subscribe after the server pruned ours. Nothing to mount.
             return;
-        stackModel.setAll(ackPayload.stack);
-        refreshStackDom(refs, stackModel);
-        // Mirror the server snapshot into the canvas's NavStackModel so
-        // the React shell re-renders with the active item. `reset` fires
-        // `onMutation` → version bump → React bridge re-reads. It also
-        // fires `onNavChange` when the top item identity moves, but that
-        // listener is intentionally NOT wired in production: server-side
-        // stack resets flowing through this ack path do not echo
-        // `canvas_navigated` back — the server already owns
-        // `activeStackItemId` for state it produced. Outbound
-        // `canvas_navigated` originates only from the `onBackGesture`
-        // callback (user-driven pop). `onNavChange` remains available for
-        // future programmatic navigation triggers that originate inside
-        // the canvas without a back-gesture.
-        canvasMountHandle?.setStack(ackPayload.stack);
-        if (triad !== null) {
-            await triad.stackRenderer.applyStack(stackModel.snapshot());
-            const snapshot = stackModel.snapshot();
-            const top = snapshot[snapshot.length - 1];
-            if (top !== undefined &&
-                top.type !== 'mcpApps' &&
-                top.type !== 'system') {
-                triad.channelTransport.applyStackItem({
-                    stackItemId: top.id,
-                    ...(top.streamSpec !== undefined
-                        ? { streamSpec: top.streamSpec }
+        }
+        mountedRender = target;
+        if (renderer !== null) {
+            await renderer.applyRender(target);
+            if (target.type !== 'mcpApps' && target.type !== 'system') {
+                renderer.channelTransport.applyRender({
+                    renderId: target.id,
+                    ...(target.streamSpec !== undefined
+                        ? { streamSpec: target.streamSpec }
                         : {}),
                 });
             }
         }
     };
+    // `code-ready` is emitted exactly once per boot. The static seed mount
+    // emits it; the WS-ack reconcile path then becomes a silent repaint.
+    // Without this guard a static+live meta would fire `code-ready` twice
+    // (seed + ack), double-triggering host selectors / accessibility scanners.
+    let codeReadyEmitted = false;
+    const emitCodeReadyOnce = () => {
+        if (codeReadyEmitted)
+            return;
+        codeReadyEmitted = true;
+        onLifecycle?.(makeLifecycleEvent('code-ready', { renderId: meta.renderId }));
+    };
+    // Mode discriminators. The mount surface is DECOUPLED from the live
+    // channel: static content (codeUrl/kind) paints immediately with no WS;
+    // the live trio (wsUrl+wsToken) is an OPTIONAL enhancement that
+    // delivers props_update / data / re-render frames. A bootstrap with
+    // NEITHER has nothing to show and nowhere to subscribe.
+    const hasStaticContent = (typeof meta.codeUrl === 'string' && meta.codeUrl.length > 0) ||
+        (typeof meta.kind === 'string' && meta.kind.length > 0);
+    const hasLiveTrio = typeof meta.wsUrl === 'string' &&
+        meta.wsUrl.length > 0 &&
+        typeof meta.wsToken === 'string' &&
+        meta.wsToken.length > 0;
+    // ── Static seed mount — zero-round-trip paint, no WS required. ──────
+    // The ONLY mount path for spec-compliant MCP-Apps hosts that expose no
+    // ggui live channel (claude.ai / ChatGPT / Claude Desktop), AND the
+    // instant first paint for first-party hosts that ALSO open a WS (the
+    // WS ack then reconciles in place — `applyRender` is idempotent on the
+    // pinned renderId, and the ack's componentCode is byte-identical to the
+    // seed's `codeUrl` bytes, so it's a props-only update, no remount).
+    if (renderer !== null && hasStaticContent) {
+        // Await the 3rd-party gadget merge before first paint when the
+        // bootstrap declares operator-registered packages — otherwise a
+        // component importing a non-STDLIB gadget hits an undefined shim and
+        // crashes. STDLIB-only bootstraps resolve this promise synchronously.
+        if (meta.gadgets !== undefined && meta.gadgets.length > 0) {
+            await renderer.composedGadgets;
+        }
+        let seed = null;
+        try {
+            seed = await buildRenderSeedInput(meta);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            if (!hasLiveTrio) {
+                // No WS fallback — a failed static fetch is terminal.
+                setStatus(refs, `static mount failed: ${message}`, 'error');
+                emitBootFailure('UI_INITIALIZE_FAILED', message);
+                return { ok: false, mountedRender };
+            }
+            // A live trio is present — the WS ack will deliver the render.
+            // The seed was best-effort; fall through to subscribe.
+            seed = null;
+        }
+        if (seed !== null) {
+            await renderer.applyRender(seed);
+            mountedRender = seed;
+            emitCodeReadyOnce();
+        }
+    }
+    // ── No live channel → static-only host. ────────────────────────────
+    // The static seed already painted (or there was nothing to paint).
+    // A bootstrap with neither static content nor a live trio is a
+    // misconfiguration — surface a typed boot failure.
+    if (!hasLiveTrio) {
+        if (mountedRender === null) {
+            const message = 'bootstrap carries neither static content (codeUrl/kind) nor a live trio (wsUrl/wsToken)';
+            setStatus(refs, message, 'error');
+            emitBootFailure('MISSING_META_GGUI_BOOTSTRAP', message);
+            return { ok: false, mountedRender };
+        }
+        // Host-context wiring for the no-WS static mount (claude.ai / ChatGPT
+        // / Claude Desktop). The INITIAL host theme/style/fonts were already
+        // applied at boot (applyHostContextStyling, above); attach the
+        // spec-canonical `hostcontextchanged` listener so a post-boot host
+        // theme toggle still re-paints the iframe. There is no WS to echo
+        // context back to a server, so the emitter's `send` is a no-op —
+        // `seed()` needs it only to initialize emitter state, and
+        // `handleHostContextChangedParams` applies the DOM styling BEFORE the
+        // (no-op) echo. WS hosts get the real echo on the live-trio path below.
+        if (parsed.hostContext !== undefined) {
+            seedHostContext({
+                renderId: meta.renderId,
+                send: () => { },
+                initial: parsed.hostContext,
+            });
+            attachHostContextListener({ app });
+        }
+        setConnectedStatus(refs);
+        return { ok: true, mountedRender };
+    }
+    // ── Live-channel subscribe (conditional enhancement). ──────────────
     let handle;
     try {
         handle = await connectFn({
-            bootstrap: parsed.bootstrap,
+            meta,
             registry: activeRegistry,
             onStatusChange: (status) => {
-                setStatus(refs, status === 'connected'
-                    ? `Connected (${stackModel.size()} item${stackModel.size() === 1 ? '' : 's'}).`
-                    : `Connection ${status}…`, status);
+                setStatus(refs, status === 'connected' ? 'Connected.' : `Connection ${status}…`, status);
                 // Propagate WS status to the per-channel transport router so
                 // it can flip WS-bound channels into polling
                 // fallback (on disconnect) and re-send `channel_subscribe`
-                // on reconnect. No-op when triad wiring is absent.
-                if (triad !== null) {
-                    triad.channelTransport.onWsStatusChange(status);
+                // on reconnect. No-op when renderer wiring is absent.
+                if (renderer !== null) {
+                    renderer.channelTransport.onWsStatusChange(status);
                 }
             },
             // Forward typed errors from subscribe through the runtime's
@@ -398,17 +540,38 @@ export async function bootSequence(opts) {
             ...(onObserve !== undefined ? { onObserve } : {}),
             // Reconnect-with-rebootstrap — on every ack received AFTER the
             // initial handshake settled, reapply the server's authoritative
-            // `stack` snapshot. A push or update that landed during a WS
+            // `render` snapshot. A render or update that landed during a WS
             // dropout window restores here without an agent re-prompt.
             onResubscribeAck: (ack) => {
-                void applyAckStack(ack);
+                void applyAck(ack);
             },
+            // R7 — registry-level events-polling fallback. Composed once at
+            // bind time from `meta.pollingUrl` (server-stamped wsToken-
+            // gated /api/renders/<id>/events URL) + `meta.lastSequence`
+            // (cursor seed). FailoverHandle uses this when WS reaches
+            // 'failed'; absent → no polling fallback (WS-only mode).
+            //
+            // Same cursor model as the WS subscribe `sinceSequence` replay
+            // path — switching transports does not lose events.
+            ...(typeof meta.pollingUrl === 'string' && meta.pollingUrl.length > 0
+                ? {
+                    polling: buildEventsPolling({
+                        baseUrl: meta.pollingUrl,
+                        ...(meta.lastSequence !== undefined
+                            ? { initialSinceSequence: meta.lastSequence }
+                            : {}),
+                    }),
+                }
+                : {}),
         });
     }
     catch (err) {
-        if (triad !== null)
-            triadWiring?.teardown?.(triad);
+        // UPGRADE_REQUIRED is TERMINAL even when static content already
+        // painted — the mounted code may be wire-incompatible with this
+        // runtime, so surfacing the upgrade prompt wins over a stale mount.
         if (isUpgradeRequiredErrorLike(err)) {
+            if (renderer !== null)
+                rendererHooks?.teardown?.(renderer);
             const message = err.message;
             setStatus(refs, message, 'upgrade-required');
             // `UPGRADE_REQUIRED` already emits a typed `version` error via
@@ -416,87 +579,96 @@ export async function bootSequence(opts) {
             // here carries the coarse-grained reason for hosts that only
             // pattern-match `kind: 'bootstrap'`.
             emitBootFailure('UPGRADE_REQUIRED', message);
-            return { ok: false, stack: stackModel };
+            return { ok: false, mountedRender };
         }
         const message = err instanceof Error ? err.message : String(err);
+        if (mountedRender !== null) {
+            // DEGRADE — a transport/auth failure AFTER a static seed already
+            // painted. Keep the mounted content, skip live updates (props_update
+            // simply stops arriving), and do NOT tear down or surface a
+            // bootstrap failure. connectFn already emitted the typed
+            // `subscribe-failed` observability event on its own onObserve path.
+            setStatus(refs, `live updates unavailable: ${message}`, 'connecting');
+            emitCodeReadyOnce();
+            return { ok: true, mountedRender };
+        }
+        if (renderer !== null)
+            rendererHooks?.teardown?.(renderer);
         setStatus(refs, `WS handshake failed: ${message}`, 'error');
         emitBootFailure('WS_HANDSHAKE_FAILED', message);
-        return { ok: false, stack: stackModel };
+        return { ok: false, mountedRender };
     }
-    // Attach the live transport handle to the triad — flushes any
+    // Attach the live transport handle to the renderer — flushes any
     // buffered outbound frames (feedback / action) that were queued
     // while the subscribe handshake completed. `handle.handle.send` is
     // the canonical send surface for the bound WS transport.
-    if (triad !== null && triadWiring?.attachManager !== undefined) {
-        triadWiring.attachManager(triad, { send: (msg) => handle.handle.send(msg) });
+    if (renderer !== null && rendererHooks?.attachManager !== undefined) {
+        rendererHooks.attachManager(renderer, { send: (msg) => handle.handle.send(msg) });
     }
-    // seed the host-context emitter with the
-    // projection `parseBootstrap` captured from `ui/initialize`'s
-    // `hostContext` field, and install the `host-context-changed`
+    // seed the host-context emitter with the projection captured from
+    // `app.getHostContext()` (the App class's spec-canonical
+    // `ui/initialize` capture), and install the `hostcontextchanged`
     // notification listener so subsequent live updates also echo to
     // the server. Both calls are idempotent and no-op when the host
     // didn't emit a HostContext (parsed.hostContext === undefined).
     if (parsed.hostContext !== undefined) {
         seedHostContext({
-            sessionId: parsed.bootstrap.sessionId,
+            renderId: meta.renderId,
             send: (msg) => handle.handle.send(msg),
             initial: parsed.hostContext,
         });
-        attachHostContextListener();
+        // Bind via App's spec-canonical `hostcontextchanged` event surface.
+        // App's onEventDispatch pre-merges the params into its internal
+        // `_hostContext` before our handler runs, so `app.getHostContext()`
+        // is always fresh by the time we project + WS-echo.
+        attachHostContextListener({ app });
     }
-    // First ack — populate the stack from the snapshot the server
-    // returned. Under triad mode, also hand the initial stack to the
-    // renderer so its mounts match the model on first frame.
-    //
-    // Reuses the same `applyAckStack` helper the reconnect-rebootstrap
-    // path uses — so a server-restart-driven full snapshot replay and
-    // the first-boot snapshot apply flow through one implementation.
-    await applyAckStack(handle.ack);
-    setConnectedStatus(refs, stackModel);
-    // Lifecycle `code-ready` — terminal happy state. The bundle has
-    // evaluated, the WS handshake completed, the first ack folded into
-    // the stack. Hosts pinning selectors on `code-ready` (E2E specs,
-    // accessibility scanners) re-resolve here. When the bootstrap pinned
-    // a `stackItemId` (single-item mode), forward it so the host can
-    // mirror per-card lifecycle on the outer element if it's keyed by
-    // stack item id.
-    onLifecycle?.(makeLifecycleEvent('code-ready', {
-        ...(parsed.bootstrap.stackItemId !== undefined
-            ? { stackItemId: parsed.bootstrap.stackItemId }
-            : {}),
-    }));
-    return { ok: true, stack: stackModel };
+    // First ack — apply the server's render snapshot (when matching
+    // `pinnedRenderId`) and mount it. Reuses the same `applyAck` helper
+    // the reconnect-rebootstrap path uses — so a server-restart-driven
+    // snapshot replay and the first-boot snapshot apply flow through
+    // one implementation.
+    await applyAck(handle.ack);
+    setConnectedStatus(refs);
+    // Lifecycle `code-ready` — terminal happy state. Emitted ONCE per boot
+    // (a static+live meta already fired it from the seed mount, so this is
+    // a no-op there); for a live-only meta this is the first + only emit.
+    // Hosts pinning selectors on `code-ready` (E2E specs, accessibility
+    // scanners) re-resolve here.
+    emitCodeReadyOnce();
+    return { ok: true, mountedRender };
 }
 /**
- * Build a minimal `ChannelRegistry` for boot paths without triad
+ * Build a minimal `ChannelRegistry` for boot paths without renderer
  * wiring (boot.test.ts + the C7a placeholder-only spec). The registry
- * carries just the `push` handler (which folds frames into the
- * placeholder DOM) — every other frame type silently drops. Production
- * boots through `bootProduction` which supplies a fully-populated
- * triad with the rich handler set.
+ * carries just the `push` handler — which logs status but does not
+ * mount React — so consumers can observe bootstrap-orchestration
+ * outcomes without paying React import cost. Every other frame type
+ * silently drops. Production boots through `bootProduction` which
+ * supplies a fully-populated renderer with the rich handler set.
  */
 function createPlaceholderRegistry(params) {
     const registry = new ChannelRegistry({
         subscribeFrameBuilder: () => ({
             type: 'subscribe',
             payload: {
-                sessionId: params.bootstrap.sessionId,
-                appId: params.bootstrap.appId,
-                ...(params.bootstrap.token !== undefined
-                    ? { bootstrap: params.bootstrap.token }
+                renderId: params.meta.renderId,
+                appId: params.meta.appId,
+                ...(params.meta.wsToken !== undefined
+                    ? { wsToken: params.meta.wsToken }
                     : {}),
             },
         }),
     });
-    registry.register(createPushHandler({
-        stackModel: params.stackModel,
+    registry.register(createRenderHandler({
         statusRefs: params.statusRefs,
+        pinnedRenderId: params.pinnedRenderId,
     }));
     return registry;
 }
 /**
- * Frame dispatch lives inside `@ggui-ai/channel-client`'s
- * `ChannelRegistry`. Every WS frame type (`push`, `data`,
+ * Frame dispatch lives inside `@ggui-ai/live-channel`'s
+ * `ChannelRegistry`. Every WS frame type (`render`, `data`,
  * `props_update`, `drain_ack`, `feedback`, `channel_payload`,
  * `channel_error`, `system`) has a registered handler in
  * `channels/*.ts`; the registry's bound transport routes inbound
@@ -504,7 +676,7 @@ function createPlaceholderRegistry(params) {
  * (`contract-error-emitted`, `auth-required`) are now inside the
  * data + system handlers respectively.
  *
- * The pre-B3b helpers (`handleServerMessage`, `handleTriadMessage`,
+ * The pre-B3b helpers (`handleServerMessage`, `handleRendererMessage`,
  * `handleObservableMessage`, `emitContractErrorFromDataFrame`,
  * `emitAuthRequiredFromSystemFrame`, `BufferedManagerShim`) lived
  * here and have been retired — see commit message + plan B3b for the
@@ -530,42 +702,109 @@ function shouldAutostart() {
     return process.env?.GGUI_RENDERER_AUTOSTART !== 'false';
 }
 /**
- * Read `globalThis.__GGUI_BOOTSTRAP__` synchronously, validate against
- * the unified bootstrap shape, and return the typed bootstrap (or null
+ * Read `globalThis.__GGUI_META__` synchronously, validate against
+ * the unified slice-meta shape, and return the typed meta (or null
  * on absence / malformation).
  *
- * Thin wrapper around {@link parseBootstrapFromGlobal}; preserved for
+ * Thin wrapper around {@link parseMetaFromGlobal}; preserved for
  * back-compat (downstream consumers + tests). Returns `null` instead
- * of `BootstrapParseResult` to match the historical reader contract
- * — the autostart resolver only needs the "valid bootstrap or fall
- * through" signal.
+ * of {@link McpAppAiGguiMetaParseResult} to match the historical
+ * reader contract — the autostart resolver only needs the "valid
+ * meta or fall through" signal.
+ */
+export function readSelfContainedMeta() {
+    const result = parseMetaFromGlobal();
+    return result.ok ? result.meta : null;
+}
+/**
+ * Parse the bootstrap meta's `propsJson` string into a {@link JsonObject}.
+ * Malformed JSON or a non-object payload is a shape-preserving skip
+ * (returns `undefined`) — a bad `propsJson` must never block the mount.
+ * `JsonValue` narrows to `JsonObject` via the object/non-null/non-array
+ * guard, so no cast is needed.
  */
-export function readSelfContainedBootstrap() {
-    const result = parseBootstrapFromGlobal();
-    return result.ok ? result.bootstrap : null;
+function parseSeedProps(propsJson) {
+    if (propsJson === undefined)
+        return undefined;
+    try {
+        const parsed = JSON.parse(propsJson);
+        if (typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed)) {
+            return parsed;
+        }
+        return undefined;
+    }
+    catch {
+        // Malformed propsJson is a shape-preserving skip — mount with no props.
+        return undefined;
+    }
 }
 /**
- * Extract a {@link SelfContainedBootstrap} from a
+ * Project the inline `__GGUI_META__` bootstrap into a
+ * {@link RenderSeedInput} the mount surface can paint immediately,
+ * BEFORE the authoritative wire `Render` arrives over the WS — and with
+ * no WS at all for spec-compliant MCP-Apps hosts that expose no ggui
+ * live channel (claude.ai / ChatGPT / Claude Desktop).
+ *
+ * Two static-content shapes (the autostart discriminator):
+ *   - `kind`    → a system-card seed (`type:'system'`); no fetch.
+ *   - `codeUrl` → a compiled-component seed; fetches the
+ *     content-addressable component bytes.
+ *
+ * Returns `null` when the meta carries NEITHER (a live-only meta has
+ * nothing to seed — the first WS ack mounts it). Throws when a `codeUrl`
+ * fetch fails so the caller can surface a typed boot failure. The four
+ * server-assigned ledger fields are intentionally absent — the first
+ * ack reconciles the seed to a full `Render` (no fabrication).
+ */
+export async function buildRenderSeedInput(meta) {
+    const props = parseSeedProps(meta.propsJson);
+    // System-card mode — `kind` keyed against the built-in registry.
+    if (meta.kind !== undefined) {
+        return {
+            id: meta.renderId,
+            appId: meta.appId,
+            type: 'system',
+            kind: meta.kind,
+            ...(props !== undefined ? { props } : {}),
+        };
+    }
+    // Compiled-component mode — fetch the content-addressable bytes.
+    if (meta.codeUrl === undefined)
+        return null;
+    const res = await fetch(meta.codeUrl);
+    if (!res.ok) {
+        throw new Error(`buildRenderSeedInput: codeUrl fetch failed (${res.status}): ${meta.codeUrl}`);
+    }
+    const componentCode = await res.text();
+    return {
+        id: meta.renderId,
+        appId: meta.appId,
+        componentCode,
+        ...(props !== undefined ? { props } : {}),
+    };
+}
+/**
+ * Extract a {@link SelfContainedMcpAppAiGguiMeta} from a
  * `ui/notifications/tool-result` JSON-RPC params payload — the
  * postMessage delivery shape MCP Apps hosts (Claude Desktop, claude.ai
  * web) use to push the active tool's `_meta` to the iframe.
  *
- * Thin wrapper around {@link parseBootstrapFromToolResult}; same
- * back-compat motivation as {@link readSelfContainedBootstrap}.
+ * Thin wrapper around {@link parseMetaFromToolResult}; same
+ * back-compat motivation as {@link readSelfContainedMeta}.
  *
  * Owning this extraction inside the runtime (instead of in the shell
  * HTML) is the architectural cure for the "shell-side validator
  * lagged the protocol" bug class: shell + runtime drift becomes
- * impossible because the shell never inspects the bootstrap shape.
+ * impossible because the shell never inspects the slice-meta shape.
  */
-export function extractBootstrapFromToolResult(params) {
-    const result = parseBootstrapFromToolResult(params);
-    return result.ok ? result.bootstrap : null;
+export function extractMetaFromToolResult(params) {
+    const result = parseMetaFromToolResult(params);
+    return result.ok ? result.meta : null;
 }
 /**
  * Drain `window.__GGUI_PENDING_TOOL_RESULTS__` — the buffer the
  * minimal shell populates while messages arrive between
- * shell-load and runtime-load. Returns the first valid bootstrap
+ * shell-load and runtime-load. Returns the first valid slice meta
  * found; later params (if any) are dropped (each new tool-result
  * supersedes the previous).
  *
@@ -581,25 +820,58 @@ function readPendingToolResults() {
     if (!Array.isArray(raw) || raw.length === 0)
         return null;
     for (const params of raw) {
-        const bootstrap = extractBootstrapFromToolResult(params);
-        if (bootstrap !== null)
-            return bootstrap;
+        const meta = extractMetaFromToolResult(params);
+        if (meta !== null)
+            return meta;
     }
     return null;
 }
 /**
- * Listen for a `ui/notifications/tool-result` postMessage from the
- * parent window and resolve to the extracted bootstrap. Times out
- * after `timeoutMs`; resolves `null` on timeout so the caller can
- * fall through to a legacy bootstrap path (e.g.
- * {@link bootProduction}).
+ * Listen for a `ui/notifications/tool-result` notification via the
+ * App's spec-canonical event surface and resolve to the extracted
+ * slice meta. Times out after `timeoutMs`; resolves `null` on timeout
+ * so the caller can fall through to a legacy boot path.
  *
- * Pairs with the minimal-shell pattern: shell buffers any tool-
- * results that arrived BEFORE runtime load (read via
- * {@link readPendingToolResults}); this listener catches the ones
- * that arrive AFTER. The two cover the full timing race.
+ * Used by `bootSequence` for the spec-canonical Tier 2 fallback when
+ * the synchronous `__GGUI_META__` inline global yields nothing. Must
+ * be called BEFORE `app.connect(transport)` — App's
+ * `_assertHandlerTiming` warns when the first handler for a one-shot
+ * event registers after the handshake.
+ */
+function awaitToolResultMetaFromApp(app, timeoutMs) {
+    return new Promise((resolve) => {
+        let settled = false;
+        const handler = (params) => {
+            if (settled)
+                return;
+            const meta = extractMetaFromToolResult(params);
+            if (meta === null)
+                return;
+            settled = true;
+            app.removeEventListener('toolresult', handler);
+            clearTimeout(timer);
+            resolve(meta);
+        };
+        app.addEventListener('toolresult', handler);
+        const timer = setTimeout(() => {
+            if (settled)
+                return;
+            settled = true;
+            app.removeEventListener('toolresult', handler);
+            resolve(null);
+        }, timeoutMs);
+    });
+}
+/**
+ * Pre-handshake variant — listens to raw `window.message` for the
+ * autostart layer. Used BEFORE the App is constructed, so this can't
+ * route through `app.addEventListener`. Pairs with the minimal-shell
+ * pattern: the shell buffers any tool-results that arrived BEFORE
+ * runtime load (read via {@link readPendingToolResults}); this
+ * listener catches the ones that arrive AFTER the bundle parses but
+ * BEFORE bootSequence runs.
  */
-function awaitToolResultBootstrap(timeoutMs) {
+function awaitToolResultMeta(timeoutMs) {
     if (typeof window === 'undefined')
         return Promise.resolve(null);
     return new Promise((resolve) => {
@@ -620,64 +892,35 @@ function awaitToolResultBootstrap(timeoutMs) {
                 m.method !== 'ui/notifications/tool-result') {
                 return;
             }
-            const bootstrap = extractBootstrapFromToolResult(m.params);
-            if (bootstrap !== null)
-                settle(bootstrap);
+            const meta = extractMetaFromToolResult(m.params);
+            if (meta !== null)
+                settle(meta);
         };
         window.addEventListener('message', onMessage);
         const timer = setTimeout(() => settle(null), timeoutMs);
     });
 }
 /**
- * Post-mount resize plumbing for MCP Apps hosts that size the outer
- * iframe based on the inner content height. claude.ai (web +
- * desktop) honors `ui/notifications/size-changed` notifications;
- * other hosts ignore them harmlessly.
- *
- * Owning this in the runtime (instead of duplicated in every shell
- * builder) is the same architectural fix as
- * {@link extractBootstrapFromToolResult}: anything that observes
- * mounted-component state belongs alongside the mount, not in the
- * shell.
+ * Module-level guard for the App-mediated post-mount toolresult
+ * re-listener. Ensures exactly one persistent
+ * `app.addEventListener('toolresult', …)` registration even when
+ * `bootSelfContained` is called multiple times (e.g. an agent fires a
+ * second `ggui_render` and we re-mount).
  */
-function installResizeObserver(rootEl) {
-    if (typeof window === 'undefined')
-        return;
-    let lastH = 0;
-    const emit = () => {
-        const docBody = window.document.body;
-        const h = Math.max(rootEl instanceof HTMLElement ? rootEl.scrollHeight : 0, docBody.scrollHeight, 200);
-        if (h === lastH)
-            return;
-        lastH = h;
-        try {
-            window.parent.postMessage({
-                jsonrpc: '2.0',
-                method: 'ui/notifications/size-changed',
-                params: { height: h },
-            }, '*');
-        }
-        catch {
-            // Detached parent — swallow (matches postBootFailure posture).
-        }
-    };
-    emit();
-    if (typeof ResizeObserver === 'function') {
-        const ro = new ResizeObserver(emit);
-        ro.observe(rootEl);
-        ro.observe(window.document.body);
-    }
-    else {
-        setInterval(emit, 500);
-    }
-}
+let postMountListenerInstalled = false;
 /**
- * Module-level guard for {@link installPostMountListener}. Ensures
- * exactly one persistent `ui/notifications/tool-result` listener is
- * attached even when `bootSelfContained` is called multiple times
- * (e.g. an agent fires a second `ggui_push` and we re-mount).
+ * Module-level handle to the active renderer's `applyRender`, published
+ * by `bootProduction`'s `setup()` once the renderer is built. The
+ * module-level {@link installPostMountListener} resolves this to re-mount
+ * on a host-re-emitted tool-result WITHOUT a fresh boot — no second mount
+ * stack, no second WS. This is the no-WS live-re-render channel for
+ * spec-compliant MCP-Apps hosts (claude.ai / ChatGPT / Claude Desktop)
+ * that re-broadcast the tool-result instead of pushing a WS frame.
+ *
+ * `null` until a renderer is published (e.g. unit tests that drive
+ * `bootSequence` with no renderer never set it → the listener no-ops).
  */
-let postMountListenerInstalled = false;
+let activeApplyRender = null;
 /**
  * Module-level guard for {@link installAnchorClickInterceptor}. Same
  * rationale as {@link postMountListenerInstalled}: re-mounts are
@@ -690,7 +933,7 @@ let anchorClickInterceptInstalled = false;
  * Module-level guard for {@link installFullscreenInterceptors}. The
  * fullscreen interceptors REPLACE prototype methods on `Element` and
  * `Document`; re-overriding on every re-mount would chain wrappers
- * and (if the captured `args` differ) leak stale `sessionId`/`appId`.
+ * and (if the captured `args` differ) leak stale `renderId`/`appId`.
  * The guard ensures exactly one prototype patch.
  */
 let fullscreenInterceptInstalled = false;
@@ -792,9 +1035,22 @@ export function formatWiredActionDataInline(data) {
  */
 /**
  * Post an arbitrary JSON-RPC envelope to the iframe's parent
- * window. Internal helper shared across {@link dispatchWiredAction},
- * {@link emitAudit}, and the native-idiom interceptors (`openLink` /
- * `requestDisplayMode`). Detached parent → silent drop (non-fatal).
+ * window. Internal helper shared across {@link emitAudit} (the
+ * fire-and-forget `tools/call` audit envelope) and any other
+ * non-spec-canonical `ggui:*` outbound envelope that doesn't have an
+ * App method equivalent. Detached parent → silent drop (non-fatal).
+ *
+ * Spec-canonical MCP-Apps notifications whose params are FULLY
+ * described by the spec schema (`ui/update-model-context`,
+ * `ui/open-link`, `ui/request-display-mode`) flow through the App
+ * method helpers below — they round-trip via the bound `Transport`
+ * and follow the spec's request/response shape.
+ *
+ * `ui/message` is the exception: its doorbell carries a content-block
+ * `_meta` extension that the host's closed `McpUiMessageRequestSchema`
+ * parse would strip (and empty the text). It posts its `ui/message`
+ * frame through this raw helper instead — see {@link
+ * emitUserActionDoorbell} for the full rationale.
  */
 function postToParent(envelope) {
     if (typeof window === 'undefined')
@@ -807,77 +1063,117 @@ function postToParent(envelope) {
     }
 }
 /**
- * Request-response JSON-RPC postMessage. Fires the envelope up to
- * `window.parent` and resolves when the parent echoes back a message
- * with the matching `id`. Used by the channel-transport router's
- * iframe-polling fallback to fire `tools/call` directly (Pattern α)
- * without an LLM consent loop.
+ * Outbound MCP-Apps notification shims — fire the spec-canonical App
+ * method when the module-level App handle is set, otherwise drop
+ * silently. Each method is a fire-and-forget request from the
+ * iframe-runtime's perspective: production never awaits the host's
+ * ack, so we use `void` + `.catch(noop)` to suppress unhandled
+ * rejections.
  *
- * Detached parent → rejects with a synchronous error. Single
- * shared listener per iframe lifecycle (added on first call) so the
- * router doesn't churn `'message'` handlers per poll tick.
- *
- * Distinct from {@link makeJsonRpcCaller} which is a CLOSURE-scoped
- * caller bound to the bootstrap-mode `ui/initialize` flow. This one
- * is a top-level helper the triad setup uses for every `tools/call`
- * — moving it here keeps the channel-transport router pure (no
- * `window.addEventListener` inside).
+ * Pre-connect call site safety: every production caller fires after
+ * the boot pipeline has installed an App (anchor clicks, fullscreen
+ * gestures, context-observer ticks, dispatch fan-outs all gate on
+ * post-mount lifecycle). The no-op fallback exists for unit tests
+ * that exercise these helpers without invoking `bootSequence` —
+ * the absence of side effects there is the test's signal that the
+ * caller did its part.
  */
-let postRpcToParentInited = false;
-const postRpcToParentPending = new Map();
-let postRpcToParentNextId = 1_000_000;
-function ensurePostRpcToParentListener() {
-    if (postRpcToParentInited)
+function callAppUpdateModelContext(params) {
+    const app = getCurrentApp();
+    if (app === null)
         return;
-    if (typeof window === 'undefined')
+    void app.updateModelContext(params).catch(() => {
+        // Detached / host-rejected — drop silently per the helper contract.
+    });
+}
+function callAppOpenLink(params) {
+    const app = getCurrentApp();
+    if (app === null)
         return;
-    postRpcToParentInited = true;
-    window.addEventListener('message', (event) => {
-        const data = event.data;
-        if (data === null || typeof data !== 'object')
-            return;
-        const id = data.id;
-        if (typeof id !== 'number')
-            return;
-        // Filter for RESPONSES — must carry `result` or `error`. Bare
-        // requests with `method` set are not responses. This matters in
-        // `/r/<shortCode>` top-level mode where `window.parent === window`,
-        // so the outbound `tools/call` echoes back through this same
-        // listener before any relay's response arrives; without the filter
-        // the pending promise resolves with the request itself and the
-        // real response is dropped.
-        if (!('result' in data) && !('error' in data))
-            return;
-        const resolver = postRpcToParentPending.get(id);
-        if (resolver === undefined)
-            return;
-        postRpcToParentPending.delete(id);
-        resolver(data);
+    void app.openLink(params).catch(() => {
+        // Detached / host-rejected — drop silently per the helper contract.
     });
 }
-function postRpcToParent(method, params) {
-    if (typeof window === 'undefined') {
-        return Promise.resolve({
-            error: { message: 'postRpcToParent: no window' },
+function callAppRequestDisplayMode(params) {
+    const app = getCurrentApp();
+    if (app === null)
+        return;
+    void app.requestDisplayMode(params).catch(() => {
+        // Detached / host-rejected — drop silently per the helper contract.
+    });
+}
+/**
+ * Production {@link ContextSnapshotPoster} — the seam the
+ * context-observer factories consume. Splits the two destinations:
+ *
+ *   - `postUpdateModelContext` → spec-canonical
+ *     `app.updateModelContext(...)` (via {@link callAppUpdateModelContext}).
+ *   - `postContextMirror` → raw `tools/call ggui_runtime_sync_context`
+ *     via {@link postToParent} (the host-relay mirror path; not yet
+ *     migrated to `app.callServerTool` — see emitAudit for the same
+ *     posture).
+ */
+const productionContextSnapshotPoster = {
+    postUpdateModelContext: (params) => {
+        callAppUpdateModelContext(params);
+    },
+    postContextMirror: (params) => {
+        postToParent({
+            jsonrpc: '2.0',
+            id: Math.floor(Math.random() * 1e9),
+            method: 'tools/call',
+            params: {
+                name: 'ggui_runtime_sync_context',
+                arguments: {
+                    renderId: params.renderId,
+                    appId: params.appId,
+                    snapshot: params.snapshot,
+                },
+            },
         });
+    },
+};
+/**
+ * Outbound `tools/call` shim. Routes through the spec-canonical
+ * `app.callServerTool` API on the module-level App handle. Production
+ * always has the handle set (bootSequence / bootSelfContained call
+ * `setCurrentApp(app)` after handshake); tests that exercise dispatch
+ * routing install one explicitly via {@link setCurrentApp} bound to
+ * a `MockTransport`.
+ *
+ * Returns a `JsonRpcResponse`-shaped object for source-compatibility
+ * with the previous direct postMessage path: callers parse
+ * `resp.result.structuredContent` to read submit_action's `{ok, code,
+ * consumerPresent}` envelope. The App branch wraps the parsed
+ * `CallToolResult` in `{result: ...}`.
+ *
+ * Drops with an error envelope when no App is bound — the dispatch
+ * pipeline classifies that as a transport error and routes to the
+ * `ui/message` fallback.
+ */
+async function callServerToolSpec(toolName, args) {
+    const app = getCurrentApp();
+    if (app === null) {
+        return {
+            error: {
+                message: 'callServerToolSpec: no App bound — call setCurrentApp() first',
+            },
+        };
+    }
+    try {
+        const result = await app.callServerTool({
+            name: toolName,
+            arguments: args,
+        });
+        return { jsonrpc: '2.0', result: result };
+    }
+    catch (err) {
+        return {
+            error: {
+                message: err instanceof Error ? err.message : String(err),
+            },
+        };
     }
-    ensurePostRpcToParentListener();
-    return new Promise((resolve) => {
-        const id = postRpcToParentNextId;
-        postRpcToParentNextId += 1;
-        postRpcToParentPending.set(id, resolve);
-        try {
-            window.parent.postMessage({ jsonrpc: '2.0', id, method, params: params ?? {} }, '*');
-        }
-        catch (err) {
-            postRpcToParentPending.delete(id);
-            resolve({
-                error: {
-                    message: err instanceof Error ? err.message : String(err),
-                },
-            });
-        }
-    });
 }
 /**
  * Fire a single canonical action envelope (`tools/call
@@ -904,10 +1200,7 @@ export function emitAudit(args) {
             arguments: {
                 kind: args.kind,
                 payload: args.payload,
-                sessionId: args.sessionId,
-                ...(args.stackItemId !== undefined
-                    ? { stackItemId: args.stackItemId }
-                    : {}),
+                renderId: args.renderId,
                 appId: args.appId,
                 actionId: args.actionId,
                 firedAt: args.firedAt,
@@ -1091,105 +1384,113 @@ function readLocalUiContext() {
     return out;
 }
 /**
- * Emit a `ui/message` envelope tagged with
- * `_meta.ggui.userAction.kind === 'inline'`. Fires when `submit_action`
- * did NOT successfully append to the pipe (PIPE_NOT_FOUND, transport
- * error, or the host has no relay). The full action payload travels
- * inline so the agent can act WITHOUT calling `ggui_consume` for this
- * stack item (the pipe is gone).
+ * Emit the `ai.ggui/userAction` PURE DOORBELL on a `ui/message`
+ * envelope. Fires when `submit_action` succeeded BUT the server
+ * reported `consumerPresent: false` — no `ggui_consume` long-poll is
+ * currently listening on this render's pipe (the agent's persistent
+ * consume loop has ended, e.g. after a page reload). The gesture is
+ * ALREADY on the pipe from the just-completed `submit_action` append;
+ * this doorbell only wakes a fresh agent turn so it calls
+ * `ggui_consume({renderId})` to drain it.
  *
- * `nextStep` is optional — when the contract bound `actionSpec[intent]`
- * to a specific agent tool we forward that hint; absent when the
- * author left it free.
+ * SINGLE SOURCE OF TRUTH: the pipe. This carries ONLY a pointer to the
+ * render — never the action payload or uiContext. Carrying the payload
+ * here would let the agent act on the inline copy AND drain the pipe =
+ * a double-trigger (the action fires twice). Pointer-only ⇒ the agent
+ * retrieves the gesture EXCLUSIVELY via `ggui_consume`, so it's
+ * exactly-once by construction.
  */
-function emitUserActionInline(args) {
-    // Prose-only text. Earlier revisions embedded a fenced ```json``` block
-    // with the full payload so hosts that strip `_meta` could still read
-    // it. That format mirrored Anthropic's tool-use JSON shape too closely
-    // and tripped claude.ai's prompt-injection classifier — even on the
-    // user-trusted `ui/message` channel — so the message got flagged
-    // before reasoning. The fix is structural: keep structured data
-    // ONLY on `_meta.ggui.userAction.payload` (where MCP Apps hosts read
-    // it through the spec's trusted path) and let the text carry a
-    // natural-language summary that no classifier can mistake for a
-    // tool-call injection.
-    const description = `User fired ${args.intent} on ${args.stackItemId}`;
-    const text = `User fired "${args.intent}" on stack item ${args.stackItemId}. ` +
-        `The action pipe was unavailable, so the gesture is inlined on this ` +
-        `message instead of queued on the consume pipe. Use the userAction ` +
-        `payload to handle it directly; do NOT call ggui_consume for this ` +
-        `stack item.`;
-    postToParent({
-        jsonrpc: '2.0',
-        id: Math.floor(Math.random() * 1e9),
-        method: 'ui/message',
-        params: {
-            role: 'user',
-            content: [{ type: 'text', text }],
-            _meta: {
-                ggui: {
-                    userAction: {
-                        kind: 'inline',
-                        description,
-                        stackItemId: args.stackItemId,
-                        actionId: args.actionId,
-                        submittedAt: args.submittedAt,
-                        intent: args.intent,
-                        payload: {
-                            actionData: args.actionData ?? null,
-                            uiContext: args.uiContext,
-                        },
-                        ...(args.nextStep !== undefined ? { nextStep: args.nextStep } : {}),
-                    },
-                },
-            },
+function emitUserActionDoorbell(args) {
+    // THE DIRECTIVE LIVES IN THIS TEXT. Every host (claude.ai,
+    // chatgpt.com, ggui-aware SDKs) forwards the `ui/message` text to the
+    // model verbatim — none of them runs a ggui-side synthesizer. So the
+    // iframe-runtime is the single directive-authoring point. The
+    // wording below is the empirically-validated XML-tagged
+    // imperative-first shape (REQUIRED FIRST TOOL CALL + `<ggui_directive>`
+    // tags + gesture framing) that was previously synthesized
+    // server-side. The imperative-first phrasing — "Call <tool> NOW. ...
+    // Do not respond conversationally." — is load-bearing for Gemini,
+    // which otherwise summarizes the situation back to the user instead
+    // of dispatching the prepared tool call.
+    //
+    // It is deliberately GENERIC: it names the render pointer, never the
+    // action specifics. Naming what the user did would tempt the agent to
+    // act before consuming = the double-trigger this whole shape exists
+    // to kill. The agent gets the actionable data EXCLUSIVELY from
+    // `ggui_consume`.
+    //
+    // Prose + XML tags only, no fenced ```json``` block: a verbatim copy
+    // of a tool-call wire shape trips claude.ai's prompt-injection
+    // classifier even on the user-trusted `ui/message` channel.
+    const nextArgs = JSON.stringify({ renderId: args.renderId });
+    const text = [
+        `Your REQUIRED FIRST TOOL CALL is ggui_consume with arguments ${nextArgs}. Call it NOW to retrieve and process the pending interaction. Do not respond conversationally; do not summarize. Issue the tool call as your next action.`,
+        '',
+        `<ggui_directive kind="user-action">`,
+        `  <render_id>${args.renderId}</render_id>`,
+        `  <next_tool>ggui_consume</next_tool>`,
+        `  <next_args>${nextArgs}</next_args>`,
+        `</ggui_directive>`,
+        '',
+        `The user interacted with render ${args.renderId} while no ggui_consume long-poll was active. The gesture is queued on the consume pipe for that render — it is NOT in this message. After ggui_consume returns, react to the returned event with the appropriate domain tool, then call ggui_update on the SAME renderId (${args.renderId}).`,
+    ].join('\n');
+    // Structured mirror of the directive for ggui-aware programmatic
+    // consumers. OPTIONAL — nothing in the loop depends on a server-side
+    // parse of this; an `_meta`-agnostic host acts on the text above
+    // alone. Typed against the protocol interface (no runtime guard
+    // exists — the shape is locked at compile time here).
+    const description = `User interacted with render ${args.renderId}; call ggui_consume to retrieve and process it.`;
+    const userAction = {
+        kind: 'user-action',
+        description,
+        renderId: args.renderId,
+        actionId: args.actionId,
+        submittedAt: args.submittedAt,
+        intent: args.intent,
+        nextStep: {
+            tool: 'ggui_consume',
+            args: { renderId: args.renderId },
         },
-    });
-}
-/**
- * Emit a `ui/message` envelope tagged with
- * `_meta.ggui.userAction.kind === 'queued'`. Fires when `submit_action`
- * succeeded BUT the server reported `consumerPresent: false` — the
- * action IS on the pipe; the agent just needs to call `ggui_consume`
- * to drain it. Carries the prepared `{tool, args}` so the SDK can
- * dispatch verbatim.
- */
-function emitUserActionQueued(args) {
-    // Prose-only text. Earlier revisions appended a fenced ```json``` block
-    // shaped as `{"tool":"ggui_consume","args":{...}}` — a verbatim copy
-    // of Anthropic's tool-call wire shape. claude.ai's prompt-injection
-    // classifier flagged this even on the user-trusted `ui/message`
-    // channel: data that looks like a tool-call injection IS treated as
-    // one, regardless of who supplied it. The stackItemId + next-tool
-    // hint stay in prose; the canonical machine-readable form lives on
-    // `_meta.ggui.userAction.nextStep`.
-    const description = `User fired ${args.intent} on ${args.stackItemId}`;
-    const text = `User fired "${args.intent}" on stack item ${args.stackItemId}. ` +
-        `The gesture is queued on the consume pipe but no consumer is active — ` +
-        `call ggui_consume with this stackItemId next to drain the canonical payload.`;
+    };
+    // RAW postMessage — NOT `app.sendMessage`. The doorbell MUST bypass
+    // the App's `ui/message` request path because the host validates the
+    // incoming request through the spec's CLOSED `McpUiMessageRequestSchema`
+    // (`Protocol.setRequestHandler` → `parseWithCompat`). That schema's
+    // `content` array is the spec `ContentBlockSchema`, which has no place
+    // for our content-block `_meta` extension — the parse strips the
+    // extension AND (as observed on the first live post-reload doorbell)
+    // can leave the host's `handleAppMessage` with an empty
+    // `content[0].text`, so it rejects the doorbell with `isError` and no
+    // fresh agent turn fires.
+    //
+    // `postToParent` posts the JSON-RPC frame verbatim to the parent, so
+    // BOTH `content[0].text` (the load-bearing directive every host
+    // forwards to the model) AND `content[0]._meta["ai.ggui/userAction"]`
+    // (the optional structured mirror) survive intact. This is the same
+    // deliberate raw-postMessage decision `ui/message` carried in #275 —
+    // the userAction-collapse refactor regressed it onto `app.sendMessage`.
+    //
+    // Spec-canonical shape: `_meta` lives on the CONTENT BLOCK (the spec
+    // closes `params._meta` via `additionalProperties: false`, but each
+    // content block has its own `_meta: { [key: string]: unknown }` open
+    // record — the proper extension point). Namespaced under
+    // `ai.ggui/userAction` to match our other protocol extensions
+    // (`ai.ggui/render`, `ai.ggui/bootstrap`, etc.).
     postToParent({
         jsonrpc: '2.0',
         id: Math.floor(Math.random() * 1e9),
         method: 'ui/message',
         params: {
             role: 'user',
-            content: [{ type: 'text', text }],
-            _meta: {
-                ggui: {
-                    userAction: {
-                        kind: 'queued',
-                        description,
-                        stackItemId: args.stackItemId,
-                        actionId: args.actionId,
-                        submittedAt: args.submittedAt,
-                        intent: args.intent,
-                        nextStep: {
-                            tool: 'ggui_consume',
-                            args: { stackItemId: args.stackItemId },
-                        },
+            content: [
+                {
+                    type: 'text',
+                    text,
+                    _meta: {
+                        'ai.ggui/userAction': userAction,
                     },
                 },
-            },
+            ],
         },
     });
 }
@@ -1197,7 +1498,7 @@ function emitUserActionQueued(args) {
 export function dispatchWiredAction(args) {
     if (typeof window === 'undefined')
         return;
-    const { toolName, intent, data, sessionId, stackItemId, appId, nextStep } = args;
+    const { toolName, intent, data, renderId, appId } = args;
     const firedAt = new Date().toISOString();
     const actionId = fnv1aHex(`${intent}|${JSON.stringify(data ?? null)}|${firedAt}`);
     const inlineData = formatWiredActionDataInline(data);
@@ -1207,25 +1508,20 @@ export function dispatchWiredAction(args) {
     // LLM's widget-context surface regardless of which downstream path
     // catches the event (pipe or ui/message). Fire-and-forget; no
     // response needed.
-    postToParent({
-        jsonrpc: '2.0',
-        id: Math.floor(Math.random() * 1e9),
-        method: 'ui/update-model-context',
-        params: {
-            content: [
-                {
-                    type: 'text',
-                    text: `[ggui:pending-action] ${JSON.stringify({
-                        actionId,
-                        intent,
-                        data: data ?? null,
-                        firedAt,
-                        sessionId,
-                        appId,
-                    })}`,
-                },
-            ],
-        },
+    callAppUpdateModelContext({
+        content: [
+            {
+                type: 'text',
+                text: `[ggui:pending-action] ${JSON.stringify({
+                    actionId,
+                    intent,
+                    data: data ?? null,
+                    firedAt,
+                    renderId,
+                    appId,
+                })}`,
+            },
+        ],
     });
     // (1.5) Toast — pending state. User sees "→ Sending: archive"
     // immediately so they know the click was registered, even when
@@ -1238,32 +1534,32 @@ export function dispatchWiredAction(args) {
     // `consumerPresent`:
     //   - true (or undefined): toast stays `pending`; drain_ack will
     //     dismiss it when the agent's ggui_consume drains the event.
-    //   - false: no consumer is registered; emit a queued userAction
-    //     nudge IMMEDIATELY so the agent's next turn drains the pipe.
-    //     No timer, no rescue — the pipe holds the data.
+    //   - false: no `ggui_consume` long-poll is currently listening
+    //     (the agent's persistent consume loop has ended — e.g. after a
+    //     page reload). Emit the `ai.ggui/userAction` PURE DOORBELL on a
+    //     `ui/message` so a fresh agent turn calls `ggui_consume` to
+    //     drain the gesture we just enqueued. No timer, no rescue, no
+    //     payload — the pipe is the single source of truth.
     //
-    // (3) On any non-success outcome (PIPE_NOT_FOUND, transport error,
-    // host has no relay), emit an inline userAction with the full
-    // gesture payload + uiContext so the agent can act without calling
-    // ggui_consume (the pipe is gone).
+    // On any non-success outcome (PIPE_NOT_FOUND, transport error, host
+    // has no relay) the gesture could NOT be enqueued; there is nothing
+    // to point a doorbell at, so we surface a toast and stop. Post-reload
+    // recovery for the abort-aware long-poll is a separate server-side
+    // concern (#292); this client never inlines the action payload.
     void (async () => {
         let resp = null;
         try {
-            resp = await postRpcToParent('tools/call', {
-                name: toolName,
-                arguments: {
-                    kind: 'dispatch',
-                    payload: {
-                        intent,
-                        actionData: data ?? null,
-                        uiContext,
-                    },
-                    sessionId,
-                    ...(stackItemId !== undefined ? { stackItemId } : {}),
-                    appId,
-                    actionId,
-                    firedAt,
+            resp = await callServerToolSpec(toolName, {
+                kind: 'dispatch',
+                payload: {
+                    intent,
+                    actionData: data ?? null,
+                    uiContext,
                 },
+                renderId,
+                appId,
+                actionId,
+                firedAt,
             });
         }
         catch {
@@ -1272,37 +1568,25 @@ export function dispatchWiredAction(args) {
         }
         if (resp !== null && classifySubmitActionResponse(resp) === 'success') {
             const consumerPresent = extractConsumerPresent(resp);
-            if (consumerPresent === false && stackItemId !== undefined) {
+            if (consumerPresent === false) {
                 showActionToast(`💬 ${intent}${dataPart} — agent not listening, sent to chat`, 'action_required');
-                emitUserActionQueued({
+                emitUserActionDoorbell({
                     intent,
-                    stackItemId,
+                    renderId,
                     actionId,
                     submittedAt: firedAt,
                 });
                 return;
             }
-            if (stackItemId === undefined) {
-                // Bootstrap didn't carry a stackItemId — no specific pipe to
-                // drain. Treat as a one-shot success.
-                showActionToast(`✓ ${intent} queued for agent`, 'success');
-            }
-            // Otherwise toast stays `pending`; drain_ack listener dismisses
+            // consumerPresent is true (or undefined — agnostic host stripped
+            // the field). Toast stays `pending`; drain_ack listener dismisses
             // it when ggui_consume drains the event.
             return;
         }
-        // Pipe gone or transport failed. Emit inline userAction so the
-        // agent can act on the gesture without calling ggui_consume.
-        showActionToast(`💬 ${intent}${dataPart} — press send in chat to forward`, 'action_required');
-        emitUserActionInline({
-            intent,
-            actionData: data ?? null,
-            uiContext,
-            actionId,
-            stackItemId: stackItemId ?? '',
-            submittedAt: firedAt,
-            ...(nextStep !== undefined ? { nextStep } : {}),
-        });
+        // Enqueue failed (pipe gone / transport error). The gesture is not
+        // on any pipe, so a doorbell would point at an empty queue. Surface
+        // the failure as a toast; no `ui/message` is emitted.
+        showActionToast(`⚠ ${intent} — could not reach the agent`, 'error');
     })();
 }
 /**
@@ -1316,7 +1600,7 @@ export function dispatchWiredAction(args) {
  * PIPE-2 design note: Pattern α deliberately does NOT fire
  * `submit_action` — a pipe append would queue the gesture for the
  * agent's `ggui_consume` long-poll, causing double-processing
- * (host's tool relay AND agent's reaction). SessionInspector loses
+ * (host's tool relay AND agent's reaction). RenderInspector loses
  * Pattern α observability for now; re-add via a dedicated audit-only
  * gesture kind if operators need it.
  *
@@ -1360,11 +1644,28 @@ export function fireDirectToolCall(args) {
  *
  * @internal — exported for unit tests + production reuse.
  */
+export function resolveDispatchToolName() {
+    // Operator escape hatch — `window.__GGUI_DISPATCH_TOOL__` lets a
+    // host override the receiver tool name when running ggui under a
+    // server that publishes the spec-canonical receiver under a
+    // different name (the agent SDK extension surface). Default:
+    // `ggui_runtime_submit_action` per the OSS handler at
+    // `@ggui-ai/mcp-server-handlers::createGguiSubmitActionHandler`.
+    if (typeof window === 'undefined')
+        return 'ggui_runtime_submit_action';
+    const override = window.__GGUI_DISPATCH_TOOL__;
+    return typeof override === 'string' && override.length > 0
+        ? override
+        : 'ggui_runtime_submit_action';
+}
+/**
+ * @internal — exported for unit tests + production reuse.
+ */
 export function routeDispatch(args) {
-    const { actionName, data, bootstrap, dispatchToolName } = args;
-    const tool = bootstrap.actionNextSteps?.[actionName];
+    const { actionName, data, meta, dispatchToolName } = args;
+    const tool = meta.actionNextSteps?.[actionName];
     const appCallable = typeof tool === 'string' &&
-        (bootstrap.appCallableTools ?? []).includes(tool);
+        (meta.appCallableTools ?? []).includes(tool);
     if (appCallable && tool !== undefined) {
         fireDirectToolCall({
             targetToolName: tool,
@@ -1372,20 +1673,18 @@ export function routeDispatch(args) {
         });
     }
     else {
-        // `actionNextSteps[actionName]` is the agent-side nextStep hint —
-        // when present, surface it on the inline-userAction envelope so
-        // the agent has a strong steer toward the right tool if the pipe
-        // is unavailable. Pattern β (this branch) is also the path where
-        // `actionSpec[*].dispatch.kind === 'agent'` lands — in that case
-        // `actionNextSteps[actionName]` is absent and `nextStep` is too.
+        // Pattern β: enqueue the gesture onto the render's pending-event
+        // pipe via `submit_action`. The agent retrieves it EXCLUSIVELY via
+        // `ggui_consume` — the gesture never travels inline, so there is no
+        // `nextStep` hint to forward (the doorbell carries only a pointer to
+        // the render). This branch is also where
+        // `actionSpec[*].dispatch.kind === 'agent'` lands.
         dispatchWiredAction({
             toolName: dispatchToolName,
             intent: actionName,
             data,
-            sessionId: bootstrap.sessionId,
-            stackItemId: bootstrap.stackItemId,
-            appId: bootstrap.appId,
-            ...(tool !== undefined ? { nextStep: tool } : {}),
+            renderId: meta.renderId,
+            appId: meta.appId,
         });
     }
 }
@@ -1398,7 +1697,7 @@ export function routeDispatch(args) {
 export function openLinkInParent(args) {
     if (typeof window === 'undefined')
         return;
-    const { toolName, url, sessionId, stackItemId, appId } = args;
+    const { toolName, url, renderId, appId } = args;
     if (typeof url !== 'string' || url.length === 0) {
         throw new RangeError('wire.openLink(url): `url` must be a non-empty string.');
     }
@@ -1408,18 +1707,12 @@ export function openLinkInParent(args) {
         toolName,
         kind: 'openLink',
         payload: { url },
-        sessionId,
-        stackItemId,
+        renderId,
         appId,
         actionId,
         firedAt,
     });
-    postToParent({
-        jsonrpc: '2.0',
-        id: Math.floor(Math.random() * 1e9),
-        method: 'ui/open-link',
-        params: { url },
-    });
+    callAppOpenLink({ url });
 }
 /**
  * `ui/request-display-mode` direct dispatch helper — used by the
@@ -1431,25 +1724,19 @@ export function openLinkInParent(args) {
 export function requestDisplayModeInParent(args) {
     if (typeof window === 'undefined')
         return;
-    const { toolName, mode, sessionId, stackItemId, appId } = args;
+    const { toolName, mode, renderId, appId } = args;
     const firedAt = new Date().toISOString();
     const actionId = fnv1aHex(`requestDisplayMode|${mode}|${firedAt}`);
     emitAudit({
         toolName,
         kind: 'requestDisplayMode',
         payload: { mode },
-        sessionId,
-        stackItemId,
+        renderId,
         appId,
         actionId,
         firedAt,
     });
-    postToParent({
-        jsonrpc: '2.0',
-        id: Math.floor(Math.random() * 1e9),
-        method: 'ui/request-display-mode',
-        params: { mode },
-    });
+    callAppRequestDisplayMode({ mode });
 }
 /**
  * Native-idiom interceptor for anchor clicks.
@@ -1494,7 +1781,7 @@ export function installAnchorClickInterceptor(args) {
     if (typeof document === 'undefined')
         return;
     anchorClickInterceptInstalled = true;
-    const { dispatchToolName, sessionId, stackItemId, appId } = args;
+    const { dispatchToolName, renderId, appId } = args;
     const onClick = (event) => {
         if (event.defaultPrevented)
             return;
@@ -1539,8 +1826,7 @@ export function installAnchorClickInterceptor(args) {
         openLinkInParent({
             toolName: dispatchToolName,
             url: absoluteHref,
-            sessionId,
-            stackItemId,
+            renderId,
             appId,
         });
     };
@@ -1580,7 +1866,7 @@ export function installAnchorClickInterceptor(args) {
  *
  * Idempotent: the {@link fullscreenInterceptInstalled} guard prevents
  * re-mounts from chaining wrappers (which would also leak the prior
- * mount's `sessionId`/`appId` if they ever differed).
+ * mount's `renderId`/`appId` if they ever differed).
  */
 /** @internal — exported for unit tests. */
 export function installFullscreenInterceptors(args) {
@@ -1592,13 +1878,12 @@ export function installFullscreenInterceptors(args) {
         return;
     }
     fullscreenInterceptInstalled = true;
-    const { dispatchToolName, sessionId, stackItemId, appId } = args;
+    const { dispatchToolName, renderId, appId } = args;
     Element.prototype.requestFullscreen = function (_options) {
         requestDisplayModeInParent({
             toolName: dispatchToolName,
             mode: 'fullscreen',
-            sessionId,
-            stackItemId,
+            renderId,
             appId,
         });
         return Promise.resolve();
@@ -1607,8 +1892,7 @@ export function installFullscreenInterceptors(args) {
         requestDisplayModeInParent({
             toolName: dispatchToolName,
             mode: 'inline',
-            sessionId,
-            stackItemId,
+            renderId,
             appId,
         });
         return Promise.resolve();
@@ -1625,533 +1909,155 @@ export function __resetInterceptorsForTest() {
     fullscreenInterceptInstalled = false;
 }
 /**
- * Install a persistent `message` listener that catches
- * `ui/notifications/tool-result` notifications arriving AFTER the
- * initial mount. Each new tool-result that carries a different
- * bootstrap (different stackItemId / codeUrl / kind) triggers a
- * re-mount via {@link bootSelfContained}. This closes the boot-only-
+ * Install a persistent `app.addEventListener('toolresult', …)` listener
+ * that catches `ui/notifications/tool-result` notifications arriving
+ * AFTER the initial mount. Each new tool-result that carries a
+ * different bootstrap (different renderId / codeUrl / kind) triggers
+ * a re-mount via {@link bootSelfContained}. This closes the boot-only-
  * listener gap that prevented live re-render when an agent issued
- * a second `ggui_push` to the same session-resource.
+ * a second `ggui_render` to the same render-resource.
  *
  * Idempotent: subsequent calls no-op via {@link postMountListenerInstalled}.
  *
- * Why module-level vs scoped to a single mount: bootSelfContained
- * may itself trigger a re-mount, and the listener should outlive any
- * single mount cycle. The compaction ensures we don't stack listeners
+ * Why module-level vs scoped to a single mount: bootSelfContained may
+ * itself trigger a re-mount, and the listener should outlive any
+ * single mount cycle. The guard ensures we don't stack listeners
  * across re-mounts.
+ *
+ * Spec-canonical (post-Phase-1.19b.3): the previous hand-rolled
+ * `window.addEventListener('message', …)` is gone; App handles every
+ * inbound `ui/notifications/tool-result` envelope and dispatches via
+ * its event system. Per-iframe single-tenancy means the App handle
+ * comes from `getCurrentApp()` — set by bootSelfContained's own
+ * connect path before this helper runs.
  */
 function installPostMountListener() {
     if (postMountListenerInstalled)
         return;
-    if (typeof window === 'undefined')
-        return;
+    const app = getCurrentApp();
+    if (app === null)
+        return; // pre-connect; caller bug, swallow safely
     postMountListenerInstalled = true;
-    let lastBootstrapKey = null;
-    const onMessage = (event) => {
-        const data = event.data;
-        if (data === null ||
-            data === undefined ||
-            data.jsonrpc !== '2.0' ||
-            data.method !== 'ui/notifications/tool-result') {
-            return;
-        }
-        const bootstrap = extractBootstrapFromToolResult(data.params);
-        if (bootstrap === null)
+    let lastMetaKey = null;
+    app.addEventListener('toolresult', (params) => {
+        const meta = extractMetaFromToolResult(params);
+        if (meta === null)
             return;
         // Cheap dedupe — the host may emit the same tool-result more
         // than once (claude.ai re-broadcasts on iframe re-attach).
-        // Re-mounting the same bootstrap would flicker without changing
+        // Re-mounting the same slice meta would flicker without changing
         // anything visible.
         //
         // `liveTrio` is load-bearing in the dedupe key: hosts (sample-agent,
-        // claude.ai) often emit the initial bootstrap WITHOUT the wsUrl+token
+        // claude.ai) often emit the initial meta WITHOUT the wsUrl+token
         // pair (the Anthropic SDK strips `_meta` from tool results), then
         // refetch + re-emit the FULL envelope. The two envelopes share
-        // stackItemId/kind/codeUrl/propsJson but differ on the live trio —
+        // renderId/kind/codeUrl/propsJson but differ on the live trio —
         // without trio in the key, the second arrival deduped silently and
         // bootSelfContained never opened the WS, so `ggui_update` props_update
         // frames fanned to zero subscribers.
-        const codeUrl = 'codeUrl' in bootstrap ? bootstrap.codeUrl : undefined;
-        const liveTrio = typeof bootstrap.wsUrl === 'string' &&
-            bootstrap.wsUrl.length > 0 &&
-            typeof bootstrap.token === 'string' &&
-            bootstrap.token.length > 0
+        const liveTrio = typeof meta.wsUrl === 'string' &&
+            meta.wsUrl.length > 0 &&
+            typeof meta.wsToken === 'string' &&
+            meta.wsToken.length > 0
             ? 'live'
             : '-';
         const key = [
-            bootstrap.stackItemId ?? '-',
-            bootstrap.kind ?? '-',
-            codeUrl ?? '-',
-            bootstrap.propsJson ?? '-',
+            meta.renderId,
+            meta.kind ?? '-',
+            meta.codeUrl ?? '-',
+            meta.propsJson ?? '-',
             liveTrio,
         ].join('|');
-        if (key === lastBootstrapKey)
+        if (key === lastMetaKey)
             return;
-        lastBootstrapKey = key;
-        void bootSelfContained(window.document, bootstrap).then(() => {
-            // Re-emit last-known contextSpec values after a successful
-            // re-mount. The host's WS to the agent server is opaque to the
-            // iframe, so "WS reopen ≈ re-mount" is the closest available
-            // proxy. Re-emitting keeps the LLM context fresh after a
-            // host-driven reconnect — the new mount's SingleSlotProviders
-            // will then take over via the regular debounced flow once the
-            // user's component begins mutating values.
-            //
-            // Filter to slot names declared by the FRESHLY mounted contract.
-            // An earlier version walked the entire `contextSlotLastValues`
-            // map, which leaked stale slot values across re-mounts with
-            // different contextSpecs. The new mount's SingleSlotProvider
-            // re-seeds from `slot.default` regardless, so cross-mount
-            // survival of stale entries was never load-bearing — only the
-            // active slot names are.
-            const activeSlotNames = new Set((bootstrap.contextSlots ?? []).map((s) => s.name));
-            const reemitIdentity = bootstrap.stackItemId !== undefined
-                ? {
-                    sessionId: bootstrap.sessionId,
-                    appId: bootstrap.appId,
-                    stackItemId: bootstrap.stackItemId,
-                }
-                : undefined;
-            reemitLastContextValues(postToParent, activeSlotNames, reemitIdentity);
+        lastMetaKey = key;
+        // Re-mount through the EXISTING renderer's `applyRender` (published
+        // module-level by bootProduction's setup) — NOT a fresh boot. One
+        // mount surface, one WS; the prior stale-closure / second-WS race
+        // (the #290 root cause) is structurally impossible. Project the new
+        // tool-result meta into a seed and re-apply it.
+        const apply = activeApplyRender;
+        if (apply === null)
+            return; // no renderer published yet — no-op safely
+        void buildRenderSeedInput(meta).then((seed) => {
+            if (seed === null)
+                return;
+            void apply(seed).then(() => {
+                // Re-emit last-known contextSpec values after a successful
+                // re-mount — keeps the LLM context fresh after a host-driven
+                // reconnect; the new mount's SingleSlotProviders take over via
+                // the regular debounced flow once the component mutates values.
+                // Filter to slot names declared by the FRESHLY mounted contract.
+                const activeSlotNames = new Set((meta.contextSlots ?? []).map((s) => s.name));
+                reemitLastContextValues(productionContextSnapshotPoster, activeSlotNames, { renderId: meta.renderId, appId: meta.appId });
+            });
         });
-    };
-    window.addEventListener('message', onMessage);
+    });
 }
 /**
- * Self-contained boot path. Mounts the compiled component into
- * `<div id="ggui-root">` (or a fresh container when absent) using the
- * same `mountReactRoot` pipeline the WS-driven path uses. No postMessage,
- * no WebSocket, no subscribe — the runtime is fully self-sufficient
- * once the bootstrap is in hand.
+ * Detect a live-channel bootstrap shape inlined onto `__GGUI_META__`.
+ * The first-party render shells (`/r/<shortCode>`,
+ * `ui://ggui/render/<renderId>`, the embedded-ui RenderViewer's thin
+ * shell) populate this synchronously before the runtime loads.
  *
- * Status surface: a parent-bound `ggui:renderer-ready` followed by a
- * `code-ready` lifecycle envelope on success. Failures emit a
- * `ggui:bootstrap-failed` envelope (`SELF_CONTAINED_MOUNT_FAILED`) +
- * an `error` lifecycle event so hosts pinning lifecycle selectors
- * still observe the terminal state.
- *
- * The implementation lives next to `bootProduction` so dynamic-imports
- * for the heavy module graph happen exactly once across both code
- * paths — the postMessage path's `import('react')` etc. resolves
- * against the same module instance.
- */
-async function bootSelfContained(doc, bootstrap) {
-    // Lifecycle: `mounting` first, paired with `ggui:renderer-ready` so
-    // outer-DOM observers see the same sequence as the postMessage path.
-    postRendererReady();
-    postLifecycleToParent(makeLifecycleEvent('mounting'));
-    // Resolve the mount container. Hosts inline `<div id="ggui-root">`
-    // in the self-contained shell; if absent (defensive), append one to
-    // the body so the React root has somewhere to mount.
-    let container = doc.getElementById('ggui-root');
-    if (container === null) {
-        container = doc.createElement('div');
-        container.id = 'ggui-root';
-        doc.body.appendChild(container);
-    }
-    try {
-        // Install precompiled, eval-free contract validators before any
-        // wire dispatch can run. Self-contained ESM modules — no bundler /
-        // `__ggui__` dependency. System-card bootstraps carry none (the
-        // loader returns the empty set); harmless to call unconditionally.
-        setActiveValidatorSet(await loadCompiledValidators(bootstrap.compiledValidators));
-        // Parse propsJson up-front — both branches (system card + compiled
-        // component) consume props from the same field, just in different
-        // shapes downstream.
-        let props;
-        if (bootstrap.propsJson !== undefined) {
-            try {
-                const parsed = JSON.parse(bootstrap.propsJson);
-                if (parsed !== null && typeof parsed === 'object' && !Array.isArray(parsed)) {
-                    props = parsed;
-                }
-            }
-            catch {
-                // Malformed propsJson is shape-preserving-skip.
-            }
-        }
-        // System-card branch — kind keyed against the built-in registry.
-        // No componentCode evaluation, no `globalThis.__ggui__` shim install,
-        // no GguiWireProvider (system cards are render-only and don't
-        // dispatch wire actions). The registry handles unknown kinds via
-        // a typed fallback, so a new server emitting a kind this runtime
-        // doesn't know still surfaces something visible.
-        if (bootstrap.kind !== undefined) {
-            const [reactMod, reactDomClient, systemCardsMod] = await Promise.all([
-                import('react'),
-                import('react-dom/client'),
-                import('./system-cards/index.js'),
-            ]);
-            const root = reactDomClient.createRoot(container);
-            root.render(reactMod.createElement(systemCardsMod.SystemCardHost, { kind: bootstrap.kind, props: props ?? {}, themeId: bootstrap.themeId }));
-            postLifecycleToParent(makeLifecycleEvent('code-ready', {
-                ...(bootstrap.stackItemId !== undefined
-                    ? { stackItemId: bootstrap.stackItemId }
-                    : {}),
-            }));
-            installResizeObserver(container);
-            installPostMountListener();
-            return;
-        }
-        // Compiled-component branch. Fetch the bytes from `codeUrl`
-        // (content-addressable, immutable cache). T3-1 (2026-05-13) retired
-        // the inline base64 `componentCode` channel — every static-component
-        // bootstrap is delivered via the URL.
-        if (bootstrap.codeUrl === undefined) {
-            throw new Error('bootSelfContained: bootstrap missing codeUrl (static-component mode requires the URL channel)');
-        }
-        const res = await fetch(bootstrap.codeUrl);
-        if (!res.ok) {
-            throw new Error(`bootSelfContained: codeUrl fetch failed (${res.status}): ${bootstrap.codeUrl}`);
-        }
-        const componentCode = await res.text();
-        // Dynamic-imports — same set as `bootProduction`, kept here so a
-        // postMessage path running in parallel hits the module cache.
-        const [reactMod, reactDomClient, designPrimitives, designComponents, designCompositions, designInteract, designTokens, wireMod, gadgetsMod,] = await Promise.all([
-            import('react'),
-            import('react-dom/client'),
-            import('@ggui-ai/design/primitives'),
-            import('@ggui-ai/design/components'),
-            import('@ggui-ai/design/compositions'),
-            import('@ggui-ai/design/interact'),
-            import('@ggui-ai/design/tokens'),
-            import('@ggui-ai/wire'),
-            // Pre-load STDLIB gadget hooks so the data-URL shim resolves
-            // `import { useGeolocation } from '@ggui-ai/gadgets'` to a real
-            // callable at iframe boot. Without this, `__ggui__.gadgets` is
-            // empty and every hook lookup returns undefined, crashing the
-            // component.
-            import('@ggui-ai/gadgets'),
-        ]);
-        const [globalsMod, reactRendererMod, gadgetLoaderMod] = await Promise.all([
-            import('./globals.js'),
-            import('./react-renderer.js'),
-            import('./gadget-loader.js'),
-        ]);
-        // Compose the gadget-package registry: STDLIB seed PLUS any
-        // operator-registered packages from the bootstrap. This path is
-        // async, so we await the merge BEFORE installing — the per-package
-        // data-URL shims see a fully-populated catalog from first render.
-        // (The WS-driven path uses an in-place mutation fallback because
-        // its `setup` callback is synchronous.)
-        const composedGadgets = await gadgetLoaderMod.loadGadgetRegistry(gadgetsMod, bootstrap.gadgets ?? []);
-        // Install `globalThis.__ggui__` BEFORE mountReactRoot — the data-
-        // URL shim rewrite reads it synchronously during module load.
-        // Same TOCTOU-critical ordering as the WS-driven path.
-        globalsMod.installGlobalRegistry({
-            react: reactMod,
-            reactDom: reactDomClient,
-            primitives: designPrimitives,
-            components: designComponents,
-            compositions: designCompositions,
-            interact: designInteract,
-            tokens: designTokens,
-            wire: wireMod,
-            // Per-package gadget registry — STDLIB namespace merged with
-            // operator-registered packages (composed above).
-            gadgets: composedGadgets,
-            // Server-filtered public env values for wrapper hooks to read
-            // via `getPublicEnv(key)`. Absent ⇒ empty record; wrappers
-            // needing values throw at hook-mount.
-            publicEnv: bootstrap.publicEnv ?? {},
-        });
-        // Synthesize one React.createContext(default) per declared
-        // contextSpec slot and register under
-        // `globalThis.__ggui__.contexts[contextName]`. Idempotent: already-
-        // registered context names REUSE the existing Context (the LLM's
-        // destructured references must stay stable across re-mounts). Boot-
-        // ordering: AFTER installGlobalRegistry, BEFORE mountReactRoot, so
-        // the boilerplate's `globalThis.__ggui__.contexts` destructure
-        // resolves on the first mount paint.
-        const registry = globalsMod.getGlobalRegistry();
-        const resolvedSlots = registry !== undefined && bootstrap.contextSlots !== undefined
-            ? installContextRegistry(registry.contexts, reactMod, bootstrap.contextSlots)
-            : [];
-        // Build a minimal WireConfig and pass it through `renderWrapper` so
-        // generated components that call `useAction` / `useStream` resolve
-        // their context. Without this, every self-contained mount whose
-        // component touches `@ggui-ai/wire` throws "useWireContext must be
-        // used within a WireProvider".
-        //
-        // Dispatch funnels through {@link dispatchWiredAction} — the
-        // empirically-validated three-message bridge (`tools/call` +
-        // `ui/update-model-context` + `ui/message`). See helper docstring
-        // for the spec §401 / §1032 reasoning. An earlier single-message
-        // dispatch only fired #1 and the LLM never saw the click on
-        // claude.ai (the host-side scope:['app'] firewall blocks
-        // tool-result feedback from reaching the model). Empirically
-        // confirmed in a protocol probe.
-        const dispatchToolName = typeof window !== 'undefined' &&
-            typeof window.__GGUI_DISPATCH_TOOL__ === 'string'
-            ? window
-                .__GGUI_DISPATCH_TOOL__
-            : 'ggui_runtime_submit_action';
-        const wireConfig = {
-            app: { appId: bootstrap.appId, appName: bootstrap.appId },
-            session: { sessionId: bootstrap.sessionId, isConnected: true },
-            auth: { isAuthenticated: false },
-            dispatch: (actionName, data) => {
-                // Per-action routing — extracted to {@link routeDispatch} as
-                // a pure helper so production + the dispatch-routing unit
-                // tests share one code path. Pattern α: same-server,
-                // app-visible target tool → direct `tools/call`. Pattern β:
-                // anything else → 3-message bridge.
-                routeDispatch({
-                    actionName,
-                    data,
-                    bootstrap: {
-                        sessionId: bootstrap.sessionId,
-                        appId: bootstrap.appId,
-                        ...(bootstrap.stackItemId !== undefined
-                            ? { stackItemId: bootstrap.stackItemId }
-                            : {}),
-                        ...(bootstrap.appCallableTools !== undefined
-                            ? { appCallableTools: bootstrap.appCallableTools }
-                            : {}),
-                        ...(bootstrap.actionNextSteps !== undefined
-                            ? { actionNextSteps: bootstrap.actionNextSteps }
-                            : {}),
-                    },
-                    dispatchToolName,
-                });
-            },
-            // Subscribe + wired-tools are no-ops in self-contained mode
-            // (no live channel). Generated components that subscribe
-            // receive nothing; the contract stays honest.
-            subscribe: () => () => { },
-            // `callWiredTool` is retired — `agentTools` is now a catalog
-            // the AGENT invokes, not a component hook surface.
-            // The `openLink` and `requestDisplayMode` host-control primitives
-            // ride native idioms (anchor click + Element.requestFullscreen) —
-            // see `installAnchorClickInterceptor` and
-            // `installFullscreenInterceptors` below. No first-class
-            // chat-shortcut primitive in v1; chat-shortcut UX degrades to the
-            // Pattern β consent prompt.
-        };
-        // Runtime owns Provider tree + useState per slot. ContextStateHost
-        // composes one SingleSlotProvider per declared slot around the
-        // user's component, so the user's `useGguiContext` reads each
-        // slot's live `[value, setValue]` tuple. An earlier design had
-        // the boilerplate emit useState + Provider INSIDE the user
-        // component while the runtime mounted observers as SIBLINGS —
-        // every observer read the createContext default, never the live
-        // state. Hoisting both useState and Provider into the runtime
-        // makes the boilerplate's destructure line resolve to the live
-        // tuple by construction.
-        const ContextStateHost = createContextStateHost({
-            react: reactMod,
-            postToParent,
-            consoleWarn: typeof console !== 'undefined' && typeof console.warn === 'function'
-                ? console.warn.bind(console)
-                : undefined,
-            ...(bootstrap.stackItemId !== undefined
-                ? {
-                    identity: {
-                        sessionId: bootstrap.sessionId,
-                        appId: bootstrap.appId,
-                        stackItemId: bootstrap.stackItemId,
-                    },
-                }
-                : {}),
-        });
-        const renderWrapper = (mountedComponent) => reactMod.createElement(wireMod.GguiWireProvider, {
-            config: wireConfig,
-            children: reactMod.createElement(ContextStateHost, {
-                slots: resolvedSlots,
-                children: mountedComponent,
-            }),
-        });
-        // Native-idiom interceptors. Install BEFORE mountReactRoot so the
-        // listeners are live the instant any generated component begins
-        // rendering. Both helpers are idempotent (module-level guards) —
-        // re-mounts via `installPostMountListener` re-call this without
-        // stacking.
-        installAnchorClickInterceptor({
-            dispatchToolName,
-            sessionId: bootstrap.sessionId,
-            ...(bootstrap.stackItemId !== undefined
-                ? { stackItemId: bootstrap.stackItemId }
-                : {}),
-            appId: bootstrap.appId,
-        });
-        installFullscreenInterceptors({
-            dispatchToolName,
-            sessionId: bootstrap.sessionId,
-            ...(bootstrap.stackItemId !== undefined
-                ? { stackItemId: bootstrap.stackItemId }
-                : {}),
-            appId: bootstrap.appId,
-        });
-        const mountOpts = {
-            stackItem: {
-                ...(bootstrap.stackItemId !== undefined ? { id: bootstrap.stackItemId } : {}),
-                componentCode,
-                ...(props !== undefined ? { props } : {}),
-            },
-            renderWrapper,
-            ...(bootstrap.themeId !== undefined ? { themeId: bootstrap.themeId } : {}),
-            ...(bootstrap.themeMode !== undefined ? { themeMode: bootstrap.themeMode } : {}),
-            // GG.8.2 — operator-registered 3rd-party gadget packages so the
-            // rewriter resolves each direct gadget import to its per-package
-            // shim. STDLIB `@ggui-ai/gadgets` is always rewritten regardless.
-            ...(bootstrap.gadgets !== undefined
-                ? { gadgetPackages: bootstrap.gadgets.map((g) => g.package) }
-                : {}),
-        };
-        const mount = await reactRendererMod.mountReactRoot(container, mountOpts);
-        postLifecycleToParent(makeLifecycleEvent('code-ready', {
-            ...(bootstrap.stackItemId !== undefined
-                ? { stackItemId: bootstrap.stackItemId }
-                : {}),
-        }));
-        installResizeObserver(container);
-        installPostMountListener();
-        // B4 — when the bootstrap carries a live trio (wsUrl + token),
-        // open a WS subscription so `ggui_update` props_update frames
-        // reach the iframe. Without this the McpAppIframe-nested mount
-        // never subscribed and `ggui_update` silently dropped on the
-        // server's outbound side.
-        //
-        // Targeted scope: this path mounts a SINGLE component (not the
-        // full stack), so the only frame type we need is `props_update`
-        // matching THIS stackItemId. Other frame types are silently
-        // dropped — no handler registered means the registry's dispatch
-        // is a no-op for them.
-        //
-        // The subscribe call is fire-and-forget; failure is logged but
-        // doesn't break the mount (the static component renders fine
-        // without live updates). When the WS goes down, mount.update()
-        // simply stops firing — gracefully degrades.
-        if (typeof bootstrap.wsUrl === 'string' &&
-            bootstrap.wsUrl.length > 0 &&
-            typeof bootstrap.token === 'string' &&
-            bootstrap.token.length > 0 &&
-            bootstrap.stackItemId !== undefined) {
-            const targetStackItemId = bootstrap.stackItemId;
-            const subscribeRegistry = new ChannelRegistry({
-                subscribeFrameBuilder: () => ({
-                    type: 'subscribe',
-                    payload: {
-                        sessionId: bootstrap.sessionId,
-                        appId: bootstrap.appId,
-                        bootstrap: bootstrap.token,
-                    },
-                }),
-            });
-            // Register only the `props_update` handler — `connectViaRegistry`
-            // registers `ack` + `error` for the handshake. Other frame
-            // types arriving on the WS will be no-ops (no handler).
-            subscribeRegistry.register({
-                type: 'props_update',
-                onMessage: (payload) => {
-                    const shaped = payload;
-                    if (shaped.stackItemId !== targetStackItemId)
-                        return;
-                    if (shaped.props === null || typeof shaped.props !== 'object')
-                        return;
-                    void mount.update({
-                        ...mountOpts,
-                        stackItem: {
-                            ...mountOpts.stackItem,
-                            props: shaped.props,
-                        },
-                    });
-                },
-            });
-            void connectViaRegistry({
-                bootstrap,
-                registry: subscribeRegistry,
-                onStatusChange: () => {
-                    /* no-op — placeholder UI is not used in self-contained mode */
-                },
-            }).catch((err) => {
-                // Self-contained mode tolerates WS failure — the component
-                // still renders with initial props; only live updates stop.
-                // eslint-disable-next-line no-console -- operator-visible degradation hint
-                console.warn('[ggui:bootSelfContained] live-update WS subscribe failed; props_update frames will not reach the mount:', err instanceof Error ? err.message : String(err));
-            });
-        }
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        // Reuse the existing failure envelope. The reason is a synthesized
-        // value because this code path is wholly outside the
-        // `BootstrapParseFailureReason` set (no postMessage parse failed
-        // — there was no postMessage). Hosts pattern-matching legacy
-        // reason strings see a new value and ignore it; new hosts can
-        // route on the explicit code.
-        postBootFailure('UI_INITIALIZE_FAILED', `self-contained mount failed: ${message}`);
-        postLifecycleToParent(makeLifecycleEvent('error', {
-            error: { code: 'SELF_CONTAINED_MOUNT_FAILED', message },
-        }));
-    }
-}
-/**
- * Detect a `GguiBootstrapMeta` shape inlined onto `__GGUI_BOOTSTRAP__`.
- * The first-party session shells (`/s/<shortCode>`,
- * `ui://ggui/session/<sessionId>`, the embedded-ui SessionViewer's
- * thin shell) populate this synchronously before the runtime loads —
- * but the shape is the WS-driven bootstrap (`wsUrl`+`token`+
- * `sessionId`+`appId`+`runtimeUrl`), NOT a `SelfContainedBootstrap`.
+ * Post-Phase-B the global carries a slice ENVELOPE (same shape as the
+ * wire `_meta`): `{ "ai.ggui/render": {...} }`. A live-channel shell
+ * omits static content (no codeUrl / kind) and ships wsUrl+token
+ * inside the render slice instead.
  *
  * This predicate exists so the autostart path can distinguish
- * "shell-inlined a WS bootstrap, run `bootProduction` immediately"
+ * "shell-inlined a live bootstrap, run `bootProduction` immediately"
  * from "no bootstrap yet, race the tool-result postMessage with a
  * 30s timeout". Without the distinction, OSS shells that never emit
  * a separate `ui/notifications/tool-result` (because the bootstrap
  * is delivered via the `ui/initialize` Reading-B path) hang at
  * `mounting` for the full 30s before `code-ready`.
  */
-function readGguiBootstrapMetaShape() {
+function readLiveBootstrapShape() {
     if (typeof window === 'undefined')
         return false;
     const raw = window
-        .__GGUI_BOOTSTRAP__;
+        .__GGUI_META__;
     if (raw === null || typeof raw !== 'object' || Array.isArray(raw)) {
         return false;
     }
     const bag = raw;
-    return (typeof bag['wsUrl'] === 'string' &&
-        bag['wsUrl'].length > 0 &&
-        typeof bag['token'] === 'string' &&
-        bag['token'].length > 0 &&
-        typeof bag['sessionId'] === 'string' &&
-        bag['sessionId'].length > 0 &&
-        typeof bag['appId'] === 'string' &&
-        bag['appId'].length > 0);
+    const renderRaw = bag['ai.ggui/render'];
+    if (renderRaw === null || typeof renderRaw !== 'object' || Array.isArray(renderRaw)) {
+        return false;
+    }
+    const renderBag = renderRaw;
+    return (typeof renderBag['wsUrl'] === 'string' &&
+        renderBag['wsUrl'].length > 0 &&
+        typeof renderBag['wsToken'] === 'string' &&
+        renderBag['wsToken'].length > 0 &&
+        typeof renderBag['renderId'] === 'string' &&
+        renderBag['renderId'].length > 0 &&
+        typeof renderBag['appId'] === 'string' &&
+        renderBag['appId'].length > 0);
 }
 /**
  * Hand off to `bootProduction` with the standard wiring (postRendererReady
  * + postBootFailure + observability + lifecycle). Extracted so both the
- * GguiBootstrapMeta-inlined fast path and the post-tool-result-timeout
+ * live-channel-inlined fast path and the post-tool-result-timeout
  * fallback share one call site — keeps the WS-driven boot semantics
  * single-sourced.
+ *
+ * `preResolvedMeta` is threaded in from the autostart resolver when
+ * it has already discovered slice meta — via inline `__GGUI_META__`
+ * global, a buffered `__GGUI_PENDING_TOOL_RESULTS__` entry, or an
+ * early `ui/notifications/tool-result` postMessage. Threading skips
+ * `bootSequence`'s internal resolver chain (which would otherwise
+ * re-await the same postMessage or re-parse the same global), saving
+ * up to the 30s postMessage timeout for spec-strict hosts.
  */
-function runBootProduction() {
-    const callUiInitialize = () => {
-        const caller = makeJsonRpcCaller();
-        // Per MCP Apps spec (specification/2026-01-26/apps.mdx:554-563),
-        // ui/initialize params are { appInfo, appCapabilities,
-        // protocolVersion } — all three required. Spec-compliant
-        // hosts (claude.ai's validator) reject empty params with
-        // "Invalid input" for each missing field.
-        return caller('ui/initialize', {
-            appInfo: { name: 'ggui-iframe-runtime', version: '1.0.0' },
-            // Declare the display modes ggui supports so spec-compliant
-            // hosts know `ui/request-display-mode` requests for these
-            // values are honored. The runtime emits `request-display-mode`
-            // from the `Element.requestFullscreen` interceptor + the
-            // canvas-mode display-mode escalation policy; both target this
-            // enum.
-            appCapabilities: {
-                availableDisplayModes: ['inline', 'fullscreen', 'pip'],
-            },
-            protocolVersion: '2026-01-26',
-        });
-    };
+function runBootProduction(preResolvedMeta) {
+    const { app, transport } = createDefaultApp();
     void bootProduction({
         doc: document,
-        callUiInitialize,
+        app,
+        transport,
         notifyParent: (msg) => {
             if (msg.type === 'ggui:renderer-ready') {
                 postRendererReady();
@@ -2161,104 +2067,47 @@ function runBootProduction() {
         },
         onObserve: postObservabilityToParent,
         onLifecycle: postLifecycleToParent,
+        ...(preResolvedMeta !== undefined ? { preResolvedMeta } : {}),
     });
 }
 if (shouldAutostart() && typeof window !== 'undefined') {
-    // Boot-source resolution, in priority order. Each tier is a
-    // distinct way the host can deliver a {@link SelfContainedBootstrap}
-    // to the runtime; downstream `bootSelfContained` is the one mount
-    // path for all of them.
-    //
-    //   1. Inline `__GGUI_BOOTSTRAP__` global — per-session shells
-    //      (`/r/<shortCode>`, `ui://ggui/session/<sessionId>`) populate
-    //      this synchronously before the runtime loads. Zero round-
-    //      trip; no postMessage.
+    // Boot-source resolution — collapsed post-consolidation. The
+    // static-vs-live FORK is gone: every meta flows through the ONE
+    // unified path (`runBootProduction` → `bootProduction` →
+    // `bootSequence`), which decides internally whether to seed-mount
+    // static content (codeUrl/kind), open a WS subscribe (wsUrl+wsToken),
+    // or both. The autostart layer's only job is to RESOLVE the meta from
+    // one of three delivery channels:
     //
+    //   1. Inline `__GGUI_META__` global — first-party shells populate
+    //      this synchronously before this bundle evaluates.
     //   2. Buffered `__GGUI_PENDING_TOOL_RESULTS__` — minimal-shell
-    //      pattern. The shell installs a postMessage listener at
-    //      first-paint, buffers any `ui/notifications/tool-result`
-    //      arrivals into the array, and the runtime drains on load.
-    //      Covers the case where the host posts the tool-result
-    //      BEFORE the runtime bundle finishes parsing.
-    //
-    //   3. Live postMessage listener — `awaitToolResultBootstrap`
-    //      catches tool-results that arrive AFTER the runtime is
-    //      ready (the more common case on Claude Desktop, where the
-    //      iframe loads before the agent's tool call resolves).
+    //      pattern (postMessage arrived before the bundle parsed).
+    //   3. Live `ui/notifications/tool-result` postMessage — the
+    //      spec-canonical channel for spec-strict hosts (`<AppRenderer>`,
+    //      ChatGPT, claude.ai). Caught meta threads through as
+    //      `preResolvedMeta` so `bootSequence` doesn't re-await it.
     //
-    //   4. `bootProduction` (legacy `ui/initialize` round-trip + WS
-    //      subscribe) — first-party hosts (Studio, Portal, console)
-    //      that drive the live-channel path. Kept as the terminal
-    //      fallback for backwards compatibility.
-    //
-    // The architectural goal: ALL bootstrap-shape narrowing happens
-    // inside the runtime (this file). Shells never validate, mount,
-    // or transform — they only deliver. That's the cure for the
-    // "shell-side validator lagged the protocol" bug class.
-    // T3-1 (2026-05-13) — bootSelfContained requires static content
-    // (codeUrl or kind) to mount. Live-only bootstraps (wsUrl+token
-    // without static content) MUST go through `bootProduction` so the
-    // stack item arrives via the live-channel WS subscribe. Pre-T3-1 the
-    // inline `componentCode` channel made every push static, so
-    // bootSelfContained always had something to mount; post-drop, we
-    // dispatch on the discriminator explicitly.
-    const inline = readSelfContainedBootstrap();
-    const inlineHasStatic = inline !== null
-        && (typeof inline.codeUrl === 'string'
-            || typeof inline.kind === 'string');
-    if (inline !== null && inlineHasStatic) {
-        void bootSelfContained(document, inline);
-    }
-    else if (inline !== null) {
-        // Live-only inline bootstrap — hand to bootProduction so it
-        // re-issues ui/initialize and walks the WS path.
-        runBootProduction();
+    // `readLiveBootstrapShape` still short-circuits the 30s tool-result
+    // wait when a live-channel envelope is already inlined — OSS embedded
+    // shells that never emit a separate tool-result would otherwise hang
+    // at `mounting` for the full timeout.
+    const inline = readSelfContainedMeta();
+    if (inline !== null) {
+        runBootProduction(inline);
     }
     else {
         const buffered = readPendingToolResults();
-        const bufferedHasStatic = buffered !== null
-            && (typeof buffered.codeUrl === 'string'
-                || typeof buffered.kind === 'string');
-        if (buffered !== null && bufferedHasStatic) {
-            void bootSelfContained(document, buffered);
+        if (buffered !== null) {
+            runBootProduction(buffered);
         }
-        else if (buffered !== null) {
+        else if (readLiveBootstrapShape()) {
             runBootProduction();
         }
         else {
-            // Pre-empt the postMessage tool-result race when `__GGUI_BOOTSTRAP__`
-            // already carries a `GguiBootstrapMeta` (wsUrl + token + sessionId
-            // + appId) — that shape isn't a `SelfContainedBootstrap`, so
-            // `readSelfContainedBootstrap` returned null, but it IS the
-            // signal that a first-party shell (`/s/<shortCode>`,
-            // `ui://ggui/session/<sessionId>`) has already inlined the WS-
-            // driven boot envelope. Skip the 30s tool-result wait and hand
-            // off to `bootProduction` directly — `bootProduction` re-issues
-            // `ui/initialize` to the host, which re-emits the same bootstrap
-            // back via Reading-B, and the WS path proceeds without delay.
-            // Without this short-circuit, the OSS embedded-ui (which never
-            // sends a separate `ui/notifications/tool-result`) hangs at
-            // `mounting` for the full 30s timeout before `code-ready`.
-            const hasGguiBootstrapMeta = readGguiBootstrapMetaShape();
-            if (hasGguiBootstrapMeta) {
-                runBootProduction();
-            }
-            else {
-                // Race a postMessage listener against the legacy production
-                // boot. Tool-result wins if it arrives within the timeout;
-                // otherwise we hand off to the WS-driven path.
-                const POSTMESSAGE_BOOT_TIMEOUT_MS = 30_000;
-                void awaitToolResultBootstrap(POSTMESSAGE_BOOT_TIMEOUT_MS).then((postMessageBootstrap) => {
-                    const hasStatic = postMessageBootstrap !== null
-                        && (typeof postMessageBootstrap.codeUrl === 'string'
-                            || typeof postMessageBootstrap.kind === 'string');
-                    if (postMessageBootstrap !== null && hasStatic) {
-                        void bootSelfContained(document, postMessageBootstrap);
-                        return;
-                    }
-                    runBootProduction();
-                });
-            }
+            void awaitToolResultMeta(POSTMESSAGE_BOOT_TIMEOUT_MS).then((postMessageMeta) => {
+                runBootProduction(postMessageMeta ?? undefined);
+            });
         }
     }
 }
@@ -2283,10 +2132,15 @@ async function bootProduction(opts) {
         import('./globals.js'),
         import('./gadget-loader.js'),
     ]);
-    // Triad wiring hook — constructs buses + stack renderer + wire
-    // config on demand inside bootSequence.
-    const triadWiring = {
-        setup: ({ bootstrap, stackModel, renderInto, statusRefs, onObserve, onCanvasLifecycle }) => {
+    // Renderer wiring hook — constructs buses + single-render mount surface
+    // + wire config on demand inside bootSequence.
+    const renderer = {
+        setup: ({ meta, renderInto, statusRefs, onObserve }) => {
+            // Post-Phase-B `meta` is the flat render slice — `renderId` /
+            // `appId` / `runtimeUrl` / `wsUrl` / `wsToken` / `themeId` /
+            // `gadgets` / `publicEnv` / `contextSlots` / `actionNextSteps` /
+            // `appCallableTools` / `streamWebSocketLocalTools` all live
+            // directly on `meta`.
             // Compose the gadget registry: STDLIB seed PLUS any
             // operator-registered wrappers carried on the bootstrap.
             // Awaited inside the synchronous `setup` callback via an IIFE
@@ -2295,13 +2149,13 @@ async function bootProduction(opts) {
             // is fast (already-resolved bundles hit the module cache).
             //
             // For now we fall back to the STDLIB-only seed if the bootstrap
-            // omits `gadgets`. The install happens BEFORE any stack
-            // item renders so `rewrite-imports.ts` reads a fully-populated
-            // registry on the first `loadModule` call.
+            // omits `gadgets`. The install happens BEFORE any render mounts
+            // so `rewrite-imports.ts` reads a fully-populated registry on
+            // the first `loadModule` call.
             const composedGadgets = gadgetLoaderMod
                 // Empty registrations → resolves to a Promise of the STDLIB
                 // seed only; the boot path doesn't wait on wrapper imports.
-                .loadGadgetRegistry(gadgetsMod, bootstrap.gadgets ?? []);
+                .loadGadgetRegistry(gadgetsMod, meta.gadgets ?? []);
             // Install with the synchronous STDLIB seed first; the WS-driven
             // boot path doesn't await wrapper loads here (the registry
             // install is TOCTOU-critical and synchronous). The Promise's
@@ -2322,8 +2176,8 @@ async function bootProduction(opts) {
                 gadgets: { '@ggui-ai/gadgets': gadgetsMod },
                 // Public env values from the bootstrap. The WS-driven path
                 // receives bootstrap synchronously via
-                // setup({bootstrap, ...}) so installing here is correct.
-                publicEnv: bootstrap.publicEnv ?? {},
+                // setup({meta, ...}) so installing here is correct.
+                publicEnv: meta.publicEnv ?? {},
             });
             // Merge 3rd-party package namespaces into the LIVE slot object —
             // not a slot replacement. The per-package data-URL shims read
@@ -2351,24 +2205,19 @@ async function bootProduction(opts) {
             // SingleSlotProvider per declared slot) hoists useState into the
             // runtime so `useGguiContext(slot)` reads the live tuple.
             const registry = globalsMod.getGlobalRegistry();
-            const resolvedSlots = registry !== undefined && bootstrap.contextSlots !== undefined
-                ? installContextRegistry(registry.contexts, reactMod, bootstrap.contextSlots)
+            const resolvedSlots = registry !== undefined && meta.contextSlots !== undefined
+                ? installContextRegistry(registry.contexts, reactMod, meta.contextSlots)
                 : [];
             const ContextStateHost = createContextStateHost({
                 react: reactMod,
-                postToParent,
+                poster: productionContextSnapshotPoster,
                 consoleWarn: typeof console !== 'undefined' && typeof console.warn === 'function'
                     ? console.warn.bind(console)
                     : undefined,
-                ...(bootstrap.stackItemId !== undefined
-                    ? {
-                        identity: {
-                            sessionId: bootstrap.sessionId,
-                            appId: bootstrap.appId,
-                            stackItemId: bootstrap.stackItemId,
-                        },
-                    }
-                    : {}),
+                identity: {
+                    renderId: meta.renderId,
+                    appId: meta.appId,
+                },
             });
             const streamBus = new StreamBus();
             // Buffered send shim — the real WS handle isn't available until
@@ -2396,64 +2245,165 @@ async function bootProduction(opts) {
                     }
                 },
             };
-            const { config: rootConfig, buildScopedConfig } = buildRootWireConfig({
-                sessionId: bootstrap.sessionId,
-                appId: bootstrap.appId,
-                getStack: () => stackModel.snapshot(),
+            // Spec-canonical outbound dispatch. The WS pipe is for streamSpec
+            // subscriptions ONLY (inbound `ggui_emit` fanout + `props_update` +
+            // `render` + `data` + `feedback` + `drain_ack` + `channel_payload`).
+            // Outbound user actions go through the MCP-Apps host relay per
+            // spec §401: postMessage `tools/call:ggui_runtime_submit_action`
+            // to the parent → `AppRenderer.onCallTool` → sample agent's
+            // `/relay/tools-call` → ggui MCP server →
+            // `createGguiSubmitActionHandler.append` → `pendingEventConsumer`
+            // → `ggui_consume` wakes the agent. The server's WS
+            // `handleInboundAction` writes to the session ledger only — no
+            // downstream consumer — so the WS action path silently drops
+            // clicks. `routeDispatch` is the same helper `bootSelfContained`
+            // uses; threading it here aligns LIVE-mode with self-contained.
+            // Single mounted render — populated by `applyRender` on the first
+            // render frame. The wire config + data channel handler read it
+            // through `currentRender`-returning thunks so they always see the
+            // latest snapshot without holding stale refs.
+            let currentRender = null;
+            let renderHandle = null;
+            const dispatchToolName = resolveDispatchToolName();
+            // Native-idiom interceptors — the replacement for the retired
+            // openLink / requestDisplayMode wire primitives. Installed here
+            // (module-guarded, idempotent) so EVERY component render mounted
+            // through this single surface — the WS-ack render, the inline
+            // static seed, and re-mounts — has anchor-click + fullscreen
+            // capture live before the first `applyRender`. Pre-consolidation
+            // these lived only in `bootSelfContained`; the WS-driven path
+            // installed neither, so anchor clicks + fullscreen requests in a
+            // live-rendered component silently no-op'd.
+            installAnchorClickInterceptor({
+                dispatchToolName,
+                renderId: meta.renderId,
+                appId: meta.appId,
+            });
+            installFullscreenInterceptors({
+                dispatchToolName,
+                renderId: meta.renderId,
+                appId: meta.appId,
+            });
+            const rootConfig = buildRootWireConfig({
+                renderId: meta.renderId,
+                appId: meta.appId,
+                getCurrentRender: () => currentRender,
                 manager,
                 streamBus,
                 ...(onObserve !== undefined ? { onObserve } : {}),
-            });
-            // containerFor: mint a `<div data-ggui-stack-item-root="<id>">`
-            // child inside `renderInto` for each stack item id. Reuse on
-            // re-apply.
-            const containersById = new Map();
-            const containerFor = (id) => {
-                const existing = containersById.get(id);
-                if (existing !== undefined)
-                    return existing;
-                const el = renderInto.ownerDocument.createElement('div');
-                el.setAttribute('data-ggui-stack-item-root', id);
-                renderInto.appendChild(el);
-                containersById.set(id, el);
-                return el;
-            };
-            const stackCtx = {
-                containerFor,
-                getScopedWireConfig: (item) => {
-                    // item.type === 'mcpApps' stack items get NO wire config —
-                    // their iframe host has its own contract (adapter-boundary
-                    // rule). Component items scope via `buildScopedConfig`
-                    // (see `packages/wire/src/context.ts`). `contractHash` is
-                    // intentionally absent — it lives on the event envelope,
-                    // not on the stack item shape.
-                    if (item.type === 'mcpApps' || item.type === 'system')
-                        return null;
-                    return buildScopedConfig({
-                        stackItemId: item.id,
-                        ...(item.actionSpec !== undefined ? { actionSpec: item.actionSpec } : {}),
-                    });
-                },
-                // Wrap every per-item React mount in
-                // `<ContextStateHost slots={resolvedSlots}>` so contextSpec
-                // values flow through `ui/update-model-context` exactly like
-                // the self-contained path. mcpApps + system items skip the
-                // wrap (their renderers don't run user component code that
-                // reads contexts). When `resolvedSlots` is empty
-                // ContextStateHost short-circuits to a Fragment, so the wrap
-                // is free for items with no contextSpec.
-                getOuterWrapper: (item) => {
-                    if (item.type === 'mcpApps' || item.type === 'system')
-                        return undefined;
-                    return (mountedTree) => reactMod.createElement(ContextStateHost, {
-                        slots: resolvedSlots,
-                        children: mountedTree,
+                onDispatchEnvelope: (envelope) => {
+                    if (envelope.type !== 'data:submit')
+                        return;
+                    const payload = envelope.payload;
+                    if (payload === undefined
+                        || typeof payload.action !== 'string'
+                        || payload.action.length === 0) {
+                        return;
+                    }
+                    routeDispatch({
+                        actionName: payload.action,
+                        data: payload.data,
+                        meta: {
+                            renderId: meta.renderId,
+                            appId: meta.appId,
+                            ...(meta.appCallableTools !== undefined
+                                ? { appCallableTools: meta.appCallableTools }
+                                : {}),
+                            ...(meta.actionNextSteps !== undefined
+                                ? { actionNextSteps: meta.actionNextSteps }
+                                : {}),
+                        },
+                        dispatchToolName,
                     });
                 },
-                streamBus,
-                sessionId: bootstrap.sessionId,
+            });
+            // Build the wrap factory used by every mount React tree:
+            // `<ContextStateHost slots={resolvedSlots}>` so contextSpec
+            // values flow through `ui/update-model-context` exactly like the
+            // self-contained path. mcpApps + system renders skip the wrap
+            // (their renderers don't run user component code that reads
+            // contexts). When `resolvedSlots` is empty ContextStateHost
+            // short-circuits to a Fragment, so the wrap is free for renders
+            // with no contextSpec.
+            const buildOuterWrapper = (render) => {
+                if (render.type === 'mcpApps' || render.type === 'system')
+                    return undefined;
+                return (mountedTree) => reactMod.createElement(ContextStateHost, {
+                    slots: resolvedSlots,
+                    children: mountedTree,
+                });
+            };
+            // Build the scoped wire config for the active render. mcpApps +
+            // system renders get NO wire config — their iframe / built-in
+            // host has its own contract (adapter-boundary rule).
+            // Post-render-identity-collapse the WireConfig is bound to the
+            // single render at boot, so there's no per-render scope factory
+            // — every dispatch resolves through `getCurrentRender`.
+            const buildScopedWireFor = (render) => {
+                if (render.type === 'mcpApps' || render.type === 'system')
+                    return null;
+                return rootConfig;
             };
-            const stackRenderer = new StackRenderer(stackCtx);
+            // Build the renderer options for the active render. Theme is
+            // forwarded from the bootstrap so the mounted React tree injects
+            // the configured theme's CSS vars (indigo, claudic, etc).
+            // Without this, react-renderer.ts falls back to
+            // `getScopedCssTokens` (no preset) and the iframe renders with
+            // the default ggui theme even when `_meta["ai.ggui/render"].themeId`
+            // is `'indigo'`. Sibling `bootSelfContained` path threads the
+            // same fields onto its `mountOpts` for parity.
+            const buildOpts = (render) => {
+                const wrapOuter = buildOuterWrapper(render);
+                return {
+                    render,
+                    scopedWireConfig: buildScopedWireFor(render),
+                    streamBus,
+                    renderId: meta.renderId,
+                    // Thread the bootstrap's 3rd-party gadget packages so the import
+                    // rewriter resolves non-STDLIB gadget imports even for a static
+                    // seed mount (which carries no gadgetDescriptors). A full
+                    // WS-delivered Render carries gadgetDescriptors and ignores this.
+                    ...(meta.gadgets !== undefined
+                        ? { gadgetPackages: meta.gadgets.map((g) => g.package) }
+                        : {}),
+                    ...(meta.themeId !== undefined ? { themeId: meta.themeId } : {}),
+                    ...(meta.themeMode !== undefined
+                        ? { themeMode: meta.themeMode }
+                        : {}),
+                    ...(wrapOuter !== undefined ? { wrapOuter } : {}),
+                };
+            };
+            /**
+             * Mount-or-update the single render slot. First call mounts the
+             * React tree into `renderInto`; subsequent calls re-apply via
+             * `renderHandle.update` (same kind ⇒ in-place props update; kind
+             * transition ⇒ tear-down + remount via `RenderItemHandle`'s own
+             * lifecycle).
+             *
+             * Shared by the render-frame and props_update channel handlers;
+             * closes over `currentRender` + `renderHandle` so the channel
+             * layer just calls `applyRender(render)` without owning
+             * lifecycle state.
+             */
+            const applyRender = async (render) => {
+                currentRender = render;
+                if (renderHandle === null) {
+                    renderHandle = await mountRender(renderInto, buildOpts(render));
+                    return;
+                }
+                await renderHandle.update(buildOpts(render));
+            };
+            // Publish `applyRender` module-level + install the persistent
+            // post-mount tool-result listener. On a host-re-emitted tool-result
+            // (claude.ai re-broadcast; the Anthropic-SDK-strips-_meta refetch),
+            // the listener re-mounts through THIS `applyRender` — no fresh boot,
+            // no second WS. The no-WS live-re-render channel; for WS hosts the
+            // render-frame handler already covers re-render, so it's a
+            // redundant-safe fallback (guarded by the renderId pin + liveTrio
+            // dedupe). Runs only on the production renderer path (tests that
+            // drive bootSequence without a renderer never reach setup()).
+            activeApplyRender = applyRender;
+            installPostMountListener();
             // Validator context — A2UI default for `_ggui:preview`; no
             // bootstrap-supplied overrides today (the
             // `extraReservedValidators` injection slot is reserved for a
@@ -2461,35 +2411,33 @@ async function bootProduction(opts) {
             const validatorCtx = {
                 reservedValidators: mergeReservedValidators(undefined, undefined),
             };
-            // Per-channel transport router. Created here so it
-            // shares the buffered manager shim (and survives the
-            // pre-attachManager send buffering) + the same StreamBus the
-            // wire config emits onto. The router consults
-            // `bootstrap.streamWebSocketLocalTools` to decide WS-subscribe
-            // vs iframe-polling per channel; absent ⇒ universal polling
-            // fallback. Activated lazily by `handleTriadMessage`'s push
-            // case (which calls `channelTransport.applyStackItem` on every
-            // stack-fold).
+            // Per-channel transport router. Created here so it shares the
+            // buffered manager shim (and survives the pre-attachManager send
+            // buffering) + the same StreamBus the wire config emits onto.
+            // The router consults `bootstrap.streamWebSocketLocalTools` to
+            // decide WS-subscribe vs iframe-polling per channel; absent ⇒
+            // universal polling fallback. Activated lazily by the render-
+            // frame handler (which calls `channelTransport.applyRender` on
+            // every render fold).
             const channelTransport = createChannelTransportRouter({
-                sessionId: bootstrap.sessionId,
-                appId: bootstrap.appId,
-                ...(bootstrap.streamWebSocketLocalTools !== undefined
+                renderId: meta.renderId,
+                appId: meta.appId,
+                ...(meta.streamWebSocketLocalTools !== undefined
                     ? {
-                        streamWebSocketLocalTools: bootstrap.streamWebSocketLocalTools,
+                        streamWebSocketLocalTools: meta.streamWebSocketLocalTools,
                     }
                     : {}),
                 send: (msg) => manager.send(msg),
                 toolsCall: async ({ toolName, args }) => {
-                    // Iframe-polling transport — `tools/call` over the parent
-                    // MCP host's JSON-RPC channel. Pattern α direct call
-                    // (no LLM consent loop). Returns the tool's
-                    // structuredContent (or `content[0]` if that's where the
-                    // payload landed) as a JsonValue. On RPC error we throw —
-                    // the router catches and silently retries on the next tick.
-                    const resp = await postRpcToParent('tools/call', {
-                        name: toolName,
-                        arguments: args,
-                    });
+                    // Iframe-polling transport — `tools/call` against the
+                    // parent MCP host via `app.callServerTool` (spec-canonical)
+                    // when the App handle is set; falls back to raw postMessage
+                    // pre-handshake or in tests. Pattern α direct call (no LLM
+                    // consent loop). Returns the tool's structuredContent (or
+                    // `content[0]` if that's where the payload landed) as a
+                    // JsonValue. On RPC error we throw — the router catches
+                    // and silently retries on the next tick.
+                    const resp = await callServerToolSpec(toolName, args);
                     if (resp.error !== undefined) {
                         throw new Error(resp.error.message ?? 'tools/call failed');
                     }
@@ -2514,8 +2462,8 @@ async function bootProduction(opts) {
                     }
                     : {}),
             });
-            // B3b — channel-client registry owns dispatch for every routable
-            // WS frame type. Each handler closes over the triad state it
+            // B3b — live-channel registry owns dispatch for every routable
+            // WS frame type. Each handler closes over the renderer state it
             // needs. `bootSequence` calls `connectFn` (default
             // `connectViaRegistry`) which registers the `ack` + `error`
             // handshake handlers and binds the WS transport — frames then
@@ -2528,45 +2476,29 @@ async function bootProduction(opts) {
                 subscribeFrameBuilder: () => ({
                     type: 'subscribe',
                     payload: {
-                        sessionId: bootstrap.sessionId,
-                        appId: bootstrap.appId,
-                        ...(bootstrap.token !== undefined
-                            ? { bootstrap: bootstrap.token }
+                        renderId: meta.renderId,
+                        appId: meta.appId,
+                        ...(meta.wsToken !== undefined
+                            ? { wsToken: meta.wsToken }
                             : {}),
                     },
                 }),
             });
-            channelRegistry.register(createPushHandler({
-                stackModel,
+            channelRegistry.register(createRenderHandler({
                 statusRefs,
-                getStackRenderer: () => stackRenderer,
+                pinnedRenderId: meta.renderId,
+                applyRender,
                 getChannelTransport: () => channelTransport,
             }));
             channelRegistry.register(createDataHandler({
-                stackModel,
+                getCurrentRender: () => currentRender,
                 streamBus,
                 validatorCtx,
                 ...(onObserve !== undefined ? { onObserve } : {}),
-                // Canvas-mode lifecycle envelopes
-                // → AnimatorEventBus publish (via the sink built in
-                // bootSequence from the canvas mount handle).
-                ...(onCanvasLifecycle !== undefined
-                    ? { onCanvasLifecycle }
-                    : {}),
             }));
             channelRegistry.register(createPropsUpdateHandler({
-                stackModel,
-                getStackRenderer: () => stackRenderer,
-                // Server stamps `pollingUrl` on the bootstrap envelope when the
-                // bootstrap is minted via `/api/bootstrap/<shortCode>` — this is
-                // the URL the iframe-runtime's `PollingTransport` fetches when
-                // the WebSocket transport is unavailable (host blocks `wss://`)
-                // or fails irrecoverably (FailoverHandle swap). Without this
-                // wired, polling has no URL and live updates silently no-op
-                // outside of WS hosts.
-                ...(bootstrap.pollingUrl !== undefined
-                    ? { pollingUrl: bootstrap.pollingUrl }
-                    : {}),
+                getCurrentRender: () => currentRender,
+                applyRender,
             }));
             channelRegistry.register(createDrainAckHandler({ dispatch: dispatchDrainAck }));
             channelRegistry.register(createFeedbackHandler());
@@ -2582,11 +2514,13 @@ async function bootProduction(opts) {
             return {
                 rootWireConfig: rootConfig,
                 streamBus,
-                stackRenderer,
+                applyRender,
+                getCurrentRender: () => currentRender,
                 validatorCtx,
                 manager,
                 channelTransport,
                 channelRegistry,
+                composedGadgets,
             };
         },
         attachManager: (handle, realManager) => {
@@ -2597,27 +2531,27 @@ async function bootProduction(opts) {
             }
         },
         teardown: (handle) => {
-            handle.stackRenderer.unmountAll();
-            // Tear down per-channel polling timers + clear subscription
-            // registry. No-op when no channel was ever activated.
+            // The React mount lifecycle is owned by the per-setup
+            // `renderHandle` closure; it stays null until the first render
+            // frame lands. Today bootSequence's failure paths fire before
+            // any render frame (handshake errors arrive before the first
+            // ack), so unmounting the React tree from here is unnecessary.
+            // The only thing the teardown hook still owns is the per-channel
+            // polling timer + transport subscription registry — no-op when
+            // no channel was activated.
             handle.channelTransport.dispose();
         },
     };
-    // Canvas-mode mount hook. Constructed
-    // here because React + the canvas modules are already dynamic-
-    // imported above; bootSequence calls it lazily only when the parsed
-    // bootstrap carries `canvasMode: true`. Non-canvas sessions never
-    // pay the canvas-mount cost; canvas sessions never re-import React
-    // separately.
-    const canvasMountMod = await import('./canvas/mount.js');
-    const canvasMount = ({ mountTarget, callbacks }) => canvasMountMod.mountCanvas(mountTarget, { react: reactMod, reactDomClient }, callbacks);
     await bootSequence({
         doc: opts.doc,
-        callUiInitialize: opts.callUiInitialize,
+        app: opts.app,
+        transport: opts.transport,
         notifyParent: opts.notifyParent,
-        triadWiring,
-        canvasMount,
+        renderer,
         ...(opts.onObserve !== undefined ? { onObserve: opts.onObserve } : {}),
         ...(opts.onLifecycle !== undefined ? { onLifecycle: opts.onLifecycle } : {}),
+        ...(opts.preResolvedMeta !== undefined
+            ? { preResolvedMeta: opts.preResolvedMeta }
+            : {}),
     });
 }