@frontmcp/uipack 0.6.1

package/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/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/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/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":"AAAA;;;;;;;;;;;;GAYG;AAGH,OAAO,KAAK,EAAE,gBAAgB,EAAE,cAAc,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AACtF,OAAO,KAAK,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAW9D;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,gBAAgB;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,gCAAgC;IAChC,SAAS,EAAE,MAAM,CAAC;IAClB,2BAA2B;IAC3B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/B,sBAAsB;IACtB,MAAM,EAAE,OAAO,CAAC;IAChB,8CAA8C;IAC9C,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,4BAA4B;IAC5B,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,6BAA6B;IAC7B,YAAY,EAAE,cAAc,CAAC;IAC7B,qCAAqC;IACrC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,+CAA+C;IAC/C,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,4BAA4B;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,iDAAiD;IACjD,IAAI,EAAE,UAAU,CAAC;CAClB;AAED;;;GAGG;AACH,MAAM,WAAW,eAAe;IAC9B,iCAAiC;IACjC,OAAO,EAAE,KAAK,CAAC;IACf,8DAA8D;IAC9D,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,cAAc,GAAG,eAAe,GAAG,MAAM,IAAI,eAAe,CAErG;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH;;GAEG;AACH,MAAM,WAAW,0BAA0B;IACzC,6CAA6C;IAC7C,QAAQ,EAAE,MAAM,CAAC;IACjB,kFAAkF;IAClF,QAAQ,EAAE,gBAAgB,CAAC,UAAU,CAAC,CAAC;IACvC,4BAA4B;IAC5B,QAAQ,EAAE,gBAAgB,CAAC;CAC5B;AAED;;;GAGG;AACH,MAAM,WAAW,sBAAsB;IACrC,8DAA8D;IAC9D,IAAI,EAAE,MAAM,CAAC;IACb,sCAAsC;IACtC,IAAI,EAAE,OAAO,GAAG,KAAK,GAAG,MAAM,CAAC;IAC/B,mCAAmC;IACnC,QAAQ,EAAE,MAAM,CAAC;IACjB,wCAAwC;IACxC,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;GAEG;AACH,MAAM,WAAW,kCAAkC;IACjD,gBAAgB;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,gCAAgC;IAChC,QAAQ,EAAE,gBAAgB,CAAC,UAAU,CAAC,CAAC;IACvC,4BAA4B;IAC5B,QAAQ,EAAE,gBAAgB,CAAC;CAC5B;AAED,qBAAa,cAAc;IACzB;;;;OAIG;IACH,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAA6B;IAE/D;;;OAGG;IACH,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAqC;IAEnE;;;OAGG;IACH,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAA0C;IAE3E;;;;;;;;;;OAUG;IACG,wBAAwB,CAAC,OAAO,EAAE,0BAA0B,GAAG,OAAO,CAAC,IAAI,CAAC;IAgGlF;;;;;;;;;;OAUG;IACH,sBAAsB,CAAC,OAAO,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,gBAAgB,CAAA;KAAE,GAAG,IAAI;IAevF;;;;;;;;;;;;;;;OAeG;IACH,wBAAwB,CAAC,OAAO,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,gBAAgB,CAAA;KAAE,GAAG,IAAI;IAgBzF;;;;;;;;;;;OAWG;IACH,2BAA2B,CAAC,OAAO,EAAE,kCAAkC,GAAG,sBAAsB,GAAG,SAAS;IAsD5G;;;;;OAKG;IACH,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAIrD;;;;;OAKG;IACH,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAI1C;;;;;OAKG;IACH,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,cAAc,GAAG,SAAS;IAIzD;;;;;OAKG;IACH,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAItC;;;;;OAKG;IACH,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,mBAAmB,GAAG,SAAS;IAIjE;;;;;OAKG;IACH,YAAY,CAAC,QAAQ,EAAE,gBAAgB,CAAC,UAAU,CAAC,GAAG,MAAM;IAK5D;;;;;;;;;;;;;;;;;OAiBG;IACG,sBAAsB,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,cAAc,GAAG,eAAe,CAAC;IAwI/F;;;;;;OAMG;IACH,OAAO,CAAC,kBAAkB;IA6B1B;;;;;OAKG;IACH,sBAAsB,CAAC,QAAQ,EAAE,gBAAgB,CAAC,UAAU,CAAC,GAAG,OAAO;CAGxE"}

package/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/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/renderers/cache.d.ts

