@frontmcp/ui 0.5.1 → 0.6.0

package/esm/registry/render-template.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Template Rendering
+ *
+ * Executes tool UI templates with proper context and helpers.
+ * Supports sync rendering for HTML strings/template functions,
+ * async rendering for React components via SSR, and MDX rendering.
+ *
+ * @packageDocumentation
+ */
+import type { UITemplateConfig, TemplateBuilderFn } from '../types';
+/**
+ * Check if a string contains MDX syntax (Markdown + JSX).
+ *
+ * Looks for:
+ * - JSX component tags (PascalCase): `<Component />`
+ * - JS expressions: `{variable}` or `{items.map(...)}`
+ * - Import/export statements
+ * - Frontmatter: `---\n...\n---`
+ */
+export declare function containsMdxSyntax(source: string): boolean;
+/**
+ * Check if a template is a React component (not a template builder function).
+ *
+ * React components are distinguished from template builder functions by:
+ * - Having $$typeof symbol (React.memo, forwardRef, etc.)
+ * - Having prototype.isReactComponent (class components)
+ * - PascalCase naming convention (function components)
+ *
+ * Template builder functions take (ctx) and return a string, while
+ * React components take props and return JSX.Element.
+ */
+export declare function isReactComponent(template: unknown): boolean;
+/**
+ * Options for rendering a tool template.
+ */
+export interface RenderTemplateOptions {
+    /** The template configuration from the tool */
+    template: TemplateBuilderFn<unknown, unknown> | string | ((props: any) => any);
+    /** Tool input arguments */
+    input: Record<string, unknown>;
+    /** Tool output (raw result from execute) */
+    output: unknown;
+    /** Structured content parsed from output */
+    structuredContent?: unknown;
+    /** Custom MDX components to use in MDX templates */
+    mdxComponents?: Record<string, any>;
+}
+/**
+ * Render a tool UI template.
+ *
+ * @param options - Template and context data
+ * @returns Rendered HTML string
+ * @throws Error if template execution fails
+ */
+export declare function renderToolTemplate(options: RenderTemplateOptions): string;
+/**
+ * Check if a tool has UI configuration.
+ * Uses loose typing to handle variance issues with generic tool metadata.
+ */
+export declare function hasUIConfig(metadata: {
+    ui?: unknown;
+}): metadata is {
+    ui: UITemplateConfig<unknown, unknown>;
+};
+/**
+ * Render a tool UI template asynchronously.
+ *
+ * This version supports:
+ * - React components via SSR
+ * - MDX strings (Markdown + JSX) via @mdx-js/mdx
+ * - HTML strings and template builder functions
+ *
+ * For React components:
+ * - Dynamically imports react and react-dom/server
+ * - Uses renderToString for SSR
+ * - React components receive the template context as props
+ *
+ * For MDX templates:
+ * - Detects MDX syntax (Markdown headers, JSX components, expressions)
+ * - Compiles and renders via @frontmcp/ui's MDX renderer
+ *
+ * Error handling behavior by environment:
+ * - **Production**: Logs warning and returns `null` for graceful degradation (no UI)
+ * - **Development/Test**: Logs error and throws for visibility and debugging
+ *
+ * @param options - Template and context data
+ * @returns Promise resolving to rendered HTML string, or `null` in production on error
+ * @throws Error if template execution or rendering fails (development/test only)
+ */
+export declare function renderToolTemplateAsync(options: RenderTemplateOptions): Promise<string | null>;
+//# sourceMappingURL=render-template.d.ts.map

package/esm/registry/render-template.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"render-template.d.ts","sourceRoot":"","sources":["../../../src/registry/render-template.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAmB,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAGrF;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAsCzD;AAkCD;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,OAAO,GAAG,OAAO,CAyB3D;AAED;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,+CAA+C;IAE/C,QAAQ,EAAE,iBAAiB,CAAC,OAAO,EAAE,OAAO,CAAC,GAAG,MAAM,GAAG,CAAC,CAAC,KAAK,EAAE,GAAG,KAAK,GAAG,CAAC,CAAC;IAC/E,2BAA2B;IAC3B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/B,4CAA4C;IAC5C,MAAM,EAAE,OAAO,CAAC;IAChB,4CAA4C;IAC5C,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,oDAAoD;IAEpD,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CACrC;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,qBAAqB,GAAG,MAAM,CAuBzE;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,QAAQ,EAAE;IAAE,EAAE,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,QAAQ,IAAI;IAAE,EAAE,EAAE,gBAAgB,CAAC,OAAO,EAAE,OAAO,CAAC,CAAA;CAAE,CAG9G;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAsB,uBAAuB,CAAC,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CA4FpG"}

