@ggui-ai/mcp-server 0.1.0-rc.1 → 0.2.0-alpha.1

package/README.md

@@ -19,7 +19,7 @@ The simplest way to start a server is the `ggui` CLI shipped by `@ggui-ai/cli`:
 npx @ggui-ai/cli serve
 ```
 
-`ggui serve` boots this package with the OSS defaults — in-memory session store
+`ggui serve` boots this package with the OSS defaults — in-memory render store
 (or SQLite when `better-sqlite3` is installed), no-auth dev posture, and every UI
 declared in `ggui.json` surfaced through the blueprint tools.
 

package/dist/build-mcp.d.ts

@@ -12,7 +12,7 @@ import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { type ZodRawShape } from 'zod';
 import type { HandlerContext, SharedHandler } from '@ggui-ai/mcp-server-handlers';
 import type { Logger } from './logger.js';
-import { type GguiSessionResourceTemplateOptions } from './mcp-apps-outbound.js';
+import { type GguiRenderResourceTemplateOptions } from './mcp-apps-outbound.js';
 export interface ServerInfo {
     readonly name: string;
     readonly version: string;
@@ -22,7 +22,7 @@ export interface BuildMcpServerOptions {
     /**
      * When set, register the MCP Apps outbound wiring on every fresh
      * server instance — advertises the `io.modelcontextprotocol/ui`
-     * capability and serves `ui://ggui/session` via `resources/read`.
+     * capability and serves `ui://ggui/render` via `resources/read`.
      *
      * Tool-declaration `_meta.ui.*` is INDEPENDENT of this flag; it's
      * carried per-handler on `SharedHandler._meta`. A server can stamp
