@frontmcp/uipack 0.6.1

package/renderers/utils/detect.d.ts

@@ -0,0 +1,107 @@
+/**
+ * Template Type Detection Utilities
+ *
+ * Provides functions to detect whether a template is:
+ * - A React component (imported or inline)
+ * - A JSX string (needs runtime transpilation)
+ * - MDX content
+ * - Plain HTML
+ */
+/**
+ * Check if a value is a React component (FC or class).
+ *
+ * Detection heuristics:
+ * 1. Has $$typeof symbol (React.memo, React.forwardRef, etc.)
+ * 2. Has prototype.isReactComponent (class components)
+ * 3. Is a function with 0-1 parameters (function components)
+ *
+ * @param value - Value to check
+ * @returns True if it's a React component
+ *
+ * @example
+ * ```typescript
+ * const MyComponent = ({ output }) => <div>{output.name}</div>;
+ * isReactComponent(MyComponent); // true
+ *
+ * const htmlFn = (ctx) => `<div>${ctx.output.name}</div>`;
+ * isReactComponent(htmlFn); // false (returns string)
+ * ```
+ */
+export declare function isReactComponent(value: unknown): boolean;
+/**
+ * Check if a function is likely a template builder (returns string).
+ *
+ * This is a heuristic based on function characteristics.
+ *
+ * @param fn - Function to check
+ * @returns True if likely a template builder function
+ */
+export declare function isTemplateBuilderFunction(fn: Function): boolean;
+/**
+ * Check if a string contains JSX syntax.
+ *
+ * Looks for patterns like:
+ * - `<Component` - JSX component tags
+ * - `</Component>` - JSX closing tags
+ * - `<div className=` - JSX attributes
+ * - `return (` followed by JSX
+ *
+ * @param source - String to check
+ * @returns True if string contains JSX
+ *
+ * @example
+ * ```typescript
+ * containsJsx('<div>Hello</div>'); // false (just HTML)
+ * containsJsx('<MyComponent />'); // true (JSX component)
+ * containsJsx('function() { return <div /> }'); // true
+ * ```
+ */
+export declare function containsJsx(source: string): boolean;
+/**
+ * Check if a string contains MDX syntax.
+ *
+ * MDX is Markdown with JSX components. Patterns:
+ * - Frontmatter: `---\ntitle: ...\n---`
+ * - JSX components: `<Component />`
+ * - JSX attributes: `className`, `onClick`, `htmlFor`
+ * - JS expressions: `{variable}` or `{items.map(...)}`
+ * - Import/export statements
+ *
+ * @param source - String to check
+ * @returns True if string contains MDX syntax
+ *
+ * @example
+ * ```typescript
+ * containsMdxSyntax('# Title\n<Card />'); // true
+ * containsMdxSyntax('# Title\n{data.name}'); // true
+ * containsMdxSyntax('<div className="test">...'); // true (JSX attribute)
+ * containsMdxSyntax('# Title\nSome text'); // false (just Markdown)
+ * ```
+ */
+export declare function containsMdxSyntax(source: string): boolean;
+/**
+ * Check if a string is plain HTML (no JSX or MDX).
+ *
+ * @param source - String to check
+ * @returns True if string is plain HTML
+ */
+export declare function isPlainHtml(source: string): boolean;
+/**
+ * Detect the type of a template.
+ *
+ * Priority order:
+ * 1. React component (imported, already transpiled)
+ * 2. MDX string
+ * 3. JSX string (needs transpilation)
+ * 4. HTML template function
+ * 5. Static HTML string
+ *
+ * @param template - Template to analyze
+ * @returns Detected type and confidence
+ */
+export declare function detectTemplateType(template: unknown): {
+    type: 'react' | 'mdx' | 'jsx-string' | 'html-function' | 'html-string';
+    confidence: number;
+    reason: string;
+};
+//# sourceMappingURL=detect.d.ts.map

package/renderers/utils/detect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"detect.d.ts","sourceRoot":"","sources":["../../../src/renderers/utils/detect.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAuCxD;AAED;;;;;;;GAOG;AACH,wBAAgB,yBAAyB,CAAC,EAAE,EAAE,QAAQ,GAAG,OAAO,CAa/D;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAqCnD;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAkCzD;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAEnD;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,OAAO,GAAG;IACrD,IAAI,EAAE,OAAO,GAAG,KAAK,GAAG,YAAY,GAAG,eAAe,GAAG,aAAa,CAAC;IACvE,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;CAChB,CA8DA"}

