@positronic/core 0.0.52 → 0.0.53

package/dist/src/dsl/execution/retry.js

@@ -0,0 +1,298 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+/**
+ * Simple sleep helper that returns a promise resolving after the specified delay.
+ */ export var sleep = function(ms) {
+    return new Promise(function(resolve) {
+        return setTimeout(resolve, ms);
+    });
+};
+/**
+ * Simple semaphore for limiting concurrent operations.
+ * Used internally by batch prompt execution.
+ */ export var Semaphore = /*#__PURE__*/ function() {
+    "use strict";
+    function Semaphore(max) {
+        _class_call_check(this, Semaphore);
+        _define_property(this, "max", void 0);
+        _define_property(this, "current", void 0);
+        _define_property(this, "queue", void 0);
+        this.max = max;
+        this.current = 0;
+        this.queue = [];
+    }
+    _create_class(Semaphore, [
+        {
+            key: "acquire",
+            value: function acquire() {
+                return _async_to_generator(function() {
+                    var _this;
+                    return _ts_generator(this, function(_state) {
+                        _this = this;
+                        if (this.current < this.max) {
+                            this.current++;
+                            return [
+                                2
+                            ];
+                        }
+                        return [
+                            2,
+                            new Promise(function(resolve) {
+                                return _this.queue.push(resolve);
+                            })
+                        ];
+                    });
+                }).call(this);
+            }
+        },
+        {
+            key: "release",
+            value: function release() {
+                this.current--;
+                var next = this.queue.shift();
+                if (next) {
+                    this.current++;
+                    next();
+                }
+            }
+        }
+    ]);
+    return Semaphore;
+}();
+/**
+ * Normalize retry config with defaults.
+ */ export function normalizeRetryConfig(config) {
+    var _config_maxRetries, _config_backoff, _config_initialDelay, _config_maxDelay;
+    return {
+        maxRetries: (_config_maxRetries = config === null || config === void 0 ? void 0 : config.maxRetries) !== null && _config_maxRetries !== void 0 ? _config_maxRetries : 3,
+        backoff: (_config_backoff = config === null || config === void 0 ? void 0 : config.backoff) !== null && _config_backoff !== void 0 ? _config_backoff : 'exponential',
+        initialDelay: (_config_initialDelay = config === null || config === void 0 ? void 0 : config.initialDelay) !== null && _config_initialDelay !== void 0 ? _config_initialDelay : 1000,
+        maxDelay: (_config_maxDelay = config === null || config === void 0 ? void 0 : config.maxDelay) !== null && _config_maxDelay !== void 0 ? _config_maxDelay : 30000
+    };
+}
+/**
+ * Calculate backoff delay based on attempt number and config.
+ */ export function calculateBackoff(attempt, config) {
+    switch(config.backoff){
+        case 'none':
+            return config.initialDelay;
+        case 'linear':
+            return Math.min(config.initialDelay * (attempt + 1), config.maxDelay);
+        case 'exponential':
+            return Math.min(config.initialDelay * Math.pow(2, attempt), config.maxDelay);
+    }
+}
+/**
+ * Execute a function with retry and exponential backoff.
+ */ export function executeWithRetry(fn, config) {
+    return _async_to_generator(function() {
+        var lastError, attempt, error, delay;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    attempt = 0;
+                    _state.label = 1;
+                case 1:
+                    if (!(attempt <= config.maxRetries)) return [
+                        3,
+                        8
+                    ];
+                    _state.label = 2;
+                case 2:
+                    _state.trys.push([
+                        2,
+                        4,
+                        ,
+                        7
+                    ]);
+                    return [
+                        4,
+                        fn()
+                    ];
+                case 3:
+                    return [
+                        2,
+                        _state.sent()
+                    ];
+                case 4:
+                    error = _state.sent();
+                    lastError = error;
+                    if (!(attempt < config.maxRetries)) return [
+                        3,
+                        6
+                    ];
+                    delay = calculateBackoff(attempt, config);
+                    return [
+                        4,
+                        sleep(delay)
+                    ];
+                case 5:
+                    _state.sent();
+                    _state.label = 6;
+                case 6:
+                    return [
+                        3,
+                        7
+                    ];
+                case 7:
+                    attempt++;
+                    return [
+                        3,
+                        1
+                    ];
+                case 8:
+                    throw lastError;
+            }
+        });
+    })();
+}

