@frontmcp/uipack 0.12.2 → 1.0.0-beta.10

package/esm/dependency/index.mjs

@@ -1,3068 +0,0 @@
-// 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/index.ts
-import {
-  safeStringify,
-  escapeHtml,
-  escapeHtmlAttr,
-  escapeJsString,
-  escapeScriptClose,
-  safeJsonForScript
-} from "@frontmcp/utils";
-
-// 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};`;
-  if (minify && code.length <= 1e5) {
-    return code.replace(/\s+/g, " ").replace(/\s*([{},:])\s*/g, "$1");
-  }
-  return 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";
-import { readFile, readFileBuffer } from "@frontmcp/utils";
-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 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
-var MAX_TEMPLATE_LENGTH = 5e4;
-function containsMdxSyntax(source) {
-  if (source.length > MAX_TEMPLATE_LENGTH) {
-    return false;
-  }
-  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-client.renderer.ts
-function buildReactCdnUrls(version = "19") {
-  return {
-    react: `https://esm.sh/react@${version}`,
-    reactDom: `https://esm.sh/react-dom@${version}/client`,
-    jsxRuntime: `https://esm.sh/react@${version}/jsx-runtime`
-  };
-}
-var DEFAULT_CDN = {
-  mdx: "https://esm.sh/@mdx-js/mdx@3",
-  ...buildReactCdnUrls("19")
-};
-var MdxClientRenderer = class {
-  type = "mdx-client";
-  priority = 8;
-  // Lower than server-side MDX (10)
-  /**
-   * Check if this renderer can handle the given template.
-   */
-  canHandle(template) {
-    if (typeof template !== "string") {
-      return false;
-    }
-    return containsMdxSyntax(template);
-  }
-  /**
-   * Prepare MDX template for rendering.
-   * Caches the template hash for deduplication. Actual MDX compilation
-   * happens client-side via CDN-loaded @mdx-js/mdx in the browser.
-   */
-  async transpile(template, _options) {
-    const hash = hashString(template);
-    const cached = transpileCache.getByKey(hash);
-    if (cached) {
-      return { ...cached, cached: true };
-    }
-    const transpileResult = {
-      code: template,
-      hash,
-      cached: false
-    };
-    transpileCache.setByKey(hash, transpileResult);
-    return transpileResult;
-  }
-  /**
-   * Render MDX template to HTML with CDN scripts.
-   *
-   * The returned HTML includes:
-   * - A container div for the rendered content
-   * - Script tags that load React and MDX from CDN
-   * - Inline script that compiles and renders the MDX
-   */
-  async render(template, context, options) {
-    const containerId = options?.containerId || "mdx-content";
-    const showLoading = options?.showLoading !== false;
-    const loadingMessage = options?.loadingMessage || "Loading...";
-    const cdn = {
-      ...DEFAULT_CDN,
-      ...options?.cdn
-    };
-    const props = {
-      input: context.input,
-      output: context.output,
-      structuredContent: context.structuredContent,
-      helpers: context.helpers
-    };
-    const reservedProps = /* @__PURE__ */ new Set(["input", "output", "structuredContent", "helpers", "components"]);
-    const outputProps = typeof context.output === "object" && context.output !== null ? Object.fromEntries(Object.entries(context.output).filter(([key]) => !reservedProps.has(key))) : {};
-    const spreadProps = {
-      ...outputProps,
-      ...props
-    };
-    const escapedMdx = escapeScriptClose(JSON.stringify(template));
-    const escapedProps = escapeScriptClose(JSON.stringify(spreadProps));
-    const safeContainerId = escapeJsString(containerId);
-    const loadingHtml = showLoading ? `<div class="mdx-loading">${escapeHtml(loadingMessage)}</div>` : "";
-    return `
-<div id="${escapeHtml(containerId)}">${loadingHtml}</div>
-<script type="module">
-(async function() {
-  try {
-    // Load dependencies from CDN
-    const [
-      { evaluate },
-      runtime,
-      React,
-      { createRoot }
-    ] = await Promise.all([
-      import('${cdn.mdx}'),
-      import('${cdn.jsxRuntime}'),
-      import('${cdn.react}'),
-      import('${cdn.reactDom}')
-    ]);
-
-    // MDX content and props
-    const mdxSource = ${escapedMdx};
-    const props = ${escapedProps};
-
-    // Compile and evaluate MDX
-    const { default: Content } = await evaluate(mdxSource, {
-      ...runtime,
-      Fragment: React.Fragment,
-      development: false
-    });
-
-    // Render to DOM
-    const container = document.getElementById('${safeContainerId}');
-    if (container) {
-      const root = createRoot(container);
-      root.render(React.createElement(Content, props));
-    }
-  } catch (error) {
-    console.error('[FrontMCP] MDX client rendering failed:', error);
-    const container = document.getElementById('${safeContainerId}');
-    if (container) {
-      container.innerHTML = '<div class="mdx-error">Failed to render MDX content</div>';
-    }
-  }
-})();
-</script>
-`;
-  }
-  /**
-   * Get runtime scripts - not needed for client renderer since scripts are inline.
-   */
-  getRuntimeScripts(platform) {
-    if (platform.networkMode === "blocked") {
-      return {
-        headScripts: "",
-        inlineScripts: `console.warn('[FrontMCP] Client-side MDX rendering requires network access. Use @frontmcp/ui for SSR.');`,
-        isInline: true
-      };
-    }
-    return {
-      headScripts: "",
-      isInline: false
-    };
-  }
-};
-var mdxClientRenderer = new MdxClientRenderer();
-
-// 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 mdxClientRenderer.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 mdxClientRenderer.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
-};