package/renderers/utils/hash.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Hash Utilities for Renderer Caching
+ *
+ * Fast, non-cryptographic hashing for content-addressable cache keys.
+ */
+/**
+ * Generate a fast hash string from source content.
+ * Uses FNV-1a algorithm for good distribution and speed.
+ *
+ * @param source - String to hash
+ * @returns Base36 encoded hash string
+ *
+ * @example
+ * ```typescript
+ * const hash = hashString('function Component() { return <div>Hello</div> }');
+ * // Returns something like "1a2b3c4d"
+ * ```
+ */
+export declare function hashString(source: string): string;
+/**
+ * Generate a hash combining multiple values.
+ * Useful for creating cache keys from multiple inputs.
+ *
+ * @param values - Values to combine into a hash
+ * @returns Combined hash string
+ *
+ * @example
+ * ```typescript
+ * const key = hashCombined('template-source', { location: 'NYC' }, { temp: 72 });
+ * ```
+ */
+export declare function hashCombined(...values: unknown[]): string;
+/**
+ * Check if a string likely represents a hash (short alphanumeric).
+ *
+ * @param value - Value to check
+ * @returns True if it looks like a hash
+ */
+export declare function isHash(value: string): boolean;
+//# sourceMappingURL=hash.d.ts.map

package/renderers/utils/hash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash.d.ts","sourceRoot":"","sources":["../../../src/renderers/utils/hash.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;;;;;;;;GAYG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAWjD;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,YAAY,CAAC,GAAG,MAAM,EAAE,OAAO,EAAE,GAAG,MAAM,CAezD;AAED;;;;;GAKG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAG7C"}

package/renderers/utils/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Renderer Utilities
+ *
+ * Utility functions for template detection, hashing, and transpilation.
+ */
+export { isReactComponent, isTemplateBuilderFunction, containsJsx, containsMdxSyntax, isPlainHtml, detectTemplateType, } from './detect';
+export { hashString, hashCombined, isHash } from './hash';
+export { transpileJsx, isSwcAvailable, executeTranspiledCode, transpileAndExecute } from './transpiler';
+//# sourceMappingURL=index.d.ts.map

package/renderers/utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/renderers/utils/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EACL,gBAAgB,EAChB,yBAAyB,EACzB,WAAW,EACX,iBAAiB,EACjB,WAAW,EACX,kBAAkB,GACnB,MAAM,UAAU,CAAC;AAGlB,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAG1D,OAAO,EAAE,YAAY,EAAE,cAAc,EAAE,qBAAqB,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC"}

package/renderers/utils/transpiler.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Runtime JSX/TSX Transpiler
+ *
+ * Uses SWC to transpile JSX/TSX strings to executable JavaScript at runtime.
+ * This enables dynamic React templates without requiring a build step.
+ */
+import type { TranspileResult } from '../types';
+/**
+ * SWC transformation options for JSX.
+ */
+interface SwcTransformOptions {
+    /** Enable TypeScript syntax */
+    typescript?: boolean;
+    /** Enable JSX syntax */
+    jsx?: boolean;
+    /** JSX runtime mode ('automatic' for React 17+, 'classic' for older) */
+    jsxRuntime?: 'automatic' | 'classic';
+    /** Enable development mode (better error messages) */
+    development?: boolean;
+}
+/**
+ * Transpile a JSX/TSX string to executable JavaScript.
+ *
+ * Uses SWC with React 17+ automatic JSX runtime.
+ * Results are cached by content hash.
+ *
+ * @param source - JSX/TSX source code string
+ * @param options - Transpilation options
+ * @returns Transpiled result with code and caching metadata
+ *
+ * @example
+ * ```typescript
+ * const source = `
+ *   function Widget({ output }) {
+ *     return <div>{output.name}</div>;
+ *   }
+ * `;
+ *
+ * const result = await transpileJsx(source);
+ * console.log(result.code); // JavaScript code
+ * console.log(result.cached); // Whether from cache
+ * ```
+ */
+export declare function transpileJsx(source: string, options?: SwcTransformOptions): Promise<TranspileResult>;
+/**
+ * Check if SWC is available for runtime transpilation.
+ *
+ * @returns Promise resolving to true if SWC is available
+ */
+export declare function isSwcAvailable(): Promise<boolean>;
+/**
+ * Execute transpiled JavaScript code and extract the component.
+ *
+ * Creates a sandboxed environment with React available,
+ * executes the code, and returns the exported component.
+ *
+ * @param code - Transpiled JavaScript code
+ * @param context - Additional context to inject
+ * @returns The exported component or default export
+ *
+ * @example
+ * ```typescript
+ * const code = `
+ *   "use strict";
+ *   Object.defineProperty(exports, "__esModule", { value: true });
+ *   const jsx_runtime = require("react/jsx-runtime");
+ *   function Widget(props) {
+ *     return jsx_runtime.jsx("div", { children: props.output.name });
+ *   }
+ *   exports.default = Widget;
+ * `;
+ *
+ * const Component = await executeTranspiledCode(code);
+ * // Component is now a usable React component function
+ * ```
+ */
+export declare function executeTranspiledCode(code: string, context?: Record<string, any>): Promise<any>;
+/**
+ * Transpile and execute a JSX string, returning the component.
+ *
+ * Convenience function that combines transpileJsx and executeTranspiledCode.
+ *
+ * @param source - JSX/TSX source code
+ * @param context - Additional context for execution
+ * @returns The component function
+ */
+export declare function transpileAndExecute(source: string, context?: Record<string, any>): Promise<any>;
+export {};
+//# sourceMappingURL=transpiler.d.ts.map