package/esm/registry/tool-ui.registry.d.ts

@@ -0,0 +1,294 @@
+/**
+ * Tool UI Registry
+ *
+ * Manages UI template rendering for tool responses.
+ * Provides platform-specific metadata generation for MCP clients.
+ *
+ * Three serving modes:
+ * - **inline**: HTML is rendered per-request and embedded in _meta['ui/html']
+ * - **static**: Static widget is pre-compiled at startup, client fetches via resources/read
+ * - **hybrid**: Shell (React + renderer) cached at startup, component + data in response
+ *
+ * @packageDocumentation
+ */
+import type { UITemplateConfig, WidgetManifest, BuildManifestResult } from '../types';
+import type { AIPlatformType, UIMetadata } from '../adapters';
+/**
+ * Options for renderAndRegisterAsync (inline mode).
+ */
+export interface RenderOptions {
+    /** Tool name */
+    toolName: string;
+    /** Unique request identifier */
+    requestId: string;
+    /** Tool input arguments */
+    input: Record<string, unknown>;
+    /** Raw tool output */
+    output: unknown;
+    /** Structured content (parsed from output) */
+    structuredContent?: unknown;
+    /** Tool UI configuration */
+    uiConfig: UITemplateConfig;
+    /** Detected platform type */
+    platformType: AIPlatformType;
+    /** Widget access token (optional) */
+    token?: string;
+    /** Direct URL for widget serving (optional) */
+    directUrl?: string;
+}
+/**
+ * Result of rendering UI for inline mode.
+ */
+export interface UIRenderResult {
+    /** Rendered HTML content */
+    html: string;
+    /** Platform-specific metadata for _meta field */
+    meta: UIMetadata;
+}
+/**
+ * Result when UI rendering fails in production (graceful degradation).
+ * The caller should proceed without UI metadata.
+ */
+export interface UIRenderFailure {
+    /** Indicates rendering failed */
+    success: false;
+    /** Reason for failure (for logging, not exposed to client) */
+    reason: string;
+}
+/**
+ * Type guard to check if a render result is a failure.
+ *
+ * @param result - The result to check
+ * @returns true if the result is a UIRenderFailure
+ *
+ * @example
+ * ```typescript
+ * const result = await registry.renderAndRegisterAsync(options);
+ * if (isUIRenderFailure(result)) {
+ *   // Handle graceful degradation - proceed without UI
+ *   console.log('UI rendering failed:', result.reason);
+ *   return;
+ * }
+ * // result is UIRenderResult, has html and meta
+ * const { html, meta } = result;
+ * ```
+ */
+export declare function isUIRenderFailure(result: UIRenderResult | UIRenderFailure): result is UIRenderFailure;
+/**
+ * ToolUIRegistry manages UI template rendering for tool responses.
+ *
+ * It provides:
+ * - Static widget compilation for static mode (pre-compiled at startup)
+ * - Per-request HTML rendering for inline mode (embedded in _meta)
+ * - Platform-specific _meta generation
+ * - Widget manifest management
+ *
+ * @example
+ * ```typescript
+ * const registry = new ToolUIRegistry();
+ *
+ * // For inline mode: render HTML per-request
+ * const result = await registry.renderAndRegisterAsync({
+ *   toolName: 'get_weather',
+ *   requestId: 'abc123',
+ *   input: { location: 'London' },
+ *   output: { temp: 72, conditions: 'Sunny' },
+ *   uiConfig: tool.metadata.ui,
+ *   platformType: 'openai',
+ * });
+ *
+ * // result.meta can be spread into tool result _meta
+ * return { content: [...], _meta: { ...result.meta } };
+ * ```
+ */
+/**
+ * Options for compiling a static widget.
+ */
+export interface CompileStaticWidgetOptions {
+    /** Tool name (used for cache key and URI) */
+    toolName: string;
+    /** The template to compile (React component, HTML string, or builder function) */
+    template: UITemplateConfig['template'];
+    /** Tool UI configuration */
+    uiConfig: UITemplateConfig;
+}
+/**
+ * Payload for hybrid mode component delivery.
+ * Sent in `_meta['ui/component']` at tool call time.
+ */
+export interface HybridComponentPayload {
+    /** Transpiled component JavaScript code (ES module format) */
+    code: string;
+    /** Renderer type for the component */
+    type: 'react' | 'mdx' | 'html';
+    /** Tool name for identification */
+    toolName: string;
+    /** Content hash for cache validation */
+    hash: string;
+}
+/**
+ * Options for building a hybrid component payload.
+ */
+export interface BuildHybridComponentPayloadOptions {
+    /** Tool name */
+    toolName: string;
+    /** The template to transpile */
+    template: UITemplateConfig['template'];
+    /** Tool UI configuration */
+    uiConfig: UITemplateConfig;
+}
+export declare class ToolUIRegistry {
+    /**
+     * Cache for static widgets (keyed by tool name).
+     * Static widgets are pre-compiled at server startup for tools with servingMode: 'static'.
+     * These widgets read data from the FrontMCP Bridge at runtime (window.openai.toolOutput).
+     */
+    private readonly staticWidgetCache;
+    /**
+     * Cache for widget manifests (keyed by tool name).
+     * Manifests describe the widget's renderer type, CSP, and other metadata.
+     */
+    private readonly manifestCache;
+    /**
+     * Cache for build results (keyed by tool name).
+     * Includes HTML, manifest, and hash for cache validation.
+     */
+    private readonly buildResultCache;
+    /**
+     * Compile a static widget template for a tool at server startup.
+     *
+     * For tools with `servingMode: 'static'`, the widget HTML is pre-compiled
+     * WITHOUT embedded data. The widget reads data from the FrontMCP Bridge at runtime
+     * (via window.openai.toolOutput or window.__frontmcp.toolOutput).
+     *
+     * This is called during tool registration, not during tool calls.
+     *
+     * @param options - Static widget compilation options
+     */
+    compileStaticWidgetAsync(options: CompileStaticWidgetOptions): Promise<void>;
+    /**
+     * Compile a lean widget shell for inline mode tools at server startup.
+     *
+     * For tools with `servingMode: 'inline'`, we create a minimal HTML shell that:
+     * - Contains only HTML structure, theme CSS, and fonts
+     * - NO React runtime, NO component code, NO bridge
+     * - OpenAI caches this at discovery time
+     * - The actual React widget comes in each tool response with embedded data
+     *
+     * @param options - Options for lean widget compilation
+     */
+    compileLeanWidgetAsync(options: {
+        toolName: string;
+        uiConfig: UITemplateConfig;
+    }): void;
+    /**
+     * Compile a hybrid widget shell at server startup.
+     *
+     * For tools with `servingMode: 'hybrid'`, we create a shell that:
+     * - Contains React 19 runtime from esm.sh CDN
+     * - Contains FrontMCP Bridge (universal)
+     * - Contains all FrontMCP hooks (useMcpBridgeContext, useToolOutput, etc.)
+     * - Contains all FrontMCP UI components (Card, Badge, Button)
+     * - Contains dynamic renderer script that imports components via blob URL
+     * - NO component code (comes at tool call time via `_meta['ui/component']`)
+     *
+     * The shell listens for `ui/component` in tool response metadata and dynamically
+     * imports the transpiled component code, then renders it with tool output data.
+     *
+     * @param options - Options for hybrid widget compilation
+     */
+    compileHybridWidgetAsync(options: {
+        toolName: string;
+        uiConfig: UITemplateConfig;
+    }): void;
+    /**
+     * Build a component payload for hybrid mode tool responses.
+     *
+     * For tools with `servingMode: 'hybrid'`, this method is called at tool call time
+     * to build the transpiled component code that gets delivered in `_meta['ui/component']`.
+     *
+     * The component code is in ES module format so it can be dynamically imported
+     * via blob URL in the hybrid shell's renderer.
+     *
+     * @param options - Options for building the component payload
+     * @returns The hybrid component payload, or undefined if template is not a function
+     */
+    buildHybridComponentPayload(options: BuildHybridComponentPayloadOptions): HybridComponentPayload | undefined;
+    /**
+     * Get the pre-compiled static widget HTML for a tool.
+     *
+     * @param toolName - The tool name to look up
+     * @returns Pre-compiled widget HTML, or undefined if not cached
+     */
+    getStaticWidget(toolName: string): string | undefined;
+    /**
+     * Check if a tool has a pre-compiled static widget.
+     *
+     * @param toolName - The tool name to check
+     * @returns true if the tool has a cached static widget
+     */
+    hasStaticWidget(toolName: string): boolean;
+    /**
+     * Get the widget manifest for a tool.
+     *
+     * @param toolName - The tool name to look up
+     * @returns Widget manifest, or undefined if not cached
+     */
+    getManifest(toolName: string): WidgetManifest | undefined;
+    /**
+     * Check if a tool has a cached manifest.
+     *
+     * @param toolName - The tool name to check
+     * @returns true if the tool has a cached manifest
+     */
+    hasManifest(toolName: string): boolean;
+    /**
+     * Get the full build result for a tool.
+     *
+     * @param toolName - The tool name to look up
+     * @returns Build result, or undefined if not cached
+     */
+    getBuildResult(toolName: string): BuildManifestResult | undefined;
+    /**
+     * Detect the UI type for a template.
+     *
+     * @param template - The template to analyze
+     * @returns Detected UI type
+     */
+    detectUIType(template: UITemplateConfig['template']): string;
+    /**
+     * Render a tool's UI template for inline mode.
+     *
+     * This version supports all template types including React components.
+     * The rendered HTML is embedded directly in _meta['ui/html'] for the client.
+     *
+     * For React/MDX components, the output is wrapped using wrapStaticWidgetUniversal
+     * which includes the React 19 CDN, client-side rendering script, and all the
+     * FrontMCP hooks/components. This provides the same rendering capability as
+     * static mode, but with data embedded in each response.
+     *
+     * Error handling:
+     * - **Production**: Returns `UIRenderFailure` on error (graceful degradation)
+     * - **Development/Test**: Throws error for visibility and debugging
+     *
+     * @param options - Rendering options
+     * @returns Promise resolving to render result with HTML and metadata, or failure on error
+     */
+    renderAndRegisterAsync(options: RenderOptions): Promise<UIRenderResult | UIRenderFailure>;
+    /**
+     * Build component code string for embedding in widget HTML.
+     *
+     * @param template - The React component
+     * @param toolName - Tool name for naming the component
+     * @returns JavaScript code string that defines and registers the component
+     */
+    private buildComponentCode;
+    /**
+     * Check if a template requires async rendering (e.g., React components).
+     *
+     * @param template - The template to check
+     * @returns true if the template requires async rendering
+     */
+    requiresAsyncRendering(template: UITemplateConfig['template']): boolean;
+}
+//# sourceMappingURL=tool-ui.registry.d.ts.map