@@ -32,26 +32,26 @@ export interface BuildMcpServerOptions {
      */
     readonly mcpAppsOutbound?: boolean;
     /**
-     * Optional override for the `ui://ggui/session` shell body. Defaults
+     * Optional override for the `ui://ggui/render` shell body. Defaults
      * to whatever shell the server was built with — either a placeholder
      * or the real thin-shell HTML.
      */
     readonly shellHtml?: string;
     /**
-     * Per-session self-contained shell options. When supplied,
+     * Per-render self-contained shell options. When supplied,
      * `installMcpAppsOutbound` ALSO registers
-     * `ui://ggui/session/{sessionId}` as a resource template — the URI
-     * `ggui_push.resultMeta` stamps on per-call `_meta.ui.resourceUri`
+     * `ui://ggui/render/{renderId}` as a resource template — the URI
+     * `ggui_render.resultMeta` stamps on per-call `_meta.ui.resourceUri`
      * for third-party MCP Apps hosts (Claude Desktop, claude.ai web)
      * that don't speak ggui's custom postMessage protocol.
      *
      * Absent → only the legacy postMessage shell is registered (first-
      * party hosts only).
      */
-    readonly selfContained?: GguiSessionResourceTemplateOptions;
+    readonly selfContained?: GguiRenderResourceTemplateOptions;
     /**
      * Public origin the server is reachable at — forwarded to
-     * `installMcpAppsOutbound` so the static `ui://ggui/session`
+     * `installMcpAppsOutbound` so the static `ui://ggui/render`
      * resource declares `_meta.ui.csp.{connectDomains,resourceDomains}`.
      * Without this, spec-compliant hosts (Claude Desktop, claude.ai
      * Connector, Claude Code) apply their default CSP (`connect-src

package/dist/build-mcp.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"build-mcp.d.ts","sourceRoot":"","sources":["../src/build-mcp.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AACpE,OAAO,EAAK,KAAK,WAAW,EAAE,MAAM,KAAK,CAAC;AAC1C,OAAO,KAAK,EACV,cAAc,EACd,aAAa,EACd,MAAM,8BAA8B,CAAC;AACtC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAC1C,OAAO,EAEL,KAAK,kCAAkC,EACxC,MAAM,wBAAwB,CAAC;AAEhC,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;CAC/B;AAED,MAAM,WAAW,qBAAqB;IACpC;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,eAAe,CAAC,EAAE,OAAO,CAAC;IACnC;;;;OAIG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,kCAAkC,CAAC;IAC5D;;;;;;;;;OASG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC;;;;;;;;;;;;;;;;;;OAkBG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,aAAa,CAAC,KAAK,GAAG,MAAM,GAAG,SAAS,CAAC,CAAC;IAElE;;;;;;;;;;;;;;OAcG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAE/B;;;;;;;;;;;;;;;;;;OAkBG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,aAAa,CAAC,CAAC,MAAM,EAAE,SAAS,KAAK,IAAI,CAAC,CAAC;CACtE;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,UAAU,EAChB,QAAQ,EAAE,aAAa,CAAC,aAAa,CAAC,WAAW,EAAE,WAAW,CAAC,CAAC,EAChE,UAAU,EAAE,MAAM,cAAc,EAChC,MAAM,EAAE,MAAM,EACd,IAAI,GAAE,qBAA0B,GAC/B,SAAS,CA6FX"}
+{"version":3,"file":"build-mcp.d.ts","sourceRoot":"","sources":["../src/build-mcp.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAEpE,OAAO,EAAK,KAAK,WAAW,EAAE,MAAM,KAAK,CAAC;AAC1C,OAAO,KAAK,EACV,cAAc,EACd,aAAa,EACd,MAAM,8BAA8B,CAAC;AACtC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAC1C,OAAO,EAEL,KAAK,iCAAiC,EACvC,MAAM,wBAAwB,CAAC;AAEhC,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;CAC/B;AAED,MAAM,WAAW,qBAAqB;IACpC;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,eAAe,CAAC,EAAE,OAAO,CAAC;IACnC;;;;OAIG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,iCAAiC,CAAC;IAC3D;;;;;;;;;OASG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC;;;;;;;;;;;;;;;;;;OAkBG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,aAAa,CAAC,KAAK,GAAG,MAAM,GAAG,SAAS,CAAC,CAAC;IAElE;;;;;;;;;;;;;;OAcG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAE/B;;;;;;;;;;;;;;;;;;OAkBG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,aAAa,CAAC,CAAC,MAAM,EAAE,SAAS,KAAK,IAAI,CAAC,CAAC;CACtE;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,UAAU,EAChB,QAAQ,EAAE,aAAa,CAAC,aAAa,CAAC,WAAW,EAAE,WAAW,CAAC,CAAC,EAChE,UAAU,EAAE,MAAM,cAAc,EAChC,MAAM,EAAE,MAAM,EACd,IAAI,GAAE,qBAA0B,GAC/B,SAAS,CA8IX"}

package/dist/build-mcp.js

@@ -9,6 +9,7 @@
  * tool return advertises its shape — wire consumers can trust the output.
  */
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { registerAppTool } from '@modelcontextprotocol/ext-apps/server';
 import { z } from 'zod';
 import { installMcpAppsOutbound, } from './mcp-apps-outbound.js';
 /**
@@ -56,17 +57,30 @@ export function buildMcpServer(info, handlers, getContext, logger, opts = {}) {
             && !handler.allowedFor.some((kind) => allowedKinds.includes(kind))) {
             continue;
         }
-        server.registerTool(handler.name, {
-            ...(handler.title ? { title: handler.title } : {}),
-            description: handler.description,
-            inputSchema: handler.inputSchema,
-            outputSchema: handler.outputSchema,
-            // Forward declaration-level `_meta` (e.g. `_meta.ui.resourceUri`
-            // / `_meta.ui.visibility` stamped by the MCP Apps outbound path).
-            // Opaque to the transport — hosts consume it per their own spec.
-            ...(handler._meta ? { _meta: handler._meta } : {}),
-        }, async (input) => {
-            const ctx = getContext();
+        const cb = async (input, extra) => {
+            // Thread per-request `_meta` AND the cancellation `signal` onto the
+            // canonical context. The MCP SDK already parses `params._meta` for
+            // us and exposes it on `RequestHandlerExtra._meta`; handlers that
+            // read host-channel slices (e.g. `ai.ggui/host-session` on
+            // `ggui_handshake`) pick it up via `ctx.requestMeta` without
+            // touching the SDK surface themselves. The same
+            // `RequestHandlerExtra` carries `signal: AbortSignal` — fired by
+            // the SDK on a `notifications/cancelled` from the caller OR on
+            // transport close (this server wires `res.on("close") →
+            // transport.close()`, which aborts every in-flight request
+            // handler). `ggui_consume` reads `ctx.signal` to break its
+            // long-poll promptly on a disconnected consumer, releasing the
+            // active-consumer count instead of zombie-holding it to the
+            // deadline. Both ride the canonical context without leaking the
+            // SDK type into the handlers package.
+            const baseCtx = getContext();
+            const ctx = {
+                ...baseCtx,
+                ...(extra?._meta !== undefined
+                    ? { requestMeta: extra._meta }
+                    : {}),
+                ...(extra?.signal !== undefined ? { signal: extra.signal } : {}),
+            };
             const start = Date.now();
             try {
                 const data = await handler.handler(input, ctx);
@@ -99,7 +113,34 @@ export function buildMcpServer(info, handlers, getContext, logger, opts = {}) {
                 });
                 throw err;
             }
-        });
+        };
+        const baseConfig = {
+            ...(handler.title ? { title: handler.title } : {}),
+            description: handler.description,
+            inputSchema: handler.inputSchema,
+            outputSchema: handler.outputSchema,
+        };
+        // Dispatch on declaration-level UI meta presence. `registerAppTool`
+        // (from `@modelcontextprotocol/ext-apps/server`) normalizes the
+        // legacy flat key — when `_meta.ui.resourceUri` is set, it also
+        // stamps `_meta["ui/resourceUri"]` for older hosts. Letting the
+        // canonical helper do that work means ggui handlers carry the
+        // single canonical key only; the helper owns the back-compat
+        // shape. Handlers without `_meta.ui` fall through to plain
+        // `registerTool` — the ext-apps helper requires `_meta.ui` to be
+        // typed.
+        if (handler._meta && 'ui' in handler._meta) {
+            registerAppTool(server, handler.name, {
+                ...baseConfig,
+                _meta: handler._meta,
+            }, cb);
+        }
+        else {
+            server.registerTool(handler.name, {
+                ...baseConfig,
+                ...(handler._meta ? { _meta: handler._meta } : {}),
+            }, cb);
+        }
     }
     return server;
 }

package/dist/console-auth.d.ts

@@ -33,7 +33,7 @@
  * so the cookie never leaves the console's origin in the first
  * place.
  *
- * Lifecycle. Cookie is minted at `POST /ggui/console/session-cookie`
+ * Lifecycle. Cookie is minted at `POST /ggui/console/render-cookie`
  * (operator posts a shortCode → server resolves → sets Set-Cookie).
  * Cookie is consumed at `GET /ws` upgrade (if the server composition
  * wires `cookieAuth` to the session-channel). Never mutated in
@@ -49,7 +49,7 @@ import type { IncomingHttpHeaders } from 'node:http';
 export declare const CONSOLE_COOKIE_NAME = "ggui_console_session";
 /**
  * Result of minting a cookie. Callers set the cookie on their response
- * (the cookie endpoint) and echo the bound `sessionId`/`appId` back in
+ * (the cookie endpoint) and echo the bound `renderId`/`appId` back in
  * the response body so the client SPA can bootstrap the viewer without
  * a follow-up round-trip.
  */
@@ -57,11 +57,11 @@ export interface DevtoolCookieMint {
     readonly cookieValue: string;
     readonly setCookieHeader: string;
     readonly expiresAt: number;
-    readonly sessionId: string;
+    readonly renderId: string;
     readonly appId: string;
 }
 export interface MintDevtoolCookieInput {
-    readonly sessionId: string;
+    readonly renderId: string;
     readonly appId: string;
     /** HMAC secret. Shared with bootstrap + session tokens by design. */
     readonly secret: string;
@@ -84,7 +84,7 @@ export interface MintDevtoolCookieInput {
     readonly sameSite?: 'Strict' | 'Lax' | 'None';
 }
 /**
- * Mint a cookie value bound to `{ sessionId, appId }` and the formatted
+ * Mint a cookie value bound to `{ renderId, appId }` and the formatted
  * `Set-Cookie` header to send on the response. Caller does
  * `res.setHeader('Set-Cookie', result.setCookieHeader)`.
  */
@@ -118,10 +118,10 @@ export declare function readDevtoolCookieFromHeaders(headers: IncomingHttpHeader
 /**
  * Verified claims extracted from an console cookie. Scope is
  * deliberately narrow: just the binding the session-channel upgrade
- * needs to enforce `subscribe.sessionId === cookie.sessionId`.
+ * needs to enforce `subscribe.renderId === cookie.renderId`.
  */
 export interface DevtoolCookieClaims {
-    readonly sessionId: string;
+    readonly renderId: string;
     readonly appId: string;
 }
 /**

package/dist/console-auth.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"console-auth.d.ts","sourceRoot":"","sources":["../src/console-auth.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,WAAW,CAAC;AAOrD;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,yBAAyB,CAAC;AAE1D;;;;;GAKG;AACH,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,qEAAqE;IACrE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,kDAAkD;IAClD,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB;;;;;OAKG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC;IAC1B,oCAAoC;IACpC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,QAAQ,GAAG,KAAK,GAAG,MAAM,CAAC;CAC/C;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,sBAAsB,GAC5B,iBAAiB,CAqBnB;AAED;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAClC,YAAY,EAAE,MAAM,GAAG,SAAS,GAC/B,MAAM,GAAG,IAAI,CAcf;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,4BAA4B,CAC1C,OAAO,EAAE,mBAAmB,GAC3B,MAAM,GAAG,IAAI,CAIf;AAED;;;;GAIG;AACH,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CACjC,WAAW,EAAE,MAAM,EACnB,MAAM,EAAE,MAAM,GACb,mBAAmB,GAAG,IAAI,CAO5B"}
+{"version":3,"file":"console-auth.d.ts","sourceRoot":"","sources":["../src/console-auth.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,WAAW,CAAC;AAOrD;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,yBAAyB,CAAC;AAE1D;;;;;GAKG;AACH,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,qEAAqE;IACrE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,kDAAkD;IAClD,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB;;;;;OAKG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC;IAC1B,oCAAoC;IACpC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,QAAQ,GAAG,KAAK,GAAG,MAAM,CAAC;CAC/C;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,sBAAsB,GAC5B,iBAAiB,CAqBnB;AAED;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAClC,YAAY,EAAE,MAAM,GAAG,SAAS,GAC/B,MAAM,GAAG,IAAI,CAcf;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,4BAA4B,CAC1C,OAAO,EAAE,mBAAmB,GAC3B,MAAM,GAAG,IAAI,CAIf;AAED;;;;GAIG;AACH,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CACjC,WAAW,EAAE,MAAM,EACnB,MAAM,EAAE,MAAM,GACb,mBAAmB,GAAG,IAAI,CAO5B"}

package/dist/console-auth.js

@@ -7,13 +7,13 @@ import { DEFAULT_DEVTOOL_SESSION_TTL_SEC, mintDevtoolSessionToken, verifyToken,
  */
 export const CONSOLE_COOKIE_NAME = 'ggui_console_session';
 /**
- * Mint a cookie value bound to `{ sessionId, appId }` and the formatted
+ * Mint a cookie value bound to `{ renderId, appId }` and the formatted
  * `Set-Cookie` header to send on the response. Caller does
  * `res.setHeader('Set-Cookie', result.setCookieHeader)`.
  */
 export function mintDevtoolCookie(input) {
     const ttlSec = input.ttlSec ?? DEFAULT_DEVTOOL_SESSION_TTL_SEC;
-    const { token, claims } = mintDevtoolSessionToken({ sessionId: input.sessionId, appId: input.appId, ttlSec }, input.secret);
+    const { token, claims } = mintDevtoolSessionToken({ renderId: input.renderId, appId: input.appId, ttlSec }, input.secret);
     const attrs = [
         `${CONSOLE_COOKIE_NAME}=${token}`,
         `Path=${input.path ?? '/'}`,
@@ -27,7 +27,7 @@ export function mintDevtoolCookie(input) {
         cookieValue: token,
         setCookieHeader: attrs.join('; '),
         expiresAt: claims.exp * 1000,
-        sessionId: input.sessionId,
+        renderId: input.renderId,
         appId: input.appId,
     };
 }
@@ -96,7 +96,7 @@ export function verifyDevtoolCookie(cookieValue, secret) {
     if (!result.ok)
         return null;
     return {
-        sessionId: result.claims.sessionId,
+        renderId: result.claims.renderId,
         appId: result.claims.appId,
     };
 }

package/dist/console-cache.d.ts

@@ -31,8 +31,8 @@
  *      may want a durable LLM trace (cost analysis) but a lossy cache
  *      trace (ops signal only). One file per sink keeps that swap lean.
  */
-import type { Express } from 'express';
-import type { CacheTraceEvent, CacheTraceSink } from '@ggui-ai/mcp-server-handlers/session-mutations';
+import type { CacheTraceEvent, CacheTraceSink } from "@ggui-ai/mcp-server-handlers/renders";
+import type { Express } from "express";
 /** SSE listener — receives one event per cache lookup. */
 type SseListener = (event: CacheTraceEvent) => void;
 /**

package/dist/console-cache.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"console-cache.d.ts","sourceRoot":"","sources":["../src/console-cache.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,OAAO,KAAK,EAAqB,OAAO,EAAE,MAAM,SAAS,CAAC;AAC1D,OAAO,KAAK,EACV,eAAe,EACf,cAAc,EACf,MAAM,gDAAgD,CAAC;AAGxD,0DAA0D;AAC1D,KAAK,WAAW,GAAG,CAAC,KAAK,EAAE,eAAe,KAAK,IAAI,CAAC;AAEpD;;;;;;;;;;GAUG;AACH,qBAAa,qBAAsB,YAAW,cAAc;IAC1D,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAClC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAyB;IAChD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA0B;gBAExC,IAAI,CAAC,EAAE;QAAE,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE;IAUjD,IAAI,CAAC,KAAK,EAAE,eAAe,GAAG,IAAI;IAclC;;;;OAIG;IACH,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,eAAe,EAAE;IAKjD,iEAAiE;IACjE,SAAS,CAAC,QAAQ,EAAE,WAAW,GAAG,MAAM,IAAI;IAO5C,uEAAuE;IACvE,aAAa,IAAI,MAAM;IAIvB,qEAAqE;IACrE,IAAI,IAAI,MAAM;CAGf;AAED;;;;;GAKG;AACH,wBAAgB,uBAAuB,CACrC,GAAG,EAAE,OAAO,EACZ,IAAI,EAAE,qBAAqB,GAC1B,IAAI,CA8CN"}
+{"version":3,"file":"console-cache.d.ts","sourceRoot":"","sources":["../src/console-cache.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,sCAAsC,CAAC;AAC5F,OAAO,KAAK,EAAE,OAAO,EAAqB,MAAM,SAAS,CAAC;AAG1D,0DAA0D;AAC1D,KAAK,WAAW,GAAG,CAAC,KAAK,EAAE,eAAe,KAAK,IAAI,CAAC;AAEpD;;;;;;;;;;GAUG;AACH,qBAAa,qBAAsB,YAAW,cAAc;IAC1D,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAClC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAyB;IAChD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA0B;gBAExC,IAAI,CAAC,EAAE;QAAE,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE;IAQjD,IAAI,CAAC,KAAK,EAAE,eAAe,GAAG,IAAI;IAclC;;;;OAIG;IACH,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,eAAe,EAAE;IAKjD,iEAAiE;IACjE,SAAS,CAAC,QAAQ,EAAE,WAAW,GAAG,MAAM,IAAI;IAO5C,uEAAuE;IACvE,aAAa,IAAI,MAAM;IAIvB,qEAAqE;IACrE,IAAI,IAAI,MAAM;CAGf;AAED;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,OAAO,EAAE,IAAI,EAAE,qBAAqB,GAAG,IAAI,CAwCvF"}

package/dist/console-cache.js

@@ -1,4 +1,4 @@
-import { applyDevtoolSecurityHeaders } from './console-headers.js';
+import { applyDevtoolSecurityHeaders } from "./console-headers.js";
 /**
  * In-memory ring buffer + listener fanout. Implements
  * {@link CacheTraceSink} so it can be passed to
@@ -68,11 +68,11 @@ export class BoundedCacheTraceSink {
  */
 export function mountConsoleCacheRoutes(app, sink) {
     // GET /ggui/console/cache/recent?limit=<n> — JSON snapshot.
-    app.get('/ggui/console/cache/recent', (req, res) => {
+    app.get("/ggui/console/cache/recent", (req, res) => {
         applyDevtoolSecurityHeaders(res);
-        const limitRaw = req.query['limit'];
+        const limitRaw = req.query["limit"];
         let limit = 100;
-        if (typeof limitRaw === 'string') {
+        if (typeof limitRaw === "string") {
             const parsed = Number.parseInt(limitRaw, 10);
             if (Number.isFinite(parsed) && parsed > 0) {
                 limit = Math.min(500, parsed);
@@ -83,21 +83,21 @@ export function mountConsoleCacheRoutes(app, sink) {
     // GET /ggui/console/cache/stream — SSE live stream.
     // Heartbeat comment every 15s so reverse proxies don't kill the
     // connection on idle. Client cleanup unregisters the listener.
-    app.get('/ggui/console/cache/stream', (req, res) => {
+    app.get("/ggui/console/cache/stream", (req, res) => {
         applyDevtoolSecurityHeaders(res);
-        res.setHeader('content-type', 'text/event-stream');
-        res.setHeader('cache-control', 'no-store');
-        res.setHeader('connection', 'keep-alive');
+        res.setHeader("content-type", "text/event-stream");
+        res.setHeader("cache-control", "no-store");
+        res.setHeader("connection", "keep-alive");
         // Flush headers immediately so the EventSource starts receiving.
         res.flushHeaders?.();
         const heartbeat = setInterval(() => {
             // SSE comment frame — clients ignore but proxies see traffic.
-            res.write(': ping\n\n');
+            res.write(": ping\n\n");
         }, 15000);
         const off = sink.subscribe((event) => {
             res.write(`data: ${JSON.stringify(event)}\n\n`);
         });
-        req.on('close', () => {
+        req.on("close", () => {
             clearInterval(heartbeat);
             off();
         });

package/dist/console-headers.d.ts

@@ -32,7 +32,7 @@
  *     neither enables `eval` / `new Function` (that needs
  *     `'unsafe-eval'`, which is explicitly absent).
  *
- *     `<ggui-shell-hash>` is `GGUI_SESSION_SHELL_SCRIPT_HASH` from
+ *     `<ggui-shell-hash>` is `GGUI_RENDER_SHELL_SCRIPT_HASH` from
  *     `mcp-apps-outbound.ts` — the sha-256 source-expression
  *     authorising the inline `<script>` block of the production thin
  *     shell `<McpAppIframe>` mounts via `srcdoc`. `srcdoc` iframes
@@ -55,7 +55,7 @@
  *     door to inline `<script>` or `<style>` blocks (different CSP
  *     directive). Scoped, not dangerous.
  *   - `connect-src 'self'` — covers both same-origin `fetch()` to
- *     `/ggui/console/session-cookie` and the `new WebSocket('/ws')`
+ *     `/ggui/console/render-cookie` and the `new WebSocket('/ws')`
  *     upgrade. CSP Level 3 treats `'self'` as matching the document's
  *     origin across http/https/ws/wss, which is exactly the scope.
  *   - `img-src 'self' data:` — no images in the minimal viewer today,

package/dist/console-headers.js

@@ -1,4 +1,4 @@
-import { GGUI_SESSION_SHELL_SCRIPT_HASH } from './mcp-apps-outbound.js';
+import { GGUI_RENDER_SHELL_SCRIPT_HASH } from './mcp-apps-outbound.js';
 /**
  * The CSP directive string. Exported so tests can assert against the
  * exact shape without hard-coding the directive order inside the test
@@ -7,7 +7,7 @@ import { GGUI_SESSION_SHELL_SCRIPT_HASH } from './mcp-apps-outbound.js';
  */
 export const DEVTOOL_CSP = [
     "default-src 'none'",
-    `script-src 'self' blob: data: ${GGUI_SESSION_SHELL_SCRIPT_HASH}`,
+    `script-src 'self' blob: data: ${GGUI_RENDER_SHELL_SCRIPT_HASH}`,
     // Google Fonts CDN allowlisted for the brand-kit Inter + Geist Mono
     // pair used by the public welcome page (`/`). The same allowlist
     // applies to every console-served HTML — every page may opt to load

package/dist/console-payloads.d.ts

@@ -15,13 +15,13 @@
  *     as they fire. Heartbeat every 15s to keep proxies awake.
  *
  * **Memory bound.** Default capacity = 100 events (vs LlmTraceSink's
- * 200). Each `ggui_push` payload may carry full componentCode, base64
+ * 200). Each `ggui_render` payload may carry full componentCode, base64
  * blobs, or a fat `story.context`, so cap is tighter to keep peak
  * memory bounded. At ~50 KB / event the worst-case ring is ~5 MB.
  * Operator can override at construction.
  */
-import type { Express } from 'express';
-import type { PayloadTraceEvent, PayloadTraceSink } from '@ggui-ai/mcp-server-handlers/session-mutations';
+import type { PayloadTraceEvent, PayloadTraceSink } from "@ggui-ai/mcp-server-handlers/renders";
+import type { Express } from "express";
 /** SSE listener — receives one event per accepted payload. */
 type SseListener = (event: PayloadTraceEvent) => void;
 /**

package/dist/console-payloads.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"console-payloads.d.ts","sourceRoot":"","sources":["../src/console-payloads.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,OAAO,KAAK,EAAqB,OAAO,EAAE,MAAM,SAAS,CAAC;AAC1D,OAAO,KAAK,EACV,iBAAiB,EACjB,gBAAgB,EACjB,MAAM,gDAAgD,CAAC;AAGxD,8DAA8D;AAC9D,KAAK,WAAW,GAAG,CAAC,KAAK,EAAE,iBAAiB,KAAK,IAAI,CAAC;AAEtD;;;;;;;;;;GAUG;AACH,qBAAa,uBAAwB,YAAW,gBAAgB;IAC9D,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAClC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA2B;IAClD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA0B;gBAExC,IAAI,CAAC,EAAE;QAAE,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE;IAUjD,IAAI,CAAC,KAAK,EAAE,iBAAiB,GAAG,IAAI;IAcpC;;;;OAIG;IACH,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,iBAAiB,EAAE;IAKnD,iEAAiE;IACjE,SAAS,CAAC,QAAQ,EAAE,WAAW,GAAG,MAAM,IAAI;IAO5C,uEAAuE;IACvE,aAAa,IAAI,MAAM;IAIvB,qEAAqE;IACrE,IAAI,IAAI,MAAM;CAGf;AAED;;;;;GAKG;AACH,wBAAgB,0BAA0B,CACxC,GAAG,EAAE,OAAO,EACZ,IAAI,EAAE,uBAAuB,GAC5B,IAAI,CA8CN"}
+{"version":3,"file":"console-payloads.d.ts","sourceRoot":"","sources":["../src/console-payloads.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,OAAO,KAAK,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,sCAAsC,CAAC;AAChG,OAAO,KAAK,EAAE,OAAO,EAAqB,MAAM,SAAS,CAAC;AAG1D,8DAA8D;AAC9D,KAAK,WAAW,GAAG,CAAC,KAAK,EAAE,iBAAiB,KAAK,IAAI,CAAC;AAEtD;;;;;;;;;;GAUG;AACH,qBAAa,uBAAwB,YAAW,gBAAgB;IAC9D,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAClC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA2B;IAClD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA0B;gBAExC,IAAI,CAAC,EAAE;QAAE,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE;IAQjD,IAAI,CAAC,KAAK,EAAE,iBAAiB,GAAG,IAAI;IAcpC;;;;OAIG;IACH,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,iBAAiB,EAAE;IAKnD,iEAAiE;IACjE,SAAS,CAAC,QAAQ,EAAE,WAAW,GAAG,MAAM,IAAI;IAO5C,uEAAuE;IACvE,aAAa,IAAI,MAAM;IAIvB,qEAAqE;IACrE,IAAI,IAAI,MAAM;CAGf;AAED;;;;;GAKG;AACH,wBAAgB,0BAA0B,CAAC,GAAG,EAAE,OAAO,EAAE,IAAI,EAAE,uBAAuB,GAAG,IAAI,CAwC5F"}

package/dist/console-payloads.js

@@ -1,4 +1,4 @@
-import { applyDevtoolSecurityHeaders } from './console-headers.js';
+import { applyDevtoolSecurityHeaders } from "./console-headers.js";
 /**
  * In-memory ring buffer + listener fanout. Implements
  * {@link PayloadTraceSink} so it can be passed to
@@ -68,11 +68,11 @@ export class BoundedPayloadTraceSink {
  */
 export function mountConsolePayloadsRoutes(app, sink) {
     // GET /ggui/console/payloads/recent?limit=<n> — JSON snapshot.
-    app.get('/ggui/console/payloads/recent', (req, res) => {
+    app.get("/ggui/console/payloads/recent", (req, res) => {
         applyDevtoolSecurityHeaders(res);
-        const limitRaw = req.query['limit'];
+        const limitRaw = req.query["limit"];
         let limit = 100;
-        if (typeof limitRaw === 'string') {
+        if (typeof limitRaw === "string") {
             const parsed = Number.parseInt(limitRaw, 10);
             if (Number.isFinite(parsed) && parsed > 0) {
                 limit = Math.min(500, parsed);
@@ -83,21 +83,21 @@ export function mountConsolePayloadsRoutes(app, sink) {
     // GET /ggui/console/payloads/stream — SSE live stream.
     // Heartbeat comment every 15s so reverse proxies don't kill the
     // connection on idle. Client cleanup unregisters the listener.
-    app.get('/ggui/console/payloads/stream', (req, res) => {
+    app.get("/ggui/console/payloads/stream", (req, res) => {
         applyDevtoolSecurityHeaders(res);
-        res.setHeader('content-type', 'text/event-stream');
-        res.setHeader('cache-control', 'no-store');
-        res.setHeader('connection', 'keep-alive');
+        res.setHeader("content-type", "text/event-stream");
+        res.setHeader("cache-control", "no-store");
+        res.setHeader("connection", "keep-alive");
         // Flush headers immediately so the EventSource starts receiving.
         res.flushHeaders?.();
         const heartbeat = setInterval(() => {
             // SSE comment frame — clients ignore but proxies see traffic.
-            res.write(': ping\n\n');
+            res.write(": ping\n\n");
         }, 15000);
         const off = sink.subscribe((event) => {
             res.write(`data: ${JSON.stringify(event)}\n\n`);
         });
-        req.on('close', () => {
+        req.on("close", () => {
             clearInterval(heartbeat);
             off();
         });

package/dist/console-timeline.d.ts

@@ -1,45 +1,27 @@
 /**
- * Console-facing session-event timeline endpoints powering
- * `/devtools/timeline` in the @ggui-ai/console SPA.
+ * Console timeline routes — `GET /ggui/console/timeline/*`.
  *
- * Unlike `/devtools/llm-trace`, the timeline does NOT introduce a new
- * sink — every event the operator wants to step through already
- * exists in the {@link SessionStore} (inbound user
- * actions + tool calls + UI mutations) and the
- * {@link SessionStreamBuffer} (outbound stream cursor). This module is
- * a thin read-only window over both.
+ * Read-only event-log inspector. Lists rendered surfaces (renders) the
+ * server has materialized, drills into the per-render event ledger for
+ * a single id, and exposes the live-channel outbound cursor alongside
+ * for diagnostic context.
  *
- * **Two surfaces, both admin-gated:**
+ * Post-Phase-B (flatten-render-identity): renamed from the prior
+ * "sessions" terminology; the canonical addressable unit is now the
+ * render. The on-wire `renderId` path param replaces `sessionId`.
  *
- *   - `GET /ggui/console/timeline/sessions` — list of sessions visible
- *     to the timeline picker. All statuses (active / completed /
- *     expired) — operators frequently want to debug a session AFTER it
- *     terminated. Sorted most-recent-`lastActivityAt` first; defaults
- *     to 50 rows, clamped to [1, 200] via `?limit=`.
- *
- *   - `GET /ggui/console/timeline/:sessionId/events` — the full event
- *     log for one session, oldest-first, drained from
- *     `sessionStore.observe(id, { tail: false })`. Also reports the
- *     outbound stream cursor (`streamBuffer.currentSeq`) so the
- *     operator can see live-channel progress without a separate fetch.
- *
- * Why REST-only (no SSE): replay is a snapshot. The operator picks a
- * session and steps through what happened — they want a stable frozen
- * view, not a live tail. SSE would force the scrubber to keep chasing
- * a moving end-of-stream and complicate the UI without paying for it.
- *
- * Memory: bounded by whatever the underlying SessionStore retains.
- * `InMemorySessionStore` keeps everything for the process lifetime —
+ * Memory: bounded by whatever the underlying RenderStore retains.
+ * `InMemoryRenderStore` keeps everything for the process lifetime —
  * fine for OSS dev. A hosted closed runtime's persistent store is the
  * durability surface.
  */
 import type { Express } from 'express';
-import type { SessionStore, SessionStreamBuffer } from '@ggui-ai/mcp-server-core';
+import type { RenderStore, SessionStreamBuffer } from '@ggui-ai/mcp-server-core';
 /**
  * Mount `/ggui/console/timeline/*` routes on `app`. Caller is
  * responsible for admin-gating the path prefix beforehand — this
  * function does not re-implement auth (matches the
  * `mountConsoleLlmTraceRoutes` shape in console-llm-trace.ts).
  */
-export declare function mountConsoleTimelineRoutes(app: Express, sessionStore: SessionStore | undefined, streamBuffer: SessionStreamBuffer | undefined): void;
+export declare function mountConsoleTimelineRoutes(app: Express, renderStore: RenderStore | undefined, streamBuffer: SessionStreamBuffer | undefined): void;
 //# sourceMappingURL=console-timeline.d.ts.map

package/dist/console-timeline.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"console-timeline.d.ts","sourceRoot":"","sources":["../src/console-timeline.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,OAAO,KAAK,EAAqB,OAAO,EAAE,MAAM,SAAS,CAAC;AAC1D,OAAO,KAAK,EAEV,YAAY,EACZ,mBAAmB,EACpB,MAAM,0BAA0B,CAAC;AAkElC;;;;;GAKG;AACH,wBAAgB,0BAA0B,CACxC,GAAG,EAAE,OAAO,EACZ,YAAY,EAAE,YAAY,GAAG,SAAS,EACtC,YAAY,EAAE,mBAAmB,GAAG,SAAS,GAC5C,IAAI,CA8JN"}
+{"version":3,"file":"console-timeline.d.ts","sourceRoot":"","sources":["../src/console-timeline.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,KAAK,EAAqB,OAAO,EAAE,MAAM,SAAS,CAAC;AAC1D,OAAO,KAAK,EAEV,WAAW,EACX,mBAAmB,EACpB,MAAM,0BAA0B,CAAC;AAiElC;;;;;GAKG;AACH,wBAAgB,0BAA0B,CACxC,GAAG,EAAE,OAAO,EACZ,WAAW,EAAE,WAAW,GAAG,SAAS,EACpC,YAAY,EAAE,mBAAmB,GAAG,SAAS,GAC5C,IAAI,CA6JN"}