package/renderers/utils/transpiler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transpiler.d.ts","sourceRoot":"","sources":["../../../src/renderers/utils/transpiler.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAEhD;;GAEG;AACH,UAAU,mBAAmB;IAC3B,+BAA+B;IAC/B,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,wBAAwB;IACxB,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,wEAAwE;IACxE,UAAU,CAAC,EAAE,WAAW,GAAG,SAAS,CAAC;IACrC,sDAAsD;IACtD,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAyCD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAsB,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,GAAE,mBAAwB,GAAG,OAAO,CAAC,eAAe,CAAC,CAwD9G;AAED;;;;GAIG;AACH,wBAAsB,cAAc,IAAI,OAAO,CAAC,OAAO,CAAC,CAGvD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAsB,qBAAqB,CACzC,IAAI,EAAE,MAAM,EAEZ,OAAO,GAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAM,GAEhC,OAAO,CAAC,GAAG,CAAC,CA+Cd;AAED;;;;;;;;GAQG;AACH,wBAAsB,mBAAmB,CACvC,MAAM,EAAE,MAAM,EAEd,OAAO,GAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAM,GAEhC,OAAO,CAAC,GAAG,CAAC,CAGd"}

package/runtime/adapters/html.adapter.d.ts

@@ -0,0 +1,59 @@
+/**
+ * HTML Renderer Adapter
+ *
+ * Client-side adapter for rendering HTML templates.
+ * Handles plain HTML and Handlebars-enhanced templates.
+ *
+ * @packageDocumentation
+ */
+import type { RendererAdapter, RenderContext, RenderOptions, RenderResult } from './types';
+import type { UIType } from '../../types/ui-runtime';
+/**
+ * HTML Renderer Adapter.
+ *
+ * Renders HTML templates to the DOM with support for:
+ * - Plain HTML strings
+ * - Handlebars-enhanced templates ({{...}} syntax)
+ * - Template builder functions
+ */
+export declare class HtmlRendererAdapter implements RendererAdapter {
+    readonly type: UIType;
+    private handlebarsRenderer;
+    /**
+     * Check if this adapter can handle the given content.
+     */
+    canHandle(content: string | unknown): boolean;
+    /**
+     * Render HTML content to a string.
+     */
+    render(content: string, context: RenderContext, _options?: RenderOptions): Promise<string>;
+    /**
+     * Render HTML content directly to the DOM.
+     */
+    renderToDOM(content: string, target: HTMLElement, context: RenderContext, _options?: RenderOptions): Promise<RenderResult>;
+    /**
+     * Update rendered content with new data.
+     */
+    update(target: HTMLElement, context: RenderContext): Promise<RenderResult>;
+    /**
+     * Clean up (no-op for HTML adapter).
+     */
+    destroy(_target: HTMLElement): void;
+    /**
+     * Check if content contains Handlebars syntax.
+     */
+    private containsHandlebars;
+    /**
+     * Render Handlebars template.
+     */
+    private renderHandlebars;
+}
+/**
+ * Create a new HTML renderer adapter.
+ */
+export declare function createHtmlAdapter(): HtmlRendererAdapter;
+/**
+ * Adapter loader for lazy loading.
+ */
+export declare function loadHtmlAdapter(): Promise<RendererAdapter>;
+//# sourceMappingURL=html.adapter.d.ts.map

