@frontmcp/uipack 0.6.1

package/esm/bundler/index.js

@@ -0,0 +1,2882 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// libs/uipack/src/bundler/file-cache/storage/interface.ts
+function calculateManifestSize(manifest) {
+  try {
+    return Buffer.byteLength(JSON.stringify(manifest), "utf8");
+  } catch {
+    return 0;
+  }
+}
+var DEFAULT_STORAGE_OPTIONS;
+var init_interface = __esm({
+  "libs/uipack/src/bundler/file-cache/storage/interface.ts"() {
+    "use strict";
+    DEFAULT_STORAGE_OPTIONS = {
+      maxEntries: 1e3,
+      maxSize: 100 * 1024 * 1024,
+      // 100MB
+      defaultTtl: 24 * 60 * 60,
+      // 24 hours
+      compress: false
+    };
+  }
+});
+
+// libs/uipack/src/bundler/file-cache/storage/filesystem.ts
+var filesystem_exports = {};
+__export(filesystem_exports, {
+  CacheInitializationError: () => CacheInitializationError,
+  CacheOperationError: () => CacheOperationError,
+  FilesystemStorage: () => FilesystemStorage,
+  StorageNotInitializedError: () => StorageNotInitializedError,
+  createFilesystemStorage: () => createFilesystemStorage
+});
+import { mkdir, readFile, writeFile, readdir, unlink, rm } from "fs/promises";
+import { join, dirname } from "path";
+import { existsSync } from "fs";
+import { createHash } from "crypto";
+function createFilesystemStorage(options) {
+  return new FilesystemStorage(options);
+}
+var CacheInitializationError, CacheOperationError, StorageNotInitializedError, DEFAULT_FS_OPTIONS, FilesystemStorage;
+var init_filesystem = __esm({
+  "libs/uipack/src/bundler/file-cache/storage/filesystem.ts"() {
+    "use strict";
+    init_interface();
+    CacheInitializationError = class extends Error {
+      cause;
+      constructor(message, cause) {
+        super(message);
+        this.name = "CacheInitializationError";
+        this.cause = cause;
+      }
+    };
+    CacheOperationError = class extends Error {
+      cause;
+      constructor(message, cause) {
+        super(message);
+        this.name = "CacheOperationError";
+        this.cause = cause;
+      }
+    };
+    StorageNotInitializedError = class extends Error {
+      constructor() {
+        super("Storage not initialized. Call initialize() first.");
+        this.name = "StorageNotInitializedError";
+      }
+    };
+    DEFAULT_FS_OPTIONS = {
+      ...DEFAULT_STORAGE_OPTIONS,
+      cacheDir: ".frontmcp-cache/builds",
+      extension: ".json"
+    };
+    FilesystemStorage = class {
+      type = "filesystem";
+      options;
+      initialized = false;
+      stats = {
+        entries: 0,
+        totalSize: 0,
+        hits: 0,
+        misses: 0,
+        hitRate: 0
+      };
+      constructor(options = {}) {
+        this.options = {
+          ...DEFAULT_FS_OPTIONS,
+          ...options
+        };
+      }
+      /**
+       * Initialize the storage directory.
+       */
+      async initialize() {
+        if (this.initialized) return;
+        try {
+          await mkdir(this.options.cacheDir, { recursive: true });
+          await this.loadStats();
+          this.initialized = true;
+        } catch (error) {
+          throw new CacheInitializationError(`Failed to initialize cache directory: ${error}`, error);
+        }
+      }
+      /**
+       * Get a cached manifest.
+       */
+      async get(key) {
+        this.ensureInitialized();
+        const filePath = this.getFilePath(key);
+        try {
+          if (!existsSync(filePath)) {
+            this.stats.misses++;
+            this.updateHitRate();
+            return void 0;
+          }
+          const content = await readFile(filePath, "utf8");
+          const entry = JSON.parse(content);
+          if (Date.now() > entry.metadata.expiresAt) {
+            await this.delete(key);
+            this.stats.misses++;
+            this.updateHitRate();
+            return void 0;
+          }
+          entry.metadata.lastAccessedAt = Date.now();
+          entry.metadata.accessCount++;
+          this.writeEntry(filePath, entry).catch((err) => {
+            if (process.env["DEBUG"]) {
+              console.debug(`[FilesystemStorage] Failed to update cache metadata for ${key}: ${err}`);
+            }
+          });
+          this.stats.hits++;
+          this.updateHitRate();
+          return entry.data;
+        } catch {
+          this.stats.misses++;
+          this.updateHitRate();
+          return void 0;
+        }
+      }
+      /**
+       * Store a manifest in cache.
+       */
+      async set(key, manifest, ttl) {
+        this.ensureInitialized();
+        const filePath = this.getFilePath(key);
+        const size = calculateManifestSize(manifest);
+        const effectiveTtl = ttl ?? this.options.defaultTtl;
+        await this.ensureCapacity(size);
+        const entry = {
+          data: manifest,
+          metadata: {
+            key,
+            size,
+            createdAt: Date.now(),
+            expiresAt: Date.now() + effectiveTtl * 1e3,
+            lastAccessedAt: Date.now(),
+            accessCount: 0
+          }
+        };
+        await this.writeEntry(filePath, entry);
+        this.stats.entries++;
+        this.stats.totalSize += size;
+      }
+      /**
+       * Check if a key exists.
+       */
+      async has(key) {
+        this.ensureInitialized();
+        const filePath = this.getFilePath(key);
+        try {
+          if (!existsSync(filePath)) return false;
+          const content = await readFile(filePath, "utf8");
+          const entry = JSON.parse(content);
+          if (Date.now() > entry.metadata.expiresAt) {
+            await this.delete(key);
+            return false;
+          }
+          return true;
+        } catch {
+          return false;
+        }
+      }
+      /**
+       * Delete a cached entry.
+       */
+      async delete(key) {
+        this.ensureInitialized();
+        const filePath = this.getFilePath(key);
+        try {
+          if (!existsSync(filePath)) return false;
+          const content = await readFile(filePath, "utf8");
+          const entry = JSON.parse(content);
+          await unlink(filePath);
+          this.stats.entries = Math.max(0, this.stats.entries - 1);
+          this.stats.totalSize = Math.max(0, this.stats.totalSize - entry.metadata.size);
+          return true;
+        } catch {
+          return false;
+        }
+      }
+      /**
+       * Clear all cached entries.
+       */
+      async clear() {
+        this.ensureInitialized();
+        try {
+          await rm(this.options.cacheDir, { recursive: true, force: true });
+          await mkdir(this.options.cacheDir, { recursive: true });
+          this.stats = {
+            entries: 0,
+            totalSize: 0,
+            hits: 0,
+            misses: 0,
+            hitRate: 0
+          };
+        } catch (error) {
+          throw new CacheOperationError(`Failed to clear cache: ${error}`, error);
+        }
+      }
+      /**
+       * Get cache statistics.
+       */
+      async getStats() {
+        return { ...this.stats };
+      }
+      /**
+       * Clean up expired entries.
+       */
+      async cleanup() {
+        this.ensureInitialized();
+        let removed = 0;
+        try {
+          const files = await readdir(this.options.cacheDir);
+          for (const file of files) {
+            if (!file.endsWith(this.options.extension)) continue;
+            const filePath = join(this.options.cacheDir, file);
+            try {
+              const content = await readFile(filePath, "utf8");
+              const entry = JSON.parse(content);
+              if (Date.now() > entry.metadata.expiresAt) {
+                await unlink(filePath);
+                this.stats.entries = Math.max(0, this.stats.entries - 1);
+                this.stats.totalSize = Math.max(0, this.stats.totalSize - entry.metadata.size);
+                removed++;
+              }
+            } catch {
+              await unlink(filePath).catch(() => {
+              });
+              removed++;
+            }
+          }
+        } catch {
+        }
+        return removed;
+      }
+      /**
+       * Close the storage (no-op for filesystem).
+       */
+      async close() {
+      }
+      /**
+       * Get the file path for a cache key.
+       * Uses SHA-256 hash to avoid collisions from key sanitization.
+       */
+      getFilePath(key) {
+        const hash = createHash("sha256").update(key).digest("hex").slice(0, 16);
+        return join(this.options.cacheDir, `${hash}${this.options.extension}`);
+      }
+      /**
+       * Write a cache entry to disk.
+       */
+      async writeEntry(filePath, entry) {
+        await mkdir(dirname(filePath), { recursive: true });
+        await writeFile(filePath, JSON.stringify(entry, null, 2), "utf8");
+      }
+      /**
+       * Ensure the storage is initialized.
+       */
+      ensureInitialized() {
+        if (!this.initialized) {
+          throw new StorageNotInitializedError();
+        }
+      }
+      /**
+       * Load stats from existing cache files.
+       * Reads entry metadata to get accurate manifest sizes.
+       */
+      async loadStats() {
+        try {
+          const files = await readdir(this.options.cacheDir);
+          let entries = 0;
+          let totalSize = 0;
+          for (const file of files) {
+            if (!file.endsWith(this.options.extension)) continue;
+            const filePath = join(this.options.cacheDir, file);
+            try {
+              const content = await readFile(filePath, "utf8");
+              const entry = JSON.parse(content);
+              entries++;
+              totalSize += entry.metadata.size;
+            } catch {
+            }
+          }
+          this.stats.entries = entries;
+          this.stats.totalSize = totalSize;
+        } catch {
+        }
+      }
+      /**
+       * Ensure there's capacity for a new entry.
+       */
+      async ensureCapacity(newEntrySize) {
+        if (this.stats.entries >= this.options.maxEntries) {
+          await this.evictLRU();
+        }
+        while (this.stats.totalSize + newEntrySize > this.options.maxSize) {
+          const evicted = await this.evictLRU();
+          if (!evicted) break;
+        }
+      }
+      /**
+       * Evict the least recently used entry.
+       */
+      async evictLRU() {
+        try {
+          const files = await readdir(this.options.cacheDir);
+          let oldestKey = null;
+          let oldestTime = Infinity;
+          let corruptedFile = null;
+          for (const file of files) {
+            if (!file.endsWith(this.options.extension)) continue;
+            const filePath = join(this.options.cacheDir, file);
+            try {
+              const content = await readFile(filePath, "utf8");
+              const entry = JSON.parse(content);
+              if (entry.metadata.lastAccessedAt < oldestTime) {
+                oldestTime = entry.metadata.lastAccessedAt;
+                oldestKey = entry.metadata.key;
+              }
+            } catch {
+              corruptedFile = filePath;
+            }
+          }
+          if (corruptedFile) {
+            try {
+              await unlink(corruptedFile);
+              this.stats.entries = Math.max(0, this.stats.entries - 1);
+              return true;
+            } catch {
+              return false;
+            }
+          }
+          if (oldestKey) {
+            return await this.delete(oldestKey);
+          }
+          return false;
+        } catch {
+          return false;
+        }
+      }
+      /**
+       * Update hit rate statistic.
+       */
+      updateHitRate() {
+        const total = this.stats.hits + this.stats.misses;
+        this.stats.hitRate = total > 0 ? this.stats.hits / total : 0;
+      }
+    };
+  }
+});
+
+// libs/uipack/src/bundler/file-cache/storage/redis.ts
+var redis_exports = {};
+__export(redis_exports, {
+  RedisStorage: () => RedisStorage,
+  createRedisStorage: () => createRedisStorage
+});
+function createRedisStorage(options) {
+  return new RedisStorage(options);
+}
+var STATS_KEY_SUFFIX, RedisStorage;
+var init_redis = __esm({
+  "libs/uipack/src/bundler/file-cache/storage/redis.ts"() {
+    "use strict";
+    init_interface();
+    STATS_KEY_SUFFIX = ":__stats__";
+    RedisStorage = class {
+      type = "redis";
+      options;
+      initialized = false;
+      localStats = {
+        entries: 0,
+        totalSize: 0,
+        hits: 0,
+        misses: 0,
+        hitRate: 0
+      };
+      constructor(options) {
+        if (!options.client) {
+          throw new Error("Redis client is required");
+        }
+        this.options = {
+          ...DEFAULT_STORAGE_OPTIONS,
+          keyPrefix: "frontmcp:ui:build:",
+          json: true,
+          ...options
+        };
+      }
+      /**
+       * Initialize the Redis connection.
+       */
+      async initialize() {
+        if (this.initialized) return;
+        try {
+          await this.options.client.ping();
+          await this.loadStats();
+          this.initialized = true;
+        } catch (error) {
+          throw new Error(`Failed to connect to Redis: ${error}`);
+        }
+      }
+      /**
+       * Get a cached manifest.
+       */
+      async get(key) {
+        this.ensureInitialized();
+        const redisKey = this.getRedisKey(key);
+        try {
+          const data = await this.options.client.get(redisKey);
+          if (!data) {
+            this.localStats.misses++;
+            this.updateHitRate();
+            await this.persistStats();
+            return void 0;
+          }
+          const entry = JSON.parse(data);
+          entry.metadata.lastAccessedAt = Date.now();
+          entry.metadata.accessCount++;
+          const ttl = await this.options.client.ttl(redisKey);
+          if (ttl > 0) {
+            const serialized = JSON.stringify(entry);
+            await this.options.client.setex(redisKey, ttl, serialized);
+          }
+          this.localStats.hits++;
+          this.updateHitRate();
+          await this.persistStats();
+          return entry.data;
+        } catch (error) {
+          console.warn?.(`Redis cache get failed for key "${key}": ${error}`);
+          this.localStats.misses++;
+          this.updateHitRate();
+          await this.persistStats().catch(() => {
+          });
+          return void 0;
+        }
+      }
+      /**
+       * Store a manifest in cache.
+       */
+      async set(key, manifest, ttl) {
+        this.ensureInitialized();
+        const redisKey = this.getRedisKey(key);
+        const size = calculateManifestSize(manifest);
+        const effectiveTtl = ttl ?? this.options.defaultTtl;
+        const entry = {
+          data: manifest,
+          metadata: {
+            key,
+            size,
+            createdAt: Date.now(),
+            expiresAt: Date.now() + effectiveTtl * 1e3,
+            lastAccessedAt: Date.now(),
+            accessCount: 0
+          }
+        };
+        const serialized = JSON.stringify(entry);
+        await this.options.client.setex(redisKey, effectiveTtl, serialized);
+        this.localStats.entries++;
+        this.localStats.totalSize += size;
+        await this.persistStats();
+      }
+      /**
+       * Check if a key exists.
+       */
+      async has(key) {
+        this.ensureInitialized();
+        const redisKey = this.getRedisKey(key);
+        const exists = await this.options.client.exists(redisKey);
+        return exists > 0;
+      }
+      /**
+       * Delete a cached entry.
+       */
+      async delete(key) {
+        this.ensureInitialized();
+        const redisKey = this.getRedisKey(key);
+        try {
+          const data = await this.options.client.get(redisKey);
+          if (data) {
+            const entry = JSON.parse(data);
+            this.localStats.totalSize = Math.max(0, this.localStats.totalSize - entry.metadata.size);
+          }
+        } catch {
+        }
+        const deleted = await this.options.client.del(redisKey);
+        if (deleted > 0) {
+          this.localStats.entries = Math.max(0, this.localStats.entries - 1);
+          await this.persistStats();
+          return true;
+        }
+        return false;
+      }
+      /**
+       * Clear all cached entries.
+       */
+      async clear() {
+        this.ensureInitialized();
+        const pattern = `${this.options.keyPrefix}*`;
+        const keys = await this.options.client.keys(pattern);
+        if (keys.length > 0) {
+          await this.options.client.del(keys);
+        }
+        this.localStats = {
+          entries: 0,
+          totalSize: 0,
+          hits: 0,
+          misses: 0,
+          hitRate: 0
+        };
+        await this.persistStats();
+      }
+      /**
+       * Get cache statistics.
+       */
+      async getStats() {
+        await this.loadStats();
+        return { ...this.localStats };
+      }
+      /**
+       * Clean up expired entries.
+       * Redis handles TTL expiration automatically, so this just refreshes stats.
+       */
+      async cleanup() {
+        this.ensureInitialized();
+        const pattern = `${this.options.keyPrefix}*`;
+        const keys = await this.options.client.keys(pattern);
+        const dataKeys = keys.filter((k) => !k.endsWith(STATS_KEY_SUFFIX));
+        const previousCount = this.localStats.entries;
+        this.localStats.entries = dataKeys.length;
+        let totalSize = 0;
+        for (const key of dataKeys) {
+          try {
+            const data = await this.options.client.get(key);
+            if (data) {
+              const entry = JSON.parse(data);
+              totalSize += entry.metadata.size;
+            }
+          } catch {
+          }
+        }
+        this.localStats.totalSize = totalSize;
+        await this.persistStats();
+        return Math.max(0, previousCount - this.localStats.entries);
+      }
+      /**
+       * Close the Redis connection.
+       */
+      async close() {
+        await this.options.client.quit();
+      }
+      /**
+       * Get the Redis key for a cache key.
+       */
+      getRedisKey(key) {
+        return `${this.options.keyPrefix}${key}`;
+      }
+      /**
+       * Get the Redis key for stats.
+       */
+      getStatsKey() {
+        return `${this.options.keyPrefix}${STATS_KEY_SUFFIX}`;
+      }
+      /**
+       * Ensure the storage is initialized.
+       */
+      ensureInitialized() {
+        if (!this.initialized) {
+          throw new Error("Storage not initialized. Call initialize() first.");
+        }
+      }
+      /**
+       * Load stats from Redis.
+       */
+      async loadStats() {
+        try {
+          const statsKey = this.getStatsKey();
+          const data = await this.options.client.get(statsKey);
+          if (data) {
+            const savedStats = JSON.parse(data);
+            this.localStats = {
+              ...this.localStats,
+              ...savedStats
+            };
+          }
+        } catch {
+        }
+      }
+      /**
+       * Persist stats to Redis.
+       */
+      async persistStats() {
+        try {
+          const statsKey = this.getStatsKey();
+          const serialized = JSON.stringify(this.localStats);
+          await this.options.client.set(statsKey, serialized);
+        } catch {
+        }
+      }
+      /**
+       * Update hit rate statistic.
+       */
+      updateHitRate() {
+        const total = this.localStats.hits + this.localStats.misses;
+        this.localStats.hitRate = total > 0 ? this.localStats.hits / total : 0;
+      }
+    };
+  }
+});
+
+// libs/uipack/src/bundler/types.ts
+var DEFAULT_SECURITY_POLICY = {
+  allowedImports: [/^react$/, /^react-dom$/, /^react\/jsx-runtime$/, /^react\/jsx-dev-runtime$/, /^@frontmcp\/ui/],
+  blockedImports: [
+    /^fs$/,
+    /^fs\//,
+    /^net$/,
+    /^child_process$/,
+    /^os$/,
+    /^path$/,
+    /^crypto$/,
+    /^http$/,
+    /^https$/,
+    /^dgram$/,
+    /^dns$/,
+    /^cluster$/,
+    /^readline$/,
+    /^repl$/,
+    /^tls$/,
+    /^vm$/,
+    /^worker_threads$/
+  ],
+  maxBundleSize: 512e3,
+  // 500KB
+  maxTransformTime: 5e3,
+  // 5s
+  noEval: true,
+  noDynamicImports: true,
+  noRequire: true,
+  allowedGlobals: [
+    "console",
+    "Math",
+    "JSON",
+    "Date",
+    "Array",
+    "Object",
+    "String",
+    "Number",
+    "Boolean",
+    "Promise",
+    "Map",
+    "Set",
+    "WeakMap",
+    "WeakSet",
+    "Symbol",
+    "Reflect",
+    "Proxy",
+    "Error",
+    "TypeError",
+    "RangeError",
+    "SyntaxError",
+    "ReferenceError",
+    "parseInt",
+    "parseFloat",
+    "isNaN",
+    "isFinite",
+    "encodeURI",
+    "encodeURIComponent",
+    "decodeURI",
+    "decodeURIComponent",
+    "setTimeout",
+    "clearTimeout",
+    "setInterval",
+    "clearInterval",
+    "atob",
+    "btoa",
+    "Intl",
+    "TextEncoder",
+    "TextDecoder",
+    "URL",
+    "URLSearchParams",
+    "Uint8Array",
+    "Int8Array",
+    "Uint16Array",
+    "Int16Array",
+    "Uint32Array",
+    "Int32Array",
+    "Float32Array",
+    "Float64Array",
+    "BigInt",
+    "BigInt64Array",
+    "BigUint64Array",
+    "ArrayBuffer",
+    "SharedArrayBuffer",
+    "DataView",
+    "queueMicrotask"
+  ]
+};
+var DEFAULT_BUNDLE_OPTIONS = {
+  sourceType: "auto",
+  format: "iife",
+  minify: false,
+  sourceMaps: false,
+  externals: ["react", "react-dom"],
+  jsx: {
+    runtime: "automatic",
+    importSource: "react"
+  },
+  target: "es2020",
+  globalName: "Widget",
+  skipCache: false
+};
+var DEFAULT_BUNDLER_OPTIONS = {
+  defaultSecurity: DEFAULT_SECURITY_POLICY,
+  cache: {
+    maxSize: 100,
+    ttl: 3e5,
+    // 5 minutes
+    disabled: false
+  },
+  verbose: false,
+  esbuildOptions: {}
+};
+var STATIC_HTML_CDN = {
+  /**
+   * ES modules from esm.sh (React 19, modern platforms)
+   */
+  esm: {
+    react: "https://esm.sh/react@19",
+    reactDom: "https://esm.sh/react-dom@19/client"
+  },
+  /**
+   * UMD builds from cdnjs (React 18.2, Claude only trusts cloudflare)
+   */
+  umd: {
+    react: "https://cdnjs.cloudflare.com/ajax/libs/react/18.2.0/umd/react.production.min.js",
+    reactDom: "https://cdnjs.cloudflare.com/ajax/libs/react-dom/18.2.0/umd/react-dom.production.min.js"
+  },
+  /**
+   * Tailwind CSS from cdnjs (cloudflare) - works on all platforms
+   * Using CSS file instead of JS browser version to avoid style normalization issues
+   */
+  tailwind: "https://cdnjs.cloudflare.com/ajax/libs/tailwindcss/3.4.1/tailwind.min.css",
+  /**
+   * Font CDN URLs
+   */
+  fonts: {
+    preconnect: ["https://fonts.googleapis.com", "https://fonts.gstatic.com"],
+    inter: "https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&display=swap"
+  }
+};
+function getCdnTypeForPlatform(platform) {
+  if (platform === "claude") return "umd";
+  return "esm";
+}
+var DEFAULT_STATIC_HTML_OPTIONS = {
+  sourceType: "auto",
+  targetPlatform: "auto",
+  minify: true,
+  skipCache: false,
+  rootId: "frontmcp-widget-root",
+  widgetAccessible: false,
+  externals: {
+    react: "cdn",
+    reactDom: "cdn",
+    tailwind: "cdn",
+    frontmcpUi: "inline"
+  },
+  // Universal mode defaults
+  universal: false,
+  contentType: "auto",
+  includeMarkdown: false,
+  includeMdx: false
+};
+
+// libs/uipack/src/bundler/sandbox/policy.ts
+var UNSAFE_PATTERNS = {
+  eval: /\beval\s*\(/g,
+  functionConstructor: /\bnew\s+Function\s*\(/g,
+  dynamicImport: /\bimport\s*\(/g,
+  require: /\brequire\s*\(/g,
+  processEnv: /\bprocess\.env\b/g,
+  globalThis: /\bglobalThis\b/g,
+  windowLocation: /\bwindow\.location\b/g,
+  documentCookie: /\bdocument\.cookie\b/g,
+  innerHTML: /\.innerHTML\s*=/g,
+  outerHTML: /\.outerHTML\s*=/g,
+  document_write: /\bdocument\.write\s*\(/g
+};
+function validateSource(source, policy = DEFAULT_SECURITY_POLICY) {
+  const violations = [];
+  if (policy.noEval !== false) {
+    const evalMatches = [...source.matchAll(UNSAFE_PATTERNS.eval)];
+    for (const match of evalMatches) {
+      violations.push({
+        type: "eval-usage",
+        message: "eval() is not allowed for security reasons",
+        location: getLocation(source, match.index ?? 0),
+        value: match[0]
+      });
+    }
+    const fnMatches = [...source.matchAll(UNSAFE_PATTERNS.functionConstructor)];
+    for (const match of fnMatches) {
+      violations.push({
+        type: "eval-usage",
+        message: "new Function() is not allowed for security reasons",
+        location: getLocation(source, match.index ?? 0),
+        value: match[0]
+      });
+    }
+  }
+  if (policy.noDynamicImports !== false) {
+    const matches = [...source.matchAll(UNSAFE_PATTERNS.dynamicImport)];
+    for (const match of matches) {
+      violations.push({
+        type: "dynamic-import",
+        message: "Dynamic imports are not allowed for security reasons",
+        location: getLocation(source, match.index ?? 0),
+        value: match[0]
+      });
+    }
+  }
+  if (policy.noRequire !== false) {
+    const matches = [...source.matchAll(UNSAFE_PATTERNS.require)];
+    for (const match of matches) {
+      violations.push({
+        type: "require-usage",
+        message: "require() is not allowed for security reasons",
+        location: getLocation(source, match.index ?? 0),
+        value: match[0]
+      });
+    }
+  }
+  const importViolations = validateImports(source, policy);
+  violations.push(...importViolations);
+  return violations;
+}
+function validateImports(source, policy = DEFAULT_SECURITY_POLICY) {
+  const violations = [];
+  const importPattern = /import\s+(?:(?:\{[^}]*\}|[\w*]+)\s+from\s+)?['"]([^'"]+)['"]/g;
+  const imports = [];
+  let match;
+  while ((match = importPattern.exec(source)) !== null) {
+    imports.push({ module: match[1], index: match.index });
+  }
+  const requirePattern = /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+  while ((match = requirePattern.exec(source)) !== null) {
+    imports.push({ module: match[1], index: match.index });
+  }
+  for (const imp of imports) {
+    if (policy.blockedImports) {
+      for (const blocked of policy.blockedImports) {
+        if (blocked.test(imp.module)) {
+          violations.push({
+            type: "blocked-import",
+            message: `Import '${imp.module}' is blocked by security policy`,
+            location: getLocation(source, imp.index),
+            value: imp.module
+          });
+          break;
+        }
+      }
+    }
+    if (policy.allowedImports && policy.allowedImports.length > 0) {
+      const isAllowed = policy.allowedImports.some((pattern) => pattern.test(imp.module));
+      if (!isAllowed) {
+        const alreadyBlocked = violations.some((v) => v.type === "blocked-import" && v.value === imp.module);
+        if (!alreadyBlocked) {
+          violations.push({
+            type: "disallowed-import",
+            message: `Import '${imp.module}' is not in the allowed imports list`,
+            location: getLocation(source, imp.index),
+            value: imp.module
+          });
+        }
+      }
+    }
+  }
+  return violations;
+}
+function validateSize(size, policy = DEFAULT_SECURITY_POLICY) {
+  const maxSize = policy.maxBundleSize ?? DEFAULT_SECURITY_POLICY.maxBundleSize ?? 512e3;
+  if (size > maxSize) {
+    return {
+      type: "size-exceeded",
+      message: `Bundle size (${formatBytes(size)}) exceeds maximum allowed (${formatBytes(maxSize)})`,
+      value: String(size)
+    };
+  }
+  return void 0;
+}
+function mergePolicy(userPolicy) {
+  if (!userPolicy) {
+    return { ...DEFAULT_SECURITY_POLICY };
+  }
+  return {
+    allowedImports: userPolicy.allowedImports ?? DEFAULT_SECURITY_POLICY.allowedImports,
+    blockedImports: userPolicy.blockedImports ?? DEFAULT_SECURITY_POLICY.blockedImports,
+    maxBundleSize: userPolicy.maxBundleSize ?? DEFAULT_SECURITY_POLICY.maxBundleSize,
+    maxTransformTime: userPolicy.maxTransformTime ?? DEFAULT_SECURITY_POLICY.maxTransformTime,
+    noEval: userPolicy.noEval ?? DEFAULT_SECURITY_POLICY.noEval,
+    noDynamicImports: userPolicy.noDynamicImports ?? DEFAULT_SECURITY_POLICY.noDynamicImports,
+    noRequire: userPolicy.noRequire ?? DEFAULT_SECURITY_POLICY.noRequire,
+    allowedGlobals: userPolicy.allowedGlobals ?? DEFAULT_SECURITY_POLICY.allowedGlobals
+  };
+}
+function getLocation(source, index) {
+  const lines = source.slice(0, index).split("\n");
+  return {
+    line: lines.length,
+    column: lines[lines.length - 1].length + 1
+  };
+}
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+var SecurityError = class extends Error {
+  violations;
+  constructor(message, violations) {
+    super(message);
+    this.name = "SecurityError";
+    this.violations = violations;
+  }
+};
+function throwOnViolations(violations) {
+  if (violations.length > 0) {
+    const message = violations.map((v) => v.message).join("; ");
+    throw new SecurityError(`Security policy violation: ${message}`, violations);
+  }
+}
+
+// libs/uipack/src/bundler/sandbox/enclave-adapter.ts
+import { Enclave } from "enclave-vm";
+var DEFAULT_ENCLAVE_OPTIONS = {
+  securityLevel: "SECURE",
+  timeout: 5e3,
+  maxIterations: 1e4,
+  validate: true,
+  transform: true
+};
+var STRICT_SECURITY_BLOCKED_IMPORTS_THRESHOLD = 10;
+function mapSecurityLevel(policy) {
+  if (policy?.blockedImports && policy.blockedImports.length > STRICT_SECURITY_BLOCKED_IMPORTS_THRESHOLD) {
+    return "STRICT";
+  }
+  return "SECURE";
+}
+function createJSXRuntime(React) {
+  const R = React;
+  return {
+    jsx: (type, props, key) => {
+      const { children, ...rest } = props;
+      return R.createElement(type, key ? { ...rest, key } : rest, children);
+    },
+    jsxs: (type, props, key) => {
+      const { children, ...rest } = props;
+      return R.createElement(type, key ? { ...rest, key } : rest, children);
+    },
+    jsxDEV: (type, props, key, _isStaticChildren, _source, _self) => {
+      const { children, ...rest } = props;
+      return R.createElement(type, key ? { ...rest, key } : rest, children);
+    },
+    Fragment: R.Fragment
+  };
+}
+var DANGEROUS_GLOBAL_KEYS = /* @__PURE__ */ new Set([
+  "process",
+  "require",
+  "__dirname",
+  "__filename",
+  "Buffer",
+  "eval",
+  "Function",
+  "constructor",
+  "global",
+  "globalThis",
+  "module",
+  "exports",
+  "__proto__"
+]);
+function sanitizeGlobalKey(key) {
+  return key.replace(/[^a-zA-Z0-9_$]/g, "_");
+}
+function buildGlobals(context) {
+  const globals = {};
+  if (context.React) {
+    globals["React"] = context.React;
+  }
+  if (context.ReactDOM) {
+    globals["ReactDOM"] = context.ReactDOM;
+  }
+  if (context.React) {
+    const jsxRuntime = createJSXRuntime(context.React);
+    globals["__jsx"] = jsxRuntime["jsx"];
+    globals["__jsxs"] = jsxRuntime["jsxs"];
+    globals["__jsxDEV"] = jsxRuntime["jsxDEV"];
+    globals["Fragment"] = jsxRuntime["Fragment"];
+  }
+  if (context.modules) {
+    for (const [key, value] of Object.entries(context.modules)) {
+      const sanitizedKey = sanitizeGlobalKey(key);
+      if (DANGEROUS_GLOBAL_KEYS.has(sanitizedKey)) {
+        throw new ExecutionError(
+          `Dangerous module key '${key}' (sanitized: '${sanitizedKey}') is not allowed in execution context`,
+          { code: "SECURITY_VIOLATION" }
+        );
+      }
+      globals[sanitizedKey] = value;
+    }
+  }
+  if (context.globals) {
+    for (const [key, value] of Object.entries(context.globals)) {
+      if (DANGEROUS_GLOBAL_KEYS.has(key)) {
+        throw new ExecutionError(`Dangerous global key '${key}' is not allowed in execution context`, {
+          code: "SECURITY_VIOLATION"
+        });
+      }
+      const sanitizedKey = sanitizeGlobalKey(key);
+      if (DANGEROUS_GLOBAL_KEYS.has(sanitizedKey)) {
+        throw new ExecutionError(
+          `Dangerous global key '${key}' (sanitized: '${sanitizedKey}') is not allowed in execution context`,
+          { code: "SECURITY_VIOLATION" }
+        );
+      }
+      globals[sanitizedKey] = value;
+    }
+  }
+  return globals;
+}
+function buildRequireFunction(context) {
+  const normalizedContextModules = {};
+  if (context.modules) {
+    for (const [key, value] of Object.entries(context.modules)) {
+      normalizedContextModules[key.toLowerCase()] = value;
+    }
+  }
+  const modules = {
+    react: context.React,
+    "react-dom": context.ReactDOM,
+    "react/jsx-runtime": context.React ? createJSXRuntime(context.React) : void 0,
+    "react/jsx-dev-runtime": context.React ? createJSXRuntime(context.React) : void 0,
+    ...normalizedContextModules
+  };
+  return (id) => {
+    const normalizedId = id.toLowerCase();
+    if (normalizedId in modules) {
+      const mod = modules[normalizedId];
+      if (mod === void 0) {
+        throw new Error(`Module '${id}' is not available. Did you forget to provide it in the context?`);
+      }
+      return mod;
+    }
+    throw new Error(`Module '${id}' is not available in the sandbox environment`);
+  };
+}
+async function executeCode(code, context = {}) {
+  const consoleOutput = [];
+  const globals = buildGlobals(context);
+  globals["console"] = {
+    log: (...args) => {
+      consoleOutput.push(args.map(String).join(" "));
+    },
+    info: (...args) => {
+      consoleOutput.push(`[INFO] ${args.map(String).join(" ")}`);
+    },
+    warn: (...args) => {
+      consoleOutput.push(`[WARN] ${args.map(String).join(" ")}`);
+    },
+    error: (...args) => {
+      consoleOutput.push(`[ERROR] ${args.map(String).join(" ")}`);
+    },
+    debug: (...args) => {
+      consoleOutput.push(`[DEBUG] ${args.map(String).join(" ")}`);
+    },
+    trace: () => {
+    },
+    dir: () => {
+    },
+    table: () => {
+    },
+    group: () => {
+    },
+    groupEnd: () => {
+    },
+    time: () => {
+    },
+    timeEnd: () => {
+    },
+    assert: () => {
+    },
+    clear: () => {
+    },
+    count: () => {
+    },
+    countReset: () => {
+    }
+  };
+  globals["require"] = buildRequireFunction(context);
+  const enclave = new Enclave({
+    ...DEFAULT_ENCLAVE_OPTIONS,
+    timeout: context.timeout ?? DEFAULT_ENCLAVE_OPTIONS.timeout,
+    maxIterations: context.maxIterations ?? DEFAULT_ENCLAVE_OPTIONS.maxIterations,
+    securityLevel: mapSecurityLevel(context.security),
+    globals,
+    allowFunctionsInGlobals: true
+    // Required for React components
+  });
+  try {
+    const wrappedCode = `
+      const module = { exports: {} };
+      const exports = module.exports;
+      const __filename = 'widget.js';
+      const __dirname = '/';
+      ${code}
+      return module.exports;
+    `;
+    const result = await enclave.run(wrappedCode);
+    if (!result.success) {
+      const errorMessage = result.error?.message ?? "Execution failed";
+      const errorCode = result.error?.code;
+      if (errorCode === "TIMEOUT") {
+        throw new ExecutionError(`Execution timed out after ${context.timeout ?? DEFAULT_ENCLAVE_OPTIONS.timeout}ms`, {
+          code: "TIMEOUT"
+        });
+      }
+      if (errorCode === "MAX_ITERATIONS") {
+        throw new ExecutionError(
+          `Maximum iterations exceeded (${context.maxIterations ?? DEFAULT_ENCLAVE_OPTIONS.maxIterations})`,
+          {
+            code: "MAX_ITERATIONS"
+          }
+        );
+      }
+      if (errorCode === "VALIDATION_ERROR") {
+        throw new ExecutionError(`Security validation failed: ${errorMessage}`, { code: "SECURITY_VIOLATION" });
+      }
+      throw new ExecutionError(errorMessage, result.error);
+    }
+    return {
+      exports: result.value,
+      executionTime: result.stats.duration,
+      consoleOutput: consoleOutput.length > 0 ? consoleOutput : void 0
+    };
+  } finally {
+    enclave.dispose();
+  }
+}
+async function executeDefault(code, context = {}) {
+  const result = await executeCode(code, context);
+  if ("default" in result.exports) {
+    return result.exports.default;
+  }
+  const exportKeys = Object.keys(result.exports);
+  if (exportKeys.length === 0) {
+    throw new ExecutionError("Code did not export any values");
+  }
+  if (exportKeys.length === 1) {
+    return result.exports[exportKeys[0]];
+  }
+  return result.exports;
+}
+var ExecutionError = class extends Error {
+  /** Error code for categorization */
+  code;
+  constructor(message, cause) {
+    super(message, { cause });
+    this.name = "ExecutionError";
+    if (cause && typeof cause === "object" && "code" in cause) {
+      this.code = cause.code;
+    }
+  }
+};
+function isExecutionError(error) {
+  return error instanceof ExecutionError;
+}
+
+// libs/uipack/src/bundler/cache.ts
+var BundlerCache = class {
+  cache = /* @__PURE__ */ new Map();
+  options;
+  stats = {
+    hits: 0,
+    misses: 0,
+    evictions: 0
+  };
+  constructor(options = {}) {
+    this.options = {
+      maxSize: options.maxSize ?? 100,
+      ttl: options.ttl ?? 3e5
+    };
+  }
+  /**
+   * Get a cached bundle result.
+   *
+   * @param key - Cache key (typically content hash)
+   * @returns Cached result or undefined if not found/expired
+   */
+  get(key) {
+    const entry = this.cache.get(key);
+    if (!entry) {
+      this.stats.misses++;
+      return void 0;
+    }
+    if (this.isExpired(entry)) {
+      this.cache.delete(key);
+      this.stats.misses++;
+      this.stats.evictions++;
+      return void 0;
+    }
+    entry.lastAccessedAt = Date.now();
+    entry.accessCount++;
+    this.stats.hits++;
+    this.cache.delete(key);
+    this.cache.set(key, entry);
+    return entry.result;
+  }
+  /**
+   * Store a bundle result in the cache.
+   *
+   * @param key - Cache key (typically content hash)
+   * @param result - Bundle result to cache
+   */
+  set(key, result) {
+    while (this.cache.size >= this.options.maxSize) {
+      this.evictOldest();
+    }
+    const now = Date.now();
+    const entry = {
+      result,
+      createdAt: now,
+      lastAccessedAt: now,
+      accessCount: 1
+    };
+    this.cache.set(key, entry);
+  }
+  /**
+   * Check if a key exists in the cache (and is not expired).
+   *
+   * @param key - Cache key to check
+   * @returns true if key exists and is not expired
+   */
+  has(key) {
+    const entry = this.cache.get(key);
+    if (!entry) return false;
+    if (this.isExpired(entry)) {
+      this.cache.delete(key);
+      this.stats.evictions++;
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Delete a specific entry from the cache.
+   *
+   * @param key - Cache key to delete
+   * @returns true if the key was found and deleted
+   */
+  delete(key) {
+    return this.cache.delete(key);
+  }
+  /**
+   * Clear all entries from the cache.
+   */
+  clear() {
+    this.cache.clear();
+    this.stats = {
+      hits: 0,
+      misses: 0,
+      evictions: 0
+    };
+  }
+  /**
+   * Get cache statistics.
+   *
+   * @returns Current cache statistics
+   */
+  getStats() {
+    const total = this.stats.hits + this.stats.misses;
+    const hitRate = total > 0 ? this.stats.hits / total : 0;
+    let memoryUsage = 0;
+    for (const entry of this.cache.values()) {
+      memoryUsage += entry.result.size;
+      if (entry.result.map) {
+        memoryUsage += entry.result.map.length;
+      }
+    }
+    return {
+      size: this.cache.size,
+      hits: this.stats.hits,
+      misses: this.stats.misses,
+      hitRate,
+      evictions: this.stats.evictions,
+      memoryUsage
+    };
+  }
+  /**
+   * Remove expired entries from the cache.
+   *
+   * @returns Number of entries removed
+   */
+  cleanup() {
+    let removed = 0;
+    for (const [key, entry] of this.cache.entries()) {
+      if (this.isExpired(entry)) {
+        this.cache.delete(key);
+        removed++;
+      }
+    }
+    this.stats.evictions += removed;
+    return removed;
+  }
+  /**
+   * Get all cache keys.
+   *
+   * @returns Array of cache keys
+   */
+  keys() {
+    return Array.from(this.cache.keys());
+  }
+  /**
+   * Get the number of entries in the cache.
+   */
+  get size() {
+    return this.cache.size;
+  }
+  /**
+   * Check if an entry is expired.
+   */
+  isExpired(entry) {
+    return Date.now() - entry.createdAt > this.options.ttl;
+  }
+  /**
+   * Evict the oldest (least recently used) entry.
+   */
+  evictOldest() {
+    const oldestKey = this.cache.keys().next().value;
+    if (oldestKey !== void 0) {
+      this.cache.delete(oldestKey);
+      this.stats.evictions++;
+    }
+  }
+};
+function hashContent(content) {
+  let hash = 2166136261;
+  for (let i = 0; i < content.length; i++) {
+    hash ^= content.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0).toString(16).padStart(8, "0");
+}
+function createCacheKey(source, options) {
+  const sourceHash = hashContent(source);
+  const optionsHash = hashContent(
+    JSON.stringify({
+      sourceType: options.sourceType,
+      format: options.format,
+      minify: options.minify,
+      externals: options.externals?.slice().sort(),
+      target: options.target
+    })
+  );
+  return `${sourceHash}-${optionsHash}`;
+}
+
+// libs/uipack/src/bundler/file-cache/storage/index.ts
+init_interface();
+init_filesystem();
+init_redis();
+
+// libs/uipack/src/bundler/file-cache/hash-calculator.ts
+import { createHash as createHash2 } from "crypto";
+import { readFile as readFile2 } from "fs/promises";
+import { existsSync as existsSync2 } from "fs";
+import { join as join2, dirname as dirname2, resolve } from "path";
+function sha256(content) {
+  return createHash2("sha256").update(content, "utf8").digest("hex");
+}
+function sha256Buffer(buffer) {
+  return createHash2("sha256").update(buffer).digest("hex");
+}
+async function hashFile(filePath) {
+  try {
+    const content = await readFile2(filePath);
+    return sha256Buffer(content);
+  } catch {
+    return void 0;
+  }
+}
+async function hashFiles(filePaths) {
+  const hashes = [];
+  for (const filePath of filePaths.sort()) {
+    const hash = await hashFile(filePath);
+    if (hash) {
+      hashes.push(`${filePath}:${hash}`);
+    }
+  }
+  return sha256(hashes.join("\n"));
+}
+async function calculateComponentHash(options) {
+  const {
+    entryPath,
+    baseDir = dirname2(entryPath),
+    externals = [],
+    dependencies = {},
+    bundleOptions = {},
+    maxDepth = 10
+  } = options;
+  const absoluteEntryPath = resolve(entryPath);
+  const files = /* @__PURE__ */ new Set();
+  const fileHashes = {};
+  await collectLocalDependencies(absoluteEntryPath, baseDir, files, maxDepth, 0);
+  for (const file of files) {
+    const hash = await hashFile(file);
+    if (hash) {
+      fileHashes[file] = hash;
+    }
+  }
+  const sortedFiles = Array.from(files).sort();
+  const fileHashContent = sortedFiles.map((f) => `${f}:${fileHashes[f] || "missing"}`).join("\n");
+  const filesHash = sha256(fileHashContent);
+  const optionsHash = sha256(JSON.stringify(sortedObject(bundleOptions)));
+  const dependenciesHash = sha256(JSON.stringify(sortedObject(dependencies)));
+  const combinedHash = sha256([filesHash, optionsHash, dependenciesHash].join(":"));
+  return {
+    hash: combinedHash,
+    entryHash: fileHashes[absoluteEntryPath] || "",
+    files: sortedFiles,
+    fileHashes,
+    optionsHash,
+    dependenciesHash
+  };
+}
+async function calculateQuickHash(entryPath, bundleOptions) {
+  const entryHash = await hashFile(entryPath);
+  const optionsHash = bundleOptions ? sha256(JSON.stringify(sortedObject(bundleOptions))) : "";
+  return sha256(`${entryHash || "missing"}:${optionsHash}`);
+}
+async function collectLocalDependencies(filePath, baseDir, collected, maxDepth, currentDepth) {
+  if (currentDepth >= maxDepth) return;
+  if (collected.has(filePath)) return;
+  if (!existsSync2(filePath)) return;
+  collected.add(filePath);
+  try {
+    const content = await readFile2(filePath, "utf8");
+    const imports = extractImportPaths(content);
+    for (const importPath of imports) {
+      if (!importPath.startsWith(".") && !importPath.startsWith("/")) {
+        continue;
+      }
+      const resolvedPath = resolveImportPath(importPath, dirname2(filePath));
+      if (resolvedPath && existsSync2(resolvedPath)) {
+        await collectLocalDependencies(resolvedPath, baseDir, collected, maxDepth, currentDepth + 1);
+      }
+    }
+  } catch {
+  }
+}
+function extractImportPaths(source) {
+  const paths = [];
+  const importRegex = /import\s+(?:[^'"]+\s+from\s+)?['"]([^'"]+)['"]/g;
+  let match;
+  while ((match = importRegex.exec(source)) !== null) {
+    paths.push(match[1]);
+  }
+  const exportRegex = /export\s+(?:\*|{[^}]+})\s+from\s+['"]([^'"]+)['"]/g;
+  while ((match = exportRegex.exec(source)) !== null) {
+    paths.push(match[1]);
+  }
+  const requireRegex = /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+  while ((match = requireRegex.exec(source)) !== null) {
+    paths.push(match[1]);
+  }
+  const dynamicRegex = /import\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+  while ((match = dynamicRegex.exec(source)) !== null) {
+    paths.push(match[1]);
+  }
+  return [...new Set(paths)];
+}
+function resolveImportPath(importPath, fromDir) {
+  const extensions = ["", ".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"];
+  for (const ext of extensions) {
+    const fullPath = join2(fromDir, importPath + ext);
+    if (existsSync2(fullPath)) {
+      return fullPath;
+    }
+  }
+  for (const ext of extensions) {
+    const indexPath = join2(fromDir, importPath, `index${ext}`);
+    if (existsSync2(indexPath)) {
+      return indexPath;
+    }
+  }
+  return void 0;
+}
+function sortedObject(obj) {
+  const sorted = {};
+  const keys = Object.keys(obj).sort();
+  for (const key of keys) {
+    const value = obj[key];
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+      sorted[key] = sortedObject(value);
+    } else {
+      sorted[key] = value;
+    }
+  }
+  return sorted;
+}
+function generateBuildId() {
+  const timestamp = Date.now().toString(36);
+  const random = Math.random().toString(36).substring(2, 10);
+  return `${timestamp}-${random}`;
+}
+function buildIdFromHash(hash) {
+  return hash.substring(0, 12);
+}
+
+// libs/uipack/src/bundler/file-cache/component-builder.ts
+import { readFile as readFile3 } from "fs/promises";
+import { existsSync as existsSync3 } from "fs";
+import { resolve as resolve2, extname } from "path";
+import { randomUUID } from "crypto";
+
+// 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 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
+  };
+}
+
+// libs/uipack/src/utils/escape-html.ts
+function escapeHtmlAttr(str) {
+  return str.replace(/&/g, "&amp;").replace(/"/g, "&quot;");
+}
+
+// libs/uipack/src/dependency/import-map.ts
+function createImportMap(dependencies) {
+  const imports = {};
+  const integrity = {};
+  for (const dep of dependencies) {
+    imports[dep.packageName] = dep.cdnUrl;
+    if (dep.integrity) {
+      integrity[dep.cdnUrl] = dep.integrity;
+    }
+  }
+  return {
+    imports,
+    integrity: Object.keys(integrity).length > 0 ? integrity : void 0
+  };
+}
+function generateImportMapScriptTag(map) {
+  const json = JSON.stringify(map, null, 2).replace(/<\//g, "<\\/");
+  return `<script type="importmap">
+${json}
+</script>`;
+}
+function generateImportMapScriptTagMinified(map) {
+  const json = JSON.stringify(map).replace(/<\//g, "<\\/");
+  return `<script type="importmap">${json}</script>`;
+}
+function generateUMDShim(dependencies, options = {}) {
+  const { safe = true, minify = false } = options;
+  const depsWithGlobals = dependencies.filter((d) => d.global && !d.esm);
+  if (depsWithGlobals.length === 0) {
+    return "";
+  }
+  const entries = depsWithGlobals.map((dep) => {
+    const global = dep.global;
+    return `'${dep.packageName}': { default: window.${global}, ...window.${global} }`;
+  });
+  const shimObject = `{
+  ${entries.join(",\n  ")}
+}`;
+  const code = safe ? `(function() {
+  try {
+    window.__esm_shim = ${shimObject};
+  } catch (e) {
+    console.warn('UMD shim failed:', e);
+  }
+})();` : `window.__esm_shim = ${shimObject};`;
+  return minify ? code.replace(/\s+/g, " ").replace(/\s*([{},:])\s*/g, "$1") : code;
+}
+function generateCDNScriptTags(dependencies) {
+  return dependencies.filter((dep) => !dep.esm).map((dep) => {
+    const attrs = [`src="${escapeHtmlAttr(dep.cdnUrl)}"`];
+    if (dep.integrity) {
+      attrs.push(`integrity="${escapeHtmlAttr(dep.integrity)}"`);
+    }
+    attrs.push('crossorigin="anonymous"');
+    return `<script ${attrs.join(" ")}></script>`;
+  });
+}
+function generateESMScriptTags(dependencies) {
+  return dependencies.filter((dep) => dep.esm).map((dep) => {
+    const attrs = ['type="module"', `src="${escapeHtmlAttr(dep.cdnUrl)}"`];
+    if (dep.integrity) {
+      attrs.push(`integrity="${escapeHtmlAttr(dep.integrity)}"`);
+    }
+    attrs.push('crossorigin="anonymous"');
+    return `<script ${attrs.join(" ")}></script>`;
+  });
+}
+function generateDependencyHTML(dependencies, options = {}) {
+  const { minify = false, includeShim = true } = options;
+  const parts = [];
+  const importMap = createImportMap(dependencies);
+  const importMapTag = minify ? generateImportMapScriptTagMinified(importMap) : generateImportMapScriptTag(importMap);
+  parts.push(importMapTag);
+  const umdTags = generateCDNScriptTags(dependencies);
+  parts.push(...umdTags);
+  if (includeShim) {
+    const shim = generateUMDShim(dependencies, { minify });
+    if (shim) {
+      parts.push(`<script>${shim}</script>`);
+    }
+  }
+  const esmTags = generateESMScriptTags(dependencies);
+  parts.push(...esmTags);
+  return parts.join(minify ? "" : "\n");
+}
+
+// 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;
+  }
+};
+
+// libs/uipack/src/bundler/file-cache/component-builder.ts
+var ComponentBuilder = class {
+  storage;
+  esbuild = null;
+  constructor(storage) {
+    this.storage = storage;
+  }
+  /**
+   * Build a component from a file path.
+   */
+  async build(options) {
+    const startTime = performance.now();
+    const {
+      entryPath,
+      toolName,
+      externals = [],
+      dependencies = {},
+      bundleOptions = {},
+      platform = "unknown",
+      skipCache = false,
+      ssr = false,
+      ssrContext = {},
+      executeCode: executeCode2
+    } = options;
+    const absoluteEntryPath = resolve2(entryPath);
+    if (!existsSync3(absoluteEntryPath)) {
+      throw new Error(`Entry file not found: ${absoluteEntryPath}`);
+    }
+    const hashResult = await calculateComponentHash({
+      entryPath: absoluteEntryPath,
+      externals,
+      dependencies,
+      bundleOptions
+    });
+    if (!skipCache) {
+      const cached = await this.storage.get(hashResult.hash);
+      if (cached) {
+        return {
+          manifest: cached,
+          cached: true,
+          buildTimeMs: performance.now() - startTime
+        };
+      }
+    }
+    const source = await readFile3(absoluteEntryPath, "utf8");
+    const resolver = new DependencyResolver({ platform });
+    const resolvedDeps = [];
+    for (const pkg of externals) {
+      try {
+        const override = dependencies[pkg];
+        const resolved = resolver.resolve(pkg, override);
+        if (resolved) {
+          resolvedDeps.push(resolved);
+        }
+      } catch (error) {
+        console.warn(`Failed to resolve external "${pkg}": ${error}`);
+      }
+    }
+    const allExternals = new Set(externals);
+    for (const dep of resolvedDeps) {
+      const entry = resolver.getRegistry()[dep.packageName];
+      if (entry?.providers) {
+        const providerConfig = Object.values(entry.providers)[0];
+        if (providerConfig?.peerDependencies) {
+          for (const peer of providerConfig.peerDependencies) {
+            if (!allExternals.has(peer)) {
+              allExternals.add(peer);
+              try {
+                const peerOverride = dependencies[peer];
+                const resolved = resolver.resolve(peer, peerOverride);
+                if (resolved) {
+                  resolvedDeps.push(resolved);
+                }
+              } catch {
+              }
+            }
+          }
+        }
+      }
+    }
+    const importMap = createImportMap(resolvedDeps);
+    const bundleResult = await this.bundleComponent({
+      source,
+      entryPath: absoluteEntryPath,
+      externals: Array.from(allExternals),
+      bundleOptions
+    });
+    let ssrHtml;
+    if (ssr) {
+      ssrHtml = await this.renderSSR(bundleResult.code, ssrContext, resolvedDeps, executeCode2);
+    }
+    const manifest = {
+      version: "1.0",
+      buildId: randomUUID(),
+      toolName,
+      entryPath: absoluteEntryPath,
+      contentHash: hashResult.hash,
+      dependencies: resolvedDeps,
+      outputs: {
+        code: bundleResult.code,
+        sourceMap: bundleResult.map,
+        ssrHtml
+      },
+      importMap,
+      metadata: {
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        buildTimeMs: performance.now() - startTime,
+        totalSize: Buffer.byteLength(bundleResult.code, "utf8"),
+        bundlerVersion: bundleResult.bundlerVersion
+      }
+    };
+    await this.storage.set(hashResult.hash, manifest);
+    return {
+      manifest,
+      cached: false,
+      buildTimeMs: performance.now() - startTime
+    };
+  }
+  /**
+   * Build multiple components.
+   */
+  async buildMany(options) {
+    return Promise.all(options.map((opt) => this.build(opt)));
+  }
+  /**
+   * Check if a component needs rebuilding.
+   */
+  async needsRebuild(options) {
+    const absoluteEntryPath = resolve2(options.entryPath);
+    const hashResult = await calculateComponentHash({
+      entryPath: absoluteEntryPath,
+      externals: options.externals,
+      dependencies: options.dependencies,
+      bundleOptions: options.bundleOptions
+    });
+    const cached = await this.storage.has(hashResult.hash);
+    return !cached;
+  }
+  /**
+   * Get a cached build if it exists.
+   */
+  async getCached(options) {
+    const absoluteEntryPath = resolve2(options.entryPath);
+    const hashResult = await calculateComponentHash({
+      entryPath: absoluteEntryPath,
+      externals: options.externals,
+      dependencies: options.dependencies,
+      bundleOptions: options.bundleOptions
+    });
+    return this.storage.get(hashResult.hash);
+  }
+  /**
+   * Invalidate a cached build.
+   */
+  async invalidate(contentHash) {
+    return this.storage.delete(contentHash);
+  }
+  /**
+   * Generate complete HTML for a built component.
+   */
+  generateHTML(manifest, minify = false) {
+    const parts = [];
+    const dependencyHtml = generateDependencyHTML(manifest.dependencies, { minify });
+    parts.push(dependencyHtml);
+    parts.push(`<script type="module">${manifest.outputs.code}</script>`);
+    return parts.join(minify ? "" : "\n");
+  }
+  /**
+   * Bundle a component using esbuild.
+   */
+  async bundleComponent(options) {
+    const { source, entryPath, externals, bundleOptions } = options;
+    if (!this.esbuild) {
+      try {
+        this.esbuild = await import("esbuild");
+      } catch {
+        throw new Error("esbuild is required for component building. Install with: npm install esbuild");
+      }
+    }
+    const ext = extname(entryPath).toLowerCase();
+    const loader = ext === ".tsx" ? "tsx" : ext === ".ts" ? "ts" : ext === ".jsx" ? "jsx" : "js";
+    try {
+      const result = await this.esbuild.transform(source, {
+        loader,
+        format: "esm",
+        minify: bundleOptions.minify ?? process.env["NODE_ENV"] === "production",
+        sourcemap: bundleOptions.sourceMaps ? "inline" : false,
+        target: bundleOptions.target ?? "es2020",
+        treeShaking: bundleOptions.treeShake ?? true,
+        jsx: "automatic",
+        jsxImportSource: bundleOptions.jsxImportSource ?? "react",
+        // Mark externals for later import map resolution
+        banner: externals.length > 0 ? `/* externals: ${externals.join(", ")} */` : void 0
+      });
+      return {
+        code: result.code,
+        map: result.map || void 0,
+        bundlerVersion: this.esbuild.version
+      };
+    } catch (error) {
+      throw new Error(`Bundle failed for ${entryPath}: ${error}`);
+    }
+  }
+  /**
+   * Perform server-side rendering.
+   */
+  async renderSSR(code, context, dependencies, executeCode2) {
+    const hasReact = dependencies.some((d) => d.packageName === "react");
+    if (!hasReact) {
+      console.warn("SSR requires React as an external dependency");
+      return void 0;
+    }
+    try {
+      const React = await import("react");
+      const ReactDOMServer = await import("react-dom/server");
+      const exports = {};
+      const module = { exports };
+      if (executeCode2) {
+        executeCode2(code, exports, module, React);
+      } else {
+        const fn = new Function("exports", "module", "React", code);
+        fn(exports, module, React);
+      }
+      const Component = module.exports.default || module.exports;
+      if (typeof Component !== "function") {
+        console.warn("SSR: No default component export found");
+        return void 0;
+      }
+      const element = React.createElement(Component, context);
+      return ReactDOMServer.renderToString(element);
+    } catch (error) {
+      console.warn(`SSR failed: ${error}`);
+      return void 0;
+    }
+  }
+};
+async function createFilesystemBuilder(cacheDir = ".frontmcp-cache/builds") {
+  const { FilesystemStorage: FilesystemStorage2 } = await Promise.resolve().then(() => (init_filesystem(), filesystem_exports));
+  const storage = new FilesystemStorage2({ cacheDir });
+  await storage.initialize();
+  return new ComponentBuilder(storage);
+}
+async function createRedisBuilder(redisClient, keyPrefix = "frontmcp:ui:build:") {
+  const { RedisStorage: RedisStorage2 } = await Promise.resolve().then(() => (init_redis(), redis_exports));
+  const storage = new RedisStorage2({
+    client: redisClient,
+    keyPrefix
+  });
+  await storage.initialize();
+  return new ComponentBuilder(storage);
+}
+export {
+  BundlerCache,
+  ComponentBuilder,
+  DEFAULT_BUNDLER_OPTIONS,
+  DEFAULT_BUNDLE_OPTIONS,
+  DEFAULT_SECURITY_POLICY,
+  DEFAULT_STATIC_HTML_OPTIONS,
+  DEFAULT_STORAGE_OPTIONS,
+  ExecutionError,
+  FilesystemStorage,
+  RedisStorage,
+  STATIC_HTML_CDN,
+  SecurityError,
+  buildIdFromHash,
+  calculateComponentHash,
+  calculateManifestSize,
+  calculateQuickHash,
+  createCacheKey,
+  createFilesystemBuilder,
+  createFilesystemStorage,
+  createRedisBuilder,
+  createRedisStorage,
+  executeCode,
+  executeDefault,
+  generateBuildId,
+  getCdnTypeForPlatform,
+  hashContent,
+  hashFile,
+  hashFiles,
+  isExecutionError,
+  mergePolicy,
+  sha256,
+  sha256Buffer,
+  throwOnViolations,
+  validateImports,
+  validateSize,
+  validateSource
+};