@@ -0,0 +1,145 @@
+/**
+ * LRU Cache for Renderer Transpilation Results
+ *
+ * Provides fast, memory-bounded caching for transpiled templates.
+ * Uses content-addressable keys (hash of source) for deduplication.
+ */
+import type { TranspileResult } from './types';
+/**
+ * Options for the transpile cache.
+ */
+export interface TranspileCacheOptions {
+    /** Maximum number of entries (default: 500) */
+    maxSize?: number;
+    /** TTL in milliseconds, 0 = infinite (default: 0 for transpile cache) */
+    ttl?: number;
+}
+/**
+ * LRU Cache for transpiled template results.
+ *
+ * Features:
+ * - Content-addressable keys via hash
+ * - LRU eviction when max size reached
+ * - Optional TTL for time-based expiration
+ * - Access statistics
+ *
+ * @example
+ * ```typescript
+ * const cache = new TranspileCache({ maxSize: 500 });
+ *
+ * // Store a transpiled result
+ * const hash = cache.set(sourceCode, transpileResult);
+ *
+ * // Retrieve it later
+ * const result = cache.get(sourceCode);
+ * if (result) {
+ *   console.log('Cache hit!', result.code);
+ * }
+ * ```
+ */
+export declare class TranspileCache {
+    private cache;
+    private readonly maxSize;
+    private readonly ttl;
+    /** Cache statistics */
+    private stats;
+    constructor(options?: TranspileCacheOptions);
+    /**
+     * Get a cached transpile result by source content.
+     *
+     * @param source - Source code to look up
+     * @returns Cached result or undefined if not found/expired
+     */
+    get(source: string): TranspileResult | undefined;
+    /**
+     * Get a cached transpile result by hash key.
+     *
+     * @param key - Hash key
+     * @returns Cached result or undefined if not found/expired
+     */
+    getByKey(key: string): TranspileResult | undefined;
+    /**
+     * Store a transpile result.
+     *
+     * @param source - Source code (used to generate key)
+     * @param value - Transpile result to cache
+     * @returns The hash key used for storage
+     */
+    set(source: string, value: TranspileResult): string;
+    /**
+     * Store a transpile result by hash key.
+     *
+     * @param key - Hash key
+     * @param value - Transpile result to cache
+     */
+    setByKey(key: string, value: TranspileResult): void;
+    /**
+     * Check if a source is cached.
+     *
+     * @param source - Source code to check
+     * @returns True if cached and not expired
+     */
+    has(source: string): boolean;
+    /**
+     * Check if a key is cached.
+     *
+     * @param key - Hash key to check
+     * @returns True if cached and not expired
+     */
+    hasByKey(key: string): boolean;
+    /**
+     * Delete a cached entry by source.
+     *
+     * @param source - Source code to delete
+     * @returns True if entry was deleted
+     */
+    delete(source: string): boolean;
+    /**
+     * Clear all cached entries.
+     */
+    clear(): void;
+    /**
+     * Get current cache size.
+     */
+    get size(): number;
+    /**
+     * Get cache statistics.
+     */
+    getStats(): {
+        hits: number;
+        misses: number;
+        evictions: number;
+        size: number;
+        hitRate: number;
+    };
+}
+/**
+ * Global transpile cache instance.
+ * Shared across all renderers for deduplication.
+ */
+export declare const transpileCache: TranspileCache;
+/**
+ * Render cache for full HTML output.
+ * Uses shorter TTL since outputs depend on input/output data.
+ */
+export declare const renderCache: TranspileCache;
+/**
+ * Simple LRU cache for storing any type of values.
+ * Used for caching compiled components (React/MDX).
+ */
+export declare class ComponentCache<T = unknown> {
+    private cache;
+    private readonly maxSize;
+    constructor(maxSize?: number);
+    get(key: string): T | undefined;
+    set(key: string, value: T): void;
+    has(key: string): boolean;
+    delete(key: string): boolean;
+    clear(): void;
+    get size(): number;
+}
+/**
+ * Global component cache for storing compiled React/MDX components.
+ */
+export declare const componentCache: ComponentCache<unknown>;
+//# sourceMappingURL=cache.d.ts.map

package/renderers/cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../../src/renderers/cache.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAc/C;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,+CAA+C;IAC/C,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,yEAAyE;IACzE,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qBAAa,cAAc;IACzB,OAAO,CAAC,KAAK,CAAkD;IAC/D,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAS;IAE7B,uBAAuB;IACvB,OAAO,CAAC,KAAK,CAIX;gBAEU,OAAO,GAAE,qBAA0B;IAK/C;;;;;OAKG;IACH,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,eAAe,GAAG,SAAS;IAKhD;;;;;OAKG;IACH,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,eAAe,GAAG,SAAS;IAwBlD;;;;;;OAMG;IACH,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,eAAe,GAAG,MAAM;IAMnD;;;;;OAKG;IACH,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,eAAe,GAAG,IAAI;IAkBnD;;;;;OAKG;IACH,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO;IAK5B;;;;;OAKG;IACH,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAa9B;;;;;OAKG;IACH,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO;IAK/B;;OAEG;IACH,KAAK,IAAI,IAAI;IAKb;;OAEG;IACH,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED;;OAEG;IACH,QAAQ,IAAI;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE;CAQ/F;AAED;;;GAGG;AACH,eAAO,MAAM,cAAc,gBAAuC,CAAC;AAEnE;;;GAGG;AACH,eAAO,MAAM,WAAW,gBAGtB,CAAC;AAEH;;;GAGG;AACH,qBAAa,cAAc,CAAC,CAAC,GAAG,OAAO;IACrC,OAAO,CAAC,KAAK,CAAsD;IACnE,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;gBAErB,OAAO,SAAM;IAIzB,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,CAAC,GAAG,SAAS;IAU/B,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI;IAYhC,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAIzB,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAI5B,KAAK,IAAI,IAAI;IAIb,IAAI,IAAI,IAAI,MAAM,CAEjB;CACF;AAED;;GAEG;AACH,eAAO,MAAM,cAAc,yBAAuB,CAAC"}