package/dist/src/dsl/types.js

@@ -1,4 +1,4 @@
 /**
- * Helper type to extract the terminal tool's input type from a tools object.
- * Used for typing the result that gets merged into state.
+ * Configuration for retry behavior with exponential backoff.
+ * Used by batch prompt execution.
  */ export { };

package/dist/src/index.js

@@ -1,7 +1,8 @@
-export { Brain, brain, DEFAULT_ENV } from './dsl/brain.js';
+export { Brain, brain } from './dsl/brain.js';
 export { BrainRunner } from './dsl/brain-runner.js';
+export { createBrain } from './dsl/create-brain.js';
 export { STATUS, BRAIN_EVENTS } from './dsl/constants.js';
-export { createPatch, applyPatches } from './dsl/json-patch.js';
+export { applyPatches } from './dsl/json-patch.js';
 // Only needed for development to ensure that zod version numbers are the same, it's a peer
 // dependency so when not using file://..path/to/package links the version numbers
 // will match just fine if the user has the same version of zod installed.
@@ -10,6 +11,7 @@ export { z } from 'zod';
 export { createResources } from './resources/resources.js';
 export { createWebhook } from './dsl/webhook.js';
 export { RESOURCE_TYPES } from './resources/resources.js';
-export { reconstructLoopContext } from './dsl/loop-messages.js';
+// Default tools
+export { defaultTools, generateUI } from './tools/index.js';
 // Brain state machine
 export { createBrainExecutionMachine, createBrainMachine, sendEvent, getDepth, isTopLevel, getCurrentStep, getBrainStack, getBrainRunId, getExecutionState, getPendingWebhooks, getError, getCompletedSteps } from './dsl/brain-state-machine.js';

package/dist/src/tools/index.js

@@ -0,0 +1,181 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+import { z } from 'zod';
+import { createWebhook } from '../dsl/webhook.js';
+/**
+ * Default generateUI tool - gets enriched with component metadata at runtime.
+ *
+ * This tool allows the LLM to generate a UI and wait for user response.
+ * The actual component list and descriptions are injected at runtime
+ * based on the components registered with .withComponents().
+ */ export var generateUI = {
+    description: 'Generate a UI to display to the user and wait for their response',
+    inputSchema: z.object({
+        component: z.string().describe('The component name to render'),
+        props: z.record(z.unknown()).describe('Props to pass to the component')
+    }),
+    execute: function execute(input) {
+        // Return waitFor to pause execution until user responds
+        // The actual webhook handling is done by the runtime
+        var uiWebhook = createWebhook('ui-response', z.object({
+            userResponse: z.unknown()
+        }), function() {
+            return _async_to_generator(function() {
+                return _ts_generator(this, function(_state) {
+                    return [
+                        2,
+                        {
+                            type: 'webhook',
+                            identifier: 'pending',
+                            response: {
+                                userResponse: null
+                            }
+                        }
+                    ];
+                });
+            })();
+        });
+        return {
+            waitFor: uiWebhook('pending')
+        };
+    }
+};
+/**
+ * Default tools bundle.
+ *
+ * Use with .withTools(defaultTools) to include standard tools in your brain.
+ * Tools can be extended or overridden in individual agent steps.
+ *
+ * @example
+ * ```typescript
+ * import { brain, defaultTools } from '@positronic/core';
+ *
+ * const myBrain = brain('my-brain')
+ *   .withTools(defaultTools)
+ *   .brain('agent', ({ tools }) => ({
+ *     system: 'You are helpful',
+ *     prompt: 'Help the user',
+ *     tools  // uses defaultTools
+ *   }));
+ * ```
+ */ export var defaultTools = {
+    generateUI: generateUI
+};

package/dist/src/ui/component-utils.js