package/runtime/adapters/html.adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"html.adapter.d.ts","sourceRoot":"","sources":["../../../src/runtime/adapters/html.adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,aAAa,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAC3F,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAErD;;;;;;;GAOG;AACH,qBAAa,mBAAoB,YAAW,eAAe;IACzD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAU;IAG/B,OAAO,CAAC,kBAAkB,CAGV;IAEhB;;OAEG;IACH,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,GAAG,OAAO;IAK7C;;OAEG;IACG,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,aAAa,EAAE,QAAQ,CAAC,EAAE,aAAa,GAAG,OAAO,CAAC,MAAM,CAAC;IAUhG;;OAEG;IACG,WAAW,CACf,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,WAAW,EACnB,OAAO,EAAE,aAAa,EACtB,QAAQ,CAAC,EAAE,aAAa,GACvB,OAAO,CAAC,YAAY,CAAC;IAqBxB;;OAEG;IACG,MAAM,CAAC,MAAM,EAAE,WAAW,EAAE,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;IAYhF;;OAEG;IACH,OAAO,CAAC,OAAO,EAAE,WAAW,GAAG,IAAI;IAInC;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAK1B;;OAEG;YACW,gBAAgB;CA4B/B;AAED;;GAEG;AACH,wBAAgB,iBAAiB,IAAI,mBAAmB,CAEvD;AAED;;GAEG;AACH,wBAAsB,eAAe,IAAI,OAAO,CAAC,eAAe,CAAC,CAEhE"}

package/runtime/adapters/index.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Renderer Adapters
+ *
+ * Client-side adapters for rendering different UI types.
+ *
+ * @packageDocumentation
+ */
+export type { RendererAdapter, RenderContext, RenderOptions, RenderResult, AdapterLoader, AdapterRegistryEntry, } from './types';
+export { HtmlRendererAdapter, createHtmlAdapter, loadHtmlAdapter } from './html.adapter';
+export { MdxRendererAdapter, createMdxAdapter, loadMdxAdapter } from './mdx.adapter';
+import type { UIType } from '../../types/ui-runtime';
+import type { AdapterLoader, RendererAdapter } from './types';
+/**
+ * Registry of adapter loaders by UI type.
+ * Note: React adapter is in @frontmcp/ui package.
+ */
+export declare const adapterLoaders: Record<UIType, AdapterLoader | undefined>;
+/**
+ * Get an adapter loader for a UI type.
+ */
+export declare function getAdapterLoader(type: UIType): AdapterLoader | undefined;
+/**
+ * Load an adapter for a UI type.
+ */
+export declare function loadAdapter(type: UIType): Promise<RendererAdapter | null>;
+//# sourceMappingURL=index.d.ts.map

package/runtime/adapters/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/runtime/adapters/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,YAAY,EACV,eAAe,EACf,aAAa,EACb,aAAa,EACb,YAAY,EACZ,aAAa,EACb,oBAAoB,GACrB,MAAM,SAAS,CAAC;AAGjB,OAAO,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAGzF,OAAO,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAKrF,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,KAAK,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAE9D;;;GAGG;AACH,eAAO,MAAM,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,GAAG,SAAS,CAMpE,CAAC;AAEF;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,aAAa,GAAG,SAAS,CAExE;AAED;;GAEG;AACH,wBAAsB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC,CAM/E"}

package/runtime/adapters/mdx.adapter.d.ts

