@frontmcp/uipack 0.6.1

package/esm/dependency/index.js

@@ -0,0 +1,3096 @@
+// libs/uipack/src/dependency/types.ts
+function detectTemplateMode(template) {
+  if (typeof template === "function") {
+    return "inline-function";
+  }
+  if (typeof template === "string") {
+    if (template.startsWith("http://") || template.startsWith("https://")) {
+      return "url";
+    }
+    const looksLikeFilePath = (
+      // Relative paths
+      template.startsWith("./") || template.startsWith("../") || // Absolute paths (Unix)
+      template.startsWith("/") || // Windows-style paths (C:\, D:\, etc.)
+      /^[A-Za-z]:\\/.test(template) || // File extensions (must not contain spaces to avoid false positives)
+      /\.(tsx?|jsx?|mdx?)$/i.test(template) && !template.includes(" ")
+    );
+    if (looksLikeFilePath && template.length < 500 && !template.includes("\n") && !template.includes("<")) {
+      return "file-path";
+    }
+  }
+  return "inline-string";
+}
+function detectFormatFromPath(pathOrUrl) {
+  const lower = pathOrUrl.toLowerCase();
+  if (lower.endsWith(".tsx") || lower.endsWith(".jsx")) {
+    return "react";
+  }
+  if (lower.endsWith(".mdx")) {
+    return "mdx";
+  }
+  if (lower.endsWith(".md")) {
+    return "markdown";
+  }
+  return "html";
+}
+
+// libs/uipack/src/dependency/schemas.ts
+import { z } from "zod";
+var cdnProviderSchema = z.enum(["cloudflare", "jsdelivr", "unpkg", "esm.sh", "skypack"]);
+var cdnPlatformTypeSchema = z.enum(["claude", "openai", "cursor", "gemini", "continue", "cody", "unknown"]);
+var cdnDependencySchema = z.object({
+  /**
+   * CDN URL (must be HTTPS).
+   */
+  url: z.string().url().refine((url) => url.startsWith("https://"), {
+    message: "CDN URLs must use HTTPS"
+  }),
+  /**
+   * SRI integrity hash.
+   */
+  integrity: z.string().regex(/^sha(256|384|512)-[A-Za-z0-9+/=]+$/, {
+    message: "Invalid SRI hash format. Must be sha256-, sha384-, or sha512- followed by base64"
+  }).optional(),
+  /**
+   * Global variable name for UMD builds.
+   */
+  global: z.string().min(1).optional(),
+  /**
+   * Named exports from the library.
+   */
+  exports: z.array(z.string().min(1)).optional(),
+  /**
+   * Whether this is an ES module.
+   */
+  esm: z.boolean().optional(),
+  /**
+   * Cross-origin attribute.
+   */
+  crossorigin: z.enum(["anonymous", "use-credentials"]).optional(),
+  /**
+   * Peer dependencies (npm package names).
+   */
+  peerDependencies: z.array(z.string().min(1)).optional()
+}).strict();
+var bundleTargetSchema = z.enum(["es2018", "es2019", "es2020", "es2021", "es2022", "esnext"]);
+var fileBundleOptionsSchema = z.object({
+  /**
+   * Minify output.
+   */
+  minify: z.boolean().optional(),
+  /**
+   * Generate source maps.
+   */
+  sourceMaps: z.boolean().optional(),
+  /**
+   * Target JavaScript version.
+   */
+  target: bundleTargetSchema.optional(),
+  /**
+   * Enable tree shaking.
+   */
+  treeShake: z.boolean().optional(),
+  /**
+   * JSX factory function.
+   */
+  jsxFactory: z.string().min(1).optional(),
+  /**
+   * JSX fragment factory.
+   */
+  jsxFragment: z.string().min(1).optional(),
+  /**
+   * JSX import source.
+   */
+  jsxImportSource: z.string().min(1).optional()
+}).strict();
+var fileTemplateConfigSchema = z.object({
+  /**
+   * Packages to load from CDN.
+   */
+  externals: z.array(z.string().min(1)).optional(),
+  /**
+   * Explicit CDN dependency overrides.
+   */
+  dependencies: z.record(z.string().min(1), cdnDependencySchema).optional(),
+  /**
+   * Bundle options.
+   */
+  bundleOptions: fileBundleOptionsSchema.optional()
+}).strict();
+var importMapSchema = z.object({
+  /**
+   * Module specifier to URL mappings.
+   */
+  imports: z.record(
+    z.string().min(1),
+    z.string().url().refine((url) => url.startsWith("https://"), {
+      message: "Import map URLs must use HTTPS"
+    })
+  ),
+  /**
+   * Scoped mappings.
+   */
+  scopes: z.record(
+    z.string().min(1),
+    z.record(
+      z.string().min(1),
+      z.string().url().refine((url) => url.startsWith("https://"), {
+        message: "Scoped import URLs must use HTTPS"
+      })
+    )
+  ).optional(),
+  /**
+   * Integrity hashes.
+   */
+  integrity: z.record(z.string().url(), z.string().regex(/^sha(256|384|512)-[A-Za-z0-9+/=]+$/)).optional()
+}).strict();
+var resolvedDependencySchema = z.object({
+  packageName: z.string().min(1),
+  version: z.string().min(1),
+  cdnUrl: z.string().url(),
+  integrity: z.string().optional(),
+  global: z.string().optional(),
+  esm: z.boolean(),
+  provider: cdnProviderSchema
+}).strict();
+var buildManifestMetadataSchema = z.object({
+  createdAt: z.string().datetime(),
+  buildTimeMs: z.number().nonnegative(),
+  totalSize: z.number().nonnegative(),
+  bundlerVersion: z.string().optional()
+}).strict();
+var buildManifestOutputsSchema = z.object({
+  code: z.string(),
+  sourceMap: z.string().optional(),
+  ssrHtml: z.string().optional()
+}).strict();
+var componentBuildManifestSchema = z.object({
+  version: z.literal("1.0"),
+  buildId: z.string().uuid(),
+  toolName: z.string().min(1),
+  entryPath: z.string().min(1),
+  contentHash: z.string().regex(/^[a-f0-9]{64}$/, {
+    message: "Content hash must be a 64-character SHA-256 hex string"
+  }),
+  dependencies: z.array(resolvedDependencySchema),
+  outputs: buildManifestOutputsSchema,
+  importMap: importMapSchema,
+  metadata: buildManifestMetadataSchema
+}).strict();
+var cdnProviderConfigSchema = z.record(cdnProviderSchema, cdnDependencySchema);
+var packageMetadataSchema = z.object({
+  description: z.string().optional(),
+  homepage: z.string().url().optional(),
+  license: z.string().optional()
+}).strict();
+var cdnRegistryEntrySchema = z.object({
+  packageName: z.string().min(1),
+  defaultVersion: z.string().min(1),
+  providers: cdnProviderConfigSchema,
+  preferredProviders: z.array(cdnProviderSchema).optional(),
+  metadata: packageMetadataSchema.optional()
+}).strict();
+var dependencyResolverOptionsSchema = z.object({
+  platform: cdnPlatformTypeSchema.optional(),
+  preferredProviders: z.array(cdnProviderSchema).optional(),
+  customRegistry: z.record(z.string().min(1), cdnRegistryEntrySchema).optional(),
+  strictMode: z.boolean().optional(),
+  requireIntegrity: z.boolean().optional()
+}).strict();
+var importTypeSchema = z.enum(["named", "default", "namespace", "side-effect", "dynamic"]);
+var parsedImportSchema = z.object({
+  statement: z.string(),
+  specifier: z.string().min(1),
+  type: importTypeSchema,
+  namedImports: z.array(z.string().min(1)).optional(),
+  defaultImport: z.string().min(1).optional(),
+  namespaceImport: z.string().min(1).optional(),
+  line: z.number().int().positive(),
+  column: z.number().int().nonnegative()
+}).strict();
+var parsedImportResultSchema = z.object({
+  imports: z.array(parsedImportSchema),
+  externalImports: z.array(parsedImportSchema),
+  relativeImports: z.array(parsedImportSchema),
+  externalPackages: z.array(z.string().min(1))
+}).strict();
+var cacheStatsSchema = z.object({
+  entries: z.number().int().nonnegative(),
+  totalSize: z.number().nonnegative(),
+  hits: z.number().int().nonnegative(),
+  misses: z.number().int().nonnegative(),
+  hitRate: z.number().min(0).max(1)
+}).strict();
+function validateCDNDependency(data) {
+  return cdnDependencySchema.parse(data);
+}
+function safeParseCDNDependency(data) {
+  return cdnDependencySchema.safeParse(data);
+}
+function validateFileTemplateConfig(data) {
+  return fileTemplateConfigSchema.parse(data);
+}
+function safeParseFileTemplateConfig(data) {
+  return fileTemplateConfigSchema.safeParse(data);
+}
+function validateBuildManifest(data) {
+  return componentBuildManifestSchema.parse(data);
+}
+function safeParseBuildManifest(data) {
+  return componentBuildManifestSchema.safeParse(data);
+}
+
+// libs/uipack/src/dependency/cdn-registry.ts
+var DEFAULT_CDN_REGISTRY = {
+  // ============================================
+  // React Ecosystem
+  // ============================================
+  react: {
+    packageName: "react",
+    defaultVersion: "18.3.1",
+    providers: {
+      cloudflare: {
+        url: "https://cdnjs.cloudflare.com/ajax/libs/react/18.3.1/umd/react.production.min.js",
+        integrity: "sha512-Qp8J4Xr8LBZ5CXNJQc/HmLqFrpXz6lNkbzMYkYHKzQx5p1q1yOqPQHntXKoYgPPE/n9m0QF1OkJdXa2ePpO4fw==",
+        global: "React",
+        crossorigin: "anonymous"
+      },
+      jsdelivr: {
+        url: "https://cdn.jsdelivr.net/npm/react@18.3.1/umd/react.production.min.js",
+        global: "React",
+        crossorigin: "anonymous"
+      },
+      unpkg: {
+        url: "https://unpkg.com/react@18.3.1/umd/react.production.min.js",
+        global: "React",
+        crossorigin: "anonymous"
+      },
+      "esm.sh": {
+        url: "https://esm.sh/react@18.3.1",
+        esm: true,
+        crossorigin: "anonymous"
+      }
+    },
+    preferredProviders: ["cloudflare", "jsdelivr", "unpkg", "esm.sh"],
+    metadata: {
+      description: "A JavaScript library for building user interfaces",
+      homepage: "https://react.dev",
+      license: "MIT"
+    }
+  },
+  "react-dom": {
+    packageName: "react-dom",
+    defaultVersion: "18.3.1",
+    providers: {
+      cloudflare: {
+        url: "https://cdnjs.cloudflare.com/ajax/libs/react-dom/18.3.1/umd/react-dom.production.min.js",
+        integrity: "sha512-6s2gVRdS3aT+FDdZTRJSzKlzIPqDXWyYl/5hPQb6hSgzKPGFcQyZhbqjbWVxGrs2dYNrINFXb0k0UD3d+CKPJA==",
+        global: "ReactDOM",
+        crossorigin: "anonymous",
+        peerDependencies: ["react"]
+      },
+      jsdelivr: {
+        url: "https://cdn.jsdelivr.net/npm/react-dom@18.3.1/umd/react-dom.production.min.js",
+        global: "ReactDOM",
+        crossorigin: "anonymous",
+        peerDependencies: ["react"]
+      },
+      unpkg: {
+        url: "https://unpkg.com/react-dom@18.3.1/umd/react-dom.production.min.js",
+        global: "ReactDOM",
+        crossorigin: "anonymous",
+        peerDependencies: ["react"]
+      },
+      "esm.sh": {
+        url: "https://esm.sh/react-dom@18.3.1",
+        esm: true,
+        crossorigin: "anonymous",
+        peerDependencies: ["react"]
+      }
+    },
+    preferredProviders: ["cloudflare", "jsdelivr", "unpkg", "esm.sh"],
+    metadata: {
+      description: "React package for working with the DOM",
+      homepage: "https://react.dev",
+      license: "MIT"
+    }
+  },
+  // ============================================
+  // Charting Libraries
+  // ============================================
+  "chart.js": {
+    packageName: "chart.js",
+    defaultVersion: "4.4.7",
+    providers: {
+      cloudflare: {
+        url: "https://cdnjs.cloudflare.com/ajax/libs/Chart.js/4.4.7/chart.umd.min.js",
+        integrity: "sha512-dMDjIoZjJD6gs0KPBhFYjLQrH3kIohSEn6HzWs6Y6GiO0+L9kk/bM3cR5KNEDK1KvMNpTIZG6pHK9SZfCJHRpQ==",
+        global: "Chart",
+        crossorigin: "anonymous"
+      },
+      jsdelivr: {
+        url: "https://cdn.jsdelivr.net/npm/chart.js@4.4.7/dist/chart.umd.min.js",
+        global: "Chart",
+        crossorigin: "anonymous"
+      },
+      unpkg: {
+        url: "https://unpkg.com/chart.js@4.4.7/dist/chart.umd.min.js",
+        global: "Chart",
+        crossorigin: "anonymous"
+      }
+    },
+    preferredProviders: ["cloudflare", "jsdelivr", "unpkg"],
+    metadata: {
+      description: "Simple yet flexible JavaScript charting library",
+      homepage: "https://www.chartjs.org",
+      license: "MIT"
+    }
+  },
+  "react-chartjs-2": {
+    packageName: "react-chartjs-2",
+    defaultVersion: "5.3.0",
+    providers: {
+      cloudflare: {
+        url: "https://cdnjs.cloudflare.com/ajax/libs/react-chartjs-2/5.3.0/react-chartjs-2.min.js",
+        global: "ReactChartjs2",
+        crossorigin: "anonymous",
+        peerDependencies: ["react", "chart.js"]
+      },
+      jsdelivr: {
+        url: "https://cdn.jsdelivr.net/npm/react-chartjs-2@5.3.0/dist/index.umd.js",
+        global: "ReactChartjs2",
+        crossorigin: "anonymous",
+        peerDependencies: ["react", "chart.js"]
+      },
+      "esm.sh": {
+        url: "https://esm.sh/react-chartjs-2@5.3.0",
+        esm: true,
+        crossorigin: "anonymous",
+        peerDependencies: ["react", "chart.js"]
+      }
+    },
+    preferredProviders: ["cloudflare", "jsdelivr", "esm.sh"],
+    metadata: {
+      description: "React components for Chart.js",
+      homepage: "https://react-chartjs-2.js.org",
+      license: "MIT"
+    }
+  },
+  // ============================================
+  // D3.js
+  // ============================================
+  d3: {
+    packageName: "d3",
+    defaultVersion: "7.9.0",
+    providers: {
+      cloudflare: {
+        url: "https://cdnjs.cloudflare.com/ajax/libs/d3/7.9.0/d3.min.js",
+        integrity: "sha512-vc58qvvBdrDR4etbxMdlTt4GBQk1qjvyORR2nrsPsFPyrs+/u5c3+1Ct6upOgdZoIl7eq6k3a1UPDSNAQi/32A==",
+        global: "d3",
+        crossorigin: "anonymous"
+      },
+      jsdelivr: {
+        url: "https://cdn.jsdelivr.net/npm/d3@7.9.0/dist/d3.min.js",
+        global: "d3",
+        crossorigin: "anonymous"
+      },
+      unpkg: {
+        url: "https://unpkg.com/d3@7.9.0/dist/d3.min.js",
+        global: "d3",
+        crossorigin: "anonymous"
+      }
+    },
+    preferredProviders: ["cloudflare", "jsdelivr", "unpkg"],
+    metadata: {
+      description: "Data-Driven Documents",
+      homepage: "https://d3js.org",
+      license: "ISC"
+    }
+  },
+  // ============================================
+  // Utility Libraries
+  // ============================================
+  lodash: {
+    packageName: "lodash",
+    defaultVersion: "4.17.21",
+    providers: {
+      cloudflare: {
+        url: "https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.21/lodash.min.js",
+        integrity: "sha512-WFN04846sdKMIP5LKNphMaWzU7YpMyCU245etK3g/2ARYbPK9Ub18eG+ljU96qKRCWh+quCY7yefSmlkQw1ANQ==",
+        global: "_",
+        crossorigin: "anonymous"
+      },
+      jsdelivr: {
+        url: "https://cdn.jsdelivr.net/npm/lodash@4.17.21/lodash.min.js",
+        global: "_",
+        crossorigin: "anonymous"
+      },
+      unpkg: {
+        url: "https://unpkg.com/lodash@4.17.21/lodash.min.js",
+        global: "_",
+        crossorigin: "anonymous"
+      }
+    },
+    preferredProviders: ["cloudflare", "jsdelivr", "unpkg"],
+    metadata: {
+      description: "A modern JavaScript utility library",
+      homepage: "https://lodash.com",
+      license: "MIT"
+    }
+  },
+  "lodash-es": {
+    packageName: "lodash-es",
+    defaultVersion: "4.17.21",
+    providers: {
+      "esm.sh": {
+        url: "https://esm.sh/lodash-es@4.17.21",
+        esm: true,
+        crossorigin: "anonymous"
+      },
+      jsdelivr: {
+        url: "https://cdn.jsdelivr.net/npm/lodash-es@4.17.21/+esm",
+        esm: true,
+        crossorigin: "anonymous"
+      }
+    },
+    preferredProviders: ["esm.sh", "jsdelivr"],
+    metadata: {
+      description: "Lodash exported as ES modules",
+      homepage: "https://lodash.com",
+      license: "MIT"
+    }
+  },
+  dayjs: {
+    packageName: "dayjs",
+    defaultVersion: "1.11.13",
+    providers: {
+      cloudflare: {
+        url: "https://cdnjs.cloudflare.com/ajax/libs/dayjs/1.11.13/dayjs.min.js",
+        integrity: "sha512-Ot7ArUEhJDU0cwoBNNnWe487kjL5wAOsIYig8llY/l0P2TUFwgsAHVmrZMHsT8NGo+HwkjTJsNErS6QqIkBxDw==",
+        global: "dayjs",
+        crossorigin: "anonymous"
+      },
+      jsdelivr: {
+        url: "https://cdn.jsdelivr.net/npm/dayjs@1.11.13/dayjs.min.js",
+        global: "dayjs",
+        crossorigin: "anonymous"
+      },
+      unpkg: {
+        url: "https://unpkg.com/dayjs@1.11.13/dayjs.min.js",
+        global: "dayjs",
+        crossorigin: "anonymous"
+      }
+    },
+    preferredProviders: ["cloudflare", "jsdelivr", "unpkg"],
+    metadata: {
+      description: "Fast 2kB alternative to Moment.js with the same modern API",
+      homepage: "https://day.js.org",
+      license: "MIT"
+    }
+  },
+  "date-fns": {
+    packageName: "date-fns",
+    defaultVersion: "4.1.0",
+    providers: {
+      "esm.sh": {
+        url: "https://esm.sh/date-fns@4.1.0",
+        esm: true,
+        crossorigin: "anonymous"
+      },
+      jsdelivr: {
+        url: "https://cdn.jsdelivr.net/npm/date-fns@4.1.0/+esm",
+        esm: true,
+        crossorigin: "anonymous"
+      }
+    },
+    preferredProviders: ["esm.sh", "jsdelivr"],
+    metadata: {
+      description: "Modern JavaScript date utility library",
+      homepage: "https://date-fns.org",
+      license: "MIT"
+    }
+  },
+  // ============================================
+  // Animation Libraries
+  // ============================================
+  "framer-motion": {
+    packageName: "framer-motion",
+    defaultVersion: "11.15.0",
+    providers: {
+      "esm.sh": {
+        url: "https://esm.sh/framer-motion@11.15.0",
+        esm: true,
+        crossorigin: "anonymous",
+        peerDependencies: ["react", "react-dom"]
+      },
+      jsdelivr: {
+        url: "https://cdn.jsdelivr.net/npm/framer-motion@11.15.0/dist/framer-motion.js",
+        global: "Motion",
+        crossorigin: "anonymous",
+        peerDependencies: ["react", "react-dom"]
+      }
+    },
+    preferredProviders: ["esm.sh", "jsdelivr"],
+    metadata: {
+      description: "Production-ready motion library for React",
+      homepage: "https://www.framer.com/motion/",
+      license: "MIT"
+    }
+  },
+  // ============================================
+  // UI Component Libraries
+  // ============================================
+  "lucide-react": {
+    packageName: "lucide-react",
+    defaultVersion: "0.468.0",
+    providers: {
+      "esm.sh": {
+        url: "https://esm.sh/lucide-react@0.468.0",
+        esm: true,
+        crossorigin: "anonymous",
+        peerDependencies: ["react"]
+      },
+      jsdelivr: {
+        url: "https://cdn.jsdelivr.net/npm/lucide-react@0.468.0/dist/esm/lucide-react.js",
+        esm: true,
+        crossorigin: "anonymous",
+        peerDependencies: ["react"]
+      }
+    },
+    preferredProviders: ["esm.sh", "jsdelivr"],
+    metadata: {
+      description: "Beautiful & consistent icon toolkit for React",
+      homepage: "https://lucide.dev",
+      license: "ISC"
+    }
+  },
+  // ============================================
+  // Markdown/Syntax Highlighting
+  // ============================================
+  marked: {
+    packageName: "marked",
+    defaultVersion: "15.0.4",
+    providers: {
+      cloudflare: {
+        url: "https://cdnjs.cloudflare.com/ajax/libs/marked/15.0.4/marked.min.js",
+        integrity: "sha512-Rn/d0sGeizGbk3VJEiYNDt/mMcfuzYoFkia3iBffv+HX8VUrHMo/0cKjZuxWGoZLPh/VxUcC9ais+RBFZW9EBg==",
+        global: "marked",
+        crossorigin: "anonymous"
+      },
+      jsdelivr: {
+        url: "https://cdn.jsdelivr.net/npm/marked@15.0.4/marked.min.js",
+        global: "marked",
+        crossorigin: "anonymous"
+      },
+      unpkg: {
+        url: "https://unpkg.com/marked@15.0.4/marked.min.js",
+        global: "marked",
+        crossorigin: "anonymous"
+      }
+    },
+    preferredProviders: ["cloudflare", "jsdelivr", "unpkg"],
+    metadata: {
+      description: "A markdown parser and compiler",
+      homepage: "https://marked.js.org",
+      license: "MIT"
+    }
+  },
+  "highlight.js": {
+    packageName: "highlight.js",
+    defaultVersion: "11.10.0",
+    providers: {
+      cloudflare: {
+        url: "https://cdnjs.cloudflare.com/ajax/libs/highlight.js/11.10.0/highlight.min.js",
+        integrity: "sha512-6yoqbrcLAHDWAdQmiRlHG4+m0g/CT/V9AGyxabG8j7Jk8j3v3k6mIP1iN/PvSofcWet2tf8SRn/j3L/+pb7LRQ==",
+        global: "hljs",
+        crossorigin: "anonymous"
+      },
+      jsdelivr: {
+        url: "https://cdn.jsdelivr.net/npm/highlight.js@11.10.0/lib/core.min.js",
+        global: "hljs",
+        crossorigin: "anonymous"
+      },
+      unpkg: {
+        url: "https://unpkg.com/highlight.js@11.10.0/lib/core.min.js",
+        global: "hljs",
+        crossorigin: "anonymous"
+      }
+    },
+    preferredProviders: ["cloudflare", "jsdelivr", "unpkg"],
+    metadata: {
+      description: "Syntax highlighting for the web",
+      homepage: "https://highlightjs.org",
+      license: "BSD-3-Clause"
+    }
+  },
+  // ============================================
+  // Interactive Libraries
+  // ============================================
+  "htmx.org": {
+    packageName: "htmx.org",
+    defaultVersion: "2.0.4",
+    providers: {
+      cloudflare: {
+        url: "https://cdnjs.cloudflare.com/ajax/libs/htmx/2.0.4/htmx.min.js",
+        integrity: "sha512-2kIcAizYXhIn5IyXrMC72f2nh0JAtESHRpOieVw5dYPYeHwLCC2eKCqvdZDYRSEgasKrPpEPpRFjL8gqwBZWAA==",
+        global: "htmx",
+        crossorigin: "anonymous"
+      },
+      jsdelivr: {
+        url: "https://cdn.jsdelivr.net/npm/htmx.org@2.0.4/dist/htmx.min.js",
+        global: "htmx",
+        crossorigin: "anonymous"
+      },
+      unpkg: {
+        url: "https://unpkg.com/htmx.org@2.0.4/dist/htmx.min.js",
+        global: "htmx",
+        crossorigin: "anonymous"
+      }
+    },
+    preferredProviders: ["cloudflare", "jsdelivr", "unpkg"],
+    metadata: {
+      description: "High power tools for HTML",
+      homepage: "https://htmx.org",
+      license: "BSD-2-Clause"
+    }
+  },
+  alpinejs: {
+    packageName: "alpinejs",
+    defaultVersion: "3.14.3",
+    providers: {
+      cloudflare: {
+        url: "https://cdnjs.cloudflare.com/ajax/libs/alpinejs/3.14.3/cdn.min.js",
+        integrity: "sha512-lrQ8FHgsWKFSuQFq8NKPJicjlvJFEIrCqEj8zeX7ZOUlHWltN/Iow4jND+x84jqTdDf9n+hvQpJjGDvOl/eDRA==",
+        global: "Alpine",
+        crossorigin: "anonymous"
+      },
+      jsdelivr: {
+        url: "https://cdn.jsdelivr.net/npm/alpinejs@3.14.3/dist/cdn.min.js",
+        global: "Alpine",
+        crossorigin: "anonymous"
+      },
+      unpkg: {
+        url: "https://unpkg.com/alpinejs@3.14.3/dist/cdn.min.js",
+        global: "Alpine",
+        crossorigin: "anonymous"
+      }
+    },
+    preferredProviders: ["cloudflare", "jsdelivr", "unpkg"],
+    metadata: {
+      description: "A rugged, minimal framework for composing behavior directly in your markup",
+      homepage: "https://alpinejs.dev",
+      license: "MIT"
+    }
+  },
+  // ============================================
+  // Templating Libraries
+  // ============================================
+  handlebars: {
+    packageName: "handlebars",
+    defaultVersion: "4.7.8",
+    providers: {
+      cloudflare: {
+        url: "https://cdnjs.cloudflare.com/ajax/libs/handlebars.js/4.7.8/handlebars.min.js",
+        integrity: "sha512-E1dSFxg+wsfJ4HKjutk/WaCzK7S2wv1POn1RRPGh8ZK+ag9l244Vqxji3r6wgz9YBf6+vhQEYJZpSjqWFPg9gg==",
+        global: "Handlebars",
+        crossorigin: "anonymous"
+      },
+      jsdelivr: {
+        url: "https://cdn.jsdelivr.net/npm/handlebars@4.7.8/dist/handlebars.min.js",
+        global: "Handlebars",
+        crossorigin: "anonymous"
+      },
+      unpkg: {
+        url: "https://unpkg.com/handlebars@4.7.8/dist/handlebars.min.js",
+        global: "Handlebars",
+        crossorigin: "anonymous"
+      }
+    },
+    preferredProviders: ["cloudflare", "jsdelivr", "unpkg"],
+    metadata: {
+      description: "Minimal templating on steroids",
+      homepage: "https://handlebarsjs.com",
+      license: "MIT"
+    }
+  }
+};
+var CDN_PROVIDER_PRIORITY = {
+  claude: ["cloudflare"],
+  // ONLY cloudflare for Claude
+  openai: ["cloudflare", "jsdelivr", "unpkg", "esm.sh"],
+  cursor: ["cloudflare", "jsdelivr", "unpkg", "esm.sh"],
+  gemini: ["cloudflare", "jsdelivr", "unpkg", "esm.sh"],
+  continue: ["cloudflare", "jsdelivr", "unpkg", "esm.sh"],
+  cody: ["cloudflare", "jsdelivr", "unpkg", "esm.sh"],
+  unknown: ["cloudflare", "jsdelivr", "unpkg", "esm.sh"]
+  // Default to cloudflare first
+};
+function lookupPackage(packageName, registry = DEFAULT_CDN_REGISTRY) {
+  return registry[packageName];
+}
+function getPackageCDNUrl(packageName, platform = "unknown", registry = DEFAULT_CDN_REGISTRY) {
+  const entry = lookupPackage(packageName, registry);
+  if (!entry) return void 0;
+  const providerPriority = CDN_PROVIDER_PRIORITY[platform];
+  for (const provider of providerPriority) {
+    const config = entry.providers[provider];
+    if (config?.url) {
+      return config.url;
+    }
+  }
+  for (const provider of Object.keys(entry.providers)) {
+    const config = entry.providers[provider];
+    if (config?.url) {
+      return config.url;
+    }
+  }
+  return void 0;
+}
+function getPackageCDNDependency(packageName, platform = "unknown", registry = DEFAULT_CDN_REGISTRY) {
+  const entry = lookupPackage(packageName, registry);
+  if (!entry) return void 0;
+  const providerPriority = CDN_PROVIDER_PRIORITY[platform];
+  for (const provider of providerPriority) {
+    const config = entry.providers[provider];
+    if (config?.url) {
+      return { provider, dependency: config };
+    }
+  }
+  for (const provider of Object.keys(entry.providers)) {
+    const config = entry.providers[provider];
+    if (config?.url) {
+      return { provider, dependency: config };
+    }
+  }
+  return void 0;
+}
+function getRegisteredPackages(registry = DEFAULT_CDN_REGISTRY) {
+  return Object.keys(registry);
+}
+function isPackageRegistered(packageName, registry = DEFAULT_CDN_REGISTRY) {
+  return packageName in registry;
+}
+function mergeRegistries(customRegistry) {
+  return {
+    ...DEFAULT_CDN_REGISTRY,
+    ...customRegistry
+  };
+}
+function getPackagePeerDependencies(packageName, registry = DEFAULT_CDN_REGISTRY) {
+  const entry = lookupPackage(packageName, registry);
+  if (!entry) return [];
+  for (const provider of Object.keys(entry.providers)) {
+    const config = entry.providers[provider];
+    if (config?.peerDependencies) {
+      return config.peerDependencies;
+    }
+  }
+  return [];
+}
+function resolveAllDependencies(packageNames, platform = "unknown", registry = DEFAULT_CDN_REGISTRY) {
+  const resolved = /* @__PURE__ */ new Set();
+  const queue = [...packageNames];
+  while (queue.length > 0) {
+    const packageName = queue.shift();
+    if (!packageName) continue;
+    if (resolved.has(packageName)) continue;
+    resolved.add(packageName);
+    const peers = getPackagePeerDependencies(packageName, registry);
+    for (const peer of peers) {
+      if (!resolved.has(peer)) {
+        queue.push(peer);
+      }
+    }
+  }
+  const result = [];
+  const remaining = new Set(resolved);
+  while (remaining.size > 0) {
+    let added = false;
+    for (const pkg of remaining) {
+      const peers = getPackagePeerDependencies(pkg, registry);
+      const allPeersResolved = peers.every((peer) => !remaining.has(peer) || result.includes(peer));
+      if (allPeersResolved) {
+        if (!result.includes(pkg)) {
+          result.push(pkg);
+        }
+        remaining.delete(pkg);
+        added = true;
+      }
+    }
+    if (!added && remaining.size > 0) {
+      const next = remaining.values().next().value;
+      if (next !== void 0) {
+        if (!result.includes(next)) {
+          result.push(next);
+        }
+        remaining.delete(next);
+      }
+    }
+  }
+  return result;
+}
+
+// libs/uipack/src/dependency/import-parser.ts
+var IMPORT_PATTERNS = {
+  /**
+   * Named imports: import { foo, bar } from 'module'
+   * Also handles renamed imports: import { foo as f } from 'module'
+   */
+  named: /import\s*\{([^}]+)\}\s*from\s*['"]([^'"]+)['"]/g,
+  /**
+   * Default imports: import foo from 'module'
+   */
+  default: /import\s+(\w+)\s+from\s*['"]([^'"]+)['"]/g,
+  /**
+   * Namespace imports: import * as foo from 'module'
+   */
+  namespace: /import\s*\*\s*as\s+(\w+)\s+from\s*['"]([^'"]+)['"]/g,
+  /**
+   * Side-effect imports: import 'module'
+   */
+  sideEffect: /import\s*['"]([^'"]+)['"]/g,
+  /**
+   * Dynamic imports: import('module') or await import('module')
+   */
+  dynamic: /(?:await\s+)?import\s*\(\s*['"]([^'"]+)['"]\s*\)/g,
+  /**
+   * Combined default and named: import foo, { bar } from 'module'
+   */
+  defaultAndNamed: /import\s+(\w+)\s*,\s*\{([^}]+)\}\s*from\s*['"]([^'"]+)['"]/g,
+  /**
+   * Combined default and namespace: import foo, * as bar from 'module'
+   */
+  defaultAndNamespace: /import\s+(\w+)\s*,\s*\*\s*as\s+(\w+)\s+from\s*['"]([^'"]+)['"]/g,
+  /**
+   * Re-exports: export { foo } from 'module'
+   */
+  reExport: /export\s*\{[^}]+\}\s*from\s*['"]([^'"]+)['"]/g,
+  /**
+   * Re-export all: export * from 'module'
+   */
+  reExportAll: /export\s*\*\s*from\s*['"]([^'"]+)['"]/g
+};
+function parseNamedImports(namedString) {
+  return namedString.split(",").map((s) => s.trim()).filter((s) => s.length > 0).map((s) => {
+    const asMatch = s.match(/^(\w+)\s+as\s+\w+$/);
+    return asMatch ? asMatch[1] : s;
+  });
+}
+function isRelativeImport(specifier) {
+  return specifier.startsWith("./") || specifier.startsWith("../") || specifier.startsWith("/");
+}
+function isExternalImport(specifier) {
+  return !isRelativeImport(specifier) && !specifier.startsWith("#");
+}
+function getPackageName(specifier) {
+  if (specifier.startsWith("@")) {
+    const parts = specifier.split("/");
+    if (parts.length >= 2) {
+      return `${parts[0]}/${parts[1]}`;
+    }
+    return specifier;
+  }
+  const firstSlash = specifier.indexOf("/");
+  return firstSlash === -1 ? specifier : specifier.slice(0, firstSlash);
+}
+function getLineNumber(source, index) {
+  let line = 1;
+  for (let i = 0; i < index && i < source.length; i++) {
+    if (source[i] === "\n") {
+      line++;
+    }
+  }
+  return line;
+}
+function getColumnNumber(source, index) {
+  let column = 0;
+  for (let i = index - 1; i >= 0 && source[i] !== "\n"; i--) {
+    column++;
+  }
+  return column;
+}
+function parseImports(source) {
+  const imports = [];
+  const seenStatements = /* @__PURE__ */ new Set();
+  const addImport = (imp) => {
+    const key = `${imp.type}:${imp.specifier}:${imp.statement}`;
+    if (!seenStatements.has(key)) {
+      seenStatements.add(key);
+      imports.push(imp);
+    }
+  };
+  let match;
+  const defaultAndNamedRegex = new RegExp(IMPORT_PATTERNS.defaultAndNamed.source, "g");
+  while ((match = defaultAndNamedRegex.exec(source)) !== null) {
+    const [statement, defaultName, namedString, specifier] = match;
+    const namedImports = parseNamedImports(namedString);
+    addImport({
+      statement,
+      specifier,
+      type: "default",
+      defaultImport: defaultName,
+      namedImports,
+      line: getLineNumber(source, match.index),
+      column: getColumnNumber(source, match.index)
+    });
+  }
+  const defaultAndNamespaceRegex = new RegExp(IMPORT_PATTERNS.defaultAndNamespace.source, "g");
+  while ((match = defaultAndNamespaceRegex.exec(source)) !== null) {
+    const [statement, defaultName, namespaceName, specifier] = match;
+    addImport({
+      statement,
+      specifier,
+      type: "default",
+      defaultImport: defaultName,
+      namespaceImport: namespaceName,
+      line: getLineNumber(source, match.index),
+      column: getColumnNumber(source, match.index)
+    });
+  }
+  const namedRegex = new RegExp(IMPORT_PATTERNS.named.source, "g");
+  while ((match = namedRegex.exec(source)) !== null) {
+    const [statement, namedString, specifier] = match;
+    const namedImports = parseNamedImports(namedString);
+    addImport({
+      statement,
+      specifier,
+      type: "named",
+      namedImports,
+      line: getLineNumber(source, match.index),
+      column: getColumnNumber(source, match.index)
+    });
+  }
+  const defaultRegex = new RegExp(IMPORT_PATTERNS.default.source, "g");
+  while ((match = defaultRegex.exec(source)) !== null) {
+    const [statement, defaultName, specifier] = match;
+    const afterMatch = source.slice(match.index + match[0].length - specifier.length - 2);
+    if (afterMatch.startsWith(",")) continue;
+    addImport({
+      statement,
+      specifier,
+      type: "default",
+      defaultImport: defaultName,
+      line: getLineNumber(source, match.index),
+      column: getColumnNumber(source, match.index)
+    });
+  }
+  const namespaceRegex = new RegExp(IMPORT_PATTERNS.namespace.source, "g");
+  while ((match = namespaceRegex.exec(source)) !== null) {
+    const [statement, namespaceName, specifier] = match;
+    addImport({
+      statement,
+      specifier,
+      type: "namespace",
+      namespaceImport: namespaceName,
+      line: getLineNumber(source, match.index),
+      column: getColumnNumber(source, match.index)
+    });
+  }
+  const sideEffectRegex = new RegExp(IMPORT_PATTERNS.sideEffect.source, "g");
+  while ((match = sideEffectRegex.exec(source)) !== null) {
+    const [statement, specifier] = match;
+    const beforeMatch = source.slice(Math.max(0, match.index - 50), match.index);
+    if (beforeMatch.includes("from")) continue;
+    addImport({
+      statement,
+      specifier,
+      type: "side-effect",
+      line: getLineNumber(source, match.index),
+      column: getColumnNumber(source, match.index)
+    });
+  }
+  const dynamicRegex = new RegExp(IMPORT_PATTERNS.dynamic.source, "g");
+  while ((match = dynamicRegex.exec(source)) !== null) {
+    const [statement, specifier] = match;
+    addImport({
+      statement,
+      specifier,
+      type: "dynamic",
+      line: getLineNumber(source, match.index),
+      column: getColumnNumber(source, match.index)
+    });
+  }
+  const reExportRegex = new RegExp(IMPORT_PATTERNS.reExport.source, "g");
+  while ((match = reExportRegex.exec(source)) !== null) {
+    const [statement, specifier] = match;
+    addImport({
+      statement,
+      specifier,
+      type: "named",
+      line: getLineNumber(source, match.index),
+      column: getColumnNumber(source, match.index)
+    });
+  }
+  const reExportAllRegex = new RegExp(IMPORT_PATTERNS.reExportAll.source, "g");
+  while ((match = reExportAllRegex.exec(source)) !== null) {
+    const [statement, specifier] = match;
+    addImport({
+      statement,
+      specifier,
+      type: "namespace",
+      line: getLineNumber(source, match.index),
+      column: getColumnNumber(source, match.index)
+    });
+  }
+  const externalImports = imports.filter((imp) => isExternalImport(imp.specifier));
+  const relativeImports = imports.filter((imp) => isRelativeImport(imp.specifier));
+  const externalPackages = [...new Set(externalImports.map((imp) => getPackageName(imp.specifier)))];
+  return {
+    imports,
+    externalImports,
+    relativeImports,
+    externalPackages
+  };
+}
+function extractExternalPackages(source) {
+  const result = parseImports(source);
+  return result.externalPackages;
+}
+function filterImportsByPackages(result, packages) {
+  const packageSet = new Set(packages);
+  return result.externalImports.filter((imp) => {
+    const pkgName = getPackageName(imp.specifier);
+    return packageSet.has(pkgName);
+  });
+}
+function getImportStats(source) {
+  const result = parseImports(source);
+  const byType = {
+    named: 0,
+    default: 0,
+    namespace: 0,
+    "side-effect": 0,
+    dynamic: 0
+  };
+  for (const imp of result.imports) {
+    byType[imp.type] = (byType[imp.type] || 0) + 1;
+  }
+  return {
+    total: result.imports.length,
+    external: result.externalImports.length,
+    relative: result.relativeImports.length,
+    byType,
+    packages: result.externalPackages
+  };
+}
+
+// libs/uipack/src/utils/escape-html.ts
+function escapeHtml(str) {
+  if (str === null || str === void 0) {
+    return "";
+  }
+  const s = String(str);
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+}
+function escapeHtmlAttr(str) {
+  return str.replace(/&/g, "&amp;").replace(/"/g, "&quot;");
+}
+
+// libs/uipack/src/dependency/import-map.ts
+function createImportMap(dependencies) {
+  const imports = {};
+  const integrity = {};
+  for (const dep of dependencies) {
+    imports[dep.packageName] = dep.cdnUrl;
+    if (dep.integrity) {
+      integrity[dep.cdnUrl] = dep.integrity;
+    }
+  }
+  return {
+    imports,
+    integrity: Object.keys(integrity).length > 0 ? integrity : void 0
+  };
+}
+function createImportMapFromOverrides(dependencies) {
+  const imports = {};
+  const integrity = {};
+  for (const [pkgName, config] of Object.entries(dependencies)) {
+    imports[pkgName] = config.url;
+    if (config.integrity) {
+      integrity[config.url] = config.integrity;
+    }
+  }
+  return {
+    imports,
+    integrity: Object.keys(integrity).length > 0 ? integrity : void 0
+  };
+}
+function mergeImportMaps(...maps) {
+  const imports = {};
+  const integrity = {};
+  const scopes = {};
+  for (const map of maps) {
+    Object.assign(imports, map.imports);
+    if (map.integrity) {
+      Object.assign(integrity, map.integrity);
+    }
+    if (map.scopes) {
+      for (const [scope, mappings] of Object.entries(map.scopes)) {
+        scopes[scope] = { ...scopes[scope], ...mappings };
+      }
+    }
+  }
+  return {
+    imports,
+    integrity: Object.keys(integrity).length > 0 ? integrity : void 0,
+    scopes: Object.keys(scopes).length > 0 ? scopes : void 0
+  };
+}
+function addScope(map, scopeUrl, mappings) {
+  return {
+    ...map,
+    scopes: {
+      ...map.scopes,
+      [scopeUrl]: { ...map.scopes?.[scopeUrl] ?? {}, ...mappings }
+    }
+  };
+}
+function generateImportMapScriptTag(map) {
+  const json2 = JSON.stringify(map, null, 2).replace(/<\//g, "<\\/");
+  return `<script type="importmap">
+${json2}
+</script>`;
+}
+function generateImportMapScriptTagMinified(map) {
+  const json2 = JSON.stringify(map).replace(/<\//g, "<\\/");
+  return `<script type="importmap">${json2}</script>`;
+}
+function generateUMDShim(dependencies, options = {}) {
+  const { safe = true, minify = false } = options;
+  const depsWithGlobals = dependencies.filter((d) => d.global && !d.esm);
+  if (depsWithGlobals.length === 0) {
+    return "";
+  }
+  const entries = depsWithGlobals.map((dep) => {
+    const global = dep.global;
+    return `'${dep.packageName}': { default: window.${global}, ...window.${global} }`;
+  });
+  const shimObject = `{
+  ${entries.join(",\n  ")}
+}`;
+  const code = safe ? `(function() {
+  try {
+    window.__esm_shim = ${shimObject};
+  } catch (e) {
+    console.warn('UMD shim failed:', e);
+  }
+})();` : `window.__esm_shim = ${shimObject};`;
+  return minify ? code.replace(/\s+/g, " ").replace(/\s*([{},:])\s*/g, "$1") : code;
+}
+function generateCDNScriptTags(dependencies) {
+  return dependencies.filter((dep) => !dep.esm).map((dep) => {
+    const attrs = [`src="${escapeHtmlAttr(dep.cdnUrl)}"`];
+    if (dep.integrity) {
+      attrs.push(`integrity="${escapeHtmlAttr(dep.integrity)}"`);
+    }
+    attrs.push('crossorigin="anonymous"');
+    return `<script ${attrs.join(" ")}></script>`;
+  });
+}
+function generateESMScriptTags(dependencies) {
+  return dependencies.filter((dep) => dep.esm).map((dep) => {
+    const attrs = ['type="module"', `src="${escapeHtmlAttr(dep.cdnUrl)}"`];
+    if (dep.integrity) {
+      attrs.push(`integrity="${escapeHtmlAttr(dep.integrity)}"`);
+    }
+    attrs.push('crossorigin="anonymous"');
+    return `<script ${attrs.join(" ")}></script>`;
+  });
+}
+function generateDependencyHTML(dependencies, options = {}) {
+  const { minify = false, includeShim = true } = options;
+  const parts = [];
+  const importMap = createImportMap(dependencies);
+  const importMapTag = minify ? generateImportMapScriptTagMinified(importMap) : generateImportMapScriptTag(importMap);
+  parts.push(importMapTag);
+  const umdTags = generateCDNScriptTags(dependencies);
+  parts.push(...umdTags);
+  if (includeShim) {
+    const shim = generateUMDShim(dependencies, { minify });
+    if (shim) {
+      parts.push(`<script>${shim}</script>`);
+    }
+  }
+  const esmTags = generateESMScriptTags(dependencies);
+  parts.push(...esmTags);
+  return parts.join(minify ? "" : "\n");
+}
+function validateImportMap(map) {
+  const errors = [];
+  if (typeof map !== "object" || map === null) {
+    return { valid: false, errors: ["Import map must be an object"] };
+  }
+  const obj = map;
+  if (!obj["imports"]) {
+    errors.push('Import map must have an "imports" field');
+  } else if (typeof obj["imports"] !== "object" || obj["imports"] === null) {
+    errors.push('"imports" must be an object');
+  } else {
+    const imports = obj["imports"];
+    for (const [key, value] of Object.entries(imports)) {
+      if (typeof value !== "string") {
+        errors.push(`Import "${key}" must map to a string URL`);
+      } else if (!value.startsWith("https://")) {
+        errors.push(`Import "${key}" URL must use HTTPS: ${value}`);
+      }
+    }
+  }
+  if (obj["integrity"] !== void 0) {
+    if (typeof obj["integrity"] !== "object" || obj["integrity"] === null) {
+      errors.push('"integrity" must be an object');
+    } else {
+      const integrity = obj["integrity"];
+      for (const [url, hash] of Object.entries(integrity)) {
+        if (typeof hash !== "string") {
+          errors.push(`Integrity for "${url}" must be a string`);
+        } else if (!hash.match(/^sha(256|384|512)-/)) {
+          errors.push(`Invalid integrity hash format for "${url}": ${hash}`);
+        }
+      }
+    }
+  }
+  if (obj["scopes"] !== void 0) {
+    if (typeof obj["scopes"] !== "object" || obj["scopes"] === null) {
+      errors.push('"scopes" must be an object');
+    }
+  }
+  return { valid: errors.length === 0, errors };
+}
+
+// libs/uipack/src/dependency/resolver.ts
+var DependencyResolutionError = class extends Error {
+  constructor(packageName, reason) {
+    super(`Failed to resolve dependency "${packageName}": ${reason}`);
+    this.packageName = packageName;
+    this.reason = reason;
+    this.name = "DependencyResolutionError";
+  }
+};
+var NoProviderError = class extends DependencyResolutionError {
+  constructor(packageName, platform) {
+    super(packageName, `No CDN provider available for platform "${platform}"`);
+    this.platform = platform;
+    this.name = "NoProviderError";
+  }
+};
+var DependencyResolver = class {
+  options;
+  registry;
+  constructor(options = {}) {
+    this.options = {
+      platform: options.platform ?? "unknown",
+      preferredProviders: options.preferredProviders ?? CDN_PROVIDER_PRIORITY[options.platform ?? "unknown"],
+      customRegistry: options.customRegistry ?? {},
+      strictMode: options.strictMode ?? true,
+      requireIntegrity: options.requireIntegrity ?? false
+    };
+    this.registry = mergeRegistries(this.options.customRegistry);
+  }
+  /**
+   * Resolve a single package to its CDN dependency.
+   *
+   * @param packageName - NPM package name
+   * @param override - Optional explicit CDN dependency override
+   * @returns Resolved dependency, or null in non-strict mode if package is not found (should be bundled)
+   * @throws DependencyResolutionError if package cannot be resolved in strict mode
+   */
+  resolve(packageName, override) {
+    if (override) {
+      return this.createResolvedDependency(packageName, override, "custom");
+    }
+    const entry = lookupPackage(packageName, this.registry);
+    if (!entry) {
+      if (this.options.strictMode) {
+        throw new DependencyResolutionError(
+          packageName,
+          'Package not found in CDN registry. Add it to "dependencies" for explicit CDN configuration.'
+        );
+      }
+      return null;
+    }
+    const providerPriority = this.options.preferredProviders;
+    for (const provider of providerPriority) {
+      const config = entry.providers[provider];
+      if (config?.url) {
+        if (this.options.requireIntegrity && !config.integrity) {
+          continue;
+        }
+        return this.createResolvedDependency(packageName, config, provider, entry.defaultVersion);
+      }
+    }
+    throw new NoProviderError(packageName, this.options.platform);
+  }
+  /**
+   * Resolve multiple packages.
+   *
+   * @param packageNames - Array of package names
+   * @param overrides - Optional explicit overrides for specific packages
+   * @returns Array of resolved dependencies (in dependency order)
+   */
+  resolveMany(packageNames, overrides) {
+    const allPackages = resolveAllDependencies(packageNames, this.options.platform, this.registry);
+    const resolved = [];
+    for (const pkgName of allPackages) {
+      try {
+        const override = overrides?.[pkgName];
+        const dep = this.resolve(pkgName, override);
+        if (dep) {
+          resolved.push(dep);
+        }
+      } catch (error) {
+        if (this.options.strictMode) {
+          throw error;
+        }
+      }
+    }
+    return resolved;
+  }
+  /**
+   * Resolve dependencies from source code.
+   *
+   * Parses the source to extract imports, then resolves external packages
+   * that are in the externals list.
+   *
+   * @param source - Source code to parse
+   * @param externals - Package names to resolve from CDN (others are bundled)
+   * @param overrides - Optional explicit CDN overrides
+   * @returns Resolved dependencies
+   */
+  resolveFromSource(source, externals, overrides) {
+    const parseResult = parseImports(source);
+    const packagesToResolve = parseResult.externalPackages.filter((pkg) => externals.includes(pkg));
+    return this.resolveMany(packagesToResolve, overrides);
+  }
+  /**
+   * Generate an import map for resolved dependencies.
+   *
+   * @param dependencies - Resolved dependencies
+   * @returns Browser import map
+   */
+  generateImportMap(dependencies) {
+    return createImportMap(dependencies);
+  }
+  /**
+   * Check if a package can be resolved for the current platform.
+   *
+   * @param packageName - Package name to check
+   * @returns true if the package can be resolved
+   */
+  canResolve(packageName) {
+    try {
+      const result = this.resolve(packageName);
+      return result !== null;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Get the resolved CDN URL for a package.
+   *
+   * @param packageName - Package name
+   * @param override - Optional explicit override
+   * @returns CDN URL or undefined if cannot resolve
+   */
+  getUrl(packageName, override) {
+    try {
+      const resolved = this.resolve(packageName, override);
+      return resolved?.cdnUrl;
+    } catch {
+      return void 0;
+    }
+  }
+  /**
+   * Get peer dependencies for a package.
+   */
+  getPeerDependencies(packageName) {
+    return getPackagePeerDependencies(packageName, this.registry);
+  }
+  /**
+   * Create the current registry (default + custom).
+   */
+  getRegistry() {
+    return this.registry;
+  }
+  /**
+   * Get the current platform.
+   */
+  getPlatform() {
+    return this.options.platform;
+  }
+  /**
+   * Create a resolved dependency object.
+   */
+  createResolvedDependency(packageName, config, provider, version) {
+    return {
+      packageName,
+      version: version ?? this.extractVersionFromUrl(config.url) ?? "latest",
+      cdnUrl: config.url,
+      integrity: config.integrity,
+      global: config.global,
+      esm: config.esm ?? false,
+      provider
+    };
+  }
+  /**
+   * Try to extract version from CDN URL.
+   */
+  extractVersionFromUrl(url) {
+    const versionMatch = url.match(/@(\d+\.\d+\.\d+(?:-[\w.]+)?)/);
+    if (versionMatch) {
+      return versionMatch[1];
+    }
+    const versionMatch2 = url.match(/\/v?(\d+\.\d+\.\d+)\//);
+    if (versionMatch2) {
+      return versionMatch2[1];
+    }
+    return void 0;
+  }
+};
+function createResolver(platform, options) {
+  return new DependencyResolver({
+    platform,
+    ...options
+  });
+}
+function createClaudeResolver(options) {
+  return createResolver("claude", options);
+}
+function createOpenAIResolver(options) {
+  return createResolver("openai", options);
+}
+function resolveDependencies(source, externals, options) {
+  const resolver = new DependencyResolver(options);
+  return resolver.resolveFromSource(source, externals);
+}
+function generateImportMapForPackages(externals, options) {
+  const resolver = new DependencyResolver(options);
+  const resolved = resolver.resolveMany(externals);
+  return resolver.generateImportMap(resolved);
+}
+
+// libs/uipack/src/dependency/template-loader.ts
+import { promises as fs } from "fs";
+import { resolve as resolvePath, isAbsolute, sep } from "path";
+
+// libs/uipack/src/bundler/file-cache/hash-calculator.ts
+import { createHash } from "crypto";
+function sha256(content) {
+  return createHash("sha256").update(content, "utf8").digest("hex");
+}
+
+// libs/uipack/src/dependency/template-loader.ts
+var urlCache = /* @__PURE__ */ new Map();
+function getUrlCache() {
+  return urlCache;
+}
+function clearUrlCache() {
+  urlCache.clear();
+}
+function detectTemplateSource(template) {
+  const mode = detectTemplateMode(template);
+  switch (mode) {
+    case "url":
+      return { type: "url", url: template };
+    case "file-path":
+      return { type: "file", path: template };
+    case "inline-string":
+    case "inline-function":
+    default:
+      return { type: "inline", content: template };
+  }
+}
+function isFileBasedTemplate(mode) {
+  return mode === "file-path" || mode === "url";
+}
+function validateTemplateUrl(url) {
+  const parsed = new URL(url);
+  if (parsed.protocol !== "https:") {
+    throw new Error(`Template URLs must use HTTPS. Got: ${parsed.protocol}`);
+  }
+}
+function detectFormatFromUrl(url) {
+  const parsed = new URL(url);
+  return detectFormatFromPath(parsed.pathname);
+}
+async function fetchTemplateFromUrl(url, options = {}) {
+  validateTemplateUrl(url);
+  const { timeout = 3e4, skipCache = false, headers: customHeaders = {} } = options;
+  if (!skipCache) {
+    const cached = urlCache.get(url);
+    if (cached?.etag) {
+      const headers = {
+        ...customHeaders,
+        "If-None-Match": cached.etag
+      };
+      const controller2 = new AbortController();
+      const timeoutId2 = setTimeout(() => controller2.abort(), timeout);
+      try {
+        const response = await fetch(url, {
+          headers,
+          signal: controller2.signal
+        });
+        clearTimeout(timeoutId2);
+        if (response.status === 304) {
+          return cached;
+        }
+        return await processFetchResponse(url, response);
+      } catch (error) {
+        clearTimeout(timeoutId2);
+        if (error instanceof Error && error.name === "AbortError") {
+          throw new Error(`Template fetch timed out after ${timeout}ms: ${url}`);
+        }
+        throw error;
+      }
+    }
+  }
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), timeout);
+  try {
+    const response = await fetch(url, {
+      headers: customHeaders,
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+    return await processFetchResponse(url, response);
+  } catch (error) {
+    clearTimeout(timeoutId);
+    if (error instanceof Error && error.name === "AbortError") {
+      throw new Error(`Template fetch timed out after ${timeout}ms: ${url}`);
+    }
+    throw error;
+  }
+}
+async function processFetchResponse(url, response) {
+  if (!response.ok) {
+    throw new Error(`Failed to fetch template: ${response.status} ${response.statusText} - ${url}`);
+  }
+  const content = await response.text();
+  const etag = response.headers.get("etag") ?? void 0;
+  const contentType = response.headers.get("content-type") ?? void 0;
+  const result = {
+    content,
+    etag,
+    contentType,
+    fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  urlCache.set(url, result);
+  return result;
+}
+async function readTemplateFromFile(filePath, options = {}) {
+  const { basePath = process.cwd(), encoding = "utf-8" } = options;
+  const absolutePath = isAbsolute(filePath) ? filePath : resolvePath(basePath, filePath);
+  const normalizedBase = resolvePath(basePath);
+  if (!absolutePath.startsWith(normalizedBase + sep) && absolutePath !== normalizedBase) {
+    throw new Error(`Template path escapes base directory: ${filePath}`);
+  }
+  try {
+    return await fs.readFile(absolutePath, encoding);
+  } catch (error) {
+    const err = error;
+    if (err.code === "ENOENT") {
+      throw new Error(`Template file not found: ${absolutePath}`);
+    }
+    if (err.code === "EACCES") {
+      throw new Error(`Permission denied reading template file: ${absolutePath}`);
+    }
+    throw new Error(`Failed to read template file: ${absolutePath} - ${err.message}`);
+  }
+}
+function resolveFilePath(filePath, basePath = process.cwd()) {
+  return isAbsolute(filePath) ? filePath : resolvePath(basePath, filePath);
+}
+async function resolveTemplate(template, options = {}) {
+  const { basePath = process.cwd(), skipCache = false, timeout = 3e4, format: overrideFormat } = options;
+  const source = detectTemplateSource(template);
+  let content;
+  let format;
+  let metadata = {};
+  switch (source.type) {
+    case "inline":
+      content = source.content;
+      format = overrideFormat ?? "html";
+      break;
+    case "file": {
+      const absolutePath = resolveFilePath(source.path, basePath);
+      content = await readTemplateFromFile(absolutePath);
+      format = overrideFormat ?? detectFormatFromPath(source.path);
+      metadata.resolvedPath = absolutePath;
+      break;
+    }
+    case "url": {
+      const fetchResult = await fetchTemplateFromUrl(source.url, {
+        skipCache,
+        timeout
+      });
+      content = fetchResult.content;
+      format = overrideFormat ?? detectFormatFromUrl(source.url);
+      metadata = {
+        fetchedAt: fetchResult.fetchedAt,
+        etag: fetchResult.etag,
+        contentType: fetchResult.contentType
+      };
+      break;
+    }
+  }
+  const hash = sha256(content);
+  return {
+    source,
+    format,
+    content,
+    hash,
+    metadata: Object.keys(metadata).length > 0 ? metadata : void 0
+  };
+}
+var URL_CACHE_TTL_MS = 5 * 60 * 1e3;
+function needsRefetch(resolved) {
+  if (resolved.source.type !== "url") {
+    return false;
+  }
+  const cached = urlCache.get(resolved.source.url);
+  if (!cached) {
+    return true;
+  }
+  if (cached.etag) {
+    return false;
+  }
+  if (cached.fetchedAt) {
+    const fetchedTime = new Date(cached.fetchedAt).getTime();
+    const age = Date.now() - fetchedTime;
+    return age > URL_CACHE_TTL_MS;
+  }
+  return true;
+}
+function invalidateUrlCache(url) {
+  return urlCache.delete(url);
+}
+
+// libs/uipack/src/handlebars/helpers.ts
+function formatDate(date, format) {
+  if (date === null || date === void 0) {
+    return "";
+  }
+  let dateObj;
+  if (date instanceof Date) {
+    dateObj = date;
+  } else if (typeof date === "string" || typeof date === "number") {
+    dateObj = new Date(date);
+  } else {
+    return String(date);
+  }
+  if (isNaN(dateObj.getTime())) {
+    return String(date);
+  }
+  const options = {};
+  switch (format) {
+    case "short":
+      options.dateStyle = "short";
+      break;
+    case "medium":
+      options.dateStyle = "medium";
+      break;
+    case "long":
+      options.dateStyle = "long";
+      break;
+    case "full":
+      options.dateStyle = "full";
+      break;
+    case "time":
+      options.timeStyle = "short";
+      break;
+    case "datetime":
+      options.dateStyle = "medium";
+      options.timeStyle = "short";
+      break;
+    case "iso":
+      return dateObj.toISOString();
+    case "relative":
+      return formatRelativeDate(dateObj);
+    default:
+      options.dateStyle = "medium";
+  }
+  return new Intl.DateTimeFormat("en-US", options).format(dateObj);
+}
+function formatRelativeDate(date) {
+  const now = /* @__PURE__ */ new Date();
+  const diffMs = now.getTime() - date.getTime();
+  const diffSecs = Math.floor(diffMs / 1e3);
+  const diffMins = Math.floor(diffSecs / 60);
+  const diffHours = Math.floor(diffMins / 60);
+  const diffDays = Math.floor(diffHours / 24);
+  if (diffSecs < 60) {
+    return "just now";
+  } else if (diffMins < 60) {
+    return `${diffMins} minute${diffMins === 1 ? "" : "s"} ago`;
+  } else if (diffHours < 24) {
+    return `${diffHours} hour${diffHours === 1 ? "" : "s"} ago`;
+  } else if (diffDays < 7) {
+    return `${diffDays} day${diffDays === 1 ? "" : "s"} ago`;
+  } else {
+    return formatDate(date, "medium");
+  }
+}
+function formatCurrency(amount, currency) {
+  if (amount === null || amount === void 0) {
+    return "";
+  }
+  const num = typeof amount === "number" ? amount : parseFloat(String(amount));
+  if (isNaN(num)) {
+    return String(amount);
+  }
+  return new Intl.NumberFormat("en-US", {
+    style: "currency",
+    currency: typeof currency === "string" ? currency : "USD"
+  }).format(num);
+}
+function formatNumber(value, decimals) {
+  if (value === null || value === void 0) {
+    return "";
+  }
+  const num = typeof value === "number" ? value : parseFloat(String(value));
+  if (isNaN(num)) {
+    return String(value);
+  }
+  const options = {};
+  if (typeof decimals === "number") {
+    options.minimumFractionDigits = decimals;
+    options.maximumFractionDigits = decimals;
+  }
+  return new Intl.NumberFormat("en-US", options).format(num);
+}
+function jsonEmbed(data) {
+  const json2 = JSON.stringify(data ?? null);
+  return json2.replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/&/g, "\\u0026").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+}
+function json(data, pretty) {
+  return JSON.stringify(data ?? null, null, pretty ? 2 : void 0);
+}
+function eq(a, b) {
+  return a === b;
+}
+function ne(a, b) {
+  return a !== b;
+}
+function gt(a, b) {
+  return Number(a) > Number(b);
+}
+function gte(a, b) {
+  return Number(a) >= Number(b);
+}
+function lt(a, b) {
+  return Number(a) < Number(b);
+}
+function lte(a, b) {
+  return Number(a) <= Number(b);
+}
+function and(a, b) {
+  return Boolean(a) && Boolean(b);
+}
+function or(a, b) {
+  return Boolean(a) || Boolean(b);
+}
+function not(value) {
+  return !value;
+}
+function first(arr) {
+  if (!Array.isArray(arr)) return void 0;
+  return arr[0];
+}
+function last(arr) {
+  if (!Array.isArray(arr)) return void 0;
+  return arr[arr.length - 1];
+}
+function length(value) {
+  if (Array.isArray(value)) return value.length;
+  if (typeof value === "string") return value.length;
+  return 0;
+}
+function includes(arr, value) {
+  if (!Array.isArray(arr)) return false;
+  return arr.includes(value);
+}
+function join(arr, separator) {
+  if (!Array.isArray(arr)) return "";
+  return arr.join(typeof separator === "string" ? separator : ", ");
+}
+function uppercase(str) {
+  return String(str ?? "").toUpperCase();
+}
+function lowercase(str) {
+  return String(str ?? "").toLowerCase();
+}
+function capitalize(str) {
+  const s = String(str ?? "");
+  return s.charAt(0).toUpperCase() + s.slice(1).toLowerCase();
+}
+function truncate(str, maxLength, suffix) {
+  const s = String(str ?? "");
+  const len = typeof maxLength === "number" ? maxLength : 50;
+  const suf = typeof suffix === "string" ? suffix : "...";
+  if (s.length <= len) return s;
+  return s.slice(0, len - suf.length) + suf;
+}
+function defaultValue(value, defaultValue2) {
+  return value || defaultValue2;
+}
+var idCounter = 0;
+function uniqueId(prefix) {
+  const id = ++idCounter;
+  return prefix ? `${prefix}-${id}` : `id-${id}`;
+}
+function classNames(...classes) {
+  return classes.filter(Boolean).map(String).join(" ");
+}
+var builtinHelpers = {
+  // Escaping
+  escapeHtml,
+  // Formatting
+  formatDate,
+  formatCurrency,
+  formatNumber,
+  json,
+  jsonEmbed,
+  // Comparison
+  eq,
+  ne,
+  gt,
+  gte,
+  lt,
+  lte,
+  // Logical
+  and,
+  or,
+  not,
+  // Array
+  first,
+  last,
+  length,
+  includes,
+  join,
+  // String
+  uppercase,
+  lowercase,
+  capitalize,
+  truncate,
+  // Utility
+  default: defaultValue,
+  uniqueId,
+  classNames
+};
+
+// libs/uipack/src/handlebars/expression-extractor.ts
+var EXPRESSION_REGEX = /\{\{\{?(?!!)(#|\/)?([^}]+?)\}?\}\}/g;
+var PATH_REGEX = /\b(output|input|structuredContent)(\.[a-zA-Z_$][a-zA-Z0-9_$]*|\.\[[^\]]+\])+/g;
+var KEYWORDS = /* @__PURE__ */ new Set(["this", "else", "@index", "@key", "@first", "@last", "@root"]);
+function extractExpressions(template) {
+  const expressions = [];
+  const lines = template.split("\n");
+  const positionMap = buildPositionMap(template);
+  let match;
+  EXPRESSION_REGEX.lastIndex = 0;
+  while ((match = EXPRESSION_REGEX.exec(template)) !== null) {
+    const fullExpression = match[0];
+    const prefix = match[1];
+    const content = match[2].trim();
+    const position = positionMap.get(match.index) ?? { line: 1, column: 1 };
+    let type = "variable";
+    let helperName;
+    if (prefix === "/") {
+      type = "block-close";
+      helperName = content;
+    } else if (prefix === "#") {
+      type = "block";
+      const parts = content.split(/\s+/);
+      helperName = parts[0];
+    } else {
+      const parts = content.split(/\s+/);
+      if (parts.length > 1 && !content.startsWith("(")) {
+        const firstToken = parts[0];
+        if (!firstToken.includes(".") && !KEYWORDS.has(firstToken)) {
+          type = "helper";
+          helperName = firstToken;
+        }
+      }
+    }
+    const paths = extractPathsFromContent(content);
+    for (const path of paths) {
+      expressions.push({
+        path,
+        fullExpression,
+        line: position.line,
+        column: position.column,
+        type,
+        helperName
+      });
+    }
+    if (paths.length === 0 && type === "variable") {
+      const cleanContent = content.trim();
+      if (!KEYWORDS.has(cleanContent) && !cleanContent.includes(" ") && !cleanContent.startsWith("(")) {
+      }
+    }
+  }
+  return expressions;
+}
+function extractPathsFromContent(content) {
+  const paths = [];
+  let match;
+  const regex = new RegExp(PATH_REGEX.source, "g");
+  while ((match = regex.exec(content)) !== null) {
+    paths.push(match[0]);
+  }
+  return paths;
+}
+function buildPositionMap(template) {
+  const map = /* @__PURE__ */ new Map();
+  let line = 1;
+  let column = 1;
+  for (let i = 0; i < template.length; i++) {
+    map.set(i, { line, column });
+    if (template[i] === "\n") {
+      line++;
+      column = 1;
+    } else {
+      column++;
+    }
+  }
+  return map;
+}
+function extractAll(template) {
+  const expressions = extractExpressions(template);
+  const paths = [...new Set(expressions.map((e) => e.path))];
+  return {
+    expressions,
+    paths,
+    outputPaths: paths.filter((p) => p.startsWith("output.")),
+    inputPaths: paths.filter((p) => p.startsWith("input.")),
+    structuredContentPaths: paths.filter((p) => p.startsWith("structuredContent."))
+  };
+}
+function normalizePath(path) {
+  return path.replace(/\.\d+\./g, ".[].").replace(/\.\d+$/g, ".[]").replace(/\[\d+\]/g, ".[]");
+}
+
+// libs/uipack/src/handlebars/index.ts
+var Handlebars = null;
+async function loadHandlebars() {
+  if (Handlebars !== null) {
+    return Handlebars;
+  }
+  try {
+    Handlebars = await import("handlebars");
+    return Handlebars;
+  } catch {
+    throw new Error("Handlebars is required for template rendering. Install it: npm install handlebars");
+  }
+}
+var HandlebarsRenderer = class {
+  options;
+  compiledTemplates = /* @__PURE__ */ new Map();
+  initialized = false;
+  hbs = null;
+  constructor(options = {}) {
+    this.options = {
+      strict: false,
+      autoEscape: true,
+      ...options
+    };
+  }
+  /**
+   * Initialize the renderer with Handlebars.
+   */
+  async init() {
+    if (this.initialized) return;
+    this.hbs = await loadHandlebars();
+    for (const [name, helper] of Object.entries(builtinHelpers)) {
+      this.hbs.registerHelper(name, helper);
+    }
+    if (this.options.helpers) {
+      for (const [name, helper] of Object.entries(this.options.helpers)) {
+        this.hbs.registerHelper(name, helper);
+      }
+    }
+    if (this.options.partials) {
+      for (const [name, template] of Object.entries(this.options.partials)) {
+        this.hbs.registerPartial(name, template);
+      }
+    }
+    this.initialized = true;
+  }
+  /**
+   * Render a Handlebars template.
+   *
+   * @param template - Template string
+   * @param context - Render context with input/output
+   * @returns Rendered HTML string
+   */
+  async render(template, context) {
+    await this.init();
+    if (!this.hbs) {
+      throw new Error("Handlebars not initialized");
+    }
+    let compiled = this.compiledTemplates.get(template);
+    if (!compiled) {
+      compiled = this.hbs.compile(template, {
+        strict: this.options.strict,
+        noEscape: !this.options.autoEscape
+      });
+      this.compiledTemplates.set(template, compiled);
+    }
+    const data = {
+      input: context.input ?? {},
+      output: context.output ?? {},
+      structuredContent: context.structuredContent,
+      // Also expose at root level for convenience
+      ...context.input,
+      ...typeof context.output === "object" && context.output !== null ? context.output : {}
+    };
+    try {
+      return compiled(data);
+    } catch (error) {
+      throw new Error(`Template rendering failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  /**
+   * Render a template synchronously.
+   *
+   * Note: Requires Handlebars to be pre-loaded. Use `render()` for async loading.
+   *
+   * @param template - Template string
+   * @param context - Render context
+   * @returns Rendered HTML string
+   */
+  renderSync(template, context) {
+    if (!this.initialized || !this.hbs) {
+      throw new Error("HandlebarsRenderer not initialized. Call render() first or use initSync().");
+    }
+    let compiled = this.compiledTemplates.get(template);
+    if (!compiled) {
+      compiled = this.hbs.compile(template, {
+        strict: this.options.strict,
+        noEscape: !this.options.autoEscape
+      });
+      this.compiledTemplates.set(template, compiled);
+    }
+    const data = {
+      input: context.input ?? {},
+      output: context.output ?? {},
+      structuredContent: context.structuredContent,
+      ...context.input,
+      ...typeof context.output === "object" && context.output !== null ? context.output : {}
+    };
+    return compiled(data);
+  }
+  /**
+   * Initialize synchronously (for environments where Handlebars is already loaded).
+   */
+  initSync(handlebars) {
+    this.hbs = handlebars;
+    for (const [name, helper] of Object.entries(builtinHelpers)) {
+      this.hbs.registerHelper(name, helper);
+    }
+    if (this.options.helpers) {
+      for (const [name, helper] of Object.entries(this.options.helpers)) {
+        this.hbs.registerHelper(name, helper);
+      }
+    }
+    if (this.options.partials) {
+      for (const [name, template] of Object.entries(this.options.partials)) {
+        this.hbs.registerPartial(name, template);
+      }
+    }
+    this.initialized = true;
+  }
+  /**
+   * Register a custom helper.
+   *
+   * @param name - Helper name
+   * @param fn - Helper function
+   */
+  registerHelper(name, fn) {
+    if (this.hbs) {
+      this.hbs.registerHelper(name, fn);
+    }
+    if (!this.options.helpers) {
+      this.options.helpers = {};
+    }
+    this.options.helpers[name] = fn;
+  }
+  /**
+   * Register a partial template.
+   *
+   * @param name - Partial name
+   * @param template - Partial template string
+   */
+  registerPartial(name, template) {
+    if (this.hbs) {
+      this.hbs.registerPartial(name, template);
+    }
+    if (!this.options.partials) {
+      this.options.partials = {};
+    }
+    this.options.partials[name] = template;
+  }
+  /**
+   * Clear compiled template cache.
+   */
+  clearCache() {
+    this.compiledTemplates.clear();
+  }
+  /**
+   * Check if a template string contains Handlebars syntax.
+   *
+   * @param template - Template string to check
+   * @returns true if contains {{...}} syntax
+   */
+  static containsHandlebars(template) {
+    return /\{\{(?!!)[\s\S]*?\}\}/.test(template);
+  }
+  /**
+   * Check if the renderer is initialized.
+   */
+  get isInitialized() {
+    return this.initialized;
+  }
+};
+function containsHandlebars(template) {
+  return HandlebarsRenderer.containsHandlebars(template);
+}
+
+// libs/uipack/src/renderers/utils/detect.ts
+function containsMdxSyntax(source) {
+  if (/<[A-Z][a-zA-Z0-9]*/.test(source)) {
+    return true;
+  }
+  if (/^(import|export)\s/m.test(source)) {
+    return true;
+  }
+  if (/\s(className|onClick|onChange|onSubmit|htmlFor|dangerouslySetInnerHTML)=/.test(source)) {
+    return true;
+  }
+  if (/\{[^}"'\n]*\}/.test(source) && !/=\s*["'][^"']*\{/.test(source)) {
+    return true;
+  }
+  if (/^---[\s\S]*?---/m.test(source)) {
+    return true;
+  }
+  if (/<>|<\/>/.test(source)) {
+    return true;
+  }
+  return false;
+}
+
+// libs/uipack/src/renderers/utils/hash.ts
+function hashString(source) {
+  let hash = 2166136261;
+  for (let i = 0; i < source.length; i++) {
+    hash ^= source.charCodeAt(i);
+    hash = hash * 16777619 >>> 0;
+  }
+  return hash.toString(36);
+}
+
+// libs/uipack/src/renderers/cache.ts
+var TranspileCache = class {
+  cache = /* @__PURE__ */ new Map();
+  maxSize;
+  ttl;
+  /** Cache statistics */
+  stats = {
+    hits: 0,
+    misses: 0,
+    evictions: 0
+  };
+  constructor(options = {}) {
+    this.maxSize = options.maxSize ?? 500;
+    this.ttl = options.ttl ?? 0;
+  }
+  /**
+   * Get a cached transpile result by source content.
+   *
+   * @param source - Source code to look up
+   * @returns Cached result or undefined if not found/expired
+   */
+  get(source) {
+    const key = hashString(source);
+    return this.getByKey(key);
+  }
+  /**
+   * Get a cached transpile result by hash key.
+   *
+   * @param key - Hash key
+   * @returns Cached result or undefined if not found/expired
+   */
+  getByKey(key) {
+    const entry = this.cache.get(key);
+    if (!entry) {
+      this.stats.misses++;
+      return void 0;
+    }
+    if (this.ttl > 0 && Date.now() - entry.timestamp > this.ttl) {
+      this.cache.delete(key);
+      this.stats.misses++;
+      return void 0;
+    }
+    this.cache.delete(key);
+    entry.accessCount++;
+    this.cache.set(key, entry);
+    this.stats.hits++;
+    return entry.value;
+  }
+  /**
+   * Store a transpile result.
+   *
+   * @param source - Source code (used to generate key)
+   * @param value - Transpile result to cache
+   * @returns The hash key used for storage
+   */
+  set(source, value) {
+    const key = hashString(source);
+    this.setByKey(key, value);
+    return key;
+  }
+  /**
+   * Store a transpile result by hash key.
+   *
+   * @param key - Hash key
+   * @param value - Transpile result to cache
+   */
+  setByKey(key, value) {
+    if (this.cache.size >= this.maxSize && !this.cache.has(key)) {
+      const oldestKey = this.cache.keys().next().value;
+      if (oldestKey) {
+        this.cache.delete(oldestKey);
+        this.stats.evictions++;
+      }
+    }
+    this.cache.set(key, {
+      value,
+      timestamp: Date.now(),
+      accessCount: 1
+    });
+  }
+  /**
+   * Check if a source is cached.
+   *
+   * @param source - Source code to check
+   * @returns True if cached and not expired
+   */
+  has(source) {
+    const key = hashString(source);
+    return this.hasByKey(key);
+  }
+  /**
+   * Check if a key is cached.
+   *
+   * @param key - Hash key to check
+   * @returns True if cached and not expired
+   */
+  hasByKey(key) {
+    const entry = this.cache.get(key);
+    if (!entry) return false;
+    if (this.ttl > 0 && Date.now() - entry.timestamp > this.ttl) {
+      this.cache.delete(key);
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Delete a cached entry by source.
+   *
+   * @param source - Source code to delete
+   * @returns True if entry was deleted
+   */
+  delete(source) {
+    const key = hashString(source);
+    return this.cache.delete(key);
+  }
+  /**
+   * Clear all cached entries.
+   */
+  clear() {
+    this.cache.clear();
+    this.stats = { hits: 0, misses: 0, evictions: 0 };
+  }
+  /**
+   * Get current cache size.
+   */
+  get size() {
+    return this.cache.size;
+  }
+  /**
+   * Get cache statistics.
+   */
+  getStats() {
+    const total = this.stats.hits + this.stats.misses;
+    return {
+      ...this.stats,
+      size: this.cache.size,
+      hitRate: total > 0 ? this.stats.hits / total : 0
+    };
+  }
+};
+var transpileCache = new TranspileCache({ maxSize: 500 });
+var renderCache = new TranspileCache({
+  maxSize: 1e3,
+  ttl: 5 * 60 * 1e3
+  // 5 minutes
+});
+var ComponentCache = class {
+  cache = /* @__PURE__ */ new Map();
+  maxSize;
+  constructor(maxSize = 200) {
+    this.maxSize = maxSize;
+  }
+  get(key) {
+    const entry = this.cache.get(key);
+    if (!entry) return void 0;
+    this.cache.delete(key);
+    this.cache.set(key, entry);
+    return entry.value;
+  }
+  set(key, value) {
+    if (this.cache.size >= this.maxSize && !this.cache.has(key)) {
+      const oldestKey = this.cache.keys().next().value;
+      if (oldestKey) {
+        this.cache.delete(oldestKey);
+      }
+    }
+    this.cache.set(key, { value, timestamp: Date.now() });
+  }
+  has(key) {
+    return this.cache.has(key);
+  }
+  delete(key) {
+    return this.cache.delete(key);
+  }
+  clear() {
+    this.cache.clear();
+  }
+  get size() {
+    return this.cache.size;
+  }
+};
+var componentCache = new ComponentCache();
+
+// libs/uipack/src/renderers/mdx.renderer.ts
+var REACT_CDN = {
+  react: "https://unpkg.com/react@18/umd/react.production.min.js",
+  reactDom: "https://unpkg.com/react-dom@18/umd/react-dom.production.min.js"
+};
+var INLINE_MDX_PLACEHOLDER = `
+// MDX runtime not available inline yet.
+// For blocked-network platforms, use pre-rendered HTML templates.
+console.warn('[FrontMCP] MDX hydration not available on this platform.');
+`;
+var MdxRenderer = class {
+  type = "mdx";
+  priority = 10;
+  // Between HTML (0) and React (20)
+  /**
+   * Lazy-loaded modules.
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  React = null;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  ReactDOMServer = null;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  jsxRuntime = null;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  mdxEvaluate = null;
+  /**
+   * Check if this renderer can handle the given template.
+   *
+   * Accepts strings containing MDX syntax (Markdown + JSX).
+   */
+  canHandle(template) {
+    if (typeof template !== "string") {
+      return false;
+    }
+    return containsMdxSyntax(template);
+  }
+  /**
+   * Transpile MDX to executable JavaScript.
+   *
+   * Uses @mdx-js/mdx to compile MDX source to a module.
+   * Note: For MDX, we use evaluate() which combines compile + run,
+   * so this method just returns the source hash for caching purposes.
+   */
+  async transpile(template, _options) {
+    const hash = hashString(template);
+    const cached = transpileCache.getByKey(hash);
+    if (cached) {
+      return { ...cached, cached: true };
+    }
+    const transpileResult = {
+      code: template,
+      // Store original MDX for evaluate()
+      hash,
+      cached: false
+    };
+    transpileCache.setByKey(hash, transpileResult);
+    return transpileResult;
+  }
+  /**
+   * Render MDX template to HTML string.
+   *
+   * Uses @mdx-js/mdx's evaluate() for clean compilation + execution,
+   * then renders the resulting React component to HTML via SSR.
+   */
+  async render(template, context, options) {
+    await this.loadReact();
+    await this.loadMdx();
+    if (!this.mdxEvaluate) {
+      throw new Error("MDX compilation requires @mdx-js/mdx. Install it: npm install @mdx-js/mdx");
+    }
+    const templateHash = hashString(template);
+    const cacheKey = `mdx-component:${templateHash}`;
+    let Content = componentCache.get(cacheKey);
+    if (!Content) {
+      const result = await this.mdxEvaluate(template, {
+        ...this.jsxRuntime,
+        Fragment: this.React.Fragment,
+        development: false
+      });
+      Content = result.default;
+      componentCache.set(cacheKey, Content);
+    }
+    const mdxComponents = {
+      // User-provided components from tool config
+      ...options?.mdxComponents,
+      // Wrapper that provides context to the content
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      wrapper: ({ children }) => {
+        return this.React.createElement("div", { className: "mdx-content" }, children);
+      }
+    };
+    const props = {
+      input: context.input,
+      output: context.output,
+      structuredContent: context.structuredContent,
+      helpers: context.helpers
+    };
+    const spreadProps = {
+      ...props,
+      ...typeof context.output === "object" && context.output !== null ? context.output : {}
+    };
+    const element = this.React.createElement(Content, {
+      components: mdxComponents,
+      ...spreadProps
+    });
+    const html = this.ReactDOMServer.renderToString(element);
+    if (options?.hydrate) {
+      const escapedProps = JSON.stringify(props).replace(/&/g, "&amp;").replace(/'/g, "&#39;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+      return `<div data-mdx-hydrate="true" data-props='${escapedProps}'>${html}</div>`;
+    }
+    return html;
+  }
+  /**
+   * Get runtime scripts for client-side functionality.
+   */
+  getRuntimeScripts(platform) {
+    if (platform.networkMode === "blocked") {
+      return {
+        headScripts: "",
+        inlineScripts: INLINE_MDX_PLACEHOLDER,
+        isInline: true
+      };
+    }
+    return {
+      headScripts: `
+        <script crossorigin src="${REACT_CDN.react}"></script>
+        <script crossorigin src="${REACT_CDN.reactDom}"></script>
+      `,
+      isInline: false
+    };
+  }
+  /**
+   * Load React and ReactDOMServer modules.
+   */
+  async loadReact() {
+    if (this.React && this.ReactDOMServer && this.jsxRuntime) {
+      return;
+    }
+    try {
+      const [react, reactDomServer, jsxRuntime] = await Promise.all([
+        import("react"),
+        import("react-dom/server"),
+        import("react/jsx-runtime")
+      ]);
+      this.React = react;
+      this.ReactDOMServer = reactDomServer;
+      this.jsxRuntime = jsxRuntime;
+    } catch {
+      throw new Error("React is required for MdxRenderer. Install react and react-dom: npm install react react-dom");
+    }
+  }
+  /**
+   * Load @mdx-js/mdx evaluate function.
+   *
+   * evaluate() is the cleanest way to run MDX - it combines
+   * compile and run in a single step, handling all the runtime
+   * injection automatically.
+   */
+  async loadMdx() {
+    if (this.mdxEvaluate) {
+      return;
+    }
+    try {
+      const mdx = await import("@mdx-js/mdx");
+      this.mdxEvaluate = mdx.evaluate;
+    } catch {
+      console.warn(
+        "[@frontmcp/ui] @mdx-js/mdx not available. MDX rendering disabled. Install @mdx-js/mdx to enable: npm install @mdx-js/mdx"
+      );
+    }
+  }
+};
+var mdxRenderer = new MdxRenderer();
+
+// libs/uipack/src/validation/schema-paths.ts
+import { z as z2 } from "zod";
+function extractSchemaPaths(schema, prefix = "output", options = {}) {
+  const { maxDepth = 10, includeArrayItems = true } = options;
+  const paths = [];
+  const visited = /* @__PURE__ */ new Set();
+  function recurse(currentSchema, currentPath, depth, isOptional, isNullable, isArrayItem) {
+    if (depth > maxDepth) return;
+    const pathKey = `${currentPath}:${depth}`;
+    if (visited.has(pathKey)) return;
+    visited.add(pathKey);
+    const description = currentSchema.description;
+    const innerType = unwrapType(currentSchema);
+    paths.push({
+      path: currentPath,
+      zodType: currentSchema,
+      optional: isOptional,
+      nullable: isNullable,
+      isArrayItem,
+      description
+    });
+    if (innerType instanceof z2.ZodObject) {
+      const shape = innerType.shape;
+      for (const [key, value] of Object.entries(shape)) {
+        const childSchema = value;
+        const childOptional = isOptional || isOptionalType(childSchema);
+        const childNullable = isNullable || isNullableType(childSchema);
+        recurse(childSchema, `${currentPath}.${key}`, depth + 1, childOptional, childNullable, false);
+      }
+    } else if (innerType instanceof z2.ZodArray && includeArrayItems) {
+      const itemSchema = innerType.element;
+      recurse(itemSchema, `${currentPath}.[]`, depth + 1, isOptional, isNullable, true);
+    } else if (innerType instanceof z2.ZodUnion || innerType instanceof z2.ZodDiscriminatedUnion) {
+      const options2 = "options" in innerType ? innerType.options : [];
+      for (const option of options2) {
+        recurse(option, currentPath, depth, isOptional, isNullable, isArrayItem);
+      }
+    } else if (innerType instanceof z2.ZodIntersection) {
+      recurse(innerType._def.left, currentPath, depth, isOptional, isNullable, isArrayItem);
+      recurse(innerType._def.right, currentPath, depth, isOptional, isNullable, isArrayItem);
+    } else if (innerType instanceof z2.ZodRecord) {
+      const valueSchema = innerType._def.valueType;
+      recurse(valueSchema, `${currentPath}.[]`, depth + 1, isOptional, isNullable, true);
+    } else if (innerType instanceof z2.ZodTuple) {
+      const items = innerType._def.items;
+      items.forEach((item, index) => {
+        recurse(item, `${currentPath}.${index}`, depth + 1, isOptional, isNullable, true);
+      });
+    }
+  }
+  recurse(schema, prefix, 0, false, false, false);
+  const seen = /* @__PURE__ */ new Set();
+  return paths.filter((p) => {
+    if (seen.has(p.path)) return false;
+    seen.add(p.path);
+    return true;
+  });
+}
+function unwrapType(schema) {
+  if (schema instanceof z2.ZodOptional) {
+    return unwrapType(schema.unwrap());
+  }
+  if (schema instanceof z2.ZodNullable) {
+    return unwrapType(schema.unwrap());
+  }
+  if (schema instanceof z2.ZodDefault) {
+    return unwrapType(schema._def.innerType);
+  }
+  if (schema instanceof z2.ZodCatch && "innerType" in schema._def) {
+    return unwrapType(schema._def.innerType);
+  }
+  return schema;
+}
+function isOptionalType(schema) {
+  if (schema instanceof z2.ZodOptional) return true;
+  if (schema instanceof z2.ZodDefault) return true;
+  if (schema instanceof z2.ZodNullable) return isOptionalType(schema.unwrap());
+  return false;
+}
+function isNullableType(schema) {
+  if (schema instanceof z2.ZodNullable) return true;
+  if (schema instanceof z2.ZodOptional) return isNullableType(schema.unwrap());
+  return false;
+}
+function getSchemaPathStrings(schema, prefix = "output") {
+  const paths = extractSchemaPaths(schema, prefix);
+  return new Set(paths.map((p) => p.path));
+}
+
+// libs/uipack/src/validation/template-validator.ts
+function validateTemplate(template, outputSchema, options = {}) {
+  const { inputSchema, warnOnOptional = true, suggestSimilar = true, maxSuggestionDistance = 3 } = options;
+  const errors = [];
+  const warnings = [];
+  const extraction = extractAll(template);
+  const expressions = extractExpressions(template);
+  const outputPaths = getSchemaPathStrings(outputSchema, "output");
+  const inputPaths = inputSchema ? getSchemaPathStrings(inputSchema, "input") : /* @__PURE__ */ new Set();
+  const outputPathInfos = extractSchemaPaths(outputSchema, "output");
+  const inputPathInfos = inputSchema ? extractSchemaPaths(inputSchema, "input") : [];
+  const pathInfoMap = /* @__PURE__ */ new Map();
+  for (const info of [...outputPathInfos, ...inputPathInfos]) {
+    pathInfoMap.set(info.path, info);
+  }
+  for (const expr of expressions) {
+    const { path, fullExpression, line, column } = expr;
+    let validPaths;
+    let allPaths;
+    if (path.startsWith("output.")) {
+      validPaths = outputPaths;
+      allPaths = Array.from(outputPaths);
+    } else if (path.startsWith("input.")) {
+      if (!inputSchema) {
+        continue;
+      }
+      validPaths = inputPaths;
+      allPaths = Array.from(inputPaths);
+    } else if (path.startsWith("structuredContent.")) {
+      continue;
+    } else {
+      continue;
+    }
+    const normalizedPath = normalizePath(path);
+    const isValid = validPaths.has(path) || validPaths.has(normalizedPath);
+    if (!isValid) {
+      const isArrayAccess = checkArrayAccess(path, validPaths);
+      if (!isArrayAccess) {
+        const suggestions = suggestSimilar ? findSimilarPaths(path, allPaths, maxSuggestionDistance) : [];
+        errors.push({
+          type: "missing_field",
+          path,
+          expression: fullExpression,
+          line,
+          column,
+          message: `Field '${getFieldName(path)}' does not exist in ${getSchemaName(path)} schema`,
+          suggestions
+        });
+      }
+    } else {
+      const pathInfo = pathInfoMap.get(path) ?? pathInfoMap.get(normalizedPath);
+      if (pathInfo && warnOnOptional) {
+        if (pathInfo.optional && expr.type === "variable") {
+          const hasGuard = hasConditionalGuard(template, path);
+          if (!hasGuard) {
+            warnings.push({
+              type: "optional_field",
+              path,
+              expression: fullExpression,
+              line,
+              message: `Accessing optional field '${getFieldName(path)}' without {{#if}} guard`
+            });
+          }
+        }
+      }
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings,
+    templatePaths: extraction.paths,
+    schemaPaths: [...outputPaths, ...inputPaths]
+  };
+}
+function checkArrayAccess(path, validPaths) {
+  const parts = path.split(".");
+  for (let i = 0; i < parts.length; i++) {
+    if (/^\d+$/.test(parts[i])) {
+      const wildcardParts = [...parts];
+      wildcardParts[i] = "[]";
+      const wildcardPath = wildcardParts.join(".");
+      if (validPaths.has(wildcardPath)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function getFieldName(path) {
+  const parts = path.split(".");
+  return parts[parts.length - 1];
+}
+function getSchemaName(path) {
+  if (path.startsWith("output.")) return "output";
+  if (path.startsWith("input.")) return "input";
+  if (path.startsWith("structuredContent.")) return "structuredContent";
+  return "unknown";
+}
+function hasConditionalGuard(template, path) {
+  const guardPattern = new RegExp(`\\{\\{#if\\s+${escapeRegex(path)}`, "i");
+  return guardPattern.test(template);
+}
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function findSimilarPaths(path, validPaths, maxDistance) {
+  const fieldName = getFieldName(path);
+  const prefix = path.substring(0, path.lastIndexOf(".") + 1);
+  const suggestions = [];
+  for (const validPath of validPaths) {
+    if (!validPath.startsWith(prefix)) continue;
+    const validFieldName = getFieldName(validPath);
+    const distance = levenshteinDistance(fieldName, validFieldName);
+    if (distance <= maxDistance && distance > 0) {
+      suggestions.push({ path: validPath, distance });
+    }
+  }
+  return suggestions.sort((a, b) => a.distance - b.distance).slice(0, 3).map((s) => s.path);
+}
+function levenshteinDistance(a, b) {
+  const matrix = [];
+  for (let i = 0; i <= a.length; i++) {
+    matrix[i] = [i];
+  }
+  for (let j = 0; j <= b.length; j++) {
+    matrix[0][j] = j;
+  }
+  for (let i = 1; i <= a.length; i++) {
+    for (let j = 1; j <= b.length; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      matrix[i][j] = Math.min(
+        matrix[i - 1][j] + 1,
+        // deletion
+        matrix[i][j - 1] + 1,
+        // insertion
+        matrix[i - 1][j - 1] + cost
+        // substitution
+      );
+    }
+  }
+  return matrix[a.length][b.length];
+}
+function formatValidationWarnings(result, toolName) {
+  if (result.valid && result.warnings.length === 0) {
+    return "";
+  }
+  const lines = [];
+  if (result.errors.length > 0) {
+    lines.push(`[FrontMCP] Template validation warnings for tool "${toolName}":`);
+    lines.push("");
+    for (const error of result.errors) {
+      lines.push(`  Line ${error.line}: ${error.expression}`);
+      lines.push(`    ${error.message}`);
+      if (error.suggestions.length > 0) {
+        lines.push(`    Did you mean: ${error.suggestions.join(", ")}?`);
+      }
+      lines.push("");
+    }
+    const outputFields = result.schemaPaths.filter((p) => p.startsWith("output.") && p.split(".").length === 2).map((p) => p.replace("output.", ""));
+    if (outputFields.length > 0) {
+      lines.push(`  Available output fields: ${outputFields.join(", ")}`);
+    }
+  }
+  if (result.warnings.length > 0) {
+    if (lines.length > 0) lines.push("");
+    lines.push(`  Warnings:`);
+    for (const warning of result.warnings) {
+      lines.push(`    Line ${warning.line}: ${warning.message}`);
+    }
+  }
+  return lines.join("\n");
+}
+function logValidationWarnings(result, toolName) {
+  const formatted = formatValidationWarnings(result, toolName);
+  if (formatted) {
+    console.warn(formatted);
+  }
+}
+
+// libs/uipack/src/dependency/template-processor.ts
+function safeInputToRecord(input) {
+  if (input && typeof input === "object" && !Array.isArray(input)) {
+    return input;
+  }
+  return {};
+}
+var defaultHelpers = {
+  escapeHtml,
+  formatDate: (date, format) => {
+    const d = date instanceof Date ? date : new Date(date);
+    if (format === "iso") return d.toISOString();
+    if (format === "time") return d.toLocaleTimeString();
+    return d.toLocaleDateString();
+  },
+  formatCurrency: (amount, currency = "USD") => new Intl.NumberFormat("en-US", { style: "currency", currency }).format(amount),
+  uniqueId: (prefix = "id") => `${prefix}-${Math.random().toString(36).substring(2, 9)}`,
+  jsonEmbed: (data) => JSON.stringify(data).replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/&/g, "\\u0026")
+};
+function getSourceName(source) {
+  switch (source.type) {
+    case "file":
+      return source.path;
+    case "url":
+      return source.url;
+    case "inline":
+      return "inline-template";
+  }
+}
+var handlebarsRenderer = null;
+async function getHandlebarsRenderer(customHelpers) {
+  if (customHelpers) {
+    const freshRenderer = new HandlebarsRenderer();
+    for (const [name, fn] of Object.entries(customHelpers)) {
+      freshRenderer.registerHelper(name, fn);
+    }
+    return freshRenderer;
+  }
+  if (!handlebarsRenderer) {
+    handlebarsRenderer = new HandlebarsRenderer();
+  }
+  return handlebarsRenderer;
+}
+function clearHandlebarsCache() {
+  if (handlebarsRenderer) {
+    handlebarsRenderer.clearCache();
+  }
+}
+var markedModule = null;
+async function loadMarked() {
+  if (markedModule) {
+    return markedModule;
+  }
+  try {
+    const moduleName = "marked";
+    markedModule = await import(
+      /* webpackIgnore: true */
+      moduleName
+    );
+    return markedModule;
+  } catch {
+    throw new Error("marked is required for Markdown rendering. Install it: npm install marked");
+  }
+}
+async function isMarkedAvailable() {
+  try {
+    await loadMarked();
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function processTemplate(resolved, options) {
+  const { format, content } = resolved;
+  const { context, handlebarsHelpers, outputSchema, inputSchema, toolName } = options;
+  if (format === "react") {
+    return {
+      code: content,
+      format: "react",
+      needsBundling: true
+    };
+  }
+  if (outputSchema && process.env["NODE_ENV"] !== "production" && containsHandlebars(content)) {
+    const sourceName = getSourceName(resolved.source);
+    const validation = validateTemplate(content, outputSchema, {
+      inputSchema,
+      warnOnOptional: true,
+      suggestSimilar: true,
+      toolName: toolName ?? sourceName
+    });
+    if (!validation.valid || validation.warnings.length > 0) {
+      logValidationWarnings(validation, toolName ?? sourceName ?? "unknown");
+    }
+  }
+  let processedContent = content;
+  if (containsHandlebars(content)) {
+    const hbs = await getHandlebarsRenderer(handlebarsHelpers);
+    const renderContext = {
+      input: safeInputToRecord(context.input),
+      output: context.output,
+      structuredContent: context.structuredContent
+    };
+    processedContent = await hbs.render(content, renderContext);
+  }
+  switch (format) {
+    case "html":
+      return {
+        html: processedContent,
+        format: "html"
+      };
+    case "markdown": {
+      const { marked } = await loadMarked();
+      const html = await marked.parse(processedContent);
+      return {
+        html,
+        format: "markdown"
+      };
+    }
+    case "mdx": {
+      const templateContext = {
+        input: context.input,
+        output: context.output,
+        structuredContent: context.structuredContent,
+        helpers: defaultHelpers
+      };
+      const html = await mdxRenderer.render(processedContent, templateContext);
+      return {
+        html,
+        format: "mdx"
+      };
+    }
+    default:
+      return {
+        html: processedContent,
+        format: "html"
+      };
+  }
+}
+async function processTemplates(items) {
+  return Promise.all(items.map(({ resolved, options }) => processTemplate(resolved, options)));
+}
+function supportsHandlebars(format) {
+  return format === "html" || format === "markdown" || format === "mdx";
+}
+function producesHtml(format) {
+  return format !== "react";
+}
+function requiresBundling(format) {
+  return format === "react";
+}
+async function processHtmlTemplate(content, context, helpers) {
+  if (!containsHandlebars(content)) {
+    return content;
+  }
+  const hbs = await getHandlebarsRenderer(helpers);
+  const renderContext = {
+    input: safeInputToRecord(context.input),
+    output: context.output,
+    structuredContent: context.structuredContent
+  };
+  return hbs.render(content, renderContext);
+}
+async function processMarkdownTemplate(content, context, helpers) {
+  let processed = content;
+  if (containsHandlebars(content)) {
+    const hbs = await getHandlebarsRenderer(helpers);
+    const renderContext = {
+      input: safeInputToRecord(context.input),
+      output: context.output,
+      structuredContent: context.structuredContent
+    };
+    processed = await hbs.render(content, renderContext);
+  }
+  const { marked } = await loadMarked();
+  return marked.parse(processed);
+}
+async function processMdxTemplate(content, context, helpers) {
+  let processed = content;
+  if (containsHandlebars(content)) {
+    const hbs = await getHandlebarsRenderer(helpers);
+    const renderContext = {
+      input: safeInputToRecord(context.input),
+      output: context.output,
+      structuredContent: context.structuredContent
+    };
+    processed = await hbs.render(content, renderContext);
+  }
+  const templateContext = {
+    input: context.input,
+    output: context.output,
+    structuredContent: context.structuredContent,
+    helpers: defaultHelpers
+  };
+  return mdxRenderer.render(processed, templateContext);
+}
+export {
+  CDN_PROVIDER_PRIORITY,
+  DEFAULT_CDN_REGISTRY,
+  DependencyResolutionError,
+  DependencyResolver,
+  NoProviderError,
+  addScope,
+  buildManifestMetadataSchema,
+  buildManifestOutputsSchema,
+  bundleTargetSchema,
+  cacheStatsSchema,
+  cdnDependencySchema,
+  cdnPlatformTypeSchema,
+  cdnProviderConfigSchema,
+  cdnProviderSchema,
+  cdnRegistryEntrySchema,
+  clearHandlebarsCache,
+  clearUrlCache,
+  componentBuildManifestSchema,
+  createClaudeResolver,
+  createImportMap,
+  createImportMapFromOverrides,
+  createOpenAIResolver,
+  createResolver,
+  dependencyResolverOptionsSchema,
+  detectFormatFromPath,
+  detectFormatFromUrl,
+  detectTemplateMode,
+  detectTemplateSource,
+  extractExternalPackages,
+  fetchTemplateFromUrl,
+  fileBundleOptionsSchema,
+  fileTemplateConfigSchema,
+  filterImportsByPackages,
+  generateCDNScriptTags,
+  generateDependencyHTML,
+  generateESMScriptTags,
+  generateImportMapForPackages,
+  generateImportMapScriptTag,
+  generateImportMapScriptTagMinified,
+  generateUMDShim,
+  getImportStats,
+  getPackageCDNDependency,
+  getPackageCDNUrl,
+  getPackageName,
+  getPackagePeerDependencies,
+  getRegisteredPackages,
+  getUrlCache,
+  importMapSchema,
+  importTypeSchema,
+  invalidateUrlCache,
+  isFileBasedTemplate,
+  isMarkedAvailable,
+  isPackageRegistered,
+  lookupPackage,
+  mergeImportMaps,
+  mergeRegistries,
+  needsRefetch,
+  packageMetadataSchema,
+  parseImports,
+  parsedImportResultSchema,
+  parsedImportSchema,
+  processHtmlTemplate,
+  processMarkdownTemplate,
+  processMdxTemplate,
+  processTemplate,
+  processTemplates,
+  producesHtml,
+  readTemplateFromFile,
+  requiresBundling,
+  resolveAllDependencies,
+  resolveDependencies,
+  resolveFilePath,
+  resolveTemplate,
+  resolvedDependencySchema,
+  safeParseBuildManifest,
+  safeParseCDNDependency,
+  safeParseFileTemplateConfig,
+  supportsHandlebars,
+  validateBuildManifest,
+  validateCDNDependency,
+  validateFileTemplateConfig,
+  validateImportMap,
+  validateTemplateUrl
+};