@guuey/mcp-apps-host 0.6.0 → 0.7.0

package/README.md

@@ -9,8 +9,12 @@ role's client-side narrowing and mount contract:
 - **View-mount dispatch** (`toolResultViewMount`, `snapshotViewMount`): one
   narrowing that answers "what, if anything, does this block mount?" across
   the UI channels a transcript carries — an inline `ui://` resource payload,
-  a vendor fast-path (ggui's render shell, until its retirement per the
-  conformance map), or a bare `ui://` **locator**.
+  or a bare `ui://` **locator** (from `uiData.resourceUri`, else
+  `structuredContent.resourceUri`). Every `ui://` producer, ggui's
+  `ggui_render` included, is a locator producer: the ggui vendor fast-path
+  retired 2026-08-16 (guuey#209) once the pod's live read door and ggui's
+  read-time mint made the spec's read path strictly fresher than any
+  inlined bootstrap. Its helpers stay exported one minor as `@deprecated`.
 - **Locator rehydration**: a persisted `ui://` locator remounts by a fresh,
   authenticated `resources/read` of the uri — the spec-consistent template
   fetch (the spec itself defers persistence/restoration; a full remount

package/dist/action.d.ts

@@ -51,10 +51,33 @@ export type McpToolCallResult = {
     structuredContent?: McpToolStructuredContent;
 };
 /**
- * The runtime-action tools a card sandbox may relay — the client-side twin
- * of the server allowlist (defense in depth: the proxy enforces it again).
+ * The runtime tools a card sandbox may RELAY over `tools/call` — the
+ * client-side twin of the server allowlist (defense in depth: the proxy
+ * enforces it again). Exactly ggui's iframe-runtime surface, all declared
+ * `_meta.ui.visibility: ['app']` (never model-callable):
+ *
+ *  - `ggui_runtime_submit_action` — the user's gesture (the SEMANTIC one);
+ *  - `ggui_runtime_refresh_ws_token` — live-channel credential refresh
+ *    (the wsToken TTL is 180 s; without the relay a view on SSE/polling
+ *    dies at that mark — guuey#220);
+ *  - `ggui_runtime_pull` — the host-relayed polling rung where the
+ *    sandbox's own transports are blocked (bridge-pull, terminal rung).
+ *
+ * Two of these are transport plumbing whose arguments are opaque runtime
+ * state — see {@link UI_SEMANTIC_ACTION_TOOLS} for the ONLY set a host may
+ * treat as "the user did something".
  */
 export declare const UI_ACTION_TOOLS: ReadonlySet<string>;
+/**
+ * The strict subset of {@link UI_ACTION_TOOLS} that carries a USER gesture —
+ * the only calls a host may project into user-facing affordances (composer
+ * staging, "the user selected X" copy, telemetry as intent). Every other
+ * relayed tool is runtime plumbing whose payload must NEVER reach the user
+ * verbatim (guuey#215/#218: a staged `sessionId …` was exactly that leak).
+ * A tool that is relayable is NOT thereby semantic; a host that widens
+ * this set is asserting the wire semantics of the new name.
+ */
+export declare const UI_SEMANTIC_ACTION_TOOLS: ReadonlySet<string>;
 /** The in-band answer for anything the relay cannot (or will not) do. */
 export declare const UI_ACTION_UNAVAILABLE_TEXT = "This action isn't available right now.";
 /**

package/dist/action.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"action.d.ts","sourceRoot":"","sources":["../src/action.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,oFAAoF;AACpF,MAAM,MAAM,kBAAkB,GAC1B;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAC9B;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GACjD;IACE,IAAI,EAAE,UAAU,CAAC;IACjB,QAAQ,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,CAC3C;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,GAChB;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,CACnB,CAAC;CACH,CAAC;AAEN;;;;GAIG;AACH,MAAM,MAAM,wBAAwB,GAAG;IACrC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB,CAAC;AAEF;;;;;GAKG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B,OAAO,EAAE,kBAAkB,EAAE,CAAC;IAC9B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,iBAAiB,CAAC,EAAE,wBAAwB,CAAC;CAC9C,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,eAAe,EAAE,WAAW,CAAC,MAAM,CAE9C,CAAC;AAEH,yEAAyE;AACzE,eAAO,MAAM,0BAA0B,2CACG,CAAC;AAE3C;;;;GAIG;AACH,wBAAgB,yBAAyB,IAAI,iBAAiB,CAK7D;AAkCD;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,iBAAiB,GAAG,SAAS,CAgB9E;AAED,iFAAiF;AACjF,MAAM,WAAW,0BAA0B;IACzC;;;;;OAKG;IACH,QAAQ,EAAE,CACR,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,wBAAwB,GAAG,SAAS,KACvC,OAAO,CAAC,OAAO,CAAC,CAAC;CACvB;AAED,uEAAuE;AACvE,MAAM,WAAW,eAAe;IAC9B,yEAAyE;IACzE,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,CAAC,EAAE,wBAAwB,CAAC;CACtC;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,0BAA0B,GAC/B,CAAC,OAAO,EAAE,eAAe,KAAK,OAAO,CAAC,iBAAiB,CAAC,CAa1D"}
+{"version":3,"file":"action.d.ts","sourceRoot":"","sources":["../src/action.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,oFAAoF;AACpF,MAAM,MAAM,kBAAkB,GAC1B;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAC9B;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GACjD;IACE,IAAI,EAAE,UAAU,CAAC;IACjB,QAAQ,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,CAC3C;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,GAChB;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,CACnB,CAAC;CACH,CAAC;AAEN;;;;GAIG;AACH,MAAM,MAAM,wBAAwB,GAAG;IACrC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB,CAAC;AAEF;;;;;GAKG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B,OAAO,EAAE,kBAAkB,EAAE,CAAC;IAC9B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,iBAAiB,CAAC,EAAE,wBAAwB,CAAC;CAC9C,CAAC;AAEF;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,eAAe,EAAE,WAAW,CAAC,MAAM,CAI9C,CAAC;AAEH;;;;;;;;GAQG;AACH,eAAO,MAAM,wBAAwB,EAAE,WAAW,CAAC,MAAM,CAEvD,CAAC;AAEH,yEAAyE;AACzE,eAAO,MAAM,0BAA0B,2CACG,CAAC;AAE3C;;;;GAIG;AACH,wBAAgB,yBAAyB,IAAI,iBAAiB,CAK7D;AAkCD;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,iBAAiB,GAAG,SAAS,CAgB9E;AAED,iFAAiF;AACjF,MAAM,WAAW,0BAA0B;IACzC;;;;;OAKG;IACH,QAAQ,EAAE,CACR,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,wBAAwB,GAAG,SAAS,KACvC,OAAO,CAAC,OAAO,CAAC,CAAC;CACvB;AAED,uEAAuE;AACvE,MAAM,WAAW,eAAe;IAC9B,yEAAyE;IACzE,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,CAAC,EAAE,wBAAwB,CAAC;CACtC;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,0BAA0B,GAC/B,CAAC,OAAO,EAAE,eAAe,KAAK,OAAO,CAAC,iBAAiB,CAAC,CAa1D"}

package/dist/action.js

@@ -13,11 +13,38 @@
  *    it crosses into the sandbox.
  */
 /**
- * The runtime-action tools a card sandbox may relay — the client-side twin
- * of the server allowlist (defense in depth: the proxy enforces it again).
+ * The runtime tools a card sandbox may RELAY over `tools/call` — the
+ * client-side twin of the server allowlist (defense in depth: the proxy
+ * enforces it again). Exactly ggui's iframe-runtime surface, all declared
+ * `_meta.ui.visibility: ['app']` (never model-callable):
+ *
+ *  - `ggui_runtime_submit_action` — the user's gesture (the SEMANTIC one);
+ *  - `ggui_runtime_refresh_ws_token` — live-channel credential refresh
+ *    (the wsToken TTL is 180 s; without the relay a view on SSE/polling
+ *    dies at that mark — guuey#220);
+ *  - `ggui_runtime_pull` — the host-relayed polling rung where the
+ *    sandbox's own transports are blocked (bridge-pull, terminal rung).
+ *
+ * Two of these are transport plumbing whose arguments are opaque runtime
+ * state — see {@link UI_SEMANTIC_ACTION_TOOLS} for the ONLY set a host may
+ * treat as "the user did something".
  */
 export const UI_ACTION_TOOLS = new Set([
     "ggui_runtime_submit_action",
+    "ggui_runtime_refresh_ws_token",
+    "ggui_runtime_pull",
+]);
+/**
+ * The strict subset of {@link UI_ACTION_TOOLS} that carries a USER gesture —
+ * the only calls a host may project into user-facing affordances (composer
+ * staging, "the user selected X" copy, telemetry as intent). Every other
+ * relayed tool is runtime plumbing whose payload must NEVER reach the user
+ * verbatim (guuey#215/#218: a staged `sessionId …` was exactly that leak).
+ * A tool that is relayable is NOT thereby semantic; a host that widens
+ * this set is asserting the wire semantics of the new name.
+ */
+export const UI_SEMANTIC_ACTION_TOOLS = new Set([
+    "ggui_runtime_submit_action",
 ]);
 /** The in-band answer for anything the relay cannot (or will not) do. */
 export const UI_ACTION_UNAVAILABLE_TEXT = "This action isn't available right now.";

package/dist/block-ui.d.ts

@@ -104,6 +104,24 @@ export declare function toolResultUiResource(block: Extract<AgBlock, {
  * are one producer of this shape.
  */
 export declare function uiLocator(uiData: JsonValue | undefined): string | undefined;
+/**
+ * The `ui://` locator a `tool-result` block carries, from EITHER channel it
+ * can arrive on — the single seam every locator reader goes through.
+ *
+ * AgJSON §2.1 routes a tool result's `structuredContent` by its `_meta.ui`
+ * sibling: WITH the sibling it is surface data and the normalizer stamps
+ * `uiData`; WITHOUT it, it is model-channel data and lands in
+ * `structuredContent`. A producer that withholds `_meta` (ggui's non-prod
+ * posture; any plain-locator MCP server) therefore delivers a locator that
+ * is byte-identical in shape but lives one field over — reading `uiData`
+ * alone renders NOTHING for it (dark, not "expired"), and the persistence
+ * projector minted no placeholder row (the read plane 404s). `uiData` wins
+ * when both carry one (guuey#209 route-A finding).
+ */
+export declare function toolResultLocator(block: {
+    uiData?: JsonValue;
+    structuredContent?: JsonValue;
+}): string | undefined;
 export declare function snapshotUiResource(cardSnapshot: JsonValue): McpUiResourcePayload | undefined;
 /**
  * The resource's HTML: inline `text` wins; else base64-decode `blob`. `atob`

package/dist/block-ui.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"block-ui.d.ts","sourceRoot":"","sources":["../src/block-ui.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAE/D;;;;;GAKG;AACH,MAAM,WAAW,oBAAoB;IACnC,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,uEAAuE;AACvE,wBAAgB,YAAY,CAAC,CAAC,EAAE,SAAS,GAAG,SAAS,GAAG,CAAC,IAAI;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,CAExF;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,SAAS,GAAG,SAAS,GAAG,oBAAoB,GAAG,SAAS,CAU5F;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,SAAS,GAAG,SAAS,GAAG,oBAAoB,GAAG,SAAS,CAK5F;AAED;;;;;;GAMG;AACH,wBAAgB,4BAA4B,CAC1C,GAAG,EAAE,SAAS,GAAG,SAAS,GACzB,oBAAoB,GAAG,SAAS,CAMlC;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,SAAS,GAAG,oBAAoB,GAAG,SAAS,CAyBlF;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,OAAO,CAAC,OAAO,EAAE;IAAE,IAAI,EAAE,aAAa,CAAA;CAAE,CAAC,GAC/C,oBAAoB,GAAG,SAAS,CAUlC;AAED;;;;;;;;;;;GAWG;AACH;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,SAAS,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAI3E;AAED,wBAAgB,kBAAkB,CAAC,YAAY,EAAE,SAAS,GAAG,oBAAoB,GAAG,SAAS,CAU5F;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,oBAAoB,GAAG,MAAM,GAAG,SAAS,CAU/E"}
+{"version":3,"file":"block-ui.d.ts","sourceRoot":"","sources":["../src/block-ui.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAE/D;;;;;GAKG;AACH,MAAM,WAAW,oBAAoB;IACnC,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,uEAAuE;AACvE,wBAAgB,YAAY,CAAC,CAAC,EAAE,SAAS,GAAG,SAAS,GAAG,CAAC,IAAI;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,CAExF;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,SAAS,GAAG,SAAS,GAAG,oBAAoB,GAAG,SAAS,CAU5F;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,SAAS,GAAG,SAAS,GAAG,oBAAoB,GAAG,SAAS,CAK5F;AAED;;;;;;GAMG;AACH,wBAAgB,4BAA4B,CAC1C,GAAG,EAAE,SAAS,GAAG,SAAS,GACzB,oBAAoB,GAAG,SAAS,CAMlC;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,SAAS,GAAG,oBAAoB,GAAG,SAAS,CAyBlF;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,OAAO,CAAC,OAAO,EAAE;IAAE,IAAI,EAAE,aAAa,CAAA;CAAE,CAAC,GAC/C,oBAAoB,GAAG,SAAS,CAUlC;AAED;;;;;;;;;;;GAWG;AACH;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,SAAS,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAI3E;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE;IACvC,MAAM,CAAC,EAAE,SAAS,CAAC;IACnB,iBAAiB,CAAC,EAAE,SAAS,CAAC;CAC/B,GAAG,MAAM,GAAG,SAAS,CAErB;AAED,wBAAgB,kBAAkB,CAAC,YAAY,EAAE,SAAS,GAAG,oBAAoB,GAAG,SAAS,CAU5F;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,oBAAoB,GAAG,MAAM,GAAG,SAAS,CAU/E"}

package/dist/block-ui.js

@@ -140,6 +140,23 @@ export function uiLocator(uiData) {
     const uri = uiData.resourceUri;
     return typeof uri === "string" && uri.startsWith("ui://") ? uri : undefined;
 }
+/**
+ * The `ui://` locator a `tool-result` block carries, from EITHER channel it
+ * can arrive on — the single seam every locator reader goes through.
+ *
+ * AgJSON §2.1 routes a tool result's `structuredContent` by its `_meta.ui`
+ * sibling: WITH the sibling it is surface data and the normalizer stamps
+ * `uiData`; WITHOUT it, it is model-channel data and lands in
+ * `structuredContent`. A producer that withholds `_meta` (ggui's non-prod
+ * posture; any plain-locator MCP server) therefore delivers a locator that
+ * is byte-identical in shape but lives one field over — reading `uiData`
+ * alone renders NOTHING for it (dark, not "expired"), and the persistence
+ * projector minted no placeholder row (the read plane 404s). `uiData` wins
+ * when both carry one (guuey#209 route-A finding).
+ */
+export function toolResultLocator(block) {
+    return uiLocator(block.uiData) ?? uiLocator(block.structuredContent);
+}
 export function snapshotUiResource(cardSnapshot) {
     if (!isJsonObject(cardSnapshot))
         return undefined;

package/dist/card-mount.d.ts

@@ -1,41 +1,53 @@
 /**
  * The card-mount dispatcher: ONE narrowing that answers "what, if anything,
- * does this block mount?" across BOTH generative-UI channels a guuey pod
- * emits.
+ * does this block mount?" for every generative-UI shape a guuey pod emits.
  *
  *   1. **inline mcp-ui resource** — `{uri, text|blob}` on `uiData`, or a
  *      `ui://` resource degraded into a `provider-raw` content part. Handled
  *      verbatim by `block-ui.ts`; this module does not touch that path, it
  *      only tries it FIRST.
- *   2. **ggui render** — `uiData.resourceUri` + the `_meta["ai.ggui/render"]`
- *      bootstrap, mounted through ggui's self-contained shell. See
- *      `ggui-render.ts`.
+ *   2. **`ui://` locator** — the durable identity of a view produced by ANY
+ *      MCP server (ggui's `ggui_render` included), on `uiData.resourceUri`
+ *      when the producer sent `_meta.ui` (AgJSON §2.1 surface routing) or on
+ *      `structuredContent.resourceUri` when it did not. The host resolves it
+ *      by a fresh, authenticated `resources/read` of the uri
+ *      ({@link UiResourceReader}) — the spec-consistent template fetch, on
+ *      the live turn (pod door) and on rehydration (persisted door) alike.
  *
- * Both channels land on the SAME `McpUiResourcePayload`, which is the whole
- * point: a host that already mounts inline resources through
- * `@mcp-ui/client`'s `AppRenderer` in a second-origin sandbox gains ggui cards
- * without a second mount mechanism, a second iframe contract, or a second
- * security posture to review.
+ * ## The ggui vendor arm is retired (guuey#209, 2026-08-16)
  *
- * Precedence is inline-first and deliberate: an inline resource is the
- * server's explicit, self-sufficient HTML. A ggui render only ever wins when
- * there is no inline resource to prefer, so this dispatcher can never change
- * what an existing inline card renders.
+ * This dispatcher used to carry a THIRD arm: when a `tool-result` carried the
+ * `_meta["ai.ggui/render"]` bootstrap it built ggui's self-contained shell
+ * inline and mounted it without a read — a fast path that existed only
+ * because the pod holds the MCP connection and a live locator had no host-
+ * side read channel. That precondition is gone: the pod door
+ * (`GET <pod>/agent/ui-resource`) answers live-turn locators, the persisted
+ * door answers rehydration, and ggui's `resources/read` mints the live-
+ * channel material FRESH at read time — strictly fresher than any inlined
+ * bootstrap. A ggui render is therefore just another locator producer; live
+ * == rehydrated == spec. The arm's narrowing helpers stay exported one
+ * minor as `@deprecated` (`ggui-render.ts`); nothing here consumes them.
  *
  * ## Why the CHANNEL is returned alongside the resource
  *
- * The payload alone cannot say where it came from — a ggui shell is a string
+ * The payload alone cannot say where it came from — ggui's shell is a string
  * of HTML like any other. But a host has one decision that genuinely depends
  * on the origin of that HTML: WHICH sandbox host page to mount it in. A ggui
  * shell must load ggui's runtime bundle and open its WSS, so it needs a page
  * whose CSP names the ggui origins; an inline card is arbitrary tenant HTML
- * and must keep the self-only page it has always had. Handing back the channel
- * keeps that one narrowing in one place — the alternative was for every host
- * to re-run `toolResultGguiRender` beside this call and ask again.
+ * and must keep the self-only page it has always had. Since the flip the
+ * channel is assigned at RESOLUTION time from the requested locator uri
+ * (`uiResourceChannel` in `reader.ts` — `ui://ggui/…` → `"ggui"`), never
+ * from the response and never from mount material a producer inlined.
  */
 import { type McpUiResourcePayload } from "./block-ui.js";
 import type { AgBlock, JsonValue } from "@silverprotocol/core";
-/** Which generative-UI channel produced a mount. See this module's header. */
+/**
+ * Which sandbox-trust channel a mount rides. See this module's header.
+ * `"ggui"` is assigned at RESOLUTION time from the requested locator uri
+ * (`uiResourceChannel`) — a `toolResultViewMount` result is only ever
+ * `"inline"` or `"locator"`.
+ */
 export type ViewMountChannel = "inline" | "ggui" | "locator";
 /**
  * A mountable card, or the locator to fetch one with.
@@ -44,7 +56,9 @@ export type ViewMountChannel = "inline" | "ggui" | "locator";
  * `"ggui"` — a shell that boots the ggui runtime from a platform-pinned
  * origin, and therefore needs a host page whose CSP allows that origin.
  * `"locator"` — no mount material in hand, only the durable `ui://`
- * identity (guuey#122): the host resolves it with a fresh, authenticated
+ * identity (guuey#122) — read from `uiData` OR, for a producer that
+ * withheld `_meta` (AgJSON §2.1 then routes it to `structuredContent`),
+ * from `structuredContent` (guuey#209): the host resolves it with a fresh, authenticated
  * `resources/read` of the uri ({@link UiResourceReader}) — the spec-consistent
  * template fetch, vendor-neutral. (The spec defers persistence/restoration
  * itself; a full remount additionally owes the View `ui/notifications/tool-input`
@@ -56,6 +70,8 @@ export type ViewMount = ResolvedViewMount | LocatorViewMount;
  * A view with mount material in hand — the arms a host can render directly,
  * and the ONLY arms a `UiResourceReader` resolves (guuey#127): a read either
  * yields mount material or the honest placeholder, never another locator.
+ * `"ggui"` here always comes from a reader (`uiResourceChannel` on the
+ * requested uri) — no dispatcher in this module produces it.
  */
 export interface ResolvedViewMount {
     channel: "inline" | "ggui";
@@ -65,7 +81,7 @@ export interface ResolvedViewMount {
 /** The durable-identity arm: no mount material, only the uri to re-fetch. */
 export interface LocatorViewMount {
     channel: "locator";
-    /** The persisted `uiData.resourceUri` (`ui://` scheme) to re-fetch. */
+    /** The durable `ui://` locator to re-fetch (`uiData.resourceUri`, else `structuredContent.resourceUri`). */
     resourceUri: string;
 }
 /**
@@ -79,9 +95,14 @@ export interface LocatorViewMount {
  */
 export type UiResourceReader = (resourceUri: string) => Promise<ViewMount | undefined>;
 /**
- * A live `tool-result` block → the card to mount, across both channels.
- * `undefined` when the block carries no generative UI at all (or carries a
- * ggui render whose bootstrap did not reach us — see `ggui-render.ts`).
+ * A live `tool-result` block → the card to mount: an inline resource, else the
+ * `ui://` locator (either channel — see `toolResultLocator`), else `undefined`
+ * when the block carries no generative UI at all.
+ *
+ * A locator on a LIVE turn resolves through the pod door (its live-card
+ * ledger registers the locator the moment the result streams — guuey#209
+ * C1/C5); the same locator persisted resolves through the platform door.
+ * One authority per lifecycle phase, one dispatcher for both.
  */
 export declare function toolResultViewMount(block: Extract<AgBlock, {
     type: "tool-result";
@@ -89,12 +110,12 @@ export declare function toolResultViewMount(block: Extract<AgBlock, {
 /**
  * A persisted `HistoryCard`'s `cardSnapshot` → the card to mount.
  *
- * There is deliberately NO bootstrap arm here (guuey#122): persistence
- * strips tool-result `_meta` (see `@guuey/threads`' fold-rows), and a
- * foreign snapshot that still carries one holds an expired `wsToken` — a
- * dead mount. A persisted `ui://` locator resolves to the `"locator"`
- * channel instead: rehydration is a fresh `resources/read` of the uri,
- * the spec-consistent template fetch, vendor-neutral.
+ * Same two arms as the live dispatcher (since guuey#209 there is no third):
+ * an inline resource, else the `ui://` locator. Persistence strips
+ * tool-result `_meta` (see `@guuey/threads`' fold-rows), and a foreign
+ * snapshot that still carries a stale bootstrap is ignored — its `wsToken`
+ * expired minutes after the render. Rehydration is a fresh `resources/read`
+ * of the uri, the spec-consistent template fetch, vendor-neutral.
  */
 export declare function snapshotViewMount(cardSnapshot: JsonValue): ViewMount | undefined;
 /**

package/dist/card-mount.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"card-mount.d.ts","sourceRoot":"","sources":["../src/card-mount.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,OAAO,EAAuD,KAAK,oBAAoB,EAAE,MAAM,eAAe,CAAC;AAE/G,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAW/D,8EAA8E;AAC9E,MAAM,MAAM,gBAAgB,GAAG,QAAQ,GAAG,MAAM,GAAG,SAAS,CAAC;AAE7D;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,SAAS,GAAG,iBAAiB,GAAG,gBAAgB,CAAC;AAE7D;;;;GAIG;AACH,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,QAAQ,GAAG,MAAM,CAAC;IAC3B,+EAA+E;IAC/E,QAAQ,EAAE,oBAAoB,CAAC;CAChC;AAED,6EAA6E;AAC7E,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,SAAS,CAAC;IACnB,uEAAuE;IACvE,WAAW,EAAE,MAAM,CAAC;CACrB;AAED;;;;;;;;GAQG;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,WAAW,EAAE,MAAM,KAAK,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC,CAAC;AAEvF;;;;GAIG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,OAAO,CAAC,OAAO,EAAE;IAAE,IAAI,EAAE,aAAa,CAAA;CAAE,CAAC,GAC/C,SAAS,GAAG,SAAS,CAkBvB;AAED;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAAC,YAAY,EAAE,SAAS,GAAG,SAAS,GAAG,SAAS,CAUhF;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,gBAAgB,CACpC,KAAK,EAAE,SAAS,GAAG,SAAS,EAC5B,MAAM,CAAC,EAAE,gBAAgB,GACxB,OAAO,CAAC,iBAAiB,GAAG,SAAS,CAAC,CAKxC"}
+{"version":3,"file":"card-mount.d.ts","sourceRoot":"","sources":["../src/card-mount.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,OAAO,EAA+D,KAAK,oBAAoB,EAAE,MAAM,eAAe,CAAC;AACvH,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAE/D;;;;;GAKG;AACH,MAAM,MAAM,gBAAgB,GAAG,QAAQ,GAAG,MAAM,GAAG,SAAS,CAAC;AAE7D;;;;;;;;;;;;;;;GAeG;AACH,MAAM,MAAM,SAAS,GAAG,iBAAiB,GAAG,gBAAgB,CAAC;AAE7D;;;;;;GAMG;AACH,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,QAAQ,GAAG,MAAM,CAAC;IAC3B,+EAA+E;IAC/E,QAAQ,EAAE,oBAAoB,CAAC;CAChC;AAED,6EAA6E;AAC7E,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,SAAS,CAAC;IACnB,4GAA4G;IAC5G,WAAW,EAAE,MAAM,CAAC;CACrB;AAED;;;;;;;;GAQG;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,WAAW,EAAE,MAAM,KAAK,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC,CAAC;AAEvF;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,OAAO,CAAC,OAAO,EAAE;IAAE,IAAI,EAAE,aAAa,CAAA;CAAE,CAAC,GAC/C,SAAS,GAAG,SAAS,CAKvB;AAED;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAAC,YAAY,EAAE,SAAS,GAAG,SAAS,GAAG,SAAS,CAUhF;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,gBAAgB,CACpC,KAAK,EAAE,SAAS,GAAG,SAAS,EAC5B,MAAM,CAAC,EAAE,gBAAgB,GACxB,OAAO,CAAC,iBAAiB,GAAG,SAAS,CAAC,CAKxC"}

package/dist/card-mount.js

@@ -1,78 +1,72 @@
 /**
  * The card-mount dispatcher: ONE narrowing that answers "what, if anything,
- * does this block mount?" across BOTH generative-UI channels a guuey pod
- * emits.
+ * does this block mount?" for every generative-UI shape a guuey pod emits.
  *
  *   1. **inline mcp-ui resource** — `{uri, text|blob}` on `uiData`, or a
  *      `ui://` resource degraded into a `provider-raw` content part. Handled
  *      verbatim by `block-ui.ts`; this module does not touch that path, it
  *      only tries it FIRST.
- *   2. **ggui render** — `uiData.resourceUri` + the `_meta["ai.ggui/render"]`
- *      bootstrap, mounted through ggui's self-contained shell. See
- *      `ggui-render.ts`.
+ *   2. **`ui://` locator** — the durable identity of a view produced by ANY
+ *      MCP server (ggui's `ggui_render` included), on `uiData.resourceUri`
+ *      when the producer sent `_meta.ui` (AgJSON §2.1 surface routing) or on
+ *      `structuredContent.resourceUri` when it did not. The host resolves it
+ *      by a fresh, authenticated `resources/read` of the uri
+ *      ({@link UiResourceReader}) — the spec-consistent template fetch, on
+ *      the live turn (pod door) and on rehydration (persisted door) alike.
  *
- * Both channels land on the SAME `McpUiResourcePayload`, which is the whole
- * point: a host that already mounts inline resources through
- * `@mcp-ui/client`'s `AppRenderer` in a second-origin sandbox gains ggui cards
- * without a second mount mechanism, a second iframe contract, or a second
- * security posture to review.
+ * ## The ggui vendor arm is retired (guuey#209, 2026-08-16)
  *
- * Precedence is inline-first and deliberate: an inline resource is the
- * server's explicit, self-sufficient HTML. A ggui render only ever wins when
- * there is no inline resource to prefer, so this dispatcher can never change
- * what an existing inline card renders.
+ * This dispatcher used to carry a THIRD arm: when a `tool-result` carried the
+ * `_meta["ai.ggui/render"]` bootstrap it built ggui's self-contained shell
+ * inline and mounted it without a read — a fast path that existed only
+ * because the pod holds the MCP connection and a live locator had no host-
+ * side read channel. That precondition is gone: the pod door
+ * (`GET <pod>/agent/ui-resource`) answers live-turn locators, the persisted
+ * door answers rehydration, and ggui's `resources/read` mints the live-
+ * channel material FRESH at read time — strictly fresher than any inlined
+ * bootstrap. A ggui render is therefore just another locator producer; live
+ * == rehydrated == spec. The arm's narrowing helpers stay exported one
+ * minor as `@deprecated` (`ggui-render.ts`); nothing here consumes them.
  *
  * ## Why the CHANNEL is returned alongside the resource
  *
- * The payload alone cannot say where it came from — a ggui shell is a string
+ * The payload alone cannot say where it came from — ggui's shell is a string
  * of HTML like any other. But a host has one decision that genuinely depends
  * on the origin of that HTML: WHICH sandbox host page to mount it in. A ggui
  * shell must load ggui's runtime bundle and open its WSS, so it needs a page
  * whose CSP names the ggui origins; an inline card is arbitrary tenant HTML
- * and must keep the self-only page it has always had. Handing back the channel
- * keeps that one narrowing in one place — the alternative was for every host
- * to re-run `toolResultGguiRender` beside this call and ask again.
+ * and must keep the self-only page it has always had. Since the flip the
+ * channel is assigned at RESOLUTION time from the requested locator uri
+ * (`uiResourceChannel` in `reader.ts` — `ui://ggui/…` → `"ggui"`), never
+ * from the response and never from mount material a producer inlined.
  */
-import { snapshotUiResource, toolResultUiResource, uiLocator } from "./block-ui.js";
-import { GGUI_RENDER_META_KEY, gguiRenderResource, toolResultGguiRender } from "./ggui-render.js";
-/** Does the block's `_meta` carry the ggui render key at all (valid or not)? */
-function blockCarriesGguiMetaKey(block) {
-    const meta = block._meta;
-    return (typeof meta === "object" && meta !== null && !Array.isArray(meta) && GGUI_RENDER_META_KEY in meta);
-}
+import { snapshotUiResource, toolResultLocator, toolResultUiResource } from "./block-ui.js";
 /**
- * A live `tool-result` block → the card to mount, across both channels.
- * `undefined` when the block carries no generative UI at all (or carries a
- * ggui render whose bootstrap did not reach us — see `ggui-render.ts`).
+ * A live `tool-result` block → the card to mount: an inline resource, else the
+ * `ui://` locator (either channel — see `toolResultLocator`), else `undefined`
+ * when the block carries no generative UI at all.
+ *
+ * A locator on a LIVE turn resolves through the pod door (its live-card
+ * ledger registers the locator the moment the result streams — guuey#209
+ * C1/C5); the same locator persisted resolves through the platform door.
+ * One authority per lifecycle phase, one dispatcher for both.
  */
 export function toolResultViewMount(block) {
     const inline = toolResultUiResource(block);
     if (inline)
         return { resource: inline, channel: "inline" };
-    const ggui = toolResultGguiRender(block);
-    const resource = ggui ? gguiRenderResource(ggui) : undefined;
-    if (resource)
-        return { resource, channel: "ggui" };
-    // A live locator whose mount material didn't reach us (a fold that
-    // dropped `_meta`): re-fetch works on live turns too — the resource is
-    // freshly minted (guuey#122). One diagnostic when `_meta` DID carry the
-    // vendor key but failed validation — a producer bug would otherwise be
-    // indistinguishable from a meta-less fold (blank UI, zero errors).
-    if (ggui && !ggui.bootstrap && blockCarriesGguiMetaKey(block)) {
-        console.warn(`mcp-apps-host: tool result ${block.toolCallId} carries a malformed ggui render bootstrap — degrading to the locator channel`);
-    }
-    const locator = uiLocator(block.uiData);
+    const locator = toolResultLocator(block);
     return locator !== undefined ? { channel: "locator", resourceUri: locator } : undefined;
 }
 /**
  * A persisted `HistoryCard`'s `cardSnapshot` → the card to mount.
  *
- * There is deliberately NO bootstrap arm here (guuey#122): persistence
- * strips tool-result `_meta` (see `@guuey/threads`' fold-rows), and a
- * foreign snapshot that still carries one holds an expired `wsToken` — a
- * dead mount. A persisted `ui://` locator resolves to the `"locator"`
- * channel instead: rehydration is a fresh `resources/read` of the uri,
- * the spec-consistent template fetch, vendor-neutral.
+ * Same two arms as the live dispatcher (since guuey#209 there is no third):
+ * an inline resource, else the `ui://` locator. Persistence strips
+ * tool-result `_meta` (see `@guuey/threads`' fold-rows), and a foreign
+ * snapshot that still carries a stale bootstrap is ignored — its `wsToken`
+ * expired minutes after the render. Rehydration is a fresh `resources/read`
+ * of the uri, the spec-consistent template fetch, vendor-neutral.
  */
 export function snapshotViewMount(cardSnapshot) {
     const inline = snapshotUiResource(cardSnapshot);
@@ -83,7 +77,7 @@ export function snapshotViewMount(cardSnapshot) {
             continue;
         if (block.type !== "tool-result")
             continue;
-        const locator = uiLocator(block.uiData);
+        const locator = toolResultLocator(block);
         if (locator !== undefined)
             return { channel: "locator", resourceUri: locator };
     }

package/dist/ggui-render.d.ts

@@ -1,61 +1,71 @@
 /**
- * The **ggui render** channel: narrowing + self-contained shell construction
- * for a generative-UI card produced by the ggui MCP server (`ggui_render`).
+ * @deprecated — the ggui vendor arm is RETIRED (guuey#209, 2026-08-16).
  *
- * ## Where the pieces live (guuey#108 / ggui#427)
+ * Everything in this module is kept exported for ONE MINOR under the
+ * post-launch compatibility rule and is removed in the minor after the one
+ * that ships this notice. Nothing in `@guuey/mcp-apps-host` calls it any
+ * more: `toolResultViewMount` hands a ggui render back as a `ui://`
+ * **locator** (`toolResultLocator`, either channel), the mount material
+ * comes from a `resources/read` through a `UiResourceReader` (pod door
+ * live, persisted door on rehydration), and the `"ggui"` sandbox-trust
+ * channel is assigned at resolution from the requested uri
+ * (`uiResourceChannel` in `reader.ts`). Migration per symbol:
  *
- * The two halves of this channel have different owners, and the module is
- * split along that line:
+ *  - {@link asGguiRender} / {@link toolResultGguiRender} /
+ *    {@link blockGguiRender} → `toolResultLocator(block)` — the locator is
+ *    the recognition signal; there is no descriptor to build.
+ *  - {@link gguiRenderResource} → resolve the locator through a reader
+ *    (`resolveViewMount(mount, reader)`); ggui's `resources/read` returns
+ *    the shell with live-channel material minted FRESH at read time.
+ *  - {@link GGUI_RENDER_META_KEY} → the wire key is ggui's; import
+ *    `MCP_APP_AI_GGUI_RENDER_META_KEY` from
+ *    `@ggui-ai/protocol/integrations/mcp-apps` if you still inspect
+ *    `_meta` (nothing here does).
+ *  - {@link asGguiRenderBootstrap} / {@link gguiShellHtml} and their types
+ *    are pure re-exports of ggui's protocol package — import them from
+ *    `@ggui-ai/protocol/integrations/mcp-apps` directly.
  *
- *  - **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.
+ * ## Why the arm existed, for the record
  *
- * ## 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
- *     (the reducer copies `uiData` — and, as of `@silverprotocol/core`
- *     0.4.1 (workspace#9), `_meta` — onto the `tool-result` block).
- *  2. **`_meta["ai.ggui/render"]` is the MOUNT MATERIAL.** Everything needed
- *     to boot the card — which runtime bundle to load, which live-channel to
- *     open, which props to seed — lives there and nowhere else.
- *
- * 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, so a stored
- * bootstrap is dead on arrival — a history card resolves to the `locator`
- * channel (`card-mount.ts`, guuey#122) and remounts by a fresh
- * `resources/read`, never a bootstrap replay.
+ * A ggui render's `tool.done` used to carry two signals: `uiData.resourceUri`
+ * (recognition — the only part surviving the fold) and the
+ * `_meta["ai.ggui/render"]` bootstrap (mount material: runtime bundle,
+ * live channel, seeded props). Because guuey's chat client is not an MCP
+ * client (the pod holds the connection), a live locator had no host-side
+ * read channel, so the bootstrap was inlined as a read-skipping fast path
+ * and this module built ggui's self-contained shell from it. The pod door
+ * (`GET <pod>/agent/ui-resource`, guuey#209 C1) closed that gap; ggui's
+ * read-time mint (C2) made the read strictly fresher than the inlined
+ * copy; the vendor arm's only reason to exist was gone.
  */
 import type { AgBlock, JsonValue } from "@silverprotocol/core";
 import { type GguiRenderBootstrap } from "@ggui-ai/protocol/integrations/mcp-apps";
 import { type McpUiResourcePayload } from "./block-ui.js";
-export { asGguiRenderBootstrap, gguiShellHtml, } from "@ggui-ai/protocol/integrations/mcp-apps";
-export type { GguiRenderBootstrap, GguiShellHtmlOptions, } from "@ggui-ai/protocol/integrations/mcp-apps";
+export { 
+/** @deprecated import from `@ggui-ai/protocol/integrations/mcp-apps` (guuey#209; removed next minor). */
+asGguiRenderBootstrap, 
+/** @deprecated import from `@ggui-ai/protocol/integrations/mcp-apps` (guuey#209; removed next minor). */
+gguiShellHtml, } from "@ggui-ai/protocol/integrations/mcp-apps";
+export type { 
+/** @deprecated import from `@ggui-ai/protocol/integrations/mcp-apps` (guuey#209; removed next minor). */
+GguiRenderBootstrap, 
+/** @deprecated import from `@ggui-ai/protocol/integrations/mcp-apps` (guuey#209; removed next minor). */
+GguiShellHtmlOptions, } from "@ggui-ai/protocol/integrations/mcp-apps";
 /**
  * The `_meta` key the ggui render bootstrap rides on. Alias of the
  * protocol package's own constant — one spelling, owned upstream.
+ *
+ * @deprecated guuey#209 — nothing in this package reads `_meta` any more.
+ * Import `MCP_APP_AI_GGUI_RENDER_META_KEY` from
+ * `@ggui-ai/protocol/integrations/mcp-apps` if you still need the key.
+ * Removed in the minor after the one shipping this notice.
  */
 export declare const GGUI_RENDER_META_KEY: "ai.ggui/render";
-/** A ggui render recognised on a tool result: its resource uri + mount material. */
+/**
+ * A ggui render recognised on a tool result: its resource uri + mount material.
+ * @deprecated guuey#209 — the locator (`toolResultLocator`) is the whole
+ * recognition signal now; there is no descriptor to build. Removed next minor.
+ */
 export interface GguiRenderDescriptor {
     /** `uiData.resourceUri` — `ui://ggui/render/<sessionId>/<contractHash>`. */
     resourceUri: string;
@@ -75,6 +85,9 @@ export interface GguiRenderDescriptor {
  * The `ui://` scheme gate is deliberate: `uiData` is a general-purpose channel
  * (every `structuredContent` of a `_meta.ui`-stamped tool lands there), so a
  * bare `resourceUri` string is not on its own a claim of generative UI.
+ *
+ * @deprecated guuey#209 — use `toolResultLocator(block)`; the vendor arm is
+ * retired and nothing consumes the descriptor. Removed next minor.
  */
 export declare function asGguiRender(uiData: JsonValue | undefined, meta: JsonValue | undefined): GguiRenderDescriptor | undefined;
 /**
@@ -84,17 +97,28 @@ export declare function asGguiRender(uiData: JsonValue | undefined, meta: JsonVa
  * 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.
+ *
+ * @deprecated guuey#209 — use `toolResultLocator(block)`. Removed next minor.
  */
 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. */
+/**
+ * An untyped (persisted-snapshot) block → its ggui render descriptor, if it is one.
+ * @deprecated guuey#209 — use `snapshotViewMount(cardSnapshot)`, whose locator
+ * arm is the persisted path. Removed next minor.
+ */
 export declare function blockGguiRender(block: JsonValue): GguiRenderDescriptor | undefined;
 /**
  * A ggui render descriptor → the mountable resource the host's existing
  * mcp-ui path already knows how to mount, or `undefined` when the descriptor
  * carries no bootstrap (history cards, and any fold that dropped `_meta`).
  *
+ * @deprecated guuey#209 — resolve the locator through a `UiResourceReader`
+ * (`resolveViewMount`); ggui's `resources/read` returns the shell with
+ * live-channel material minted FRESH at read time, which this inlined
+ * copy could never be. Removed next minor.
+ *
  * The `uri` is the render's REAL `resourceUri` — the shell is the payload, not
  * a renaming of the resource.
  *

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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,eAAe,CAAC;AAExE,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"}
+{"version":3,"file":"ggui-render.d.ts","sourceRoot":"","sources":["../src/ggui-render.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;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,eAAe,CAAC;AAExE,OAAO;AACL,yGAAyG;AACzG,qBAAqB;AACrB,yGAAyG;AACzG,aAAa,GACd,MAAM,yCAAyC,CAAC;AACjD,YAAY;AACV,yGAAyG;AACzG,mBAAmB;AACnB,yGAAyG;AACzG,oBAAoB,GACrB,MAAM,yCAAyC,CAAC;AAEjD;;;;;;;;GAQG;AACH,eAAO,MAAM,oBAAoB,kBAAkC,CAAC;AAKpE;;;;GAIG;AACH,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;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,CAC1B,MAAM,EAAE,SAAS,GAAG,SAAS,EAC7B,IAAI,EAAE,SAAS,GAAG,SAAS,GAC1B,oBAAoB,GAAG,SAAS,CAUlC;AAED;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,OAAO,CAAC,OAAO,EAAE;IAAE,IAAI,EAAE,aAAa,CAAA;CAAE,CAAC,GAC/C,oBAAoB,GAAG,SAAS,CAElC;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,SAAS,GAAG,oBAAoB,GAAG,SAAS,CAIlF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,oBAAoB,GAC3B,oBAAoB,GAAG,SAAS,CAOlC"}