@@ -0,0 +1,73 @@
+/**
+ * MDX Renderer Adapter
+ *
+ * Client-side adapter for rendering MDX (Markdown + JSX) content.
+ * Builds on top of the React adapter for component rendering.
+ *
+ * @packageDocumentation
+ */
+import type { RendererAdapter, RenderContext, RenderOptions, RenderResult } from './types';
+import type { UIType } from '../../types/ui-runtime';
+/**
+ * MDX Renderer Adapter.
+ *
+ * Renders MDX content to the DOM with support for:
+ * - Pre-compiled MDX (recommended)
+ * - Runtime MDX compilation (if mdx-js available)
+ * - Custom component injection
+ */
+export declare class MdxRendererAdapter implements RendererAdapter {
+    readonly type: UIType;
+    private mdxRuntime;
+    private loadPromise;
+    /**
+     * Check if this adapter can handle the given content.
+     */
+    canHandle(content: string | unknown): boolean;
+    /**
+     * Render MDX content to a string.
+     */
+    render(content: string, context: RenderContext, _options?: RenderOptions): Promise<string>;
+    /**
+     * Render MDX content directly to the DOM.
+     */
+    renderToDOM(content: string, target: HTMLElement, context: RenderContext, _options?: RenderOptions): Promise<RenderResult>;
+    /**
+     * Hydrate existing SSR content.
+     * MDX hydration follows React patterns.
+     */
+    hydrate(target: HTMLElement, context: RenderContext, options?: RenderOptions): Promise<RenderResult>;
+    /**
+     * Update rendered MDX content with new data.
+     */
+    update(target: HTMLElement, context: RenderContext): Promise<RenderResult>;
+    /**
+     * Clean up (no-op for MDX adapter).
+     */
+    destroy(_target: HTMLElement): void;
+    /**
+     * Ensure MDX runtime is loaded.
+     */
+    private ensureMdxLoaded;
+    /**
+     * Load MDX runtime.
+     */
+    private loadMdx;
+    /**
+     * Compile MDX content.
+     */
+    private compileMdx;
+    /**
+     * Basic markdown rendering (fallback).
+     */
+    private renderMarkdown;
+}
+/**
+ * Create a new MDX renderer adapter.
+ */
+export declare function createMdxAdapter(): MdxRendererAdapter;
+/**
+ * Adapter loader for lazy loading.
+ */
+export declare function loadMdxAdapter(): Promise<RendererAdapter>;
+//# sourceMappingURL=mdx.adapter.d.ts.map

package/runtime/adapters/mdx.adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mdx.adapter.d.ts","sourceRoot":"","sources":["../../../src/runtime/adapters/mdx.adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,aAAa,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAC3F,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAYrD;;;;;;;GAOG;AACH,qBAAa,kBAAmB,YAAW,eAAe;IACxD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAS;IAG9B,OAAO,CAAC,UAAU,CAA2B;IAC7C,OAAO,CAAC,WAAW,CAA8B;IAEjD;;OAEG;IACH,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,GAAG,OAAO;IAoB7C;;OAEG;IACG,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,aAAa,EAAE,QAAQ,CAAC,EAAE,aAAa,GAAG,OAAO,CAAC,MAAM,CAAC;IAmBhG;;OAEG;IACG,WAAW,CACf,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,WAAW,EACnB,OAAO,EAAE,aAAa,EACtB,QAAQ,CAAC,EAAE,aAAa,GACvB,OAAO,CAAC,YAAY,CAAC;IAqBxB;;;OAGG;IACG,OAAO,CAAC,MAAM,EAAE,WAAW,EAAE,OAAO,EAAE,aAAa,EAAE,OAAO,CAAC,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;IAW1G;;OAEG;IACG,MAAM,CAAC,MAAM,EAAE,WAAW,EAAE,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;IAShF;;OAEG;IACH,OAAO,CAAC,OAAO,EAAE,WAAW,GAAG,IAAI;IAInC;;OAEG;YACW,eAAe;IAa7B;;OAEG;YACW,OAAO;IAgBrB;;OAEG;YACW,UAAU;IAqBxB;;OAEG;IACH,OAAO,CAAC,cAAc;CAqEvB;AAED;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,kBAAkB,CAErD;AAED;;GAEG;AACH,wBAAsB,cAAc,IAAI,OAAO,CAAC,eAAe,CAAC,CAE/D"}

