@guuey/agent-client 0.2.2 → 0.2.3

package/dist/ggui-render.d.ts

@@ -2,27 +2,27 @@
  * The **ggui render** channel: narrowing + self-contained shell construction
  * for a generative-UI card produced by the ggui MCP server (`ggui_render`).
  *
- * ## Why this is a second channel and not the existing one
+ * ## Where the pieces live (guuey#108 / ggui#427)
  *
- * `block-ui.ts`'s original narrowing accepts exactly one shape — an mcp-ui
- * embedded resource that carries its HTML INLINE (`{uri, text|blob}`). A ggui
- * render carries no HTML at all. Its `tool.done` looks like this on the wire
- * (shaped identically to the production capture the widget's fixtures
- * replay, but with the SAME synthetic ids those redacted fixtures use —
- * `apps/widget/src/fixtures/issue2627-render-capture.sse.txt` seq 48):
+ * The two halves of this channel have different owners, and the module is
+ * split along that line:
  *
- * ```jsonc
- * {"type":"tool.done", "toolCallId":"toolu_0000…0005",
- *  "uiData":{"sessionId":"render_0000…0001",
- *            "resourceUri":"ui://ggui/render/render_0000…0001/c10a2055…", … },
- *  "_meta":{"ai.ggui/render":{"sessionId":"render_0000…0001","appId":"APP00000",
- *              "runtimeUrl":"https://dev.mcp.sandbox.ggui.ai/_ggui/iframe-runtime.js",
- *              "wsUrl":"wss://…/ws","wsToken":"eyJ…","expiresAt":"…",
- *              "propsJson":"{…}"},
- *           "ui":{"resourceUri":"ui://ggui/render/…"}}}
- * ```
+ *  - **ggui's wire contract** — what makes a `_meta` slice a mountable
+ *    render bootstrap, and what the self-contained shell must contain — is
+ *    OWNED by ggui and imported from
+ *    `@ggui-ai/protocol/integrations/mcp-apps` ({@link asGguiRenderBootstrap},
+ *    {@link gguiShellHtml}, the `ai.ggui/render` key). This package used to
+ *    carry byte-compatible private copies (lifted upstream as ggui#427);
+ *    re-exporting the originals means a shell-contract change lands here by
+ *    bumping the pin, not by mirror-editing two repos.
+ *  - **host/silverprotocol shapes** — the `uiData`-keyed RECOGNITION signal,
+ *    the `AgBlock` tool-result narrowing, and the `McpUiResourcePayload`
+ *    adapter onto the host's existing mcp-ui mount path — are guuey-side
+ *    contracts and stay implemented here.
  *
- * Two facts follow, and they shape everything below:
+ * ## Why recognition and mounting are separate
+ *
+ * A ggui render's `tool.done` carries two distinct signals:
  *
  *  1. **`uiData.resourceUri` is the RECOGNITION signal.** It is the only part
  *     of the render's identity that survives `@silverprotocol/core`'s fold
@@ -32,61 +32,29 @@
  *     to boot the card — which runtime bundle to load, which live-channel to
  *     open, which props to seed — lives there and nowhere else.
  *
- * ## How the card mounts (the ggui-documented self-contained shell)
- *
- * ggui's iframe runtime accepts its bootstrap from three delivery channels;
- * the highest-priority one is the **self-contained shell**: HTML that inlines
- * the slice envelope at `globalThis.__GGUI_META__` synchronously BEFORE the
- * runtime bundle's `<script type="module">` evaluates, after which the runtime
- * autostarts, creates its own mount container and renders — no postMessage
- * round-trip, no host-side ggui code. That contract is stated verbatim by the
- * runtime's own reader (`@ggui-ai/iframe-runtime`'s `parseMetaFromGlobal`:
- * *"The global carries the SAME slice envelope shape as the wire `_meta`
- * (`{ "ai.ggui/render": {...} }`) … per-render shells populate this
- * synchronously BEFORE the runtime bundle's `<script type="module">`
- * evaluates"*), and by its boot resolver (`runtime.js`'s autostart:
- * `readSelfContainedMeta()` first, postMessage channels after).
- *
- * {@link gguiShellHtml} builds exactly that shell. Because the shell IS a
- * string of HTML, the ggui card then rides the host's EXISTING mcp-ui mount
- * path unchanged: it narrows to the same `McpUiResourcePayload` an inline
- * resource does, so `@mcp-ui/client`'s `AppRenderer` posts it as `srcdoc` into
- * the second-origin `mcp-app-sandbox.html` page — same double-iframe rule,
- * same sandbox origin, same opaque inner frame. No second mount mechanism.
- *
- * The slice is inlined **verbatim**: `runtimeUrl` is honored as given (ggui's
- * host checklist item 8 — "no fallback URL, no substitution"), and every other
- * field is passed through untouched for the runtime's own projector to
- * validate. This module reads exactly one field (`runtimeUrl`) and only to
- * prove the slice is mountable at all.
+ * The shell {@link gguiShellHtml} builds is a string of HTML, so the ggui
+ * card rides the host's EXISTING mcp-ui mount path unchanged: it narrows to
+ * the same `McpUiResourcePayload` an inline resource does, so
+ * `@mcp-ui/client`'s `AppRenderer` posts it as `srcdoc` into the
+ * second-origin `mcp-app-sandbox.html` page — same double-iframe rule, same
+ * sandbox origin, same opaque inner frame. No second mount mechanism.
  *
  * NOT in scope here: rehydrating a ggui card from persisted history. The
- * bootstrap's `wsToken` expires minutes after the render (`expiresAt` in the
- * capture above), so a stored bootstrap is dead on arrival — a history card
- * without a live bootstrap correctly resolves to `undefined` and renders the
- * host's placeholder rather than a broken mount.
+ * bootstrap's `wsToken` expires minutes after the render, so a stored
+ * bootstrap is dead on arrival — a history card without a live bootstrap
+ * correctly resolves to `undefined` and renders the host's placeholder
+ * rather than a broken mount.
  */
 import type { AgBlock, JsonValue } from "@silverprotocol/core";