package/esm/registry/tool-ui.registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-ui.registry.d.ts","sourceRoot":"","sources":["../../../src/registry/tool-ui.registry.ts"],"names":[],"mappings":"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"}

package/esm/registry/uri-utils.d.ts

@@ -0,0 +1,56 @@
+/**
+ * UI Resource URI Utilities
+ *
+ * Standalone utilities for parsing and building ui:// resource URIs.
+ * Used for static widget serving mode where widgets are pre-compiled
+ * at startup and fetched via resources/read.
+ *
+ * @packageDocumentation
+ */
+import type { AIPlatformType } from '../adapters';
+/**
+ * UI resource URI scheme
+ */
+export declare const UI_RESOURCE_SCHEME = "ui://";
+/**
+ * Parsed static widget URI
+ */
+export interface ParsedWidgetUri {
+    toolName: string;
+    fullUri: string;
+}
+/**
+ * Check if a URI is a UI resource URI
+ *
+ * @param uri - URI to check
+ * @returns True if the URI starts with ui://
+ */
+export declare function isUIResourceUri(uri: string): boolean;
+/**
+ * Parse a static widget URI into its components
+ *
+ * @param uri - URI to parse (format: ui://widget/{toolName}.html)
+ * @returns Parsed components or undefined if invalid
+ */
+export declare function parseWidgetUri(uri: string): ParsedWidgetUri | undefined;
+/**
+ * Check if URI is a static widget URI (ui://widget/{toolName}.html)
+ */
+export declare function isStaticWidgetUri(uri: string): boolean;
+/**
+ * Build a static widget URI from tool name
+ *
+ * @param toolName - Name of the tool
+ * @returns Static widget URI (ui://widget/{toolName}.html)
+ */
+export declare function buildStaticWidgetUri(toolName: string): string;
+/**
+ * Get the MIME type for UI resources based on platform.
+ *
+ * Per user requirement: OpenAI or default uses 'text/html+skybridge'
+ *
+ * @param platformType - The detected platform type
+ * @returns The appropriate MIME type
+ */
+export declare function getUIResourceMimeType(platformType?: AIPlatformType): string;
+//# sourceMappingURL=uri-utils.d.ts.map