package/runtime/adapters/types.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Renderer Adapter Types
+ *
+ * Defines the interface for renderer adapters that handle different
+ * UI types (HTML, React, MDX) at runtime.
+ *
+ * @packageDocumentation
+ */
+import type { UIType } from '../../types/ui-runtime';
+/**
+ * Context passed to renderer adapters.
+ */
+export interface RenderContext {
+    /** Tool input arguments */
+    input: Record<string, unknown>;
+    /** Tool output/result */
+    output: unknown;
+    /** Structured content (if schema provided) */
+    structuredContent?: unknown;
+    /** Tool name */
+    toolName: string;
+}
+/**
+ * Options for rendering.
+ */
+export interface RenderOptions {
+    /** Target element to render into */
+    target?: HTMLElement;
+    /** Whether to hydrate existing SSR content */
+    hydrate?: boolean;
+    /** Manifest data from the page */
+    manifest?: Record<string, unknown>;
+}
+/**
+ * Result of a render operation.
+ */
+export interface RenderResult {
+    /** Whether rendering was successful */
+    success: boolean;
+    /** Error message if failed */
+    error?: string;
+    /** The rendered HTML (for SSR) */
+    html?: string;
+}
+/**
+ * Renderer adapter interface.
+ *
+ * Each adapter handles a specific UI type and provides methods
+ * for rendering templates to the DOM.
+ */
+export interface RendererAdapter {
+    /** The UI type this adapter handles */
+    readonly type: UIType;
+    /**
+     * Check if this adapter can handle the given content.
+     */
+    canHandle(content: string | unknown): boolean;
+    /**
+     * Render content to an HTML string.
+     * Used for SSR and initial page generation.
+     */
+    render(content: string, context: RenderContext, options?: RenderOptions): Promise<string>;
+    /**
+     * Render content directly to the DOM.
+     * Used for client-side rendering.
+     */
+    renderToDOM?(content: string, target: HTMLElement, context: RenderContext, options?: RenderOptions): Promise<RenderResult>;
+    /**
+     * Hydrate existing SSR content with interactivity.
+     * Used for React/MDX components that were server-rendered.
+     */
+    hydrate?(target: HTMLElement, context: RenderContext, options?: RenderOptions): Promise<RenderResult>;
+    /**
+     * Update the rendered content with new data.
+     * Used when tool output changes at runtime.
+     */
+    update?(target: HTMLElement, context: RenderContext): Promise<RenderResult>;
+    /**
+     * Clean up any resources (event listeners, etc.).
+     */
+    destroy?(target: HTMLElement): void;
+}
+/**
+ * Lazy loader function for adapters.
+ */
+export type AdapterLoader = () => Promise<RendererAdapter>;
+/**
+ * Adapter registry entry.
+ */
+export interface AdapterRegistryEntry {
+    type: UIType;
+    loader: AdapterLoader;
+    instance?: RendererAdapter;
+}
+//# sourceMappingURL=types.d.ts.map

package/runtime/adapters/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/runtime/adapters/types.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAErD;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,2BAA2B;IAC3B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/B,yBAAyB;IACzB,MAAM,EAAE,OAAO,CAAC;IAChB,8CAA8C;IAC9C,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,gBAAgB;IAChB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,oCAAoC;IACpC,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,8CAA8C;IAC9C,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,kCAAkC;IAClC,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpC;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,uCAAuC;IACvC,OAAO,EAAE,OAAO,CAAC;IACjB,8BAA8B;IAC9B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,kCAAkC;IAClC,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED;;;;;GAKG;AACH,MAAM,WAAW,eAAe;IAC9B,uCAAuC;IACvC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAEtB;;OAEG;IACH,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,GAAG,OAAO,CAAC;IAE9C;;;OAGG;IACH,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,aAAa,EAAE,OAAO,CAAC,EAAE,aAAa,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAE1F;;;OAGG;IACH,WAAW,CAAC,CACV,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,WAAW,EACnB,OAAO,EAAE,aAAa,EACtB,OAAO,CAAC,EAAE,aAAa,GACtB,OAAO,CAAC,YAAY,CAAC,CAAC;IAEzB;;;OAGG;IACH,OAAO,CAAC,CAAC,MAAM,EAAE,WAAW,EAAE,OAAO,EAAE,aAAa,EAAE,OAAO,CAAC,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;IAEtG;;;OAGG;IACH,MAAM,CAAC,CAAC,MAAM,EAAE,WAAW,EAAE,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;IAE5E;;OAEG;IACH,OAAO,CAAC,CAAC,MAAM,EAAE,WAAW,GAAG,IAAI,CAAC;CACrC;AAED;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,MAAM,OAAO,CAAC,eAAe,CAAC,CAAC;AAE3D;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,aAAa,CAAC;IACtB,QAAQ,CAAC,EAAE,eAAe,CAAC;CAC5B"}