+import { type GguiRenderBootstrap } from "@ggui-ai/protocol/integrations/mcp-apps";
 import { type McpUiResourcePayload } from "./block-ui";
-/** The `_meta` key the ggui render bootstrap rides on (MCP-Apps slice convention). */
-export declare const GGUI_RENDER_META_KEY = "ai.ggui/render";
+export { asGguiRenderBootstrap, gguiShellHtml, } from "@ggui-ai/protocol/integrations/mcp-apps";
+export type { GguiRenderBootstrap, GguiShellHtmlOptions, } from "@ggui-ai/protocol/integrations/mcp-apps";
 /**
- * A ggui render bootstrap: the runtime bundle URL this module reads, plus the
- * WHOLE `ai.ggui/render` slice, verbatim, for the shell to inline.
+ * The `_meta` key the ggui render bootstrap rides on. Alias of the
+ * protocol package's own constant — one spelling, owned upstream.
  */
-export interface GguiRenderBootstrap {
-    /** `runtimeUrl` — the ESM bundle the shell loads. Honored as given. */
-    runtimeUrl: string;
-    /**
-     * The verbatim slice. Open-ended by construction: it is ggui's wire
-     * contract, not one this package owns, and the runtime's own projector is
-     * the authority on every field. Re-declaring it here would duplicate a
-     * contract we do not own and rot at ggui's next field addition.
-     */
-    slice: {
-        [key: string]: JsonValue;
-    };
-}
+export declare const GGUI_RENDER_META_KEY: "ai.ggui/render";
 /** A ggui render recognised on a tool result: its resource uri + mount material. */
 export interface GguiRenderDescriptor {
     /** `uiData.resourceUri` — `ui://ggui/render/<sessionId>/<contractHash>`. */
@@ -100,17 +68,6 @@ export interface GguiRenderDescriptor {
      */
     bootstrap?: GguiRenderBootstrap;
 }
-/**
- * A `_meta` container → the ggui render bootstrap, or `undefined`.
- *
- * Two hard requirements, both the runtime's own `validateMeta` enforces
- * (`MALFORMED_BOOTSTRAP`): a non-empty `runtimeUrl`, AND at least one mode
- * discriminator (see {@link hasModeDiscriminator}). A slice with `runtimeUrl`
- * alone has a bundle to load but nothing for it to mount — the runtime would
- * boot into a blank shell rather than a card, so this guard treats that shape
- * as unmountable too and returns `undefined`.
- */
-export declare function asGguiRenderBootstrap(meta: JsonValue | undefined): GguiRenderBootstrap | undefined;
 /**
  * A tool result's `uiData` (+ its `_meta`, when carried) → a ggui render
  * descriptor, or `undefined` for anything that is not one.
@@ -120,21 +77,19 @@ export declare function asGguiRenderBootstrap(meta: JsonValue | undefined): Ggui
  * bare `resourceUri` string is not on its own a claim of generative UI.
  */
 export declare function asGguiRender(uiData: JsonValue | undefined, meta: JsonValue | undefined): GguiRenderDescriptor | undefined;
-/** A live `tool-result` AgBlock → its ggui render descriptor, if it is one. */
+/**
+ * A live `tool-result` AgBlock → its ggui render descriptor, if it is one.
+ *
+ * NOTE: `@ggui-ai/protocol/integrations/mcp-apps` exports a helper of the
+ * same name that narrows a spec-canonical MCP `CallToolResult` instead. This
+ * one is the silverprotocol-side twin — the input is the FOLDED block, whose
+ * `uiData`/`_meta` carriage is `@silverprotocol/core`'s contract, not ggui's.
+ */
 export declare function toolResultGguiRender(block: Extract<AgBlock, {
     type: "tool-result";
 }>): GguiRenderDescriptor | undefined;
 /** An untyped (persisted-snapshot) block → its ggui render descriptor, if it is one. */
 export declare function blockGguiRender(block: JsonValue): GguiRenderDescriptor | undefined;
-/**
- * The ggui **self-contained shell** for a render bootstrap — see this module's
- * header for the contract it implements.
- *
- * Ordering is guaranteed twice over: the classic `<script>` runs during parse,
- * and the runtime's `<script type="module">` is deferred by definition, so the
- * global is always populated before the bundle evaluates.
- */
-export declare function gguiShellHtml(bootstrap: GguiRenderBootstrap): string;
 /**
  * A ggui render descriptor → the mountable resource the host's existing
  * mcp-ui path already knows how to mount, or `undefined` when the descriptor
@@ -143,6 +98,12 @@ export declare function gguiShellHtml(bootstrap: GguiRenderBootstrap): string;
  * The `uri` is the render's REAL `resourceUri` — the shell is the payload, not
  * a renaming of the resource.
  *
+ * The shell is built `background: 'transparent'`: every guuey host that
+ * mounts through this adapter (widget, portal web, Studio) draws its own
+ * card chrome around the iframe, so the host page composits behind the card.
+ * The upstream default (`'surface'`) is for standalone served documents —
+ * see `GguiShellHtmlOptions` in `@ggui-ai/protocol/integrations/mcp-apps`.
+ *
  * **On `_meta` being required to MOUNT (but never to RECOGNISE).** Recognition
  * — "this tool result is a ggui card" — is keyed on `uiData.resourceUri` alone
  * and never waits for anything (see {@link asGguiRender}); nothing in this
@@ -150,12 +111,10 @@ export declare function gguiShellHtml(bootstrap: GguiRenderBootstrap): string;
  * requirement is ggui's, not ours: its runtime rejects a slice without
  * `runtimeUrl` AND without at least one mode discriminator (`wsUrl`+`wsToken`,
  * `codeUrl`, or `kind`) as `MALFORMED_BOOTSTRAP` and renders nothing. `uiData`
- * carries none of those fields — it has `sessionId`, `resourceUri`, `action`,
- * `contractHash`, `blueprintId`, `variantKey`, `cache`, `nextStep`, and that is
- * all. So a bootstrap-less descriptor could only ever produce a blank frame;
- * returning `undefined` and letting the host show its own placeholder is the
- * honest answer, not a deferral. `@silverprotocol/core`'s `Reducer` is what
- * puts `_meta` on the block for a live turn, in-repo, today.
+ * carries none of those fields, so a bootstrap-less descriptor could only ever
+ * produce a blank frame; returning `undefined` and letting the host show its
+ * own placeholder is the honest answer, not a deferral. `@silverprotocol/core`'s
+ * `Reducer` is what puts `_meta` on the block for a live turn, in-repo, today.
  */
 export declare function gguiRenderResource(render: GguiRenderDescriptor): McpUiResourcePayload | undefined;
 //# sourceMappingURL=ggui-render.d.ts.map

package/dist/ggui-render.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ggui-render.d.ts","sourceRoot":"","sources":["../src/ggui-render.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmEG;AACH,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAC/D,OAAO,EAAgB,KAAK,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAErE,sFAAsF;AACtF,eAAO,MAAM,oBAAoB,mBAAmB,CAAC;AAKrD;;;GAGG;AACH,MAAM,WAAW,mBAAmB;IAClC,uEAAuE;IACvE,UAAU,EAAE,MAAM,CAAC;IACnB;;;;;OAKG;IACH,KAAK,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,CAAA;KAAE,CAAC;CACrC;AAED,oFAAoF;AACpF,MAAM,WAAW,oBAAoB;IACnC,4EAA4E;IAC5E,WAAW,EAAE,MAAM,CAAC;IACpB,wCAAwC;IACxC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;;OAIG;IACH,SAAS,CAAC,EAAE,mBAAmB,CAAC;CACjC;AAwBD;;;;;;;;;GASG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,SAAS,GAAG,SAAS,GAAG,mBAAmB,GAAG,SAAS,CAQlG;AAED;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAC1B,MAAM,EAAE,SAAS,GAAG,SAAS,EAC7B,IAAI,EAAE,SAAS,GAAG,SAAS,GAC1B,oBAAoB,GAAG,SAAS,CAUlC;AAED,+EAA+E;AAC/E,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,OAAO,CAAC,OAAO,EAAE;IAAE,IAAI,EAAE,aAAa,CAAA;CAAE,CAAC,GAC/C,oBAAoB,GAAG,SAAS,CAElC;AAED,wFAAwF;AACxF,wBAAgB,eAAe,CAAC,KAAK,EAAE,SAAS,GAAG,oBAAoB,GAAG,SAAS,CAIlF;AA0BD;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,SAAS,EAAE,mBAAmB,GAAG,MAAM,CAkBpE;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,oBAAoB,GAC3B,oBAAoB,GAAG,SAAS,CAOlC"}
+{"version":3,"file":"ggui-render.d.ts","sourceRoot":"","sources":["../src/ggui-render.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAC/D,OAAO,EAIL,KAAK,mBAAmB,EACzB,MAAM,yCAAyC,CAAC;AACjD,OAAO,EAAgB,KAAK,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAErE,OAAO,EACL,qBAAqB,EACrB,aAAa,GACd,MAAM,yCAAyC,CAAC;AACjD,YAAY,EACV,mBAAmB,EACnB,oBAAoB,GACrB,MAAM,yCAAyC,CAAC;AAEjD;;;GAGG;AACH,eAAO,MAAM,oBAAoB,kBAAkC,CAAC;AAKpE,oFAAoF;AACpF,MAAM,WAAW,oBAAoB;IACnC,4EAA4E;IAC5E,WAAW,EAAE,MAAM,CAAC;IACpB,wCAAwC;IACxC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;;OAIG;IACH,SAAS,CAAC,EAAE,mBAAmB,CAAC;CACjC;AAED;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAC1B,MAAM,EAAE,SAAS,GAAG,SAAS,EAC7B,IAAI,EAAE,SAAS,GAAG,SAAS,GAC1B,oBAAoB,GAAG,SAAS,CAUlC;AAED;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,OAAO,CAAC,OAAO,EAAE;IAAE,IAAI,EAAE,aAAa,CAAA;CAAE,CAAC,GAC/C,oBAAoB,GAAG,SAAS,CAElC;AAED,wFAAwF;AACxF,wBAAgB,eAAe,CAAC,KAAK,EAAE,SAAS,GAAG,oBAAoB,GAAG,SAAS,CAIlF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,oBAAoB,GAC3B,oBAAoB,GAAG,SAAS,CAOlC"}

package/dist/ggui-render.js

@@ -1,54 +1,13 @@
+import { asGguiRenderBootstrap, gguiShellHtml, MCP_APP_AI_GGUI_RENDER_META_KEY, } from "@ggui-ai/protocol/integrations/mcp-apps";
 import { isJsonObject } from "./block-ui";
-/** The `_meta` key the ggui render bootstrap rides on (MCP-Apps slice convention). */
-export const GGUI_RENDER_META_KEY = "ai.ggui/render";
-/** The `ui://` scheme prefix every ggui render resource uri carries. */
-const UI_SCHEME = "ui://";
-/** A non-empty JSON string field. */
-function isNonEmptyString(value) {
-    return typeof value === "string" && value.length > 0;
-}
-/**
- * Does this slice carry at least one MOUNT MODE discriminator?
- *
- * Mirrors `@ggui-ai/iframe-runtime`'s `validateMeta` (see
- * `node_modules/@ggui-ai/iframe-runtime/dist/meta-parse.d.ts`) and the
- * `McpAppAiGguiRenderMeta` doc comment it implements
- * (`@ggui-ai/protocol/integrations/mcp-apps`): the runtime needs `runtimeUrl`
- * PLUS one of live mode (`wsUrl` + `wsToken` together), `codeUrl`, or `kind` —
- * without one of those three the iframe has nothing to mount.
- */
-function hasModeDiscriminator(slice) {
-    if (isNonEmptyString(slice.wsUrl) && isNonEmptyString(slice.wsToken))
-        return true;
-    if (isNonEmptyString(slice.codeUrl))
-        return true;
-    if (isNonEmptyString(slice.kind))
-        return true;
-    return false;
-}
+export { asGguiRenderBootstrap, gguiShellHtml, } from "@ggui-ai/protocol/integrations/mcp-apps";
 /**
- * A `_meta` container → the ggui render bootstrap, or `undefined`.
- *
- * Two hard requirements, both the runtime's own `validateMeta` enforces
- * (`MALFORMED_BOOTSTRAP`): a non-empty `runtimeUrl`, AND at least one mode
- * discriminator (see {@link hasModeDiscriminator}). A slice with `runtimeUrl`
- * alone has a bundle to load but nothing for it to mount — the runtime would
- * boot into a blank shell rather than a card, so this guard treats that shape
- * as unmountable too and returns `undefined`.
+ * The `_meta` key the ggui render bootstrap rides on. Alias of the
+ * protocol package's own constant — one spelling, owned upstream.
  */
-export function asGguiRenderBootstrap(meta) {
-    if (!isJsonObject(meta))
-        return undefined;
-    const slice = meta[GGUI_RENDER_META_KEY];
-    if (!isJsonObject(slice))
-        return undefined;
-    const runtimeUrl = slice.runtimeUrl;
-    if (typeof runtimeUrl !== "string" || runtimeUrl.length === 0)
-        return undefined;
-    if (!hasModeDiscriminator(slice))
-        return undefined;
-    return { runtimeUrl, slice };
-}
+export const GGUI_RENDER_META_KEY = MCP_APP_AI_GGUI_RENDER_META_KEY;
+/** The `ui://` scheme prefix every ggui render resource uri carries. */
+const UI_SCHEME = "ui://";
 /**
  * A tool result's `uiData` (+ its `_meta`, when carried) → a ggui render
  * descriptor, or `undefined` for anything that is not one.
@@ -70,7 +29,14 @@ export function asGguiRender(uiData, meta) {
         ...(bootstrap ? { bootstrap } : {}),
     };
 }
-/** A live `tool-result` AgBlock → its ggui render descriptor, if it is one. */
+/**
+ * A live `tool-result` AgBlock → its ggui render descriptor, if it is one.
+ *
+ * NOTE: `@ggui-ai/protocol/integrations/mcp-apps` exports a helper of the
+ * same name that narrows a spec-canonical MCP `CallToolResult` instead. This
+ * one is the silverprotocol-side twin — the input is the FOLDED block, whose
+ * `uiData`/`_meta` carriage is `@silverprotocol/core`'s contract, not ggui's.
+ */
 export function toolResultGguiRender(block) {
     return asGguiRender(block.uiData, block._meta);
 }
@@ -82,55 +48,6 @@ export function blockGguiRender(block) {
         return undefined;
     return asGguiRender(block.uiData, block._meta);
 }
-/**
- * Embed a JSON value inside an inline `<script>` safely.
- *
- * `</script` inside a string literal terminates the element in the HTML
- * parser regardless of JS quoting, and U+2028/U+2029 are line terminators in
- * JS source but not in JSON — both are escaped at the `<`/codepoint level so
- * the emitted text is still exactly the same JSON value.
- */
-function inlineJson(value) {
-    return JSON.stringify(value)
-        .replace(/</g, "\\u003c")
-        .replace(/\u2028/g, "\\u2028")
-        .replace(/\u2029/g, "\\u2029");
-}
-/** Escape a string for use inside a double-quoted HTML attribute. */
-function attr(value) {
-    return value
-        .replace(/&/g, "&amp;")
-        .replace(/"/g, "&quot;")
-        .replace(/</g, "&lt;")
-        .replace(/>/g, "&gt;");
-}
-/**
- * The ggui **self-contained shell** for a render bootstrap — see this module's
- * header for the contract it implements.
- *
- * Ordering is guaranteed twice over: the classic `<script>` runs during parse,
- * and the runtime's `<script type="module">` is deferred by definition, so the
- * global is always populated before the bundle evaluates.
- */
-export function gguiShellHtml(bootstrap) {
-    const envelope = inlineJson({ [GGUI_RENDER_META_KEY]: bootstrap.slice });
-    return [
-        "<!doctype html>",
-        '<html lang="en">',
-        "<head>",
-        '<meta charset="utf-8">',
-        '<meta name="viewport" content="width=device-width, initial-scale=1">',
-        '<meta name="color-scheme" content="light dark">',
-        "<title>ggui card</title>",
-        "<style>html,body{margin:0;height:100%;background:transparent}</style>",
-        `<script>globalThis.__GGUI_META__=${envelope};</script>`,
-        `<script type="module" src="${attr(bootstrap.runtimeUrl)}"></script>`,
-        "</head>",
-        "<body></body>",
-        "</html>",
-        "",
-    ].join("\n");
-}
 /**
  * A ggui render descriptor → the mountable resource the host's existing
  * mcp-ui path already knows how to mount, or `undefined` when the descriptor
@@ -139,6 +56,12 @@ export function gguiShellHtml(bootstrap) {
  * The `uri` is the render's REAL `resourceUri` — the shell is the payload, not
  * a renaming of the resource.
  *
+ * The shell is built `background: 'transparent'`: every guuey host that
+ * mounts through this adapter (widget, portal web, Studio) draws its own
+ * card chrome around the iframe, so the host page composits behind the card.
+ * The upstream default (`'surface'`) is for standalone served documents —
+ * see `GguiShellHtmlOptions` in `@ggui-ai/protocol/integrations/mcp-apps`.
+ *
  * **On `_meta` being required to MOUNT (but never to RECOGNISE).** Recognition
  * — "this tool result is a ggui card" — is keyed on `uiData.resourceUri` alone
  * and never waits for anything (see {@link asGguiRender}); nothing in this
@@ -146,12 +69,10 @@ export function gguiShellHtml(bootstrap) {
  * requirement is ggui's, not ours: its runtime rejects a slice without
  * `runtimeUrl` AND without at least one mode discriminator (`wsUrl`+`wsToken`,
  * `codeUrl`, or `kind`) as `MALFORMED_BOOTSTRAP` and renders nothing. `uiData`
- * carries none of those fields — it has `sessionId`, `resourceUri`, `action`,
- * `contractHash`, `blueprintId`, `variantKey`, `cache`, `nextStep`, and that is
- * all. So a bootstrap-less descriptor could only ever produce a blank frame;
- * returning `undefined` and letting the host show its own placeholder is the
- * honest answer, not a deferral. `@silverprotocol/core`'s `Reducer` is what
- * puts `_meta` on the block for a live turn, in-repo, today.
+ * carries none of those fields, so a bootstrap-less descriptor could only ever
+ * produce a blank frame; returning `undefined` and letting the host show its
+ * own placeholder is the honest answer, not a deferral. `@silverprotocol/core`'s
+ * `Reducer` is what puts `_meta` on the block for a live turn, in-repo, today.
  */
 export function gguiRenderResource(render) {
     if (!render.bootstrap)
@@ -159,6 +80,6 @@ export function gguiRenderResource(render) {
     return {
         uri: render.resourceUri,
         mimeType: "text/html",
-        text: gguiShellHtml(render.bootstrap),
+        text: gguiShellHtml(render.bootstrap, { background: "transparent" }),
     };
 }

package/dist/index.d.ts

@@ -4,7 +4,7 @@ export { createWebAdapters, localStorageThreadStore, webGenerateId, fetchStreamT
 export { fetchThreadHistory, threadHistoryRowsToMessages, threadHistoryRowsToCards, HistoryUnauthorizedError, type ThreadHistoryRow, type ThreadHistoryFetchOptions, } from "./history";
 export { ingestMessageFrame } from "./blocks";
 export { asResourcePayload, asUiResource, blockUiResource, cardUiResource, isJsonObject, resourceHtml, scanProviderRawForUiResource, sortHistoryCards, toolNameFor, toolResultUiResource, type McpUiResourcePayload, } from "./block-ui";
-export { asGguiRender, asGguiRenderBootstrap, blockGguiRender, gguiRenderResource, gguiShellHtml, toolResultGguiRender, GGUI_RENDER_META_KEY, type GguiRenderBootstrap, type GguiRenderDescriptor, } from "./ggui-render";
+export { asGguiRender, asGguiRenderBootstrap, blockGguiRender, gguiRenderResource, gguiShellHtml, toolResultGguiRender, GGUI_RENDER_META_KEY, type GguiRenderBootstrap, type GguiRenderDescriptor, type GguiShellHtmlOptions, } from "./ggui-render";
 export { cardCardMount, toolResultCardMount, type CardMount, type CardMountChannel, } from "./card-mount";
 export type { AgEvent, AgReduceResult, AgMessage, AgBlock } from "@silverprotocol/core";
 export type { AgentMessage, HistoryCard, ProfileConsentRequest, ProfileLinkRequest, ThreadIdStore, GenerateId, InvokeRequest, InvokeTransport, AgentInvokeAdapters, AgentInvokeHistoryAdapter, AgentInvokeStatus, HistoryLoadResult, UseAgentInvokeOptions, UseAgentInvokeReturn, } from "./types";

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,cAAc,EACd,oBAAoB,EACpB,mBAAmB,EACnB,WAAW,EACX,mBAAmB,EACnB,gBAAgB,EAChB,KAAK,cAAc,GACpB,MAAM,OAAO,CAAC;AACf,OAAO,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAClD,OAAO,EACL,iBAAiB,EACjB,uBAAuB,EACvB,aAAa,EACb,oBAAoB,EACpB,kBAAkB,EAClB,KAAK,wBAAwB,GAC9B,MAAM,gBAAgB,CAAC;AACxB,OAAO,EACL,kBAAkB,EAClB,2BAA2B,EAC3B,wBAAwB,EACxB,wBAAwB,EACxB,KAAK,gBAAgB,EACrB,KAAK,yBAAyB,GAC/B,MAAM,WAAW,CAAC;AACnB,OAAO,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAG9C,OAAO,EACL,iBAAiB,EACjB,YAAY,EACZ,eAAe,EACf,cAAc,EACd,YAAY,EACZ,YAAY,EACZ,4BAA4B,EAC5B,gBAAgB,EAChB,WAAW,EACX,oBAAoB,EACpB,KAAK,oBAAoB,GAC1B,MAAM,YAAY,CAAC;AAIpB,OAAO,EACL,YAAY,EACZ,qBAAqB,EACrB,eAAe,EACf,kBAAkB,EAClB,aAAa,EACb,oBAAoB,EACpB,oBAAoB,EACpB,KAAK,mBAAmB,EACxB,KAAK,oBAAoB,GAC1B,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,aAAa,EACb,mBAAmB,EACnB,KAAK,SAAS,EACd,KAAK,gBAAgB,GACtB,MAAM,cAAc,CAAC;AAItB,YAAY,EAAE,OAAO,EAAE,cAAc,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AACxF,YAAY,EACV,YAAY,EACZ,WAAW,EACX,qBAAqB,EACrB,kBAAkB,EAClB,aAAa,EACb,UAAU,EACV,aAAa,EACb,eAAe,EACf,mBAAmB,EACnB,yBAAyB,EACzB,iBAAiB,EACjB,iBAAiB,EACjB,qBAAqB,EACrB,oBAAoB,GACrB,MAAM,SAAS,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,cAAc,EACd,oBAAoB,EACpB,mBAAmB,EACnB,WAAW,EACX,mBAAmB,EACnB,gBAAgB,EAChB,KAAK,cAAc,GACpB,MAAM,OAAO,CAAC;AACf,OAAO,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAClD,OAAO,EACL,iBAAiB,EACjB,uBAAuB,EACvB,aAAa,EACb,oBAAoB,EACpB,kBAAkB,EAClB,KAAK,wBAAwB,GAC9B,MAAM,gBAAgB,CAAC;AACxB,OAAO,EACL,kBAAkB,EAClB,2BAA2B,EAC3B,wBAAwB,EACxB,wBAAwB,EACxB,KAAK,gBAAgB,EACrB,KAAK,yBAAyB,GAC/B,MAAM,WAAW,CAAC;AACnB,OAAO,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAG9C,OAAO,EACL,iBAAiB,EACjB,YAAY,EACZ,eAAe,EACf,cAAc,EACd,YAAY,EACZ,YAAY,EACZ,4BAA4B,EAC5B,gBAAgB,EAChB,WAAW,EACX,oBAAoB,EACpB,KAAK,oBAAoB,GAC1B,MAAM,YAAY,CAAC;AAIpB,OAAO,EACL,YAAY,EACZ,qBAAqB,EACrB,eAAe,EACf,kBAAkB,EAClB,aAAa,EACb,oBAAoB,EACpB,oBAAoB,EACpB,KAAK,mBAAmB,EACxB,KAAK,oBAAoB,EACzB,KAAK,oBAAoB,GAC1B,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,aAAa,EACb,mBAAmB,EACnB,KAAK,SAAS,EACd,KAAK,gBAAgB,GACtB,MAAM,cAAc,CAAC;AAItB,YAAY,EAAE,OAAO,EAAE,cAAc,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AACxF,YAAY,EACV,YAAY,EACZ,WAAW,EACX,qBAAqB,EACrB,kBAAkB,EAClB,aAAa,EACb,UAAU,EACV,aAAa,EACb,eAAe,EACf,mBAAmB,EACnB,yBAAyB,EACzB,iBAAiB,EACjB,iBAAiB,EACjB,qBAAqB,EACrB,oBAAoB,GACrB,MAAM,SAAS,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@guuey/agent-client",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "description": "Client SDK for Guuey's agent runtime: the `useAgentInvoke` React hook + pure SSE helpers that speak the /agent/invoke streaming contract, plus the paginated thread-history read plane. Host adapters (storage / id / transport) are injected, so it runs on web (Next) and React Native alike.",
   "license": "MIT",
   "type": "module",
@@ -28,6 +28,7 @@
     }
   },
   "dependencies": {
+    "@ggui-ai/protocol": "0.6.3",
     "@silverprotocol/core": "0.4.1"
   },
   "peerDependencies": {

package/src/ggui-render.ts

@@ -2,27 +2,27 @@
  * The **ggui render** channel: narrowing + self-contained shell construction
  * for a generative-UI card produced by the ggui MCP server (`ggui_render`).
  *
- * ## Why this is a second channel and not the existing one
+ * ## Where the pieces live (guuey#108 / ggui#427)
  *
- * `block-ui.ts`'s original narrowing accepts exactly one shape — an mcp-ui
- * embedded resource that carries its HTML INLINE (`{uri, text|blob}`). A ggui
- * render carries no HTML at all. Its `tool.done` looks like this on the wire
- * (shaped identically to the production capture the widget's fixtures
- * replay, but with the SAME synthetic ids those redacted fixtures use —
- * `apps/widget/src/fixtures/issue2627-render-capture.sse.txt` seq 48):
+ * The two halves of this channel have different owners, and the module is
+ * split along that line:
  *
- * ```jsonc
- * {"type":"tool.done", "toolCallId":"toolu_0000…0005",
- *  "uiData":{"sessionId":"render_0000…0001",
- *            "resourceUri":"ui://ggui/render/render_0000…0001/c10a2055…", … },
- *  "_meta":{"ai.ggui/render":{"sessionId":"render_0000…0001","appId":"APP00000",
- *              "runtimeUrl":"https://dev.mcp.sandbox.ggui.ai/_ggui/iframe-runtime.js",
- *              "wsUrl":"wss://…/ws","wsToken":"eyJ…","expiresAt":"…",
- *              "propsJson":"{…}"},
- *           "ui":{"resourceUri":"ui://ggui/render/…"}}}
- * ```
+ *  - **ggui's wire contract** — what makes a `_meta` slice a mountable
+ *    render bootstrap, and what the self-contained shell must contain — is
+ *    OWNED by ggui and imported from
+ *    `@ggui-ai/protocol/integrations/mcp-apps` ({@link asGguiRenderBootstrap},
+ *    {@link gguiShellHtml}, the `ai.ggui/render` key). This package used to
+ *    carry byte-compatible private copies (lifted upstream as ggui#427);
+ *    re-exporting the originals means a shell-contract change lands here by
+ *    bumping the pin, not by mirror-editing two repos.
+ *  - **host/silverprotocol shapes** — the `uiData`-keyed RECOGNITION signal,
+ *    the `AgBlock` tool-result narrowing, and the `McpUiResourcePayload`
+ *    adapter onto the host's existing mcp-ui mount path — are guuey-side
+ *    contracts and stay implemented here.
  *
- * Two facts follow, and they shape everything below:
+ * ## Why recognition and mounting are separate
+ *
+ * A ggui render's `tool.done` carries two distinct signals:
  *
  *  1. **`uiData.resourceUri` is the RECOGNITION signal.** It is the only part
  *     of the render's identity that survives `@silverprotocol/core`'s fold
@@ -32,64 +32,45 @@
  *     to boot the card — which runtime bundle to load, which live-channel to
  *     open, which props to seed — lives there and nowhere else.
  *
- * ## How the card mounts (the ggui-documented self-contained shell)
- *
- * ggui's iframe runtime accepts its bootstrap from three delivery channels;
- * the highest-priority one is the **self-contained shell**: HTML that inlines
- * the slice envelope at `globalThis.__GGUI_META__` synchronously BEFORE the
- * runtime bundle's `<script type="module">` evaluates, after which the runtime
- * autostarts, creates its own mount container and renders — no postMessage
- * round-trip, no host-side ggui code. That contract is stated verbatim by the
- * runtime's own reader (`@ggui-ai/iframe-runtime`'s `parseMetaFromGlobal`:
- * *"The global carries the SAME slice envelope shape as the wire `_meta`
- * (`{ "ai.ggui/render": {...} }`) … per-render shells populate this
- * synchronously BEFORE the runtime bundle's `<script type="module">`
- * evaluates"*), and by its boot resolver (`runtime.js`'s autostart:
- * `readSelfContainedMeta()` first, postMessage channels after).
- *
- * {@link gguiShellHtml} builds exactly that shell. Because the shell IS a
- * string of HTML, the ggui card then rides the host's EXISTING mcp-ui mount
- * path unchanged: it narrows to the same `McpUiResourcePayload` an inline
- * resource does, so `@mcp-ui/client`'s `AppRenderer` posts it as `srcdoc` into
- * the second-origin `mcp-app-sandbox.html` page — same double-iframe rule,
- * same sandbox origin, same opaque inner frame. No second mount mechanism.
- *
- * The slice is inlined **verbatim**: `runtimeUrl` is honored as given (ggui's
- * host checklist item 8 — "no fallback URL, no substitution"), and every other
- * field is passed through untouched for the runtime's own projector to
- * validate. This module reads exactly one field (`runtimeUrl`) and only to
- * prove the slice is mountable at all.
+ * The shell {@link gguiShellHtml} builds is a string of HTML, so the ggui
+ * card rides the host's EXISTING mcp-ui mount path unchanged: it narrows to
+ * the same `McpUiResourcePayload` an inline resource does, so
+ * `@mcp-ui/client`'s `AppRenderer` posts it as `srcdoc` into the
+ * second-origin `mcp-app-sandbox.html` page — same double-iframe rule, same
+ * sandbox origin, same opaque inner frame. No second mount mechanism.
  *
  * NOT in scope here: rehydrating a ggui card from persisted history. The
- * bootstrap's `wsToken` expires minutes after the render (`expiresAt` in the
- * capture above), so a stored bootstrap is dead on arrival — a history card
- * without a live bootstrap correctly resolves to `undefined` and renders the
- * host's placeholder rather than a broken mount.
+ * bootstrap's `wsToken` expires minutes after the render, so a stored
+ * bootstrap is dead on arrival — a history card without a live bootstrap
+ * correctly resolves to `undefined` and renders the host's placeholder
+ * rather than a broken mount.
  */
 import type { AgBlock, JsonValue } from "@silverprotocol/core";
+import {
+  asGguiRenderBootstrap,
+  gguiShellHtml,
+  MCP_APP_AI_GGUI_RENDER_META_KEY,
+  type GguiRenderBootstrap,
+} from "@ggui-ai/protocol/integrations/mcp-apps";
 import { isJsonObject, type McpUiResourcePayload } from "./block-ui";
 
-/** The `_meta` key the ggui render bootstrap rides on (MCP-Apps slice convention). */
-export const GGUI_RENDER_META_KEY = "ai.ggui/render";
-
-/** The `ui://` scheme prefix every ggui render resource uri carries. */
-const UI_SCHEME = "ui://";
+export {
+  asGguiRenderBootstrap,
+  gguiShellHtml,
+} from "@ggui-ai/protocol/integrations/mcp-apps";
+export type {
+  GguiRenderBootstrap,
+  GguiShellHtmlOptions,
+} from "@ggui-ai/protocol/integrations/mcp-apps";
 
 /**
- * A ggui render bootstrap: the runtime bundle URL this module reads, plus the
- * WHOLE `ai.ggui/render` slice, verbatim, for the shell to inline.
+ * The `_meta` key the ggui render bootstrap rides on. Alias of the
+ * protocol package's own constant — one spelling, owned upstream.
  */
-export interface GguiRenderBootstrap {
-  /** `runtimeUrl` — the ESM bundle the shell loads. Honored as given. */
-  runtimeUrl: string;
-  /**
-   * The verbatim slice. Open-ended by construction: it is ggui's wire
-   * contract, not one this package owns, and the runtime's own projector is
-   * the authority on every field. Re-declaring it here would duplicate a
-   * contract we do not own and rot at ggui's next field addition.
-   */
-  slice: { [key: string]: JsonValue };
-}
+export const GGUI_RENDER_META_KEY = MCP_APP_AI_GGUI_RENDER_META_KEY;
+
+/** The `ui://` scheme prefix every ggui render resource uri carries. */
+const UI_SCHEME = "ui://";
 
 /** A ggui render recognised on a tool result: its resource uri + mount material. */
 export interface GguiRenderDescriptor {
@@ -105,48 +86,6 @@ export interface GguiRenderDescriptor {
   bootstrap?: GguiRenderBootstrap;
 }
 
-/** A non-empty JSON string field. */
-function isNonEmptyString(value: JsonValue | undefined): value is string {
-  return typeof value === "string" && value.length > 0;
-}
-
-/**
- * Does this slice carry at least one MOUNT MODE discriminator?
- *
- * Mirrors `@ggui-ai/iframe-runtime`'s `validateMeta` (see
- * `node_modules/@ggui-ai/iframe-runtime/dist/meta-parse.d.ts`) and the
- * `McpAppAiGguiRenderMeta` doc comment it implements
- * (`@ggui-ai/protocol/integrations/mcp-apps`): the runtime needs `runtimeUrl`
- * PLUS one of live mode (`wsUrl` + `wsToken` together), `codeUrl`, or `kind` —
- * without one of those three the iframe has nothing to mount.
- */
-function hasModeDiscriminator(slice: { [key: string]: JsonValue }): boolean {
-  if (isNonEmptyString(slice.wsUrl) && isNonEmptyString(slice.wsToken)) return true;
-  if (isNonEmptyString(slice.codeUrl)) return true;
-  if (isNonEmptyString(slice.kind)) return true;
-  return false;
-}
-
-/**
- * A `_meta` container → the ggui render bootstrap, or `undefined`.
- *
- * Two hard requirements, both the runtime's own `validateMeta` enforces
- * (`MALFORMED_BOOTSTRAP`): a non-empty `runtimeUrl`, AND at least one mode
- * discriminator (see {@link hasModeDiscriminator}). A slice with `runtimeUrl`
- * alone has a bundle to load but nothing for it to mount — the runtime would
- * boot into a blank shell rather than a card, so this guard treats that shape
- * as unmountable too and returns `undefined`.
- */
-export function asGguiRenderBootstrap(meta: JsonValue | undefined): GguiRenderBootstrap | undefined {
-  if (!isJsonObject(meta)) return undefined;
-  const slice = meta[GGUI_RENDER_META_KEY];
-  if (!isJsonObject(slice)) return undefined;
-  const runtimeUrl = slice.runtimeUrl;
-  if (typeof runtimeUrl !== "string" || runtimeUrl.length === 0) return undefined;
-  if (!hasModeDiscriminator(slice)) return undefined;
-  return { runtimeUrl, slice };
-}
-
 /**
  * A tool result's `uiData` (+ its `_meta`, when carried) → a ggui render
  * descriptor, or `undefined` for anything that is not one.
@@ -170,7 +109,14 @@ export function asGguiRender(
   };
 }
 
-/** A live `tool-result` AgBlock → its ggui render descriptor, if it is one. */
+/**
+ * A live `tool-result` AgBlock → its ggui render descriptor, if it is one.
+ *
+ * NOTE: `@ggui-ai/protocol/integrations/mcp-apps` exports a helper of the
+ * same name that narrows a spec-canonical MCP `CallToolResult` instead. This
+ * one is the silverprotocol-side twin — the input is the FOLDED block, whose
+ * `uiData`/`_meta` carriage is `@silverprotocol/core`'s contract, not ggui's.
+ */
 export function toolResultGguiRender(
   block: Extract<AgBlock, { type: "tool-result" }>,
 ): GguiRenderDescriptor | undefined {
@@ -184,58 +130,6 @@ export function blockGguiRender(block: JsonValue): GguiRenderDescriptor | undefi
   return asGguiRender(block.uiData, block._meta);
 }
 
-/**
- * Embed a JSON value inside an inline `<script>` safely.
- *
- * `</script` inside a string literal terminates the element in the HTML
- * parser regardless of JS quoting, and U+2028/U+2029 are line terminators in
- * JS source but not in JSON — both are escaped at the `<`/codepoint level so
- * the emitted text is still exactly the same JSON value.
- */
-function inlineJson(value: JsonValue): string {
-  return JSON.stringify(value)
-    .replace(/</g, "\\u003c")
-    .replace(/\u2028/g, "\\u2028")
-    .replace(/\u2029/g, "\\u2029");
-}
-
-/** Escape a string for use inside a double-quoted HTML attribute. */
-function attr(value: string): string {
-  return value
-    .replace(/&/g, "&amp;")
-    .replace(/"/g, "&quot;")
-    .replace(/</g, "&lt;")
-    .replace(/>/g, "&gt;");
-}
-
-/**
- * The ggui **self-contained shell** for a render bootstrap — see this module's
- * header for the contract it implements.
- *
- * Ordering is guaranteed twice over: the classic `<script>` runs during parse,
- * and the runtime's `<script type="module">` is deferred by definition, so the
- * global is always populated before the bundle evaluates.
- */
-export function gguiShellHtml(bootstrap: GguiRenderBootstrap): string {
-  const envelope = inlineJson({ [GGUI_RENDER_META_KEY]: bootstrap.slice });
-  return [
-    "<!doctype html>",
-    '<html lang="en">',
-    "<head>",
-    '<meta charset="utf-8">',
-    '<meta name="viewport" content="width=device-width, initial-scale=1">',
-    '<meta name="color-scheme" content="light dark">',
-    "<title>ggui card</title>",
-    "<style>html,body{margin:0;height:100%;background:transparent}</style>",
-    `<script>globalThis.__GGUI_META__=${envelope};</script>`,
-    `<script type="module" src="${attr(bootstrap.runtimeUrl)}"></script>`,
-    "</head>",
-    "<body></body>",
-    "</html>",
-    "",
-  ].join("\n");
-}
-
 /**
  * A ggui render descriptor → the mountable resource the host's existing
  * mcp-ui path already knows how to mount, or `undefined` when the descriptor
@@ -244,6 +138,12 @@ export function gguiShellHtml(bootstrap: GguiRenderBootstrap): string {
  * The `uri` is the render's REAL `resourceUri` — the shell is the payload, not
  * a renaming of the resource.
  *
+ * The shell is built `background: 'transparent'`: every guuey host that
+ * mounts through this adapter (widget, portal web, Studio) draws its own
+ * card chrome around the iframe, so the host page composits behind the card.
+ * The upstream default (`'surface'`) is for standalone served documents —
+ * see `GguiShellHtmlOptions` in `@ggui-ai/protocol/integrations/mcp-apps`.
+ *
  * **On `_meta` being required to MOUNT (but never to RECOGNISE).** Recognition
  * — "this tool result is a ggui card" — is keyed on `uiData.resourceUri` alone
  * and never waits for anything (see {@link asGguiRender}); nothing in this
@@ -251,12 +151,10 @@ export function gguiShellHtml(bootstrap: GguiRenderBootstrap): string {
  * requirement is ggui's, not ours: its runtime rejects a slice without
  * `runtimeUrl` AND without at least one mode discriminator (`wsUrl`+`wsToken`,
  * `codeUrl`, or `kind`) as `MALFORMED_BOOTSTRAP` and renders nothing. `uiData`
- * carries none of those fields — it has `sessionId`, `resourceUri`, `action`,
- * `contractHash`, `blueprintId`, `variantKey`, `cache`, `nextStep`, and that is
- * all. So a bootstrap-less descriptor could only ever produce a blank frame;
- * returning `undefined` and letting the host show its own placeholder is the
- * honest answer, not a deferral. `@silverprotocol/core`'s `Reducer` is what
- * puts `_meta` on the block for a live turn, in-repo, today.
+ * carries none of those fields, so a bootstrap-less descriptor could only ever
+ * produce a blank frame; returning `undefined` and letting the host show its
+ * own placeholder is the honest answer, not a deferral. `@silverprotocol/core`'s
+ * `Reducer` is what puts `_meta` on the block for a live turn, in-repo, today.
  */
 export function gguiRenderResource(
   render: GguiRenderDescriptor,
@@ -265,6 +163,6 @@ export function gguiRenderResource(
   return {
     uri: render.resourceUri,
     mimeType: "text/html",
-    text: gguiShellHtml(render.bootstrap),
+    text: gguiShellHtml(render.bootstrap, { background: "transparent" }),
   };
 }

package/src/index.ts

@@ -53,6 +53,7 @@ export {
   GGUI_RENDER_META_KEY,
   type GguiRenderBootstrap,
   type GguiRenderDescriptor,
+  type GguiShellHtmlOptions,
 } from "./ggui-render";
 export {
   cardCardMount,