package/esm/registry/uri-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uri-utils.d.ts","sourceRoot":"","sources":["../../../src/registry/uri-utils.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAElD;;GAEG;AACH,eAAO,MAAM,kBAAkB,UAAU,CAAC;AAQ1C;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAEpD;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,eAAe,GAAG,SAAS,CAUvE;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAEtD;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAE7D;AAED;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CAAC,YAAY,CAAC,EAAE,cAAc,GAAG,MAAM,CAqB3E"}

package/esm/render/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @file render/index.ts
+ * @description React 19 static rendering utilities.
+ *
+ * @module @frontmcp/ui/render
+ */
+export { renderToString, renderToStringSync, isReactAvailable } from './prerender';
+//# sourceMappingURL=index.d.ts.map

package/esm/render/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/render/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,cAAc,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC"}

package/esm/render/index.js

@@ -0,0 +1,45 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// libs/ui/src/render/prerender.ts
+async function renderToString(element) {
+  const { prerender } = await import("react-dom/static");
+  const { prelude } = await prerender(element);
+  const reader = prelude.getReader();
+  const chunks = [];
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    if (value) chunks.push(value);
+  }
+  const totalLength = chunks.reduce((acc, chunk) => acc + chunk.length, 0);
+  const combined = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const chunk of chunks) {
+    combined.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return new TextDecoder().decode(combined);
+}
+function renderToStringSync(element) {
+  const ReactDOMServer = __require("react-dom/server");
+  return ReactDOMServer.renderToStaticMarkup(element);
+}
+function isReactAvailable() {
+  try {
+    __require("react");
+    __require("react-dom/server");
+    return true;
+  } catch {
+    return false;
+  }
+}
+export {
+  isReactAvailable,
+  renderToString,
+  renderToStringSync
+};