package/runtime/csp.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Content Security Policy Builder
+ *
+ * Generates CSP meta tags for sandboxed UI templates based on
+ * OpenAI Apps SDK and ext-apps (SEP-1865) specifications.
+ */
+import type { UIContentSecurityPolicy } from './types';
+/**
+ * Default CDN domains used by FrontMCP UI templates.
+ * These are required for Tailwind, Google Fonts, and other external resources.
+ */
+export declare const DEFAULT_CDN_DOMAINS: readonly ["https://cdn.jsdelivr.net", "https://cdnjs.cloudflare.com", "https://fonts.googleapis.com", "https://fonts.gstatic.com"];
+/**
+ * Default CSP when no custom policy is provided.
+ * Includes CDN domains required for standard FrontMCP templates.
+ */
+export declare const DEFAULT_CSP_DIRECTIVES: readonly ["default-src 'none'", `script-src 'self' 'unsafe-inline' ${string}`, `style-src 'self' 'unsafe-inline' ${string}`, `img-src 'self' data: ${string}`, `font-src 'self' data: ${string}`, "connect-src 'none'"];
+/**
+ * Restrictive CSP for sandboxed environments with no external resources.
+ * Use this when you want to block all external resources.
+ */
+export declare const RESTRICTIVE_CSP_DIRECTIVES: readonly ["default-src 'none'", "script-src 'self' 'unsafe-inline'", "style-src 'self' 'unsafe-inline'", "img-src 'self' data:", "font-src 'self' data:", "connect-src 'none'"];
+/**
+ * Build CSP directives from a UIContentSecurityPolicy configuration
+ */
+export declare function buildCSPDirectives(csp?: UIContentSecurityPolicy): string[];
+/**
+ * Build a CSP meta tag from directives
+ */
+export declare function buildCSPMetaTag(csp?: UIContentSecurityPolicy): string;
+/**
+ * Build CSP for OpenAI Apps SDK format
+ * Returns the object format expected by _meta['openai/widgetCSP']
+ */
+export declare function buildOpenAICSP(csp?: UIContentSecurityPolicy): {
+    connect_domains?: string[];
+    resource_domains?: string[];
+} | undefined;
+/**
+ * Validate CSP domain format
+ * Domains should be valid URLs or wildcard patterns
+ */
+export declare function validateCSPDomain(domain: string): boolean;
+/**
+ * Filter and warn about invalid CSP domains
+ */
+export declare function sanitizeCSPDomains(domains: string[] | undefined): string[];
+//# sourceMappingURL=csp.d.ts.map

package/runtime/csp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"csp.d.ts","sourceRoot":"","sources":["../../src/runtime/csp.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,SAAS,CAAC;AAEvD;;;GAGG;AACH,eAAO,MAAM,mBAAmB,oIAKtB,CAAC;AAEX;;;GAGG;AACH,eAAO,MAAM,sBAAsB,yNAOzB,CAAC;AAEX;;;GAGG;AACH,eAAO,MAAM,0BAA0B,iLAO7B,CAAC;AAEX;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,CAAC,EAAE,uBAAuB,GAAG,MAAM,EAAE,CAmC1E;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,GAAG,CAAC,EAAE,uBAAuB,GAAG,MAAM,CAIrE;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,GAAG,CAAC,EAAE,uBAAuB,GACxD;IACE,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;IAC3B,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAC;CAC7B,GACD,SAAS,CAiBZ;AAcD;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAezD;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,SAAS,GAAG,MAAM,EAAE,CAa1E"}

