@servlyadmin/runtime-core 0.1.8 → 0.1.9

package/dist/index.js

@@ -1,24 +1,522 @@
-import {
-  DEFAULT_SERVLY_TAILWIND_CONFIG,
-  addCustomStyles,
-  getTailwind,
-  initServlyTailwind,
-  injectTailwind,
-  isTailwindLoaded,
-  removeCustomStyles,
-  removeTailwind,
-  updateTailwindConfig
-} from "./chunk-IWFVKY5N.js";
-import {
-  buildRegistryFromBundle,
-  collectAllDependencies,
-  createRegistry,
-  detectCircularDependencies,
-  extractDependencies,
-  extractDependenciesFromCode
-} from "./chunk-CIUQK4GA.js";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// packages/runtime-core/src/tailwind.ts
+var tailwind_exports = {};
+__export(tailwind_exports, {
+  DEFAULT_SERVLY_TAILWIND_CONFIG: () => DEFAULT_SERVLY_TAILWIND_CONFIG,
+  addCustomStyles: () => addCustomStyles,
+  default: () => tailwind_default,
+  getTailwind: () => getTailwind,
+  initServlyTailwind: () => initServlyTailwind,
+  injectTailwind: () => injectTailwind,
+  isTailwindLoaded: () => isTailwindLoaded,
+  removeCustomStyles: () => removeCustomStyles,
+  removeTailwind: () => removeTailwind,
+  updateTailwindConfig: () => updateTailwindConfig
+});
+function injectTailwind(config = {}) {
+  return new Promise((resolve, reject) => {
+    if (tailwindInjected && tailwindScript) {
+      resolve();
+      return;
+    }
+    if (typeof document === "undefined") {
+      resolve();
+      return;
+    }
+    if (window.tailwind) {
+      tailwindInjected = true;
+      config.onReady?.();
+      resolve();
+      return;
+    }
+    const {
+      cdnUrl = DEFAULT_TAILWIND_CDN,
+      config: tailwindConfig,
+      plugins = [],
+      usePlayCdn = false,
+      onReady,
+      onError
+    } = config;
+    const script = document.createElement("script");
+    script.src = usePlayCdn ? `${cdnUrl}?plugins=forms,typography,aspect-ratio` : cdnUrl;
+    script.async = true;
+    script.onload = () => {
+      tailwindInjected = true;
+      tailwindScript = script;
+      if (tailwindConfig && window.tailwind) {
+        window.tailwind.config = tailwindConfig;
+      }
+      onReady?.();
+      resolve();
+    };
+    script.onerror = (event) => {
+      const error = new Error(`Failed to load Tailwind CSS from ${cdnUrl}`);
+      onError?.(error);
+      reject(error);
+    };
+    document.head.appendChild(script);
+  });
+}
+function removeTailwind() {
+  if (tailwindScript && tailwindScript.parentNode) {
+    tailwindScript.parentNode.removeChild(tailwindScript);
+    tailwindScript = null;
+    tailwindInjected = false;
+    delete window.tailwind;
+  }
+}
+function isTailwindLoaded() {
+  return tailwindInjected || !!window.tailwind;
+}
+function getTailwind() {
+  return window.tailwind;
+}
+function updateTailwindConfig(config) {
+  if (window.tailwind) {
+    window.tailwind.config = {
+      ...window.tailwind.config,
+      ...config
+    };
+  }
+}
+function addCustomStyles(css, id) {
+  if (typeof document === "undefined") {
+    throw new Error("addCustomStyles can only be used in browser environment");
+  }
+  const styleId = id || `servly-custom-styles-${Date.now()}`;
+  let existingStyle = document.getElementById(styleId);
+  if (existingStyle) {
+    existingStyle.textContent = css;
+    return existingStyle;
+  }
+  const style = document.createElement("style");
+  style.id = styleId;
+  style.textContent = css;
+  document.head.appendChild(style);
+  return style;
+}
+function removeCustomStyles(id) {
+  if (typeof document === "undefined") return;
+  const style = document.getElementById(id);
+  if (style && style.parentNode) {
+    style.parentNode.removeChild(style);
+  }
+}
+async function initServlyTailwind(customConfig) {
+  const config = customConfig ? { ...DEFAULT_SERVLY_TAILWIND_CONFIG, ...customConfig } : DEFAULT_SERVLY_TAILWIND_CONFIG;
+  await injectTailwind({
+    config,
+    usePlayCdn: true
+  });
+}
+var DEFAULT_TAILWIND_CDN, tailwindInjected, tailwindScript, DEFAULT_SERVLY_TAILWIND_CONFIG, tailwind_default;
+var init_tailwind = __esm({
+  "packages/runtime-core/src/tailwind.ts"() {
+    DEFAULT_TAILWIND_CDN = "https://cdn.tailwindcss.com";
+    tailwindInjected = false;
+    tailwindScript = null;
+    DEFAULT_SERVLY_TAILWIND_CONFIG = {
+      theme: {
+        extend: {
+          // Add any Servly-specific theme extensions here
+        }
+      },
+      // Safelist common dynamic classes
+      safelist: [
+        // Spacing
+        { pattern: /^(p|m|gap)-/ },
+        // Sizing
+        { pattern: /^(w|h|min-w|min-h|max-w|max-h)-/ },
+        // Flexbox
+        { pattern: /^(flex|justify|items|self)-/ },
+        // Grid
+        { pattern: /^(grid|col|row)-/ },
+        // Colors
+        { pattern: /^(bg|text|border|ring)-/ },
+        // Typography
+        { pattern: /^(font|text|leading|tracking)-/ },
+        // Borders
+        { pattern: /^(rounded|border)-/ },
+        // Effects
+        { pattern: /^(shadow|opacity|blur)-/ },
+        // Transforms
+        { pattern: /^(scale|rotate|translate|skew)-/ },
+        // Transitions
+        { pattern: /^(transition|duration|ease|delay)-/ }
+      ]
+    };
+    tailwind_default = {
+      injectTailwind,
+      removeTailwind,
+      isTailwindLoaded,
+      getTailwind,
+      updateTailwindConfig,
+      addCustomStyles,
+      removeCustomStyles,
+      initServlyTailwind,
+      DEFAULT_SERVLY_TAILWIND_CONFIG
+    };
+  }
+});
+
+// packages/runtime-core/src/registry.ts
+var registry_exports = {};
+__export(registry_exports, {
+  buildRegistryFromBundle: () => buildRegistryFromBundle,
+  collectAllDependencies: () => collectAllDependencies,
+  createRegistry: () => createRegistry,
+  detectCircularDependencies: () => detectCircularDependencies,
+  extractDependencies: () => extractDependencies,
+  extractDependenciesFromCode: () => extractDependenciesFromCode
+});
+function createRegistry() {
+  const components = /* @__PURE__ */ new Map();
+  return {
+    get(id, version) {
+      if (version) {
+        const key = `${id}@${version}`;
+        if (components.has(key)) {
+          return components.get(key);
+        }
+      }
+      for (const [key, component] of components) {
+        if (key.startsWith(`${id}@`)) {
+          return component;
+        }
+      }
+      return components.get(id);
+    },
+    has(id, version) {
+      if (version) {
+        return components.has(`${id}@${version}`);
+      }
+      for (const key of components.keys()) {
+        if (key.startsWith(`${id}@`) || key === id) {
+          return true;
+        }
+      }
+      return false;
+    },
+    set(id, version, component) {
+      components.set(`${id}@${version}`, component);
+    }
+  };
+}
+function buildRegistryFromBundle(data) {
+  const registry = createRegistry();
+  registry.set(data.id, data.version, {
+    layout: data.layout,
+    propsInterface: data.propsInterface
+  });
+  if (data.bundle) {
+    for (const [key, component] of Object.entries(data.bundle)) {
+      const [id, version] = key.split("@");
+      if (id && version) {
+        registry.set(id, version, component);
+      }
+    }
+  }
+  return registry;
+}
+function extractDependencies(elements) {
+  const dependencies = [];
+  for (const element of elements) {
+    const config = element.configuration;
+    if (!config) continue;
+    if (config.componentViewRef) {
+      dependencies.push({
+        id: config.componentViewRef,
+        version: config.componentViewVersion,
+        type: "viewRef",
+        elementId: element.i
+      });
+    }
+    if (config.blueprint) {
+      dependencies.push({
+        id: config.blueprint,
+        version: config.blueprintVersion,
+        type: "blueprint",
+        elementId: element.i
+      });
+    }
+  }
+  return dependencies;
+}
+function extractDependenciesFromCode(code) {
+  const dependencies = [];
+  const pattern = /renderDynamicList\s*\(\s*\{[^}]*blueprint\s*:\s*["']([^"']+)["']/g;
+  let match;
+  while ((match = pattern.exec(code)) !== null) {
+    dependencies.push({
+      id: match[1],
+      type: "blueprint"
+    });
+  }
+  return dependencies;
+}
+async function collectAllDependencies(rootId, rootVersion, fetchComponent2, maxDepth = 10) {
+  const manifest = {};
+  const visited = /* @__PURE__ */ new Set();
+  async function collect(id, version, via, depth) {
+    if (depth > maxDepth) {
+      console.warn(`Max dependency depth (${maxDepth}) reached for ${id}`);
+      return;
+    }
+    const key = `${id}@${version || "latest"}`;
+    if (visited.has(key)) {
+      return;
+    }
+    visited.add(key);
+    try {
+      const component = await fetchComponent2(id, version);
+      if (!component) {
+        console.warn(`Dependency not found: ${id}@${version || "latest"}`);
+        return;
+      }
+      manifest[id] = {
+        version: version || "latest",
+        resolved: component.version,
+        type: via ? "viewRef" : "viewRef",
+        // Will be set by caller
+        via
+      };
+      const nestedDeps = extractDependencies(component.layout);
+      for (const dep of nestedDeps) {
+        await collect(dep.id, dep.version, id, depth + 1);
+      }
+    } catch (error) {
+      console.error(`Failed to fetch dependency ${id}:`, error);
+    }
+  }
+  const rootComponent = await fetchComponent2(rootId, rootVersion);
+  if (rootComponent) {
+    const rootDeps = extractDependencies(rootComponent.layout);
+    for (const dep of rootDeps) {
+      manifest[dep.id] = {
+        version: dep.version || "latest",
+        resolved: "",
+        // Will be filled when fetched
+        type: dep.type
+      };
+      await collect(dep.id, dep.version, void 0, 1);
+    }
+  }
+  return manifest;
+}
+function detectCircularDependencies(manifest) {
+  const graph = /* @__PURE__ */ new Map();
+  for (const [id, entry] of Object.entries(manifest)) {
+    if (entry.via) {
+      const deps = graph.get(entry.via) || [];
+      deps.push(id);
+      graph.set(entry.via, deps);
+    }
+  }
+  const visited = /* @__PURE__ */ new Set();
+  const stack = /* @__PURE__ */ new Set();
+  const path = [];
+  function dfs(node) {
+    if (stack.has(node)) {
+      const cycleStart = path.indexOf(node);
+      return [...path.slice(cycleStart), node];
+    }
+    if (visited.has(node)) {
+      return null;
+    }
+    visited.add(node);
+    stack.add(node);
+    path.push(node);
+    const neighbors = graph.get(node) || [];
+    for (const neighbor of neighbors) {
+      const cycle = dfs(neighbor);
+      if (cycle) return cycle;
+    }
+    stack.delete(node);
+    path.pop();
+    return null;
+  }
+  for (const node of graph.keys()) {
+    const cycle = dfs(node);
+    if (cycle) return cycle;
+  }
+  return null;
+}
+var init_registry = __esm({
+  "packages/runtime-core/src/registry.ts"() {
+  }
+});
+
+// packages/runtime-core/src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AnalyticsCollector: () => AnalyticsCollector,
+  DEFAULT_CACHE_CONFIG: () => DEFAULT_CACHE_CONFIG,
+  DEFAULT_RETRY_CONFIG: () => DEFAULT_RETRY_CONFIG,
+  DEFAULT_SERVLY_TAILWIND_CONFIG: () => DEFAULT_SERVLY_TAILWIND_CONFIG,
+  EVENT_HANDLERS: () => EVENT_HANDLERS,
+  EventSystem: () => EventSystem,
+  LongTaskObserver: () => LongTaskObserver,
+  MemorySampler: () => MemorySampler,
+  OverrideSystem: () => OverrideSystem,
+  SessionManager: () => SessionManager,
+  StateManager: () => StateManager,
+  addClass: () => addClass,
+  addCustomStyles: () => addCustomStyles,
+  analytics: () => analytics,
+  applyStyles: () => applyStyles,
+  batchFetchComponents: () => batchFetchComponents,
+  buildClassName: () => buildClassName,
+  buildElementStyles: () => buildElementStyles,
+  buildRegistryFromBundle: () => buildRegistryFromBundle,
+  bumpVersion: () => bumpVersion,
+  camelToKebab: () => camelToKebab,
+  clearAllCaches: () => clearAllCaches,
+  clearIconCache: () => clearIconCache,
+  clearLocalStorageCache: () => clearLocalStorageCache,
+  clearMemoryCache: () => clearMemoryCache,
+  clearStyles: () => clearStyles,
+  collectAllDependencies: () => collectAllDependencies,
+  collectAllViewDependencies: () => collectAllViewDependencies,
+  compareVersions: () => compareVersions,
+  configureAnalytics: () => configureAnalytics,
+  createIconSVG: () => createIconSVG,
+  createPlaceholderIcon: () => createPlaceholderIcon,
+  createRegistry: () => createRegistry,
+  createServlyRenderer: () => createServlyRenderer,
+  createViewsMap: () => createViewsMap,
+  deepMerge: () => deepMerge,
+  deleteValueByPath: () => deleteValueByPath,
+  detectCircularDependencies: () => detectCircularDependencies,
+  extractBindingKeys: () => extractBindingKeys,
+  extractDependencies: () => extractDependencies,
+  extractDependenciesFromCode: () => extractDependenciesFromCode,
+  extractIconFromReactIcons: () => extractIconFromReactIcons,
+  extractIconsForLayout: () => extractIconsForLayout,
+  extractOverrideDependencies: () => extractOverrideDependencies,
+  extractReferencedViewIds: () => extractReferencedViewIds,
+  fetchComponent: () => fetchComponent,
+  fetchComponentWithDependencies: () => fetchComponentWithDependencies,
+  findIconsInLayout: () => findIconsInLayout,
+  formatStyleValue: () => formatStyleValue,
+  formatVersion: () => formatVersion,
+  generateIconBundle: () => generateIconBundle,
+  generateTestCases: () => generateTestCases,
+  getAnalytics: () => getAnalytics,
+  getCacheKey: () => getCacheKey,
+  getCleanupOverrides: () => getCleanupOverrides,
+  getDependencyTree: () => getDependencyTree,
+  getEventSystem: () => getEventSystem,
+  getFromCache: () => getFromCache,
+  getIconData: () => getIconData,
+  getIconDataSync: () => getIconDataSync,
+  getIconifyCollection: () => getIconifyCollection,
+  getLocalStorage: () => getLocalStorage,
+  getLongTaskObserver: () => getLongTaskObserver,
+  getMemoryCacheSize: () => getMemoryCacheSize,
+  getMemorySampler: () => getMemorySampler,
+  getMountOverrides: () => getMountOverrides,
+  getOverrideSystem: () => getOverrideSystem,
+  getRegisteredIconKeys: () => getRegisteredIconKeys,
+  getRegistryUrl: () => getRegistryUrl,
+  getSessionManager: () => getSessionManager,
+  getSessionStorage: () => getSessionStorage,
+  getSupportedIconSets: () => getSupportedIconSets,
+  getTailwind: () => getTailwind,
+  getUrlInfo: () => getUrlInfo,
+  getValueByPath: () => getValueByPath,
+  goBack: () => goBack,
+  goForward: () => goForward,
+  hasClass: () => hasClass,
+  hasDependencyOverrides: () => hasDependencyOverrides,
+  hasOverrides: () => hasOverrides,
+  hasTemplateSyntax: () => hasTemplateSyntax,
+  initServlyTailwind: () => initServlyTailwind,
+  injectTailwind: () => injectTailwind,
+  invalidateCache: () => invalidateCache,
+  isComponentAvailable: () => isComponentAvailable,
+  isIconCdnEnabled: () => isIconCdnEnabled,
+  isIconRegistered: () => isIconRegistered,
+  isIconSetSupported: () => isIconSetSupported,
+  isTailwindLoaded: () => isTailwindLoaded,
+  isValidSpecifier: () => isValidSpecifier,
+  navigateTo: () => navigateTo,
+  parseVersion: () => parseVersion,
+  prefetchComponents: () => prefetchComponents,
+  preloadIcons: () => preloadIcons,
+  processStyles: () => processStyles,
+  registerIcon: () => registerIcon,
+  registerIcons: () => registerIcons,
+  removeClass: () => removeClass,
+  removeCustomStyles: () => removeCustomStyles,
+  removeLocalStorage: () => removeLocalStorage,
+  removeSessionStorage: () => removeSessionStorage,
+  removeTailwind: () => removeTailwind,
+  render: () => render,
+  renderDynamicList: () => renderDynamicList,
+  renderIcon: () => renderIcon,
+  renderInShadow: () => renderInShadow,
+  renderNode: () => renderNode,
+  resetAnalytics: () => resetAnalytics,
+  resetEventSystem: () => resetEventSystem,
+  resetLongTaskObserver: () => resetLongTaskObserver,
+  resetMemorySampler: () => resetMemorySampler,
+  resetOverrideSystem: () => resetOverrideSystem,
+  resetSessionManager: () => resetSessionManager,
+  resolveBindingPath: () => resolveBindingPath,
+  resolveTemplate: () => resolveTemplate,
+  resolveTemplateValue: () => resolveTemplateValue,
+  resolveTemplatesDeep: () => resolveTemplatesDeep,
+  resolveVersion: () => resolveVersion,
+  runAllTests: () => runAllTests,
+  runTestCase: () => runTestCase,
+  satisfiesVersion: () => satisfiesVersion,
+  setIconCdnEnabled: () => setIconCdnEnabled,
+  setInCache: () => setInCache,
+  setLocalStorage: () => setLocalStorage,
+  setRegistryUrl: () => setRegistryUrl,
+  setSessionStorage: () => setSessionStorage,
+  setValueByPath: () => setValueByPath,
+  toDomEventName: () => toDomEventName,
+  toReactEventName: () => toReactEventName,
+  toggleClass: () => toggleClass,
+  updateStyles: () => updateStyles,
+  updateTailwindConfig: () => updateTailwindConfig,
+  validateAssertion: () => validateAssertion,
+  validateProps: () => validateProps
+});
+module.exports = __toCommonJS(index_exports);
 