package/esm/render/prerender.d.ts

@@ -0,0 +1,57 @@
+/**
+ * @file prerender.ts
+ * @description React 19 static rendering utilities.
+ *
+ * Provides both async (prerender) and sync (renderToStaticMarkup) methods
+ * for converting React elements to HTML strings.
+ *
+ * @example Async rendering (recommended)
+ * ```typescript
+ * import { renderToString } from '@frontmcp/ui/render';
+ * import { Card } from '@frontmcp/ui/components';
+ *
+ * const html = await renderToString(<Card title="Hello">Content</Card>);
+ * ```
+ *
+ * @example Sync rendering (backwards compatible)
+ * ```typescript
+ * import { renderToStringSync } from '@frontmcp/ui/render';
+ *
+ * const html = renderToStringSync(<Card title="Hello">Content</Card>);
+ * ```
+ *
+ * @module @frontmcp/ui/render
+ */
+import type { ReactElement } from 'react';
+/**
+ * Render a React element to static HTML string using React 19's prerender API.
+ *
+ * This is the recommended async method that:
+ * - Waits for all Suspense boundaries to resolve
+ * - Uses React 19's streaming prerender API
+ * - Returns clean static HTML without hydration markers
+ *
+ * @param element - The React element to render
+ * @returns Promise resolving to HTML string
+ */
+export declare function renderToString(element: ReactElement): Promise<string>;
+/**
+ * Render a React element to static HTML string synchronously.
+ *
+ * This is the sync method for backwards compatibility that:
+ * - Does NOT wait for Suspense boundaries
+ * - Uses React's renderToStaticMarkup
+ * - Returns clean static HTML without hydration markers
+ *
+ * @param element - The React element to render
+ * @returns HTML string
+ */
+export declare function renderToStringSync(element: ReactElement): string;
+/**
+ * Check if React and react-dom are available.
+ * Useful for conditional rendering in environments where React may not be installed.
+ *
+ * @returns true if React and react-dom are available
+ */
+export declare function isReactAvailable(): boolean;
+//# sourceMappingURL=prerender.d.ts.map

package/esm/render/prerender.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prerender.d.ts","sourceRoot":"","sources":["../../../src/render/prerender.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAIH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,OAAO,CAAC;AAE1C;;;;;;;;;;GAUG;AACH,wBAAsB,cAAc,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,MAAM,CAAC,CA0B3E;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,YAAY,GAAG,MAAM,CAKhE;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,IAAI,OAAO,CAQ1C"}