package/runtime/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * MCP Bridge Runtime Module
+ *
+ * Provides the infrastructure for rendering tool UI templates
+ * that work across multiple host environments (OpenAI, Claude, ext-apps).
+ *
+ * @module @frontmcp/uipack/runtime
+ */
+export type { ProviderType, DisplayMode, ThemeMode, HostContext, MCPBridge, MCPBridgeExtended, WrapToolUIOptions, OpenAIRuntime, OpenAIUserAgent, SafeAreaInsets, UIContentSecurityPolicy, TemplateContext, TemplateHelpers, TemplateBuilderFn, ToolUITemplate, ToolUIConfig, WidgetServingMode, } from './types';
+export { MCP_BRIDGE_RUNTIME, getMCPBridgeScript, isMCPBridgeSupported } from './mcp-bridge';
+export { FRONTMCP_BRIDGE_RUNTIME, PLATFORM_BRIDGE_SCRIPTS, generateCustomBridge, type IIFEGeneratorOptions, } from './mcp-bridge';
+export { DEFAULT_CDN_DOMAINS, DEFAULT_CSP_DIRECTIVES, RESTRICTIVE_CSP_DIRECTIVES, buildCSPDirectives, buildCSPMetaTag, buildOpenAICSP, validateCSPDomain, sanitizeCSPDomains, } from './csp';
+export { type WrapToolUIFullOptions, type WrapToolUIUniversalOptions, type WrapStaticWidgetOptions, type WrapLeanWidgetShellOptions, type WrapHybridWidgetShellOptions, type WrapToolUIForClaudeOptions, wrapToolUI, wrapToolUIMinimal, wrapToolUIUniversal, wrapStaticWidgetUniversal, wrapLeanWidgetShell, wrapHybridWidgetShell, wrapToolUIForClaude, createTemplateHelpers, buildOpenAIMeta, getToolUIMimeType, } from './wrapper';
+export { type SanitizerFn, type SanitizeOptions, REDACTION_TOKENS, PII_PATTERNS, sanitizeInput, createSanitizer, detectPII, isEmail, isPhone, isCreditCard, isSSN, isIPv4, detectPIIType, redactPIIFromText, } from './sanitizer';
+export { RendererRuntime, createRendererRuntime, bootstrapRendererRuntime, generateBootstrapScript, type RendererRuntimeConfig, } from './renderer-runtime';
+export { type RendererAdapter, type RenderContext, type RenderOptions, type RenderResult, type AdapterLoader, HtmlRendererAdapter, MdxRendererAdapter, createHtmlAdapter, createMdxAdapter, loadAdapter, getAdapterLoader, adapterLoaders, } from './adapters';
+//# sourceMappingURL=index.d.ts.map

package/runtime/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/runtime/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,YAAY,EACV,YAAY,EACZ,WAAW,EACX,SAAS,EACT,WAAW,EACX,SAAS,EACT,iBAAiB,EACjB,iBAAiB,EACjB,aAAa,EACb,eAAe,EACf,cAAc,EAEd,uBAAuB,EACvB,eAAe,EACf,eAAe,EACf,iBAAiB,EACjB,cAAc,EACd,YAAY,EACZ,iBAAiB,GAClB,MAAM,SAAS,CAAC;AAGjB,OAAO,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AAG5F,OAAO,EACL,uBAAuB,EACvB,uBAAuB,EACvB,oBAAoB,EACpB,KAAK,oBAAoB,GAC1B,MAAM,cAAc,CAAC;AAGtB,OAAO,EACL,mBAAmB,EACnB,sBAAsB,EACtB,0BAA0B,EAC1B,kBAAkB,EAClB,eAAe,EACf,cAAc,EACd,iBAAiB,EACjB,kBAAkB,GACnB,MAAM,OAAO,CAAC;AAGf,OAAO,EACL,KAAK,qBAAqB,EAC1B,KAAK,0BAA0B,EAC/B,KAAK,uBAAuB,EAC5B,KAAK,0BAA0B,EAC/B,KAAK,4BAA4B,EACjC,KAAK,0BAA0B,EAC/B,UAAU,EACV,iBAAiB,EACjB,mBAAmB,EACnB,yBAAyB,EACzB,mBAAmB,EACnB,qBAAqB,EACrB,mBAAmB,EACnB,qBAAqB,EACrB,eAAe,EACf,iBAAiB,GAClB,MAAM,WAAW,CAAC;AAGnB,OAAO,EACL,KAAK,WAAW,EAChB,KAAK,eAAe,EACpB,gBAAgB,EAChB,YAAY,EACZ,aAAa,EACb,eAAe,EACf,SAAS,EACT,OAAO,EACP,OAAO,EACP,YAAY,EACZ,KAAK,EACL,MAAM,EACN,aAAa,EACb,iBAAiB,GAClB,MAAM,aAAa,CAAC;AAGrB,OAAO,EACL,eAAe,EACf,qBAAqB,EACrB,wBAAwB,EACxB,uBAAuB,EACvB,KAAK,qBAAqB,GAC3B,MAAM,oBAAoB,CAAC;AAI5B,OAAO,EACL,KAAK,eAAe,EACpB,KAAK,aAAa,EAClB,KAAK,aAAa,EAClB,KAAK,YAAY,EACjB,KAAK,aAAa,EAClB,mBAAmB,EACnB,kBAAkB,EAClB,iBAAiB,EACjB,gBAAgB,EAChB,WAAW,EACX,gBAAgB,EAChB,cAAc,GACf,MAAM,YAAY,CAAC"}