@renderify/core 0.1.0

package/dist/core.cjs.js

@@ -0,0 +1,1583 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  DefaultApiIntegration: () => DefaultApiIntegration,
+  DefaultCodeGenerator: () => DefaultCodeGenerator,
+  DefaultContextManager: () => DefaultContextManager,
+  DefaultCustomizationEngine: () => DefaultCustomizationEngine,
+  DefaultPerformanceOptimizer: () => DefaultPerformanceOptimizer,
+  DefaultRenderifyConfig: () => DefaultRenderifyConfig,
+  DefaultUIRenderer: () => import_runtime.DefaultUIRenderer,
+  PolicyRejectionError: () => PolicyRejectionError,
+  RenderifyApp: () => RenderifyApp,
+  createJspmOnlyStrictModeConfig: () => createJspmOnlyStrictModeConfig,
+  createRenderifyApp: () => createRenderifyApp
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/api-integration.ts
+var DefaultApiIntegration = class {
+  apis = /* @__PURE__ */ new Map();
+  registerApi(api) {
+    this.apis.set(api.name, api);
+  }
+  listApis() {
+    return [...this.apis.values()];
+  }
+  async callApi(name, params) {
+    const api = this.apis.get(name);
+    if (!api) {
+      throw new Error(`API not found: ${name}`);
+    }
+    const controller = typeof AbortController !== "undefined" ? new AbortController() : void 0;
+    const timeout = this.createTimeout(controller, api.timeoutMs ?? 1e4);
+    try {
+      const url = this.buildUrl(api, params);
+      const init = {
+        method: api.method,
+        headers: {
+          "content-type": "application/json",
+          ...api.headers ?? {}
+        },
+        signal: controller?.signal
+      };
+      if (api.method !== "GET" && api.method !== "DELETE" && params) {
+        init.body = JSON.stringify(params);
+      }
+      const response = await fetch(url, init);
+      if (!response.ok) {
+        const bodyText = await response.text();
+        throw new Error(
+          `API ${name} failed with ${response.status}: ${bodyText}`
+        );
+      }
+      const contentType = response.headers.get("content-type") ?? "";
+      if (contentType.includes("application/json")) {
+        return await response.json();
+      }
+      return await response.text();
+    } finally {
+      if (timeout) {
+        clearTimeout(timeout);
+      }
+    }
+  }
+  buildUrl(api, params) {
+    if (!params || api.method !== "GET" && api.method !== "DELETE") {
+      return api.endpoint;
+    }
+    const url = new URL(api.endpoint);
+    for (const [key, value] of Object.entries(params)) {
+      if (value === void 0 || value === null) {
+        continue;
+      }
+      url.searchParams.set(key, String(value));
+    }
+    return url.toString();
+  }
+  createTimeout(controller, timeoutMs) {
+    if (!controller || timeoutMs <= 0) {
+      return void 0;
+    }
+    return setTimeout(() => controller.abort(), timeoutMs);
+  }
+};
+
+// src/codegen.ts
+var import_ir = require("@renderify/ir");
+var DefaultCodeGenerator = class {
+  createIncrementalSession(input) {
+    let buffer = "";
+    let lastSignature = "";
+    const tryGenerate = async () => {
+      const candidate = await this.tryBuildIncrementalCandidate(
+        input.prompt,
+        buffer
+      );
+      if (!candidate) {
+        return void 0;
+      }
+      const signature = this.createIncrementalPlanSignature(candidate.plan);
+      if (signature === lastSignature) {
+        return void 0;
+      }
+      lastSignature = signature;
+      return candidate;
+    };
+    return {
+      pushDelta: async (delta) => {
+        if (delta.length > 0) {
+          buffer += delta;
+        }
+        return await tryGenerate();
+      },
+      finalize: async (finalText) => {
+        if (typeof finalText === "string" && finalText.length > 0) {
+          buffer = finalText;
+        }
+        const candidate = await tryGenerate();
+        return candidate?.plan;
+      }
+    };
+  }
+  async generatePlan(input) {
+    const parsedPlan = await this.tryParseRuntimePlan(
+      input.llmText,
+      input.prompt
+    );
+    if (parsedPlan) {
+      return parsedPlan;
+    }
+    const source = this.tryExtractRuntimeSource(input.llmText);
+    if (source) {
+      return await this.createSourcePlan(input.prompt, source);
+    }
+    const parsedRoot = this.tryParseRuntimeNode(input.llmText);
+    const root = parsedRoot ?? this.createFallbackRoot(input.prompt, input.llmText);
+    const imports = (0, import_ir.collectComponentModules)(root);
+    return this.createPlanFromRoot(root, {
+      prompt: input.prompt,
+      imports,
+      capabilities: {
+        domWrite: true,
+        allowedModules: imports
+      }
+    });
+  }
+  async validatePlan(plan) {
+    if (!plan.id || !Number.isInteger(plan.version) || plan.version <= 0) {
+      return false;
+    }
+    if (!(0, import_ir.isRuntimeNode)(plan.root)) {
+      return false;
+    }
+    return typeof plan.capabilities === "object" && plan.capabilities !== null;
+  }
+  async transformPlan(plan, transforms) {
+    return transforms.reduce((current, transform) => transform(current), plan);
+  }
+  createFallbackRoot(prompt, llmText) {
+    const title = prompt.trim().length > 0 ? prompt.trim() : "Untitled prompt";
+    const summary = llmText.trim().length > 0 ? llmText.trim() : "No model output";
+    return (0, import_ir.createElementNode)("section", { class: "renderify-runtime-output" }, [
+      (0, import_ir.createElementNode)("h1", void 0, [(0, import_ir.createTextNode)(title)]),
+      (0, import_ir.createElementNode)("p", void 0, [(0, import_ir.createTextNode)(summary)])
+    ]);
+  }
+  async tryBuildIncrementalCandidate(prompt, llmText) {
+    const parsedPlan = await this.tryParseRuntimePlan(llmText, prompt);
+    if (parsedPlan) {
+      return {
+        plan: parsedPlan,
+        complete: this.isLikelyCompleteJsonPayload(llmText),
+        mode: "runtime-plan-json"
+      };
+    }
+    const parsedNode = this.tryParseRuntimeNode(llmText);
+    if (parsedNode) {
+      return {
+        plan: this.createPlanFromRoot(parsedNode, {
+          prompt,
+          imports: (0, import_ir.collectComponentModules)(parsedNode),
+          capabilities: {
+            domWrite: true,
+            allowedModules: (0, import_ir.collectComponentModules)(parsedNode)
+          }
+        }),
+        complete: this.isLikelyCompleteJsonPayload(llmText),
+        mode: "runtime-node-json"
+      };
+    }
+    const source = this.tryExtractRuntimeSource(llmText);
+    if (source) {
+      return {
+        plan: await this.createSourcePlan(prompt, source),
+        complete: this.hasClosedCodeFence(llmText),
+        mode: "runtime-source"
+      };
+    }
+    const fallbackRoot = this.createFallbackRoot(prompt, llmText);
+    const fallbackImports = (0, import_ir.collectComponentModules)(fallbackRoot);
+    return {
+      plan: this.createPlanFromRoot(fallbackRoot, {
+        prompt,
+        imports: fallbackImports,
+        capabilities: {
+          domWrite: true,
+          allowedModules: fallbackImports
+        }
+      }),
+      complete: false,
+      mode: "runtime-text-fallback"
+    };
+  }
+  createIncrementalPlanSignature(plan) {
+    return this.hashIncrementalSignatureValue({
+      root: plan.root,
+      imports: plan.imports ?? [],
+      source: plan.source,
+      capabilities: plan.capabilities,
+      state: plan.state
+    });
+  }
+  hashIncrementalSignatureValue(value) {
+    const hasher = (0, import_ir.createFnv1a64Hasher)();
+    const update = (chunk) => {
+      hasher.update(chunk);
+    };
+    const visit = (input) => {
+      if (input === null) {
+        update("null;");
+        return;
+      }
+      if (input === void 0) {
+        update("undefined;");
+        return;
+      }
+      if (typeof input === "string") {
+        update(`s:${input};`);
+        return;
+      }
+      if (typeof input === "number") {
+        update(Number.isFinite(input) ? `n:${String(input)};` : "n:null;");
+        return;
+      }
+      if (typeof input === "boolean") {
+        update(input ? "b:1;" : "b:0;");
+        return;
+      }
+      if (Array.isArray(input)) {
+        update("a:[");
+        for (const entry of input) {
+          visit(entry);
+        }
+        update("];");
+        return;
+      }
+      if (typeof input === "object") {
+        const entries = Object.entries(input).filter(([, entryValue]) => entryValue !== void 0).sort(([left], [right]) => left.localeCompare(right));
+        update("o:{");
+        for (const [key, entryValue] of entries) {
+          update(`k:${key}=`);
+          visit(entryValue);
+        }
+        update("};");
+        return;
+      }
+      update(`x:${String(input)};`);
+    };
+    visit(value);
+    return hasher.digestHex();
+  }
+  createPlanFromRoot(root, input) {
+    const imports = this.normalizeImports(input.imports) ?? (0, import_ir.collectComponentModules)(root);
+    const source = this.normalizeSourceModule(input.source);
+    const moduleManifest = this.normalizeModuleManifest(input.moduleManifest) ?? this.createModuleManifestFromImports(imports);
+    const capabilities = this.normalizeCapabilities(
+      input.capabilities,
+      imports
+    );
+    const metadata = this.normalizeMetadata(input.prompt, input.metadata);
+    const id = this.normalizePlanId(input.id);
+    const version = this.normalizePlanVersion(input.version);
+    return {
+      specVersion: (0, import_ir.resolveRuntimePlanSpecVersion)(
+        input.specVersion ?? import_ir.DEFAULT_RUNTIME_PLAN_SPEC_VERSION
+      ),
+      id,
+      version,
+      root,
+      imports,
+      ...moduleManifest ? { moduleManifest } : {},
+      capabilities,
+      ...metadata ? { metadata } : {},
+      ...input.state ? { state: input.state } : {},
+      ...source ? { source } : {}
+    };
+  }
+  async tryParseRuntimePlan(text, prompt) {
+    const parsed = this.tryParseJsonPayload(text);
+    if (!this.isRecord(parsed) || !("root" in parsed)) {
+      return void 0;
+    }
+    const root = parsed.root;
+    if (!(0, import_ir.isRuntimeNode)(root)) {
+      return void 0;
+    }
+    const metadata = this.isRecord(parsed.metadata) ? (0, import_ir.isRuntimePlanMetadata)(parsed.metadata) ? parsed.metadata : void 0 : void 0;
+    const moduleManifest = this.isRecord(parsed.moduleManifest) && (0, import_ir.isRuntimeModuleManifest)(parsed.moduleManifest) ? parsed.moduleManifest : void 0;
+    const state = this.isRecord(parsed.state) && (0, import_ir.isRuntimeStateModel)(parsed.state) ? parsed.state : void 0;
+    const source = this.isRecord(parsed.source) && (0, import_ir.isRuntimeSourceModule)(parsed.source) ? parsed.source : void 0;
+    const importsFromPayload = Array.isArray(parsed.imports) ? parsed.imports.filter((item) => typeof item === "string").map((item) => item.trim()).filter((item) => item.length > 0) : void 0;
+    const importsFromManifest = moduleManifest ? Object.keys(moduleManifest) : void 0;
+    const imports = importsFromPayload ?? importsFromManifest ?? (source ? await this.parseImportsFromSource(source.code) : void 0);
+    return this.createPlanFromRoot(root, {
+      prompt,
+      specVersion: typeof parsed.specVersion === "string" ? parsed.specVersion : void 0,
+      id: typeof parsed.id === "string" ? parsed.id : void 0,
+      version: typeof parsed.version === "number" ? parsed.version : void 0,
+      imports,
+      moduleManifest,
+      capabilities: this.isRecord(parsed.capabilities) && (0, import_ir.isRuntimeCapabilities)(parsed.capabilities) ? parsed.capabilities : void 0,
+      metadata,
+      state,
+      source
+    });
+  }
+  tryParseRuntimeNode(text) {
+    const parsed = this.tryParseJsonPayload(text);
+    if ((0, import_ir.isRuntimeNode)(parsed)) {
+      return parsed;
+    }
+    return void 0;
+  }
+  tryParseJsonPayload(text) {
+    const codeBlockMatch = text.match(/```json\s*([\s\S]*?)\s*```/i);
+    const payload = codeBlockMatch ? codeBlockMatch[1] : text;
+    const trimmed = payload.trim();
+    if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) {
+      return void 0;
+    }
+    try {
+      return JSON.parse(trimmed);
+    } catch {
+      return void 0;
+    }
+  }
+  isLikelyCompleteJsonPayload(text) {
+    const codeBlockMatch = text.match(/```json\s*([\s\S]*?)\s*```/i);
+    const payload = codeBlockMatch ? codeBlockMatch[1] : text;
+    const trimmed = payload.trim();
+    if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) {
+      return false;
+    }
+    const stack = [];
+    let inString = false;
+    let escaped = false;
+    for (const char of trimmed) {
+      if (inString) {
+        if (escaped) {
+          escaped = false;
+          continue;
+        }
+        if (char === "\\") {
+          escaped = true;
+          continue;
+        }
+        if (char === '"') {
+          inString = false;
+        }
+        continue;
+      }
+      if (char === '"') {
+        inString = true;
+        continue;
+      }
+      if (char === "{" || char === "[") {
+        stack.push(char);
+        continue;
+      }
+      if (char === "}" || char === "]") {
+        const top = stack.pop();
+        if (!top) {
+          return false;
+        }
+        if (char === "}" && top !== "{" || char === "]" && top !== "[") {
+          return false;
+        }
+      }
+    }
+    return !inString && stack.length === 0;
+  }
+  hasClosedCodeFence(text) {
+    const fences = text.match(/```/g);
+    return Boolean(fences && fences.length >= 2 && fences.length % 2 === 0);
+  }
+  normalizePlanId(id) {
+    if (typeof id === "string" && id.trim().length > 0) {
+      return id.trim();
+    }
+    return `plan_${Date.now().toString(36)}`;
+  }
+  normalizePlanVersion(version) {
+    if (Number.isInteger(version) && version > 0) {
+      return version;
+    }
+    return 1;
+  }
+  normalizeImports(imports) {
+    if (!imports || imports.length === 0) {
+      return void 0;
+    }
+    return [...new Set(imports)];
+  }
+  normalizeModuleManifest(manifest) {
+    if (!manifest || Object.keys(manifest).length === 0) {
+      return void 0;
+    }
+    return manifest;
+  }
+  normalizeCapabilities(capabilities, imports) {
+    const normalized = {
+      domWrite: true,
+      allowedModules: imports,
+      ...capabilities ?? {}
+    };
+    if (!Array.isArray(normalized.allowedModules)) {
+      normalized.allowedModules = imports;
+    }
+    if (typeof normalized.maxImports === "number" && (!Number.isFinite(normalized.maxImports) || normalized.maxImports < 0)) {
+      delete normalized.maxImports;
+    }
+    if (typeof normalized.maxExecutionMs === "number" && (!Number.isFinite(normalized.maxExecutionMs) || normalized.maxExecutionMs < 1)) {
+      delete normalized.maxExecutionMs;
+    }
+    if (typeof normalized.maxComponentInvocations === "number" && (!Number.isFinite(normalized.maxComponentInvocations) || normalized.maxComponentInvocations < 0)) {
+      delete normalized.maxComponentInvocations;
+    }
+    return normalized;
+  }
+  createModuleManifestFromImports(imports) {
+    if (imports.length === 0) {
+      return void 0;
+    }
+    const manifest = {};
+    for (const specifier of imports) {
+      const resolvedUrl = this.resolveImportToUrl(specifier);
+      const version = this.extractVersionFromSpecifier(specifier);
+      manifest[specifier] = {
+        resolvedUrl,
+        ...version ? { version } : {},
+        signer: "renderify-codegen"
+      };
+    }
+    return manifest;
+  }
+  resolveImportToUrl(specifier) {
+    if (this.isHttpUrl(specifier)) {
+      return specifier;
+    }
+    if (specifier.startsWith("./") || specifier.startsWith("../") || specifier.startsWith("/")) {
+      return specifier;
+    }
+    if (specifier.startsWith("npm:")) {
+      return this.resolveJspmSpecifier(specifier.slice(4));
+    }
+    return this.resolveJspmSpecifier(specifier);
+  }
+  extractVersionFromSpecifier(specifier) {
+    if (!specifier.startsWith("npm:")) {
+      return void 0;
+    }
+    const body = specifier.slice(4);
+    const atIndex = body.lastIndexOf("@");
+    if (atIndex <= 0) {
+      return void 0;
+    }
+    const version = body.slice(atIndex + 1).trim();
+    if (version.length === 0 || version.includes("/")) {
+      return void 0;
+    }
+    return version;
+  }
+  normalizeMetadata(prompt, metadata) {
+    const sourcePrompt = prompt.trim().length > 0 ? prompt.trim() : void 0;
+    const merged = {
+      ...metadata ?? {},
+      ...sourcePrompt ? { sourcePrompt } : {}
+    };
+    return Object.keys(merged).length > 0 ? merged : void 0;
+  }
+  tryExtractRuntimeSource(text) {
+    const match = text.match(/```(tsx|jsx|ts|js)\s*([\s\S]*?)\s*```/i);
+    if (!match) {
+      return void 0;
+    }
+    const language = match[1].toLowerCase();
+    const code = match[2].trim();
+    if (code.length === 0) {
+      return void 0;
+    }
+    return this.normalizeSourceModule({
+      language,
+      code,
+      exportName: "default"
+    });
+  }
+  async createSourcePlan(prompt, source) {
+    const imports = await this.parseImportsFromSource(source.code);
+    const normalizedSource = this.normalizeSourceModule(source);
+    const sourceRuntime = normalizedSource?.runtime ?? "renderify";
+    return this.createPlanFromRoot(
+      (0, import_ir.createElementNode)("section", { class: "renderify-runtime-source-plan" }, [
+        (0, import_ir.createElementNode)("h2", void 0, [(0, import_ir.createTextNode)(prompt)]),
+        (0, import_ir.createElementNode)("p", void 0, [
+          (0, import_ir.createTextNode)(`Runtime source module (${source.language}) prepared`)
+        ])
+      ]),
+      {
+        prompt,
+        imports,
+        capabilities: {
+          domWrite: true,
+          allowedModules: imports
+        },
+        metadata: {
+          sourcePrompt: prompt,
+          tags: ["source-module", source.language, `runtime:${sourceRuntime}`]
+        },
+        source: normalizedSource
+      }
+    );
+  }
+  async parseImportsFromSource(code) {
+    return (0, import_ir.collectRuntimeSourceImports)(code);
+  }
+  isHttpUrl(value) {
+    try {
+      const parsed = new URL(value);
+      return parsed.protocol === "http:" || parsed.protocol === "https:";
+    } catch {
+      return false;
+    }
+  }
+  isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+  }
+  normalizeSourceModule(source) {
+    if (!source) {
+      return void 0;
+    }
+    const runtime = source.runtime ?? this.inferSourceRuntimeFromLanguage(source.language, source.code);
+    return {
+      ...source,
+      runtime
+    };
+  }
+  inferSourceRuntimeFromLanguage(language, code) {
+    if (language === "jsx" || language === "tsx") {
+      return "preact";
+    }
+    if ((language === "js" || language === "ts") && /from\s+["'](?:preact|react|recharts)["']/.test(code)) {
+      return "preact";
+    }
+    return "renderify";
+  }
+  resolveJspmSpecifier(specifier) {
+    const normalized = specifier.trim();
+    if (normalized.length === 0) {
+      return "https://ga.jspm.io/npm:missing";
+    }
+    const override = import_ir.DEFAULT_JSPM_SPECIFIER_OVERRIDES[normalized];
+    if (override) {
+      return override;
+    }
+    return `https://ga.jspm.io/npm:${normalized}`;
+  }
+};
+
+// src/config.ts
+var DEFAULT_RUNTIME_SPEC_VERSIONS = ["runtime-plan/v1"];
+var DEFAULT_RUNTIME_REMOTE_FALLBACK_CDNS = ["https://esm.sh"];
+var DEFAULT_JSPM_ALLOWED_NETWORK_HOSTS = ["ga.jspm.io", "cdn.jspm.io"];
+function createJspmOnlyStrictModeConfig(options = {}) {
+  const allowedNetworkHosts = normalizeJspmAllowedNetworkHosts(
+    options.allowedNetworkHosts
+  );
+  return {
+    runtimeJspmOnlyStrictMode: true,
+    strictSecurity: true,
+    securityProfile: "strict",
+    runtimeEnforceModuleManifest: true,
+    runtimeAllowIsolationFallback: false,
+    runtimeEnableDependencyPreflight: true,
+    runtimeFailOnDependencyPreflightError: true,
+    runtimeRemoteFallbackCdnBases: [],
+    securityPolicy: {
+      allowArbitraryNetwork: false,
+      allowedNetworkHosts,
+      requireModuleManifestForBareSpecifiers: true,
+      requireModuleIntegrity: true,
+      allowDynamicSourceImports: false
+    }
+  };
+}
+var DefaultRenderifyConfig = class {
+  config = {};
+  async load(overrides) {
+    const env = getEnvironmentValues();
+    const defaultValues = {
+      llmProvider: "openai",
+      llmModel: "gpt-4.1-mini",
+      llmBaseUrl: "https://api.openai.com/v1",
+      llmRequestTimeoutMs: 3e4,
+      jspmCdnUrl: "https://ga.jspm.io/npm",
+      strictSecurity: true,
+      llmUseStructuredOutput: true,
+      securityProfile: "balanced",
+      runtimeJspmOnlyStrictMode: false,
+      runtimeEnforceModuleManifest: true,
+      runtimeAllowIsolationFallback: false,
+      runtimeSupportedSpecVersions: [...DEFAULT_RUNTIME_SPEC_VERSIONS],
+      runtimeEnableDependencyPreflight: true,
+      runtimeFailOnDependencyPreflightError: false,
+      runtimeRemoteFetchTimeoutMs: 12e3,
+      runtimeRemoteFetchRetries: 2,
+      runtimeRemoteFetchBackoffMs: 150,
+      runtimeRemoteFallbackCdnBases: [...DEFAULT_RUNTIME_REMOTE_FALLBACK_CDNS],
+      runtimeBrowserSourceSandboxMode: "worker",
+      runtimeBrowserSourceSandboxTimeoutMs: 4e3,
+      runtimeBrowserSourceSandboxFailClosed: true
+    };
+    const merged = {
+      ...defaultValues,
+      ...env,
+      ...overrides ?? {}
+    };
+    this.config = applyDerivedConfig(merged);
+  }
+  get(key) {
+    return this.config[key];
+  }
+  set(key, value) {
+    this.config[key] = value;
+  }
+  snapshot() {
+    return { ...this.config };
+  }
+  async save() {
+  }
+};
+function applyDerivedConfig(input) {
+  if (input.runtimeJspmOnlyStrictMode !== true) {
+    return input;
+  }
+  const existingPolicy = toSecurityPolicyOverrides(input.securityPolicy);
+  const strictPreset = createJspmOnlyStrictModeConfig({
+    allowedNetworkHosts: normalizeJspmAllowedNetworkHosts(
+      existingPolicy.allowedNetworkHosts
+    )
+  });
+  return {
+    ...input,
+    ...strictPreset,
+    securityPolicy: {
+      ...existingPolicy,
+      ...toSecurityPolicyOverrides(strictPreset.securityPolicy)
+    }
+  };
+}
+function getEnvironmentValues() {
+  if (typeof process === "undefined" || typeof process.env === "undefined" || process.env === null) {
+    return {};
+  }
+  const values = {
+    llmUseStructuredOutput: process.env.RENDERIFY_LLM_USE_STRUCTURED_OUTPUT !== "false",
+    strictSecurity: process.env.RENDERIFY_STRICT_SECURITY !== "false",
+    securityProfile: parseSecurityProfile(
+      process.env.RENDERIFY_SECURITY_PROFILE
+    ),
+    runtimeJspmOnlyStrictMode: process.env.RENDERIFY_RUNTIME_JSPM_ONLY_STRICT_MODE === "true",
+    runtimeEnforceModuleManifest: process.env.RENDERIFY_RUNTIME_ENFORCE_MANIFEST !== "false",
+    runtimeAllowIsolationFallback: process.env.RENDERIFY_RUNTIME_ALLOW_ISOLATION_FALLBACK === "true",
+    runtimeSupportedSpecVersions: parseSpecVersions(
+      process.env.RENDERIFY_RUNTIME_SPEC_VERSIONS
+    ),
+    runtimeEnableDependencyPreflight: process.env.RENDERIFY_RUNTIME_PREFLIGHT !== "false",
+    runtimeFailOnDependencyPreflightError: process.env.RENDERIFY_RUNTIME_PREFLIGHT_FAIL_FAST === "true",
+    runtimeRemoteFetchTimeoutMs: parsePositiveInt(process.env.RENDERIFY_RUNTIME_REMOTE_FETCH_TIMEOUT_MS) ?? 12e3,
+    runtimeRemoteFetchRetries: parseNonNegativeInt(process.env.RENDERIFY_RUNTIME_REMOTE_FETCH_RETRIES) ?? 2,
+    runtimeRemoteFetchBackoffMs: parseNonNegativeInt(
+      process.env.RENDERIFY_RUNTIME_REMOTE_FETCH_BACKOFF_MS
+    ) ?? 150,
+    runtimeRemoteFallbackCdnBases: parseCsvValues(
+      process.env.RENDERIFY_RUNTIME_REMOTE_FALLBACK_CDNS,
+      DEFAULT_RUNTIME_REMOTE_FALLBACK_CDNS
+    ),
+    runtimeBrowserSourceSandboxMode: parseSourceSandboxMode(
+      process.env.RENDERIFY_RUNTIME_BROWSER_SANDBOX_MODE
+    ),
+    runtimeBrowserSourceSandboxFailClosed: process.env.RENDERIFY_RUNTIME_BROWSER_SANDBOX_FAIL_CLOSED !== "false"
+  };
+  if (process.env.RENDERIFY_LLM_API_KEY) {
+    values.llmApiKey = process.env.RENDERIFY_LLM_API_KEY;
+  }
+  if (process.env.RENDERIFY_LLM_PROVIDER) {
+    values.llmProvider = parseLlmProvider(process.env.RENDERIFY_LLM_PROVIDER);
+  }
+  if (process.env.RENDERIFY_LLM_MODEL) {
+    values.llmModel = process.env.RENDERIFY_LLM_MODEL;
+  }
+  if (process.env.RENDERIFY_LLM_BASE_URL) {
+    values.llmBaseUrl = process.env.RENDERIFY_LLM_BASE_URL;
+  }
+  const timeoutMs = parsePositiveInt(process.env.RENDERIFY_LLM_TIMEOUT_MS);
+  if (timeoutMs !== void 0) {
+    values.llmRequestTimeoutMs = timeoutMs;
+  }
+  if (process.env.RENDERIFY_JSPM_CDN_URL) {
+    values.jspmCdnUrl = process.env.RENDERIFY_JSPM_CDN_URL;
+  }
+  const browserSandboxTimeout = parsePositiveInt(
+    process.env.RENDERIFY_RUNTIME_BROWSER_SANDBOX_TIMEOUT_MS
+  );
+  if (browserSandboxTimeout !== void 0) {
+    values.runtimeBrowserSourceSandboxTimeoutMs = browserSandboxTimeout;
+  }
+  return values;
+}
+function parsePositiveInt(value) {
+  if (!value) {
+    return void 0;
+  }
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed <= 0) {
+    return void 0;
+  }
+  return parsed;
+}
+function parseNonNegativeInt(value) {
+  if (!value) {
+    return void 0;
+  }
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed < 0) {
+    return void 0;
+  }
+  return parsed;
+}
+function parseSecurityProfile(value) {
+  if (value === "strict" || value === "balanced" || value === "relaxed") {
+    return value;
+  }
+  return "balanced";
+}
+function parseLlmProvider(value) {
+  if (typeof value === "string" && value.trim().length > 0) {
+    return value.trim().toLowerCase();
+  }
+  return "openai";
+}
+function parseSpecVersions(value) {
+  if (!value || value.trim().length === 0) {
+    return [...DEFAULT_RUNTIME_SPEC_VERSIONS];
+  }
+  const parsed = value.split(",").map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+  return parsed.length > 0 ? parsed : [...DEFAULT_RUNTIME_SPEC_VERSIONS];
+}
+function parseCsvValues(value, fallback) {
+  if (!value || value.trim().length === 0) {
+    return [...fallback];
+  }
+  const parsed = value.split(",").map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+  return parsed.length > 0 ? parsed : [...fallback];
+}
+function parseSourceSandboxMode(value) {
+  if (value === "none" || value === "worker" || value === "iframe") {
+    return value;
+  }
+  return "worker";
+}
+function toSecurityPolicyOverrides(value) {
+  if (!isRecord(value)) {
+    return {};
+  }
+  return value;
+}
+function normalizeJspmAllowedNetworkHosts(input) {
+  const values = Array.isArray(input) ? input : DEFAULT_JSPM_ALLOWED_NETWORK_HOSTS;
+  const normalized = [];
+  for (const entry of values) {
+    if (typeof entry !== "string") {
+      continue;
+    }
+    const host = normalizeNetworkHostEntry(entry);
+    if (!host || !host.endsWith("jspm.io")) {
+      continue;
+    }
+    if (!normalized.includes(host)) {
+      normalized.push(host);
+    }
+  }
+  return normalized.length > 0 ? normalized : [...DEFAULT_JSPM_ALLOWED_NETWORK_HOSTS];
+}
+function normalizeNetworkHostEntry(value) {
+  const trimmed = value.trim().toLowerCase();
+  if (trimmed.length === 0) {
+    return void 0;
+  }
+  try {
+    if (trimmed.includes("://")) {
+      const parsed = new URL(trimmed);
+      return parsed.host;
+    }
+  } catch {
+  }
+  const hostLike = trimmed.replace(/^https?:\/\//, "").replace(/^\/+/, "").replace(/\/.*$/, "");
+  return hostLike.length > 0 ? hostLike : void 0;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+
+// src/context.ts
+var DefaultContextManager = class {
+  ctx = {};
+  listeners = /* @__PURE__ */ new Set();
+  async initialize() {
+    this.ctx = {
+      user: { id: "anonymous" },
+      app: { version: "0.1.0", environment: "development" }
+    };
+  }
+  getContext() {
+    return this.ctx;
+  }
+  updateContext(partialCtx) {
+    const nextUser = partialCtx.user || this.ctx.user ? {
+      id: partialCtx.user?.id ?? this.ctx.user?.id ?? "anonymous",
+      name: partialCtx.user?.name ?? this.ctx.user?.name,
+      role: partialCtx.user?.role ?? this.ctx.user?.role
+    } : void 0;
+    const nextApp = partialCtx.app || this.ctx.app ? {
+      version: partialCtx.app?.version ?? this.ctx.app?.version ?? "0.1.0",
+      environment: partialCtx.app?.environment ?? this.ctx.app?.environment
+    } : void 0;
+    this.ctx = {
+      ...this.ctx,
+      ...partialCtx,
+      user: nextUser,
+      app: nextApp
+    };
+    this.notify();
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  notify() {
+    for (const cb of this.listeners) {
+      cb(this.ctx);
+    }
+  }
+};
+
+// src/customization.ts
+var DefaultCustomizationEngine = class {
+  plugins = [];
+  registerPlugin(plugin) {
+    this.plugins.push(plugin);
+  }
+  getPlugins() {
+    return [...this.plugins];
+  }
+  async runHook(hookName, payload, context) {
+    let currentPayload = payload;
+    for (const plugin of this.plugins) {
+      const hookFn = plugin.hooks[hookName];
+      if (!hookFn) {
+        continue;
+      }
+      currentPayload = await hookFn(currentPayload, context);
+    }
+    return currentPayload;
+  }
+};
+
+// src/performance.ts
+var DefaultPerformanceOptimizer = class {
+  timers = /* @__PURE__ */ new Map();
+  metrics = [];
+  startMeasurement(label) {
+    this.timers.set(label, {
+      label,
+      startedAt: nowMs()
+    });
+  }
+  endMeasurement(label) {
+    const timer = this.timers.get(label);
+    if (!timer) {
+      return void 0;
+    }
+    const endedAt = nowMs();
+    const metric = {
+      label,
+      startedAt: timer.startedAt,
+      endedAt,
+      durationMs: endedAt - timer.startedAt
+    };
+    this.metrics.push(metric);
+    this.timers.delete(label);
+    return metric;
+  }
+  getMetrics() {
+    return [...this.metrics];
+  }
+  reset() {
+    this.timers.clear();
+    this.metrics.length = 0;
+  }
+};
+function nowMs() {
+  if (typeof performance !== "undefined" && typeof performance.now === "function") {
+    return performance.now();
+  }
+  return Date.now();
+}
+
+// src/security.ts
+var security_exports = {};
+__reExport(security_exports, require("@renderify/security"));
+
+// src/index.ts
+__reExport(src_exports, security_exports, module.exports);
+
+// src/ui.ts
+var import_runtime = require("@renderify/runtime");
+
+// src/index.ts
+var PolicyRejectionError = class extends Error {
+  result;
+  constructor(result) {
+    super(`Security policy rejected runtime plan: ${result.issues.join("; ")}`);
+    this.name = "PolicyRejectionError";
+    this.result = result;
+  }
+};
+var RenderifyApp = class {
+  deps;
+  listeners = /* @__PURE__ */ new Map();
+  running = false;
+  constructor(deps) {
+    this.deps = deps;
+  }
+  async start() {
+    if (this.running) {
+      return;
+    }
+    await this.deps.config.load();
+    this.deps.llm.configure(this.deps.config.snapshot());
+    await this.deps.context.initialize();
+    const policyOverrides = this.deps.config.get("securityPolicy");
+    const securityProfile = this.deps.config.get("securityProfile");
+    this.deps.security.initialize({
+      profile: securityProfile,
+      overrides: policyOverrides
+    });
+    await this.deps.runtime.initialize();
+    this.running = true;
+    this.emit("started");
+  }
+  async stop() {
+    if (!this.running) {
+      return;
+    }
+    await this.deps.runtime.terminate();
+    this.running = false;
+    this.emit("stopped");
+  }
+  async renderPrompt(prompt, options = {}) {
+    this.ensureRunning();
+    this.throwIfAborted(options.signal);
+    const traceId = options.traceId ?? this.createTraceId();
+    const metricLabel = this.createMetricLabel(traceId);
+    this.deps.performance.startMeasurement(metricLabel);
+    let llmResponse;
+    let promptAfterHook = prompt;
+    let handoffToPlanFlow = false;
+    try {
+      const pluginContextFactory = (hookName) => ({
+        traceId,
+        hookName
+      });
+      promptAfterHook = await this.runHook(
+        "beforeLLM",
+        prompt,
+        pluginContextFactory("beforeLLM")
+      );
+      const llmContext = this.toRecord(this.deps.context.getContext());
+      const llmRequestBase = {
+        prompt: promptAfterHook,
+        context: llmContext,
+        signal: options.signal
+      };
+      const llmUseStructuredOutput = this.deps.config.get("llmUseStructuredOutput") !== false;
+      let llmStructuredResponse;
+      let llmResponseRaw;
+      if (llmUseStructuredOutput && typeof this.deps.llm.generateStructuredResponse === "function") {
+        const structuredRequest = {
+          ...llmRequestBase,
+          format: "runtime-plan",
+          strict: true
+        };
+        llmStructuredResponse = await this.deps.llm.generateStructuredResponse(structuredRequest);
+        if (llmStructuredResponse.valid && llmStructuredResponse.text.trim().length > 0) {
+          llmResponseRaw = {
+            text: llmStructuredResponse.text,
+            tokensUsed: llmStructuredResponse.tokensUsed,
+            model: llmStructuredResponse.model,
+            raw: {
+              mode: "structured",
+              value: llmStructuredResponse.value,
+              errors: llmStructuredResponse.errors,
+              payload: llmStructuredResponse.raw
+            }
+          };
+        } else {
+          const fallbackResponse = await this.deps.llm.generateResponse(llmRequestBase);
+          llmResponseRaw = {
+            ...fallbackResponse,
+            raw: {
+              mode: "fallback-text",
+              structuredErrors: llmStructuredResponse.errors ?? [],
+              fallbackPayload: fallbackResponse.raw
+            }
+          };
+        }
+      } else {
+        llmResponseRaw = await this.deps.llm.generateResponse(llmRequestBase);
+      }
+      llmResponse = await this.runHook(
+        "afterLLM",
+        llmResponseRaw,
+        pluginContextFactory("afterLLM")
+      );
+      const codegenInputRaw = {
+        prompt: promptAfterHook,
+        llmText: llmResponse.text,
+        context: llmContext
+      };
+      const codegenInput = await this.runHook(
+        "beforeCodeGen",
+        codegenInputRaw,
+        pluginContextFactory("beforeCodeGen")
+      );
+      const planned = await this.deps.codegen.generatePlan(codegenInput);
+      const planAfterCodegen = await this.runHook(
+        "afterCodeGen",
+        planned,
+        pluginContextFactory("afterCodeGen")
+      );
+      handoffToPlanFlow = true;
+      const planFlowResult = await this.executePlanFlow({
+        traceId,
+        metricLabel,
+        prompt: promptAfterHook,
+        plan: planAfterCodegen,
+        target: options.target,
+        signal: options.signal
+      });
+      return {
+        ...planFlowResult,
+        prompt: promptAfterHook,
+        llm: llmResponse
+      };
+    } catch (error) {
+      if (!handoffToPlanFlow) {
+        const metric = this.deps.performance.endMeasurement(metricLabel);
+        this.emit("renderFailed", { traceId, metric, error });
+      }
+      throw error;
+    }
+  }
+  async *renderPromptStream(prompt, options = {}) {
+    this.ensureRunning();
+    this.throwIfAborted(options.signal);
+    const traceId = options.traceId ?? this.createTraceId();
+    const metricLabel = this.createMetricLabel(traceId);
+    this.deps.performance.startMeasurement(metricLabel);
+    let promptAfterHook = prompt;
+    let handoffToPlanFlow = false;
+    let llmResponse;
+    try {
+      const pluginContextFactory = (hookName) => ({
+        traceId,
+        hookName
+      });
+      promptAfterHook = await this.runHook(
+        "beforeLLM",
+        prompt,
+        pluginContextFactory("beforeLLM")
+      );
+      const llmContext = this.toRecord(this.deps.context.getContext());
+      const llmRequestBase = {
+        prompt: promptAfterHook,
+        context: llmContext,
+        signal: options.signal
+      };
+      const incrementalCodegenSession = typeof this.deps.codegen.createIncrementalSession === "function" ? this.deps.codegen.createIncrementalSession({
+        prompt: promptAfterHook,
+        context: llmContext
+      }) : void 0;
+      const llmUseStructuredOutput = this.deps.config.get("llmUseStructuredOutput") !== false;
+      const streamPreviewInterval = Math.max(
+        1,
+        Math.floor(options.previewEveryChunks ?? 2)
+      );
+      const buildPreviewChunk = async (llmText, delta) => {
+        const preview = await this.buildStreamingPreview(
+          promptAfterHook,
+          llmText,
+          llmContext,
+          options.target,
+          incrementalCodegenSession,
+          delta,
+          options.signal
+        );
+        if (!preview) {
+          return void 0;
+        }
+        return {
+          type: "preview",
+          traceId,
+          prompt: promptAfterHook,
+          llmText,
+          html: preview.html,
+          diagnostics: preview.execution.diagnostics,
+          planId: preview.plan.id
+        };
+      };
+      if (llmUseStructuredOutput && typeof this.deps.llm.generateStructuredResponse === "function") {
+        const structuredRequest = {
+          ...llmRequestBase,
+          format: "runtime-plan",
+          strict: true
+        };
+        const structuredResponse = await this.deps.llm.generateStructuredResponse(structuredRequest);
+        if (structuredResponse.valid && structuredResponse.text.trim().length > 0) {
+          const fullText = structuredResponse.text;
+          const chunkSize = Math.max(256, Math.floor(fullText.length / 4));
+          let latestText = "";
+          for (let offset = 0; offset < fullText.length; offset += chunkSize) {
+            const delta = fullText.slice(offset, offset + chunkSize);
+            latestText += delta;
+            const done = latestText.length >= fullText.length;
+            yield {
+              type: "llm-delta",
+              traceId,
+              prompt: promptAfterHook,
+              llmText: latestText,
+              delta
+            };
+            if (done) {
+              const previewChunk = await buildPreviewChunk(latestText, delta);
+              if (previewChunk) {
+                yield previewChunk;
+              }
+            }
+          }
+          llmResponse = {
+            text: fullText,
+            tokensUsed: structuredResponse.tokensUsed ?? fullText.length,
+            model: structuredResponse.model,
+            raw: {
+              mode: "structured",
+              value: structuredResponse.value,
+              errors: structuredResponse.errors,
+              payload: structuredResponse.raw
+            }
+          };
+        } else {
+          let fallbackRaw;
+          if (typeof this.deps.llm.generateResponseStream === "function") {
+            let latestText = "";
+            let latestChunk;
+            let chunkCount = 0;
+            for await (const chunk of this.deps.llm.generateResponseStream(
+              llmRequestBase
+            )) {
+              this.throwIfAborted(options.signal);
+              chunkCount += 1;
+              latestChunk = chunk;
+              latestText = chunk.text;
+              yield {
+                type: "llm-delta",
+                traceId,
+                prompt: promptAfterHook,
+                llmText: latestText,
+                delta: chunk.delta
+              };
+              if (chunk.done || chunkCount % streamPreviewInterval === 0) {
+                const previewChunk = await buildPreviewChunk(
+                  latestText,
+                  chunk.delta
+                );
+                if (previewChunk) {
+                  yield previewChunk;
+                }
+              }
+            }
+            fallbackRaw = {
+              text: latestText,
+              tokensUsed: latestChunk?.tokensUsed ?? latestText.length,
+              model: latestChunk?.model,
+              raw: {
+                mode: "stream",
+                source: latestChunk?.raw
+              }
+            };
+          } else {
+            fallbackRaw = await this.deps.llm.generateResponse(llmRequestBase);
+            yield {
+              type: "llm-delta",
+              traceId,
+              prompt: promptAfterHook,
+              llmText: fallbackRaw.text,
+              delta: fallbackRaw.text
+            };
+          }
+          llmResponse = {
+            ...fallbackRaw,
+            raw: {
+              mode: "fallback-text",
+              structuredErrors: structuredResponse.errors ?? [],
+              fallbackPayload: fallbackRaw.raw
+            }
+          };
+        }
+      } else if (typeof this.deps.llm.generateResponseStream === "function") {
+        let latestText = "";
+        let latestChunk;
+        let chunkCount = 0;
+        for await (const chunk of this.deps.llm.generateResponseStream(
+          llmRequestBase
+        )) {
+          this.throwIfAborted(options.signal);
+          chunkCount += 1;
+          latestChunk = chunk;
+          latestText = chunk.text;
+          yield {
+            type: "llm-delta",
+            traceId,
+            prompt: promptAfterHook,
+            llmText: latestText,
+            delta: chunk.delta
+          };
+          if (chunk.done || chunkCount % streamPreviewInterval === 0) {
+            const previewChunk = await buildPreviewChunk(
+              latestText,
+              chunk.delta
+            );
+            if (previewChunk) {
+              yield previewChunk;
+            }
+          }
+        }
+        llmResponse = {
+          text: latestText,
+          tokensUsed: latestChunk?.tokensUsed ?? latestText.length,
+          model: latestChunk?.model,
+          raw: {
+            mode: "stream",
+            source: latestChunk?.raw
+          }
+        };
+      } else {
+        llmResponse = await this.deps.llm.generateResponse(llmRequestBase);
+        yield {
+          type: "llm-delta",
+          traceId,
+          prompt: promptAfterHook,
+          llmText: llmResponse.text,
+          delta: llmResponse.text
+        };
+      }
+      llmResponse = await this.runHook(
+        "afterLLM",
+        llmResponse,
+        pluginContextFactory("afterLLM")
+      );
+      const codegenInputRaw = {
+        prompt: promptAfterHook,
+        llmText: llmResponse.text,
+        context: llmContext
+      };
+      const codegenInput = await this.runHook(
+        "beforeCodeGen",
+        codegenInputRaw,
+        pluginContextFactory("beforeCodeGen")
+      );
+      const planned = await incrementalCodegenSession?.finalize(llmResponse.text) ?? await this.deps.codegen.generatePlan(codegenInput);
+      const planAfterCodegen = await this.runHook(
+        "afterCodeGen",
+        planned,
+        pluginContextFactory("afterCodeGen")
+      );
+      handoffToPlanFlow = true;
+      const planFlowResult = await this.executePlanFlow({
+        traceId,
+        metricLabel,
+        prompt: promptAfterHook,
+        plan: planAfterCodegen,
+        target: options.target,
+        signal: options.signal
+      });
+      const final = {
+        ...planFlowResult,
+        prompt: promptAfterHook,
+        llm: llmResponse
+      };
+      yield {
+        type: "final",
+        traceId,
+        prompt: promptAfterHook,
+        llmText: llmResponse.text,
+        html: final.html,
+        diagnostics: final.execution.diagnostics,
+        planId: final.plan.id,
+        final
+      };
+      return final;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      const errorName = error instanceof Error ? error.name : void 0;
+      yield {
+        type: "error",
+        traceId,
+        prompt: promptAfterHook,
+        llmText: llmResponse?.text ?? "",
+        error: {
+          message: errorMessage,
+          ...errorName ? { name: errorName } : {}
+        }
+      };
+      if (!handoffToPlanFlow) {
+        const metric = this.deps.performance.endMeasurement(metricLabel);
+        this.emit("renderFailed", { traceId, metric, error });
+      }
+      throw error;
+    }
+  }
+  async renderPlan(plan, options = {}) {
+    this.ensureRunning();
+    const traceId = options.traceId ?? this.createTraceId();
+    const metricLabel = this.createMetricLabel(traceId);
+    this.deps.performance.startMeasurement(metricLabel);
+    return this.executePlanFlow({
+      traceId,
+      metricLabel,
+      prompt: options.prompt,
+      plan,
+      target: options.target,
+      signal: options.signal
+    });
+  }
+  getConfig() {
+    return this.deps.config;
+  }
+  getContext() {
+    return this.deps.context;
+  }
+  getLLM() {
+    return this.deps.llm;
+  }
+  getCodeGenerator() {
+    return this.deps.codegen;
+  }
+  getRuntimeManager() {
+    return this.deps.runtime;
+  }
+  getSecurityChecker() {
+    return this.deps.security;
+  }
+  on(eventName, callback) {
+    if (!this.listeners.has(eventName)) {
+      this.listeners.set(eventName, /* @__PURE__ */ new Set());
+    }
+    this.listeners.get(eventName)?.add(callback);
+    return () => {
+      this.listeners.get(eventName)?.delete(callback);
+    };
+  }
+  emit(eventName, payload) {
+    const callbacks = this.listeners.get(eventName);
+    if (!callbacks) {
+      return;
+    }
+    for (const callback of callbacks) {
+      callback(payload);
+    }
+  }
+  async executePlanFlow(params) {
+    const { traceId, metricLabel, prompt, plan, target, signal } = params;
+    this.throwIfAborted(signal);
+    try {
+      const pluginContextFactory = (hookName) => ({
+        traceId,
+        hookName
+      });
+      const planBeforePolicy = await this.runHook(
+        "beforePolicyCheck",
+        plan,
+        pluginContextFactory("beforePolicyCheck")
+      );
+      const securityResultRaw = await this.deps.security.checkPlan(planBeforePolicy);
+      const securityResult = await this.runHook(
+        "afterPolicyCheck",
+        securityResultRaw,
+        pluginContextFactory("afterPolicyCheck")
+      );
+      if (!securityResult.safe) {
+        this.emit("policyRejected", securityResult);
+        throw new PolicyRejectionError(securityResult);
+      }
+      const runtimeInputRaw = {
+        plan: planBeforePolicy,
+        context: {
+          userId: this.resolveUserId(),
+          variables: {}
+        },
+        signal
+      };
+      const runtimeInput = await this.runHook(
+        "beforeRuntime",
+        runtimeInputRaw,
+        pluginContextFactory("beforeRuntime")
+      );
+      const runtimeExecutionRaw = await this.deps.runtime.execute(runtimeInput);
+      const runtimeExecution = await this.runHook(
+        "afterRuntime",
+        runtimeExecutionRaw,
+        pluginContextFactory("afterRuntime")
+      );
+      const renderInput = await this.runHook(
+        "beforeRender",
+        runtimeExecution,
+        pluginContextFactory("beforeRender")
+      );
+      const htmlRaw = await this.deps.ui.render(renderInput, target);
+      this.throwIfAborted(signal);
+      const html = await this.runHook(
+        "afterRender",
+        htmlRaw,
+        pluginContextFactory("afterRender")
+      );
+      const metric = this.deps.performance.endMeasurement(metricLabel);
+      this.emit("rendered", {
+        traceId,
+        metric,
+        prompt,
+        planId: planBeforePolicy.id
+      });
+      return {
+        traceId,
+        plan: planBeforePolicy,
+        security: securityResult,
+        execution: runtimeExecution,
+        html
+      };
+    } catch (error) {
+      const metric = this.deps.performance.endMeasurement(metricLabel);
+      this.emit("renderFailed", { traceId, metric, prompt, error });
+      throw error;
+    }
+  }
+  ensureRunning() {
+    if (!this.running) {
+      throw new Error("RenderifyApp is not started");
+    }
+  }
+  async runHook(hookName, payload, context) {
+    if (!this.deps.customization) {
+      return payload;
+    }
+    return this.deps.customization.runHook(hookName, payload, context);
+  }
+  toRecord(value) {
+    if (typeof value !== "object" || value === null) {
+      return {};
+    }
+    return value;
+  }
+  createTraceId() {
+    return `trace_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+  }
+  createMetricLabel(traceId) {
+    return `pipeline:${traceId}`;
+  }
+  resolveUserId() {
+    const candidate = this.deps.context.getContext().user?.id;
+    if (typeof candidate === "string" && candidate.trim().length > 0) {
+      return candidate.trim();
+    }
+    return "anonymous";
+  }
+  async buildStreamingPreview(prompt, llmText, context, target, incrementalCodegenSession, delta, signal) {
+    try {
+      this.throwIfAborted(signal);
+      let plan;
+      if (incrementalCodegenSession) {
+        if (typeof delta === "string" && delta.length > 0) {
+          const incrementalUpdate = await incrementalCodegenSession.pushDelta(delta);
+          plan = incrementalUpdate?.plan;
+        }
+        if (!plan) {
+          return void 0;
+        }
+      } else {
+        plan = await this.deps.codegen.generatePlan({
+          prompt,
+          llmText,
+          context
+        });
+      }
+      const security = await this.deps.security.checkPlan(plan);
+      if (!security.safe) {
+        return void 0;
+      }
+      const execution = await this.deps.runtime.execute({
+        plan,
+        context: {
+          userId: this.resolveUserId(),
+          variables: {}
+        },
+        signal
+      });
+      const html = await this.deps.ui.render(execution, target);
+      return {
+        plan,
+        execution,
+        html
+      };
+    } catch (error) {
+      if (error instanceof Error && error.name === "AbortError") {
+        throw error;
+      }
+      return void 0;
+    }
+  }
+  throwIfAborted(signal) {
+    if (!signal?.aborted) {
+      return;
+    }
+    const error = new Error("Renderify request aborted");
+    error.name = "AbortError";
+    throw error;
+  }
+};
+function createRenderifyApp(deps) {
+  return new RenderifyApp(deps);
+}
+//# sourceMappingURL=core.cjs.js.map