-// src/analyticsTypes.ts
+// packages/runtime-core/src/analyticsTypes.ts
 var DEFAULT_ANALYTICS_CONFIG = {
   enabled: true,
   endpoint: "/api/v1/analytics/events",
@@ -36,7 +534,7 @@ var MAX_RETRY_ATTEMPTS = 3;
 var SESSION_TIMEOUT_MS = 30 * 60 * 1e3;
 var SDK_VERSION = "1.0.0";
 
-// src/sessionManager.ts
+// packages/runtime-core/src/sessionManager.ts
 var SESSION_STORAGE_KEY = "servly_analytics_session";
 function generateUUID() {
   if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
@@ -98,8 +596,8 @@ function isSessionExpired(session) {
   return now - session.lastActivityAt > SESSION_TIMEOUT_MS;
 }
 var SessionManager = class {
+  session = null;
   constructor() {
-    this.session = null;
     this.initialize();
   }
   /**
@@ -179,13 +677,15 @@ function resetSessionManager() {
   sessionManagerInstance = null;
 }
 
-// src/analytics.ts
+// packages/runtime-core/src/analytics.ts
 var AnalyticsCollector = class {
+  config;
+  eventQueue = [];
+  flushTimer = null;
+  isEnabled;
+  isFlushing = false;
+  retryDelay = 1e3;
   constructor(config) {
-    this.eventQueue = [];
-    this.flushTimer = null;
-    this.isFlushing = false;
-    this.retryDelay = 1e3;
     this.config = { ...DEFAULT_ANALYTICS_CONFIG, ...config };
     this.isEnabled = this.config.enabled;
     this.startFlushTimer();
@@ -528,7 +1028,7 @@ var analytics = {
   enable: () => getAnalytics().enable()
 };
 
-// src/bindings.ts
+// packages/runtime-core/src/bindings.ts
 var BINDING_SOURCES = [
   "props",
   "state",
@@ -912,7 +1412,7 @@ function extractBindingKeys(template) {
   return Array.from(keys);
 }
 
-// src/styles.ts
+// packages/runtime-core/src/styles.ts
 var UNITLESS_PROPERTIES = /* @__PURE__ */ new Set([
   "animationIterationCount",
   "borderImageOutset",
@@ -1086,8 +1586,9 @@ function updateStyles(element, oldStyles, newStyles) {
   }
 }
 
-// src/memorySampler.ts
+// packages/runtime-core/src/memorySampler.ts
 var MemorySampler = class {
+  isSupported;
   constructor() {
     this.isSupported = this.checkSupport();
   }
@@ -1147,12 +1648,13 @@ function resetMemorySampler() {
   memorySamplerInstance = null;
 }
 
-// src/longTaskObserver.ts
+// packages/runtime-core/src/longTaskObserver.ts
 var LongTaskObserver = class {
+  observer = null;
+  longTaskCount = 0;
+  isSupported;
+  isObserving = false;
   constructor() {
-    this.observer = null;
-    this.longTaskCount = 0;
-    this.isObserving = false;
     this.isSupported = this.checkSupport();
   }
   /**
@@ -1242,11 +1744,12 @@ function resetLongTaskObserver() {
   longTaskObserverInstance = null;
 }
 
-// src/stateManager.ts
+// packages/runtime-core/src/stateManager.ts
 var StateManager = class {
+  state = {};
+  listeners = /* @__PURE__ */ new Set();
+  config;
   constructor(config = {}) {
-    this.state = {};
-    this.listeners = /* @__PURE__ */ new Set();
     this.config = config;
     this.state = config.initialState || {};
     if (config.persistToLocalStorage && typeof localStorage !== "undefined") {
@@ -1632,7 +2135,7 @@ function getUrlInfo() {
   };
 }
 
-// src/eventSystem.ts
+// packages/runtime-core/src/eventSystem.ts
 var builtInPlugins = {
   /**
    * Set state value
@@ -1898,9 +2401,11 @@ var builtInPlugins = {
   }
 };
 var EventSystem = class {
+  config;
+  pluginExecutors;
+  debounceTimers = /* @__PURE__ */ new Map();
+  throttleTimers = /* @__PURE__ */ new Map();
   constructor(config = {}) {
-    this.debounceTimers = /* @__PURE__ */ new Map();
-    this.throttleTimers = /* @__PURE__ */ new Map();
     this.config = config;
     this.pluginExecutors = {
       ...builtInPlugins,
@@ -2070,11 +2575,12 @@ function resetEventSystem() {
   }
 }
 
-// src/overrides.ts
+// packages/runtime-core/src/overrides.ts
 var OverrideSystem = class {
+  config;
+  elementStates = /* @__PURE__ */ new Map();
+  watchIntervals = /* @__PURE__ */ new Map();
   constructor(config = {}) {
-    this.elementStates = /* @__PURE__ */ new Map();
-    this.watchIntervals = /* @__PURE__ */ new Map();
     this.config = config;
   }
   /**
@@ -2291,7 +2797,317 @@ function resetOverrideSystem() {
   }
 }
 
-// src/renderer.ts
+// packages/runtime-core/src/icons.ts
+var cdnEnabled = false;
+function setIconCdnEnabled(enabled) {
+  cdnEnabled = enabled;
+}
+function isIconCdnEnabled() {
+  return cdnEnabled;
+}
+var ICONIFY_COLLECTIONS = {
+  Ai: "ant-design",
+  Bi: "bi",
+  Bs: "bi",
+  Bx: "bx",
+  Ci: "circum",
+  Cg: "gg",
+  Di: "devicon",
+  Fi: "feather",
+  Fc: "flat-color-icons",
+  Fa: "fa-solid",
+  Fa6: "fa6-solid",
+  Gi: "game-icons",
+  Go: "octicon",
+  Gr: "grommet-icons",
+  Hi: "heroicons-outline",
+  Hi2: "heroicons",
+  Im: "icomoon-free",
+  Io: "ion",
+  Io5: "ion",
+  Lu: "lucide",
+  Md: "ic",
+  Pi: "ph",
+  Ri: "ri",
+  Rx: "radix-icons",
+  Si: "simple-icons",
+  Sl: "simple-line-icons",
+  Tb: "tabler",
+  Tfi: "themify",
+  Vsc: "codicon",
+  Wi: "wi"
+};
+var ICON_SET_STYLES = {
+  Fi: { stroke: true },
+  Lu: { stroke: true },
+  Hi: { stroke: true },
+  Hi2: { stroke: true },
+  Tb: { stroke: true }
+};
+var iconCache = /* @__PURE__ */ new Map();
+var pendingFetches = /* @__PURE__ */ new Map();
+var registeredIcons = /* @__PURE__ */ new Map();
+function registerIcon(set, name, data) {
+  const key = `${set}:${name}`;
+  registeredIcons.set(key, data);
+  iconCache.set(key, data);
+}
+function registerIcons(icons) {
+  for (const [set, setIcons] of Object.entries(icons)) {
+    for (const [name, data] of Object.entries(setIcons)) {
+      registerIcon(set, name, data);
+    }
+  }
+}
+function isIconRegistered(icon) {
+  const key = `${icon.set}:${icon.name}`;
+  return registeredIcons.has(key);
+}
+function getRegisteredIconKeys() {
+  return Array.from(registeredIcons.keys());
+}
+function toKebabCase(str) {
+  return str.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/([A-Z])([A-Z][a-z])/g, "$1-$2").toLowerCase();
+}
+function getIconifyName(name, set) {
+  const prefixLength = set.length;
+  let baseName = name;
+  if (name.startsWith(set)) {
+    baseName = name.slice(prefixLength);
+  }
+  let kebabName = toKebabCase(baseName);
+  switch (set) {
+    case "Md":
+      if (baseName.startsWith("Outline")) {
+        kebabName = toKebabCase(baseName.slice(7)) + "-outline";
+      }
+      kebabName = "baseline-" + kebabName;
+      break;
+    case "Hi2":
+      if (baseName.startsWith("Outline")) {
+        kebabName = toKebabCase(baseName.slice(7));
+      } else if (baseName.startsWith("Solid")) {
+        kebabName = toKebabCase(baseName.slice(5)) + "-solid";
+      }
+      break;
+    case "Io":
+    case "Io5":
+      if (baseName.startsWith("Ios")) {
+        kebabName = toKebabCase(baseName.slice(3));
+      } else if (baseName.startsWith("Md")) {
+        kebabName = toKebabCase(baseName.slice(2));
+      }
+      break;
+    case "Pi":
+      if (baseName.endsWith("Bold")) {
+        kebabName = toKebabCase(baseName.slice(0, -4)) + "-bold";
+      } else if (baseName.endsWith("Fill")) {
+        kebabName = toKebabCase(baseName.slice(0, -4)) + "-fill";
+      } else if (baseName.endsWith("Light")) {
+        kebabName = toKebabCase(baseName.slice(0, -5)) + "-light";
+      } else if (baseName.endsWith("Thin")) {
+        kebabName = toKebabCase(baseName.slice(0, -4)) + "-thin";
+      } else if (baseName.endsWith("Duotone")) {
+        kebabName = toKebabCase(baseName.slice(0, -7)) + "-duotone";
+      }
+      break;
+  }
+  return kebabName;
+}
+async function fetchIconFromIconify(set, name) {
+  if (!cdnEnabled) {
+    return null;
+  }
+  const collection = ICONIFY_COLLECTIONS[set];
+  if (!collection) {
+    return null;
+  }
+  const iconName = getIconifyName(name, set);
+  try {
+    const url = `https://api.iconify.design/${collection}/${iconName}.svg`;
+    const response = await fetch(url);
+    if (!response.ok) {
+      const altNames = [
+        iconName.replace(/-outline$/, ""),
+        iconName.replace(/-solid$/, ""),
+        iconName.replace(/-fill$/, ""),
+        iconName.replace(/^baseline-/, "")
+      ].filter((alt) => alt !== iconName);
+      for (const altName of altNames) {
+        const altUrl = `https://api.iconify.design/${collection}/${altName}.svg`;
+        const altResponse = await fetch(altUrl);
+        if (altResponse.ok) {
+          return parseSvgResponse(await altResponse.text());
+        }
+      }
+      return null;
+    }
+    return parseSvgResponse(await response.text());
+  } catch {
+    return null;
+  }
+}
+function parseSvgResponse(svgText) {
+  try {
+    const parser = new DOMParser();
+    const doc = parser.parseFromString(svgText, "image/svg+xml");
+    const svg = doc.querySelector("svg");
+    if (!svg) {
+      return null;
+    }
+    const viewBox = svg.getAttribute("viewBox");
+    const width = parseInt(svg.getAttribute("width") || "24", 10);
+    const height = parseInt(svg.getAttribute("height") || "24", 10);
+    const body = svg.innerHTML;
+    return {
+      body,
+      width,
+      height,
+      viewBox: viewBox || `0 0 ${width} ${height}`
+    };
+  } catch {
+    return null;
+  }
+}
+async function getIconData(icon) {
+  const key = `${icon.set}:${icon.name}`;
+  if (iconCache.has(key)) {
+    return iconCache.get(key);
+  }
+  if (pendingFetches.has(key)) {
+    return pendingFetches.get(key);
+  }
+  if (!cdnEnabled) {
+    return null;
+  }
+  const fetchPromise = fetchIconFromIconify(icon.set, icon.name);
+  pendingFetches.set(key, fetchPromise);
+  const data = await fetchPromise;
+  pendingFetches.delete(key);
+  if (data) {
+    iconCache.set(key, data);
+  }
+  return data;
+}
+function getIconDataSync(icon) {
+  const key = `${icon.set}:${icon.name}`;
+  return iconCache.get(key) || null;
+}
+function createIconSVG(icon, data, size = 24, color = "currentColor") {
+  const svg = document.createElementNS("http://www.w3.org/2000/svg", "svg");
+  svg.setAttribute("width", String(size));
+  svg.setAttribute("height", String(size));
+  svg.setAttribute("viewBox", data.viewBox || "0 0 24 24");
+  svg.setAttribute("data-icon-name", icon.name);
+  svg.setAttribute("data-icon-set", icon.set);
+  svg.setAttribute("class", `servly-icon servly-icon-${icon.set.toLowerCase()}`);
+  const style = ICON_SET_STYLES[icon.set];
+  if (style?.stroke) {
+    svg.setAttribute("fill", "none");
+    svg.setAttribute("stroke", color);
+    svg.setAttribute("stroke-width", "2");
+    svg.setAttribute("stroke-linecap", "round");
+    svg.setAttribute("stroke-linejoin", "round");
+  } else {
+    svg.setAttribute("fill", color);
+  }
+  svg.innerHTML = data.body;
+  const paths = svg.querySelectorAll("path, circle, rect, polygon, line, polyline");
+  paths.forEach((el) => {
+    if (!el.getAttribute("fill") || el.getAttribute("fill") === "currentColor") {
+      if (style?.stroke) {
+        el.setAttribute("stroke", color);
+      } else {
+        el.setAttribute("fill", color);
+      }
+    }
+  });
+  return svg;
+}
+function createPlaceholderIcon(icon, size = 24, color = "currentColor") {
+  const svg = document.createElementNS("http://www.w3.org/2000/svg", "svg");
+  svg.setAttribute("width", String(size));
+  svg.setAttribute("height", String(size));
+  svg.setAttribute("viewBox", "0 0 24 24");
+  svg.setAttribute("fill", "none");
+  svg.setAttribute("stroke", color);
+  svg.setAttribute("stroke-width", "2");
+  svg.setAttribute("stroke-linecap", "round");
+  svg.setAttribute("stroke-linejoin", "round");
+  svg.setAttribute("data-icon-name", icon.name);
+  svg.setAttribute("data-icon-set", icon.set);
+  svg.setAttribute("data-icon-missing", "true");
+  svg.setAttribute("class", "servly-icon servly-icon-placeholder");
+  const circle = document.createElementNS("http://www.w3.org/2000/svg", "circle");
+  circle.setAttribute("cx", "12");
+  circle.setAttribute("cy", "12");
+  circle.setAttribute("r", "10");
+  const path = document.createElementNS("http://www.w3.org/2000/svg", "path");
+  path.setAttribute("d", "M9.09 9a3 3 0 0 1 5.83 1c0 2-3 3-3 3");
+  const dot = document.createElementNS("http://www.w3.org/2000/svg", "line");
+  dot.setAttribute("x1", "12");
+  dot.setAttribute("y1", "17");
+  dot.setAttribute("x2", "12.01");
+  dot.setAttribute("y2", "17");
+  svg.appendChild(circle);
+  svg.appendChild(path);
+  svg.appendChild(dot);
+  return svg;
+}
+function renderIcon(container, icon, size = 24, color = "currentColor") {
+  const cachedData = getIconDataSync(icon);
+  if (cachedData) {
+    const svg = createIconSVG(icon, cachedData, size, color);
+    container.innerHTML = "";
+    container.appendChild(svg);
+    return;
+  }
+  if (!cdnEnabled) {
+    const placeholder2 = createPlaceholderIcon(icon, size, color);
+    container.innerHTML = "";
+    container.appendChild(placeholder2);
+    console.warn(
+      `[Icons] Icon not bundled: ${icon.set}:${icon.name}. Use registerIcon() to bundle it, or enable CDN with setIconCdnEnabled(true).`
+    );
+    return;
+  }
+  const placeholder = createPlaceholderIcon(icon, size, color);
+  placeholder.setAttribute("data-icon-loading", "true");
+  placeholder.removeAttribute("data-icon-missing");
+  container.innerHTML = "";
+  container.appendChild(placeholder);
+  getIconData(icon).then((data) => {
+    if (data) {
+      const svg = createIconSVG(icon, data, size, color);
+      container.innerHTML = "";
+      container.appendChild(svg);
+    } else {
+      placeholder.setAttribute("data-icon-missing", "true");
+      placeholder.removeAttribute("data-icon-loading");
+    }
+  });
+}
+async function preloadIcons(icons) {
+  await Promise.all(icons.map((icon) => getIconData(icon)));
+}
+function clearIconCache() {
+  iconCache.clear();
+  pendingFetches.clear();
+  registeredIcons.forEach((data, key) => {
+    iconCache.set(key, data);
+  });
+}
+function isIconSetSupported(set) {
+  return set in ICONIFY_COLLECTIONS;
+}
+function getSupportedIconSets() {
+  return Object.keys(ICONIFY_COLLECTIONS);
+}
+function getIconifyCollection(set) {
+  return ICONIFY_COLLECTIONS[set];
+}
+
+// packages/runtime-core/src/renderer.ts
 var COMPONENT_TO_TAG = {
   container: "div",
   text: "span",
@@ -2673,6 +3489,9 @@ function renderElement(element, tree, context, eventHandlers, elementStates, sta
   if (element.componentId === "slot") {
     return renderSlotElement(element, tree, context, eventHandlers, elementStates, state, isRootElement);
   }
+  if (element.componentId === "icon") {
+    return renderIconElement(element, context, eventHandlers, elementStates, state, isRootElement);
+  }
   const elementState = createElement(element, context, eventHandlers, isRootElement, state);
   elementStates.set(element.i, elementState);
   const config = element.configuration;
@@ -2690,6 +3509,40 @@ function renderElement(element, tree, context, eventHandlers, elementStates, sta
   }
   return elementState.domElement;
 }
+function renderIconElement(element, context, eventHandlers, elementStates, state, isRootElement) {
+  const config = element.configuration || {};
+  const icon = config.icon;
+  const iconColor = config.iconColor || "currentColor";
+  const iconSize = config.iconSize || 24;
+  const wrapper = document.createElement("div");
+  wrapper.setAttribute("data-servly-id", element.i);
+  wrapper.className = "pointer-events-none";
+  const styles = buildElementStyles(element, context);
+  applyStyles(wrapper, styles);
+  const className = buildClassName(element, context);
+  if (className) {
+    wrapper.className = `pointer-events-none ${className}`;
+  }
+  if (state.iconRenderer && icon) {
+    const iconElement = state.iconRenderer(icon, iconSize, iconColor, "");
+    if (iconElement) {
+      wrapper.appendChild(iconElement);
+    }
+  } else if (icon) {
+    renderIcon(wrapper, icon, iconSize, iconColor);
+  }
+  const elementState = {
+    element,
+    domElement: wrapper,
+    styles,
+    className: wrapper.className,
+    textContent: "",
+    eventListeners: /* @__PURE__ */ new Map()
+  };
+  elementStates.set(element.i, elementState);
+  attachEventHandlers(wrapper, element, eventHandlers, context, elementState, isRootElement, state);
+  return wrapper;
+}
 function renderComponentViewElement(element, tree, context, eventHandlers, elementStates, state, isRootElement) {
   const componentViewId = `${element.componentId}-${element.i}`;
   if (globalRenderingStack.has(componentViewId)) {
@@ -2709,7 +3562,15 @@ function renderComponentViewElement(element, tree, context, eventHandlers, eleme
       viewLayout = component.layout;
     }
   }
+  if (!viewLayout && state.views === void 0 && state.viewsArray) {
+    const viewsArray = state.viewsArray;
+    const found = viewsArray.find((v) => v.id === element.componentId);
+    if (found) {
+      viewLayout = found.layout;
+    }
+  }
   if (!viewLayout) {
+    console.warn(`[Servly] Component not found: ${element.componentId}. Available in views: ${state.views ? Array.from(state.views.keys()).join(", ") : "none"}. Registry has: ${state.componentRegistry?.has(element.componentId) ? "yes" : "no"}`);
     const placeholder = document.createElement("div");
     placeholder.className = "border-2 border-yellow-500 border-dashed p-4 bg-yellow-50";
     placeholder.innerHTML = `<p class="text-yellow-600 text-sm">Component not found: ${element.componentId}</p>`;
@@ -2823,14 +3684,26 @@ function render(options) {
     eventHandlers,
     componentRegistry,
     onDependencyNeeded,
-    views,
+    views: viewsInput,
     enableStateManager,
     initialState,
     onStateChange,
     pluginExecutors,
     onNavigate,
-    onApiCall
+    onApiCall,
+    iconRenderer
   } = options;
+  let views;
+  if (viewsInput instanceof Map) {
+    views = viewsInput;
+  } else if (Array.isArray(viewsInput)) {
+    views = /* @__PURE__ */ new Map();
+    for (const view of viewsInput) {
+      if (view && view.id) {
+        views.set(view.id, view);
+      }
+    }
+  }
   const startTime = performance.now();
   const memorySampler = getMemorySampler();
   const longTaskObserver = getLongTaskObserver();
@@ -2878,7 +3751,8 @@ function render(options) {
       eventSystem,
       stateManager,
       overrideSystem,
-      enableOverrides: hasAnyOverrides
+      enableOverrides: hasAnyOverrides,
+      iconRenderer
     };
     container.innerHTML = "";
     if (rootElements.length === 0) {
@@ -3155,7 +4029,7 @@ async function createServlyRenderer(options) {
     container = containerOption;
   }
   if (shouldInjectTailwind) {
-    const { initServlyTailwind: initServlyTailwind2 } = await import("./tailwind-CGAHPC3O.js");
+    const { initServlyTailwind: initServlyTailwind2 } = await Promise.resolve().then(() => (init_tailwind(), tailwind_exports));
     await initServlyTailwind2(tailwindConfig);
   }
   const activeRenders = [];
@@ -3253,7 +4127,7 @@ function collectAllViewDependencies(views, startViewId) {
   return collected;
 }
 
-// src/cache.ts
+// packages/runtime-core/src/cache.ts
 var DEFAULT_CACHE_CONFIG = {
   maxEntries: 50,
   ttl: 5 * 60 * 1e3,
@@ -3497,7 +4371,8 @@ function invalidateCache(id, version, config = DEFAULT_CACHE_CONFIG) {
   }
 }
 
-// src/fetcher.ts
+// packages/runtime-core/src/fetcher.ts
+init_registry();
 var DEFAULT_RETRY_CONFIG = {
   maxRetries: 3,
   initialDelay: 1e3,
@@ -3727,7 +4602,7 @@ async function fetchComponent(id, options = {}) {
 async function fetchComponentWithDependencies(id, options = {}) {
   const result = await fetchComponent(id, { ...options, includeBundle: true });
   if (result.pendingDependencies && result.pendingDependencies.length > 0) {
-    const { createRegistry: createRegistry2 } = await import("./registry-GCCVK65D.js");
+    const { createRegistry: createRegistry2 } = await Promise.resolve().then(() => (init_registry(), registry_exports));
     const registry = result.registry || createRegistry2();
     await Promise.all(
       result.pendingDependencies.map(async (dep) => {
@@ -3833,7 +4708,7 @@ async function getDependencyTree(id, options = {}) {
   return data.data;
 }
 
-// src/version.ts
+// packages/runtime-core/src/version.ts
 function parseVersion(version) {
   const match = version.match(/^(\d+)\.(\d+)\.(\d+)$/);
   if (!match) return null;
@@ -3945,7 +4820,7 @@ function formatVersion(version) {
   return `v${parsed.major}.${parsed.minor}.${parsed.patch}`;
 }
 
-// src/testRunner.ts
+// packages/runtime-core/src/testRunner.ts
 function runTestCase(elements, testCase, container) {
   const startTime = performance.now();
   const assertionResults = [];
@@ -4199,7 +5074,148 @@ function getSampleValue(def) {
       return def.defaultValue;
   }
 }
-export {
+
+// packages/runtime-core/src/index.ts
+init_registry();
+init_tailwind();
+
+// packages/runtime-core/src/iconExtractor.ts
+var REACT_ICONS_PACKAGES = {
+  Ai: "react-icons/ai",
+  Bi: "react-icons/bi",
+  Bs: "react-icons/bs",
+  Cg: "react-icons/cg",
+  Di: "react-icons/di",
+  Fa: "react-icons/fa",
+  Fa6: "react-icons/fa6",
+  Fc: "react-icons/fc",
+  Fi: "react-icons/fi",
+  Gi: "react-icons/gi",
+  Go: "react-icons/go",
+  Gr: "react-icons/gr",
+  Hi: "react-icons/hi",
+  Hi2: "react-icons/hi2",
+  Im: "react-icons/im",
+  Io: "react-icons/io",
+  Io5: "react-icons/io5",
+  Lu: "react-icons/lu",
+  Md: "react-icons/md",
+  Pi: "react-icons/pi",
+  Ri: "react-icons/ri",
+  Rx: "react-icons/rx",
+  Si: "react-icons/si",
+  Sl: "react-icons/sl",
+  Tb: "react-icons/tb",
+  Tfi: "react-icons/tfi",
+  Vsc: "react-icons/vsc",
+  Wi: "react-icons/wi"
+};
+async function extractIconFromReactIcons(iconName, iconSet) {
+  const packagePath = REACT_ICONS_PACKAGES[iconSet];
+  if (!packagePath) {
+    console.warn(`Unknown icon set: ${iconSet}`);
+    return null;
+  }
+  try {
+    const iconModule = await import(packagePath);
+    const IconComponent = iconModule[iconName];
+    if (!IconComponent) {
+      console.warn(`Icon not found: ${iconName} in ${packagePath}`);
+      return null;
+    }
+    const React = await import("react");
+    const { renderToStaticMarkup } = await import("react-dom/server");
+    const svgString = renderToStaticMarkup(React.createElement(IconComponent, { size: 24 }));
+    return parseSvgString(svgString);
+  } catch (error) {
+    console.error(`Failed to extract icon ${iconSet}:${iconName}:`, error);
+    return null;
+  }
+}
+function parseSvgString(svgString) {
+  const viewBoxMatch = svgString.match(/viewBox="([^"]+)"/);
+  const viewBox = viewBoxMatch ? viewBoxMatch[1] : "0 0 24 24";
+  const widthMatch = svgString.match(/width="(\d+)"/);
+  const heightMatch = svgString.match(/height="(\d+)"/);
+  const width = widthMatch ? parseInt(widthMatch[1], 10) : 24;
+  const height = heightMatch ? parseInt(heightMatch[1], 10) : 24;
+  const bodyMatch = svgString.match(/<svg[^>]*>([\s\S]*)<\/svg>/);
+  const body = bodyMatch ? bodyMatch[1].trim() : "";
+  if (!body) {
+    return null;
+  }
+  return {
+    body,
+    viewBox,
+    width,
+    height
+  };
+}
+function findIconsInLayout(elements) {
+  const icons = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const element of elements) {
+    if (element.componentId === "icon" && element.configuration?.icon) {
+      const icon = element.configuration.icon;
+      const key = `${icon.set}:${icon.name}`;
+      if (!seen.has(key)) {
+        seen.add(key);
+        icons.push({
+          name: icon.name,
+          set: icon.set,
+          setName: icon.setName
+        });
+      }
+    }
+  }
+  return icons;
+}
+async function extractIconsForLayout(elements) {
+  const icons = findIconsInLayout(elements);
+  const result = {};
+  for (const icon of icons) {
+    const data = await extractIconFromReactIcons(icon.name, icon.set);
+    if (data) {
+      if (!result[icon.set]) {
+        result[icon.set] = {};
+      }
+      result[icon.set][icon.name] = data;
+    }
+  }
+  return result;
+}
+function generateIconBundle(icons) {
+  const lines = [
+    "// Auto-generated icon bundle",
+    "// Do not edit manually",
+    "",
+    "import { registerIcons, type IconData } from '@servlyadmin/runtime-core';",
+    "",
+    "const BUNDLED_ICONS: Record<string, Record<string, IconData>> = {"
+  ];
+  for (const [set, setIcons] of Object.entries(icons)) {
+    lines.push(`  ${set}: {`);
+    for (const [name, data] of Object.entries(setIcons)) {
+      const escapedBody = data.body.replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/\n/g, "\\n");
+      lines.push(`    ${name}: {`);
+      lines.push(`      body: '${escapedBody}',`);
+      lines.push(`      viewBox: '${data.viewBox}',`);
+      if (data.width) lines.push(`      width: ${data.width},`);
+      if (data.height) lines.push(`      height: ${data.height},`);
+      lines.push(`    },`);
+    }
+    lines.push(`  },`);
+  }
+  lines.push("};");
+  lines.push("");
+  lines.push("// Register all bundled icons");
+  lines.push("registerIcons(BUNDLED_ICONS);");
+  lines.push("");
+  lines.push("export { BUNDLED_ICONS };");
+  return lines.join("\n");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
   AnalyticsCollector,
   DEFAULT_CACHE_CONFIG,
   DEFAULT_RETRY_CONFIG,
@@ -4222,6 +5238,7 @@ export {
   bumpVersion,
   camelToKebab,
   clearAllCaches,
+  clearIconCache,
   clearLocalStorageCache,
   clearMemoryCache,
   clearStyles,
@@ -4229,6 +5246,8 @@ export {
   collectAllViewDependencies,
   compareVersions,
   configureAnalytics,
+  createIconSVG,
+  createPlaceholderIcon,
   createRegistry,
   createServlyRenderer,
   createViewsMap,
@@ -4238,12 +5257,16 @@ export {
   extractBindingKeys,
   extractDependencies,
   extractDependenciesFromCode,
+  extractIconFromReactIcons,
+  extractIconsForLayout,
   extractOverrideDependencies,
   extractReferencedViewIds,
   fetchComponent,
   fetchComponentWithDependencies,
+  findIconsInLayout,
   formatStyleValue,
   formatVersion,
+  generateIconBundle,
   generateTestCases,
   getAnalytics,
   getCacheKey,
@@ -4251,15 +5274,20 @@ export {
   getDependencyTree,
   getEventSystem,
   getFromCache,
+  getIconData,
+  getIconDataSync,
+  getIconifyCollection,
   getLocalStorage,
   getLongTaskObserver,
   getMemoryCacheSize,
   getMemorySampler,
   getMountOverrides,
   getOverrideSystem,
+  getRegisteredIconKeys,
   getRegistryUrl,
   getSessionManager,
   getSessionStorage,
+  getSupportedIconSets,
   getTailwind,
   getUrlInfo,
   getValueByPath,
@@ -4273,12 +5301,18 @@ export {
   injectTailwind,
   invalidateCache,
   isComponentAvailable,
+  isIconCdnEnabled,
+  isIconRegistered,
+  isIconSetSupported,
   isTailwindLoaded,
   isValidSpecifier,
   navigateTo,
   parseVersion,
   prefetchComponents,
+  preloadIcons,
   processStyles,
+  registerIcon,
+  registerIcons,
   removeClass,
   removeCustomStyles,
   removeLocalStorage,
@@ -4286,6 +5320,7 @@ export {
   removeTailwind,
   render,
   renderDynamicList,
+  renderIcon,
   renderInShadow,
   renderNode,
   resetAnalytics,
@@ -4302,6 +5337,7 @@ export {
   runAllTests,
   runTestCase,
   satisfiesVersion,
+  setIconCdnEnabled,
   setInCache,
   setLocalStorage,
   setRegistryUrl,
@@ -4314,4 +5350,4 @@ export {
   updateTailwindConfig,
   validateAssertion,
   validateProps
-};
+});