@@ -0,0 +1,107 @@
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+/**
+ * Merge multiple component objects into one.
+ * Later objects override earlier ones for component definitions.
+ *
+ * @param componentSets - Component objects to merge
+ * @returns A merged component object
+ *
+ * @example
+ * ```typescript
+ * import { components } from '@positronic/gen-ui-components';
+ * import { myComponents } from './my-components';
+ *
+ * const merged = mergeComponents(components, myComponents);
+ * brain.withComponents(merged);
+ * ```
+ */ export function mergeComponents() {
+    for(var _len = arguments.length, componentSets = new Array(_len), _key = 0; _key < _len; _key++){
+        componentSets[_key] = arguments[_key];
+    }
+    var merged = {};
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = componentSets[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var set = _step.value;
+            var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+            try {
+                for(var _iterator1 = Object.entries(set)[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
+                    var _step_value = _sliced_to_array(_step1.value, 2), name = _step_value[0], component = _step_value[1];
+                    merged[name] = component;
+                }
+            } catch (err) {
+                _didIteratorError1 = true;
+                _iteratorError1 = err;
+            } finally{
+                try {
+                    if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                        _iterator1.return();
+                    }
+                } finally{
+                    if (_didIteratorError1) {
+                        throw _iteratorError1;
+                    }
+                }
+            }
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    return merged;
+}

package/dist/src/ui/generate-page-html.js

@@ -0,0 +1,36 @@
+/**
+ * Bootstrap runtime that builds and renders the React tree from placements.
+ * This is inlined into the generated page.
+ */ var bootstrapRuntime = "\n(function() {\n  const components = window.PositronicComponents;\n  const data = window.__POSITRONIC_DATA__;\n  const tree = window.__POSITRONIC_TREE__;\n  const rootId = window.__POSITRONIC_ROOT__;\n  const formAction = window.__POSITRONIC_FORM_ACTION__;\n\n  if (!components) {\n    console.error('PositronicComponents not loaded');\n    return;\n  }\n\n  /**\n   * Resolve a binding path against a data context.\n   * e.g., \"email.subject\" against { email: { subject: \"Hello\" } } -> \"Hello\"\n   */\n  function resolveBinding(path, ctx) {\n    return path.split('.').reduce(function(obj, key) {\n      return obj && obj[key];\n    }, ctx);\n  }\n\n  /**\n   * Resolve a prop value - handle both full bindings and embedded bindings.\n   * - \"{{path}}\" -> resolved value (preserves type - arrays, objects, etc.)\n   * - \"Hello {{name}}, score: {{score}}\" -> \"Hello John, score: 42\"\n   */\n  function resolveProp(value, ctx) {\n    if (typeof value !== 'string') {\n      return value;\n    }\n    // Check if the entire value is a single binding - return the actual value (preserves arrays/objects)\n    var fullBindingMatch = value.match(/^{{([^}]+)}}$/);\n    if (fullBindingMatch) {\n      var resolved = resolveBinding(fullBindingMatch[1].trim(), ctx);\n      return resolved !== undefined ? resolved : value;\n    }\n    // Otherwise replace embedded bindings as strings\n    return value.replace(/{{([^}]+)}}/g, function(match, path) {\n      var resolved = resolveBinding(path.trim(), ctx);\n      return resolved !== undefined ? String(resolved) : match;\n    });\n  }\n\n  /**\n   * Build a React element from a placement.\n   */\n  function buildElement(placementId, ctx) {\n    var placement = tree.find(function(p) { return p.id === placementId; });\n    if (!placement) {\n      console.error('Placement not found:', placementId);\n      return null;\n    }\n\n    // Resolve props first (needed for List handling)\n    var props = {};\n    for (var key in placement.props) {\n      props[key] = resolveProp(placement.props[key], ctx);\n    }\n\n    // Handle List component specially - it's a virtual component that creates a loop context\n    if (placement.component === 'List') {\n      var items = Array.isArray(props.items) ? props.items : [];\n      var itemVarName = props.as || 'item';\n\n      // Find direct children of this List\n      var childIds = tree\n        .filter(function(p) { return p.parentId === placementId; })\n        .map(function(p) { return p.id; });\n\n      var listItems = items.map(function(item, index) {\n        // Create new context with loop variable\n        var itemCtx = Object.assign({}, ctx);\n        itemCtx[itemVarName] = item;\n        itemCtx[itemVarName + 'Index'] = index;\n\n        var children = childIds.map(function(childId) {\n          return buildElement(childId, itemCtx);\n        });\n\n        return React.createElement('div', { key: index, className: 'p-4 bg-white border border-gray-200 rounded-lg' }, children);\n      });\n\n      return React.createElement('div', { className: 'flex flex-col gap-4' }, listItems);\n    }\n\n    // Look up the component (after handling virtual components like List)\n    var Component = components[placement.component];\n    if (!Component) {\n      console.error('Component not found:', placement.component);\n      return null;\n    }\n\n    // Handle Form component - inject action URL\n    if (placement.component === 'Form' && formAction) {\n      props.action = formAction;\n    }\n\n    // Find direct children\n    var childIds = tree\n      .filter(function(p) { return p.parentId === placementId; })\n      .map(function(p) { return p.id; });\n\n    var children = childIds.map(function(childId) {\n      return buildElement(childId, ctx);\n    });\n\n    return React.createElement(Component, props, children.length > 0 ? children : undefined);\n  }\n\n  // Render the tree\n  var root = document.getElementById('root');\n  if (root && rootId) {\n    var element = buildElement(rootId, data);\n    ReactDOM.render(element, root);\n  }\n})();\n";
+/**
+ * Generate a complete HTML page from placements.
+ *
+ * The generated page includes:
+ * - React and ReactDOM from CDN
+ * - Tailwind CSS from CDN
+ * - Reference to component bundle at /bundle/components.js
+ * - Data and placements embedded as JSON
+ * - Bootstrap runtime that builds and renders the React tree
+ *
+ * @example
+ * ```typescript
+ * const html = generatePageHtml({
+ *   placements: result.placements,
+ *   rootId: result.rootId,
+ *   data: brainState,
+ *   title: 'My Generated Page',
+ *   formAction: '/api/submit',
+ * });
+ * ```
+ */ export function generatePageHtml(options) {
+    var placements = options.placements, rootId = options.rootId, data = options.data, _options_title = options.title, title = _options_title === void 0 ? 'Generated Page' : _options_title, formAction = options.formAction;
+    // Escape for embedding in HTML
+    var escapeHtml = function(str) {
+        return str.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+    };
+    // Serialize data safely for embedding in script tag
+    var safeJsonStringify = function(obj) {
+        return JSON.stringify(obj).replace(/</g, '\\u003c').replace(/>/g, '\\u003e').replace(/&/g, '\\u0026');
+    };
+    return '<!DOCTYPE html>\n<html lang="en">\n<head>\n  <meta charset="UTF-8">\n  <meta name="viewport" content="width=device-width, initial-scale=1.0">\n  <title>'.concat(escapeHtml(title), '</title>\n  <script crossorigin src="https://unpkg.com/react@18/umd/react.production.min.js"></script>\n  <script crossorigin src="https://unpkg.com/react-dom@18/umd/react-dom.production.min.js"></script>\n  <script src="https://cdn.tailwindcss.com"></script>\n</head>\n<body class="bg-gray-50 min-h-screen">\n  <div id="root" class="max-w-4xl mx-auto p-6"></div>\n\n  <!-- Pre-bundled components -->\n  <script src="/bundle/components.js"></script>\n\n  <!-- Data and placements -->\n  <script>\n    window.__POSITRONIC_DATA__ = ').concat(safeJsonStringify(data), ";\n    window.__POSITRONIC_TREE__ = ").concat(safeJsonStringify(placements), ";\n    window.__POSITRONIC_ROOT__ = ").concat(safeJsonStringify(rootId), ";\n    window.__POSITRONIC_FORM_ACTION__ = ").concat(formAction ? safeJsonStringify(formAction) : 'null', ";\n  </script>\n\n  <!-- Bootstrap runtime -->\n  <script>\n").concat(bootstrapRuntime, "\n  </script>\n</body>\n</html>");
+}