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

package/dist/protocol-error.js

@@ -1,6 +1,6 @@
 /**
  * Default emitter — operator-visible `console.warn` with a grep-
- * friendly tag. Identical posture to `GguiSession.surfaceContractViolation`'s
+ * friendly tag. Identical posture to `GguiRender.surfaceContractViolation`'s
  * console.warn fallback. Callers override by injecting their own.
  */
 export function defaultProtocolErrorEmitter(err) {
@@ -17,18 +17,10 @@ export function defaultProtocolErrorEmitter(err) {
  * outbound action, or when an inbound stream / props payload fails the
  * local validator) onto a `ProtocolError`.
  *
- * Client-side violations do NOT ride the server-emitted
- * `_ggui:contract-error` envelope — that shape (`ContractErrorPayload`)
- * is tool-failure-scoped and authored by the session-channel router.
- * A client-side violation is a DIFFERENT category: nothing reached the
- * tool. We surface it as `{kind: 'protocol'; code:
+ * A client-side violation never left the renderer — nothing reached
+ * the server. We surface it as `{kind: 'protocol'; code:
  * 'CLIENT_CONTRACT_VIOLATION'}` with structured `details` so hosts can
  * render the same summary that `console.warn` would have produced.
- *
- * Server-emitted `ContractErrorPayload` landing on
- * `_ggui:contract-error` rides the separate `{kind: 'contract'}`
- * variant — that path activates when the renderer observes the
- * reserved channel.
  */
 export function fromClientContractViolation(err) {
     return {
@@ -41,16 +33,6 @@ export function fromClientContractViolation(err) {
         },
     };
 }
-/**
- * Wrap a server-emitted `ContractErrorPayload` (received over the
- * reserved `_ggui:contract-error` channel) as the 'contract' variant.
- * Trivial wrapper — exists so call sites produce the union via a
- * factory rather than an object literal (keeps emission uniform and
- * makes grep for creation sites exact).
- */
-export function fromContractErrorPayload(payload) {
-    return { kind: 'contract', payload };
-}
 /**
  * Build a `ProtocolError` of kind 'version' from the existing
  * `UpgradeRequiredError` class. Matches the `liftUpgradeRequiredFromError`
@@ -104,8 +86,8 @@ export function fromTransportFailure(code, retryable, message) {
     };
 }
 /**
- * Build a `ProtocolError` of kind 'auth' — session / token rejection
- * pre-handshake.
+ * Build a `ProtocolError` of kind 'auth' — session / ws-token rejection
+ * pre-ack (see {@link AuthFailureCode}).
  */
 export function fromAuthFailure(code, message) {
     return {

package/dist/provisional-renderer.js

@@ -36,9 +36,9 @@ import { createRoot } from 'react-dom/client';
  * Spec-canonical A2UI preview channel name (from
  * `@ggui-ai/protocol::PREVIEW_CHANNEL`). Inlined here so this
  * module's runtime imports stay off the protocol root barrel —
- * importing the constant from `@ggui-ai/protocol` pulls in
- * `openrouter-models` + the entire zod validation graph via the
- * root re-export chain, adding ~250 KB gz to the renderer bundle.
+ * importing the constant from `@ggui-ai/protocol` pulls in the
+ * entire zod validation graph via the root re-export chain,
+ * adding hundreds of KB gz to the renderer bundle.
  * The value is a stable string literal (`isKnownReservedChannel`
  * and the spec both reference `_ggui:preview` directly); re-declaring
  * it here is shape-preserving and covered by the structural-lock

package/dist/react-renderer.d.ts

@@ -22,9 +22,8 @@
  *
  * Error handling — ErrorBoundary with auto-retry (AUTO_RETRY_LIMIT +
  * AUTO_RETRY_DELAY) matches the `ReactComponentRenderer` contract.
- * On terminal error, the callback `onRequestRepair` fires; the
- * render dispatcher (`render-item.ts`) wires this to the
- * `ggui:request-repair` live-channel envelope it dispatches.
+ * On terminal error, `onError` fires and the boundary paints the
+ * terminal error UI.
  *
  * No JSX in this file — the mount-root code uses
  * `React.createElement` + `React.Fragment` directly so the renderer's
@@ -33,7 +32,7 @@
 import React, { type ReactNode } from 'react';
 export interface ReactRootMountOptions {
     /**
-     * Render whose componentCode + props drive the mount. Only
+     * GguiSession whose componentCode + props drive the mount. Only
      * `componentCode` + `props` are read here; the caller is
      * responsible for wrapping this with a `<GguiWireProvider>` at the
      * higher-level dispatcher (see `render-item.ts`).
@@ -50,9 +49,20 @@ export interface ReactRootMountOptions {
      * registered theme paints when the operator selected it.
      */
     readonly themeMode?: 'light' | 'dark';
+    /**
+     * Per-app theme overlay applied at the iframe's `:root` AFTER the base
+     * token block, so the operator-supplied `--ggui-*` values win the
+     * cascade (a partial set — unset vars keep their token defaults). A
+     * structural subset of protocol's `AppTheme` (`name` is display-only,
+     * not needed at render). `mode` drives `color-scheme` so native
+     * controls / scrollbars / canvas pick up dark vs light.
+     */
+    readonly appTheme?: {
+        readonly mode: 'light' | 'dark';
+        readonly cssVariables: Record<string, string>;
+    };
     readonly cssOverrides?: string;
     readonly onError?: (error: Error) => void;
-    readonly onRequestRepair?: (error: Error) => void;
     /**
      * Children injected BETWEEN the mount DOM (scope + CSS) and the
      * evaluated component element. The caller's render dispatcher
@@ -64,7 +74,7 @@ export interface ReactRootMountOptions {
     readonly renderWrapper?: (mountedComponent: ReactNode) => ReactNode;
     /**
      * Bare npm package names of the operator-registered 3rd-party gadget
-     * packages reachable in this session (GG.8.2). Forwarded to
+     * packages reachable in this render (GG.8.2). Forwarded to
      * `rewriteImports` so each direct gadget import resolves to its
      * per-package data-URL shim. Sourced from the bootstrap's `gadgets`
      * channel; `@ggui-ai/gadgets` (STDLIB) is always rewritten and need

package/dist/react-renderer.js

@@ -22,9 +22,8 @@
  *
  * Error handling — ErrorBoundary with auto-retry (AUTO_RETRY_LIMIT +
  * AUTO_RETRY_DELAY) matches the `ReactComponentRenderer` contract.
- * On terminal error, the callback `onRequestRepair` fires; the
- * render dispatcher (`render-item.ts`) wires this to the
- * `ggui:request-repair` live-channel envelope it dispatches.
+ * On terminal error, `onError` fires and the boundary paints the
+ * terminal error UI.
  *
  * No JSX in this file — the mount-root code uses
  * `React.createElement` + `React.Fragment` directly so the renderer's
@@ -59,7 +58,6 @@ class RcrErrorBoundary extends Component {
         error: null,
         catchCount: 0,
         autoRetrying: false,
-        repairRequested: false,
     };
     retryTimer = null;
     static getDerivedStateFromError(error) {
@@ -76,20 +74,16 @@ class RcrErrorBoundary extends Component {
             return;
         }
         this.props.onError?.(error);
-        if (this.props.onRequestRepair && !this.state.repairRequested) {
-            this.setState({ repairRequested: true });
-            this.props.onRequestRepair(error);
-        }
     }
     componentWillUnmount() {
         if (this.retryTimer !== null)
             clearTimeout(this.retryTimer);
     }
     render() {
-        const { error, autoRetrying, repairRequested, catchCount } = this.state;
+        const { error, autoRetrying, catchCount } = this.state;
         if (error === null)
             return this.props.children;
-        // The three fallback UIs match the host-SDK error boundary
+        // The two fallback UIs match the host-SDK error boundary
         // verbatim (same inline styles so operator-visible DOM is
         // identical between the host-SDK and iframe-renderer paths).
         const FONT = '-apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif';
@@ -117,30 +111,6 @@ class RcrErrorBoundary extends Component {
                 },
             }), 'Retrying...', createElement('style', null, '@keyframes ggui-err-spin { to { transform: rotate(360deg); } }'));
         }
-        if (repairRequested) {
-            return createElement('div', {
-                style: {
-                    display: 'flex',
-                    flexDirection: 'column',
-                    alignItems: 'center',
-                    justifyContent: 'center',
-                    padding: '32px 24px',
-                    minHeight: 120,
-                    gap: 10,
-                    textAlign: 'center',
-                    fontFamily: FONT,
-                },
-            }, createElement('div', {
-                style: {
-                    width: 16,
-                    height: 16,
-                    border: '2px solid rgba(139,92,246,0.2)',
-                    borderTopColor: 'rgba(139,92,246,0.7)',
-                    borderRadius: '50%',
-                    animation: 'ggui-err-spin 0.8s linear infinite',
-                },
-            }), createElement('div', { style: { fontSize: 13, color: 'rgba(255,255,255,0.5)' } }, 'Repairing component...'), createElement('style', null, '@keyframes ggui-err-spin { to { transform: rotate(360deg); } }'));
-        }
         return createElement('div', {
             style: {
                 display: 'flex',
@@ -165,7 +135,7 @@ class RcrErrorBoundary extends Component {
                 fontSize: 22,
             },
         }, '!'), createElement('div', { style: { fontSize: 14, fontWeight: 600, color: 'rgba(255,255,255,0.8)' } }, 'Something went wrong'), createElement('div', { style: { fontSize: 12, color: 'rgba(255,255,255,0.4)', maxWidth: 280, lineHeight: 1.4 } }, 'This component encountered an error. Try asking for a different view.'), createElement('button', {
-            onClick: () => this.setState({ error: null, catchCount: 0, repairRequested: false }),
+            onClick: () => this.setState({ error: null, catchCount: 0 }),
             style: {
                 marginTop: 4,
                 padding: '8px 20px',
@@ -241,9 +211,22 @@ export async function mountReactRoot(container, opts) {
         // `ThemeProvider` so a Studio/Portal context with both runtime + RP
         // active doesn't double-stack.
         if (typeof document !== 'undefined') {
-            const rootCss = opts.themeId
+            let rootCss = opts.themeId
                 ? getThemeCss(opts.themeId, opts.themeMode)
                 : getCssTokens(opts.themeMode);
+            if (opts.appTheme) {
+                const decls = Object.entries(opts.appTheme.cssVariables)
+                    .map(([k, v]) => `${k}: ${v};`)
+                    .join('');
+                // Appended AFTER the base block → the per-app overlay wins; it is a
+                // partial set (unset vars keep their token defaults). CSS custom
+                // properties at :root inherit into the scoped React tree, so this
+                // alone is sufficient for the component to resolve `var(--ggui-*)`.
+                // Values were validated injection-safe upstream (write-side
+                // `appThemeSchema` + the wire parser re-validates), so the
+                // string-join here is safe — do NOT re-sanitize.
+                rootCss += `:root{color-scheme:${opts.appTheme.mode};${decls}}`;
+            }
             const styleId = 'ggui-theme-vars';
             let styleEl = document.getElementById(styleId);
             if (!styleEl) {
@@ -267,7 +250,6 @@ export async function mountReactRoot(container, opts) {
         root.render(createElement('div', { className: scopeClass }, createElement('style', null, `${themeCss}${opts.cssOverrides ?? ''}`), createElement(RcrErrorBoundary, {
             key: currentCode?.length ?? 0,
             ...(opts.onError ? { onError: opts.onError } : {}),
-            ...(opts.onRequestRepair ? { onRequestRepair: opts.onRequestRepair } : {}),
         }, createElement(Fragment, null, wrapped))));
     }
     async function initialEvaluate() {
@@ -286,9 +268,9 @@ export async function mountReactRoot(container, opts) {
         catch (err) {
             const e = err instanceof Error ? err : new Error(String(err));
             // Fail-loud on eval errors. The OPTIONAL `onError` callback is
-            // not enough on its own — bootSelfContained doesn't wire one,
-            // so without this log a self-contained mount with a broken
-            // component renders a blank iframe and emits nothing.
+            // not enough on its own — not every mount path wires one, so
+            // without this log a mount with a broken component renders a
+            // blank iframe and emits nothing.
             // eslint-disable-next-line no-console -- operator-visible failure signal
             console.error('[ggui] mountReactRoot: component evaluation failed —', e);
             currentComponent = null;

package/dist/registry-subscribe.d.ts

@@ -1,4 +1,4 @@
-import type { AckPayload, ContractErrorPayload } from '@ggui-ai/protocol';
+import type { AckPayload } from '@ggui-ai/protocol';
 import type { ConnectionStatus } from '@ggui-ai/protocol/transport/websocket';
 import type { McpAppAiGguiRenderMeta } from '@ggui-ai/protocol/integrations/mcp-apps';
 import type { ChannelRegistry, RegistryPollingOptions, WsTransportHandle } from '@ggui-ai/live-channel';
@@ -8,7 +8,7 @@ import type { ObservabilityEmitter } from './observability.js';
  * Result of a successful handshake — the live typed transport handle
  * plus the resolved `AckPayload` from the first ack frame. The caller
  * attaches `handle` to the renderer's outbound send surface (via the
- * BufferedManagerShim flush) and applies `ack.render` to the mounted
+ * BufferedManagerShim flush) and applies `ack.session` to the mounted
  * render slot.
  */
 export interface RegistrySubscribeHandle {
@@ -21,8 +21,8 @@ export interface RegistrySubscribeHandle {
  */
 export interface ConnectViaRegistryOptions {
     /**
-     * Render slice (`McpAppAiGguiRenderMeta`) — the live-channel
-     * credentials this subscribe path actually needs: `renderId`,
+     * GguiSession slice (`McpAppAiGguiRenderMeta`) — the live-channel
+     * credentials this subscribe path actually needs: `sessionId`,
      * `appId`, `wsUrl`, `wsToken`. The rest of the slice (codeUrl /
      * propsJson / contextSlots / etc.) is load-bearing only for the
      * renderer / mount layer.
@@ -72,7 +72,7 @@ export interface ConnectViaRegistryOptions {
      * during a WS dropout window flows back into the iframe on
      * reconnect.
      *
-     * Idempotent at the runtime layer: `applyRender(ack.render)` patches
+     * Idempotent at the runtime layer: `applyRender(ack.session)` patches
      * in place. Channels re-subscribed by
      * `ChannelTransportRouter.onWsStatusChange('connected')` upstream
      * of this callback, so the per-channel transport state is already
@@ -100,7 +100,7 @@ export interface ConnectViaRegistryOptions {
  * error.
  *
  * Once the promise settles, subsequent server frames flow through the
- * registered channel handlers (props_update, drain_ack, push, data,
+ * registered channel handlers (props_update, drain_ack, render, data,
  * etc.) — there is no longer a separate `onMessage` callback fanning
  * frames across multiple handler chains.
  */
@@ -117,4 +117,4 @@ export type ConnectFn = typeof connectViaRegistry;
  * Type re-export for callers that want to thread the handle type
  * through their own seams (e.g. `bootSequence`'s shim attach).
  */
-export type { WsTransportHandle, ContractErrorPayload };
+export type { WsTransportHandle };

package/dist/registry-subscribe.js

@@ -6,9 +6,9 @@
  * Replaces the pre-B3b `subscribe()` helper + the `RendererWebSocketManager`
  * lifecycle class. The two retired modules paired a hand-rolled WS
  * manager with a separate handshake helper; B3b unifies both behind
- * the `@ggui-ai/live-channel` library so every WS frame type (push,
+ * the `@ggui-ai/live-channel` library so every WS frame type (render,
  * data, props_update, drain_ack, channel_payload, channel_error,
- * system, feedback) flows through one registry-owned transport.
+ * system) flows through one registry-owned transport.
  *
  * Composition:
  *
@@ -92,19 +92,33 @@ function normalizeObservedVersion(value) {
         return value;
     return value.join(', ');
 }
+/**
+ * Auth-class pre-ack codes — the §12.2.3 vocabulary first-party servers
+ * actually emit on the pre-ack error frame (ws-token verification +
+ * upgrade-auth failures). Replaced the phantom `AUTH_REJECTED` /
+ * `TOKEN_EXPIRED` arms in draft-2026-06-12 — a real ws-token expiry
+ * previously fell into the generic `'protocol'` bucket.
+ */
+const PRE_ACK_AUTH_CODES = new Set([
+    'SESSION_NOT_FOUND',
+    'BOOTSTRAP_EXPIRED',
+    'BOOTSTRAP_INVALID',
+    'BOOTSTRAP_SESSION_MISMATCH',
+    'BOOTSTRAP_APP_MISMATCH',
+    'UNAUTHENTICATED',
+]);
+function isAuthFailureCode(code) {
+    return PRE_ACK_AUTH_CODES.has(code);
+}
 /**
  * Map a pre-ack `error` frame onto a non-UPGRADE_REQUIRED ProtocolError.
- * `RENDER_NOT_FOUND` / `AUTH_REJECTED` → `'auth'`; every other code
- * → `'protocol'` with the extensibly-closed tail carrying the wire code
- * verbatim.
+ * {@link PRE_ACK_AUTH_CODES} → `'auth'`; every other code → `'protocol'`
+ * with the extensibly-closed tail carrying the wire code verbatim.
  */
 function classifyPreAckError(payload) {
-    if (payload.code === 'RENDER_NOT_FOUND' || payload.code === 'AUTH_REJECTED') {
+    if (isAuthFailureCode(payload.code)) {
         return fromAuthFailure(payload.code, payload.message);
     }
-    if (payload.code === 'TOKEN_EXPIRED') {
-        return fromAuthFailure('TOKEN_EXPIRED', payload.message);
-    }
     return {
         kind: 'protocol',
         code: payload.code,
@@ -121,7 +135,7 @@ function classifyPreAckError(payload) {
  * error.
  *
  * Once the promise settles, subsequent server frames flow through the
- * registered channel handlers (props_update, drain_ack, push, data,
+ * registered channel handlers (props_update, drain_ack, render, data,
  * etc.) — there is no longer a separate `onMessage` callback fanning
  * frames across multiple handler chains.
  */
@@ -153,9 +167,9 @@ export function connectViaRegistry(opts) {
             onMessage: (payload) => {
                 const ack = payload;
                 // Post-handshake ack — the WS reconnected and the server
-                // re-sent the subscribe ack with a fresh `stack` snapshot.
+                // re-sent the subscribe ack with a fresh `render` snapshot.
                 // Fan it onto the caller's resubscribe callback so the
-                // runtime can reapply the authoritative stack (a push or
+                // runtime can reapply the authoritative render (a render or
                 // update that landed during the WS dropout window now
                 // restores). Skip the version handshake / settle bookkeeping
                 // — that already fired on the original ack.
@@ -270,7 +284,7 @@ export function connectViaRegistry(opts) {
         const composedUrl = composeWsUrl(wsUrl, wsToken);
         // `bind()` selects the transport (WS for wsUrl+wsToken sessions;
         // the live-channel narrows on its `bootstrap` shape) and starts
-        // it. We override `session.wsUrl` with the composed URL so the
+        // it. We override `bootstrap.wsUrl` with the composed URL so the
         // registry's WS transport gets the wsToken-threaded variant. The
         // live-channel's `bootstrap` arg is its internal name; the field
         // on the wire is `wsToken`.
@@ -279,7 +293,7 @@ export function connectViaRegistry(opts) {
             bootstrap: {
                 wsUrl: composedUrl,
                 wsToken,
-                renderId: opts.meta.renderId,
+                sessionId: opts.meta.sessionId,
                 appId: opts.meta.appId,
             },
             onStatusChange: mappedStatusCallback,

package/dist/render-item.d.ts

@@ -1,36 +1,34 @@
 import type { ReactNode } from 'react';
-import type { Render } from '@ggui-ai/protocol';
-import type { RenderSeedInput } from './types.js';
+import type { GguiSession } from '@ggui-ai/protocol';
+import type { GguiSessionSeedInput } from './types.js';
 import { type WireConfig } from '@ggui-ai/wire';
 import type { StreamBus } from './wire-config.js';
 export interface RenderItemOptions {
     /** The render to mount. */
-    readonly render: Render | RenderSeedInput;
-    /** Wire config for this render — caller pre-scopes via the runtime's
-     *  `buildScopedConfig(render)` (see
-     *  `wire-config.ts::RootWireConfigBundle`). `null` ⇒ the component
-     *  mounts without a wire provider (standalone — matches today's
-     *  DynamicComponent fallback when no GguiSession parent is present). */
+    readonly render: GguiSession | GguiSessionSeedInput;
+    /** Wire config for this render — caller builds it via the runtime's
+     *  `buildRootWireConfig(...)` (see `wire-config.ts`). `null` ⇒ the
+     *  component mounts without a wire provider (standalone — matches
+     *  today's DynamicComponent fallback when no GguiRender parent is
+     *  present). */
     readonly scopedWireConfig: WireConfig | null;
     /** Shared stream bus — provisional renderer subscribes to
      *  `_ggui:preview` for this render. */
     readonly streamBus: StreamBus;
-    /** Render id — used by the mcp-apps iframe host for proxy URLs. */
-    readonly renderId: string;
+    /** GguiSession id — used by the mcp-apps iframe host for proxy URLs. */
+    readonly sessionId: string;
     /**
      * 3rd-party gadget package names whose direct imports the rewriter
      * must resolve to per-package shims. FALLBACK source used only when
      * the render carries no `gadgetDescriptors` sidecar — i.e. the static
-     * seed mount ({@link RenderSeedInput}, which has no descriptors). The
+     * seed mount ({@link GguiSessionSeedInput}, which has no descriptors). The
      * caller threads the bootstrap's `meta.gadgets` package names here so a
      * generated component importing a non-STDLIB gadget on a no-WS host
      * (claude.ai / ChatGPT) still resolves its shim on first paint. A
-     * WS-delivered full `Render` carries `gadgetDescriptors` and ignores
+     * WS-delivered full `GguiSession` carries `gadgetDescriptors` and ignores
      * this. STDLIB `@ggui-ai/gadgets` is always rewritten regardless.
      */
     readonly gadgetPackages?: readonly string[];
-    /** ggui-server base URL (for mcp-apps proxy). Empty = same-origin. */
-    readonly mcpAppsServerBaseUrl?: string;
     /** Theme id passed to ReactComponentRenderer for scoped CSS. */
     readonly themeId?: string;
     /**
@@ -39,9 +37,18 @@ export interface RenderItemOptions {
      * design registry's `getTheme(id, mode?)` default.
      */
     readonly themeMode?: 'light' | 'dark';
+    /**
+     * Per-app theme overlay forwarded to {@link ReactRootMountOptions.appTheme}
+     * so the renderer injects the `--ggui-*` overrides + `color-scheme` at
+     * `:root`. Sourced from the bootstrap's `_meta["ai.ggui/render"].theme`.
+     * A structural subset of protocol's `AppTheme` (`name` is display-only).
+     */
+    readonly appTheme?: {
+        readonly mode: 'light' | 'dark';
+        readonly cssVariables: Record<string, string>;
+    };
     readonly cssOverrides?: string;
     readonly onError?: (err: Error) => void;
-    readonly onRequestRepair?: (err: Error) => void;
     /**
      * Optional outer wrapper applied AROUND the GguiWireProvider — used
      * by `bootProduction` to install the `<ContextStateHost>` provider

package/dist/render-item.js

@@ -1,5 +1,5 @@
 /**
- * Render dispatcher — routes a single {@link Render} to the
+ * GguiSession dispatcher — routes a single {@link GguiSession} to the
  * appropriate renderer based on its discriminator.
  *
  * Post-render-identity-collapse (2026-05-27): the iframe-runtime mounts
@@ -101,21 +101,18 @@ export async function mountRender(container, opts) {
     }
     async function mountByKind(kind) {
         if (kind === 'mcpApps') {
-            // Render narrows to McpAppsRender when type='mcpApps'.
+            // GguiSession narrows to McpAppsGguiSession when type='mcpApps'.
             const render = currentOpts.render;
             mcpMount = mountMcpAppIframe(container, {
                 render,
-                renderId: currentOpts.renderId,
-                ...(currentOpts.mcpAppsServerBaseUrl !== undefined
-                    ? { serverBaseUrl: currentOpts.mcpAppsServerBaseUrl }
-                    : {}),
+                sessionId: currentOpts.sessionId,
             });
             currentKind = 'mcpApps';
             return;
         }
         if (kind === 'system') {
             // System card — server-emitted `kind` mapped to a built-in
-            // `.tsx` via `SystemCardHost`. Render-only: no `__ggui__` shim,
+            // `.tsx` via `SystemCardHost`. GguiSession-only: no `__ggui__` shim,
             // no GguiWireProvider, no contextSpec wrap (system cards don't
             // dispatch wire actions or read contexts). The registry handles
             // unknown kinds via a typed fallback. Dynamic-import keeps the
@@ -176,13 +173,11 @@ export async function mountRender(container, opts) {
             ...(gadgetPackages !== undefined ? { gadgetPackages } : {}),
             ...(currentOpts.themeId !== undefined ? { themeId: currentOpts.themeId } : {}),
             ...(currentOpts.themeMode !== undefined ? { themeMode: currentOpts.themeMode } : {}),
+            ...(currentOpts.appTheme !== undefined ? { appTheme: currentOpts.appTheme } : {}),
             ...(currentOpts.cssOverrides !== undefined
                 ? { cssOverrides: currentOpts.cssOverrides }
                 : {}),
             ...(currentOpts.onError !== undefined ? { onError: currentOpts.onError } : {}),
-            ...(currentOpts.onRequestRepair !== undefined
-                ? { onRequestRepair: currentOpts.onRequestRepair }
-                : {}),
             renderWrapper: wrapInScopedProvider,
         });
         currentKind = 'react';
@@ -191,7 +186,7 @@ export async function mountRender(container, opts) {
      * Wrap the mounted component in `<GguiWireProvider
      * config={scopedConfig}>` when the caller supplied one. Without a
      * scoped config, the component renders standalone — matches
-     * today's DynamicComponent fallback when no GguiSession parent is
+     * today's DynamicComponent fallback when no GguiRender parent is
      * present.
      *
      * Composition order (outer → inner):
@@ -242,11 +237,9 @@ export async function mountRender(container, opts) {
                     },
                     ...(next.themeId !== undefined ? { themeId: next.themeId } : {}),
                     ...(next.themeMode !== undefined ? { themeMode: next.themeMode } : {}),
+                    ...(next.appTheme !== undefined ? { appTheme: next.appTheme } : {}),
                     ...(next.cssOverrides !== undefined ? { cssOverrides: next.cssOverrides } : {}),
                     ...(next.onError !== undefined ? { onError: next.onError } : {}),
-                    ...(next.onRequestRepair !== undefined
-                        ? { onRequestRepair: next.onRequestRepair }
-                        : {}),
                     renderWrapper: wrapInScopedProvider,
                 });
                 return;