@servlyadmin/runtime-core 0.1.7 → 0.1.9

package/dist/index.js

@@ -1,13 +1,522 @@
-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",
@@ -25,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") {
@@ -87,8 +596,8 @@ function isSessionExpired(session) {
   return now - session.lastActivityAt > SESSION_TIMEOUT_MS;
 }
 var SessionManager = class {
+  session = null;
   constructor() {
-    this.session = null;
     this.initialize();
   }
   /**
@@ -168,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();
@@ -517,7 +1028,7 @@ var analytics = {
   enable: () => getAnalytics().enable()
 };
 
-// src/bindings.ts
+// packages/runtime-core/src/bindings.ts
 var BINDING_SOURCES = [
   "props",
   "state",
@@ -526,16 +1037,95 @@ var BINDING_SOURCES = [
   "input",
   "currentItem",
   "localStore",
+  "localStorage",
+  "sessionStorage",
   "config",
   "element",
   "self",
   "params",
-  "query"
+  "query",
+  "window",
+  "bindings",
+  "binding",
+  "boundInputs",
+  "parent"
 ];
 var TEMPLATE_REGEX = /\{\{([^}]+)\}\}/g;
 function hasTemplateSyntax(value) {
   return typeof value === "string" && value.includes("{{") && value.includes("}}");
 }
+function getLocalStorageValue(key) {
+  if (typeof localStorage === "undefined") return void 0;
+  try {
+    const stored = localStorage.getItem(key);
+    if (stored === null) return void 0;
+    try {
+      return JSON.parse(stored);
+    } catch {
+      return stored;
+    }
+  } catch {
+    return void 0;
+  }
+}
+function getSessionStorageValue(key) {
+  if (typeof sessionStorage === "undefined") return void 0;
+  try {
+    const stored = sessionStorage.getItem(key);
+    if (stored === null) return void 0;
+    try {
+      return JSON.parse(stored);
+    } catch {
+      return stored;
+    }
+  } catch {
+    return void 0;
+  }
+}
+function getWindowInfo() {
+  if (typeof window === "undefined") return {};
+  const searchParams = {};
+  try {
+    const urlSearchParams = new URLSearchParams(window.location.search);
+    urlSearchParams.forEach((value, key) => {
+      searchParams[key] = value;
+    });
+  } catch {
+  }
+  return {
+    href: window.location.href,
+    pathname: window.location.pathname,
+    search: window.location.search,
+    hash: window.location.hash,
+    origin: window.location.origin,
+    protocol: window.location.protocol,
+    host: window.location.host,
+    hostname: window.location.hostname,
+    port: window.location.port,
+    searchParams,
+    params: searchParams,
+    innerWidth: window.innerWidth,
+    innerHeight: window.innerHeight,
+    screenWidth: window.screen?.width,
+    screenHeight: window.screen?.height
+  };
+}
+function navigatePath(obj, parts) {
+  let current = obj;
+  for (const part of parts) {
+    if (current === null || current === void 0) return void 0;
+    const arrayMatch = part.match(/^(\w+)\[(\d+)\]$/);
+    if (arrayMatch) {
+      const [, propName, indexStr] = arrayMatch;
+      current = current[propName];
+      if (!Array.isArray(current)) return void 0;
+      current = current[parseInt(indexStr, 10)];
+    } else {
+      current = current[part];
+    }
+  }
+  return current;
+}
 function resolveBindingPath(path, context) {
   const trimmed = path.trim();
   const parts = trimmed.split(".");
@@ -543,17 +1133,70 @@ function resolveBindingPath(path, context) {
     return void 0;
   }
   const prefix = parts[0].toLowerCase();
+  if (prefix === "localstore" || prefix === "localstorage") {
+    if (parts.length === 1) {
+      const all = {};
+      if (typeof localStorage !== "undefined") {
+        for (let i = 0; i < localStorage.length; i++) {
+          const key2 = localStorage.key(i);
+          if (key2) {
+            all[key2] = getLocalStorageValue(key2);
+          }
+        }
+      }
+      return all;
+    }
+    const key = parts[1];
+    const value = getLocalStorageValue(key);
+    if (parts.length === 2) return value;
+    return navigatePath(value, parts.slice(2));
+  }
+  if (prefix === "sessionstorage") {
+    if (parts.length === 1) {
+      const all = {};
+      if (typeof sessionStorage !== "undefined") {
+        for (let i = 0; i < sessionStorage.length; i++) {
+          const key2 = sessionStorage.key(i);
+          if (key2) {
+            all[key2] = getSessionStorageValue(key2);
+          }
+        }
+      }
+      return all;
+    }
+    const key = parts[1];
+    const value = getSessionStorageValue(key);
+    if (parts.length === 2) return value;
+    return navigatePath(value, parts.slice(2));
+  }
+  if (prefix === "window" || prefix === "url") {
+    const windowInfo = getWindowInfo();
+    if (parts.length === 1) return windowInfo;
+    return navigatePath(windowInfo, parts.slice(1));
+  }
+  if (prefix === "params" || prefix === "query") {
+    const windowInfo = getWindowInfo();
+    const params = windowInfo.searchParams || {};
+    if (parts.length === 1) return params;
+    return navigatePath(params, parts.slice(1));
+  }
   let source;
   let startIndex = 0;
-  if (prefix === "props" || prefix === "input") {
+  if (prefix === "props" || prefix === "input" || prefix === "bindings" || prefix === "binding" || prefix === "boundinputs" || prefix === "parent") {
     source = context.props;
     startIndex = 1;
   } else if (prefix === "state" || prefix === "appstate") {
     source = context.state;
     startIndex = 1;
-  } else if (prefix === "context") {
+  } else if (prefix === "context" || prefix === "config") {
     source = context.context;
     startIndex = 1;
+  } else if (prefix === "currentitem") {
+    source = context.props;
+    startIndex = 0;
+  } else if (prefix === "self" || prefix === "element") {
+    source = context.state;
+    startIndex = 1;
   } else if (BINDING_SOURCES.includes(prefix)) {
     source = context.props;
     startIndex = 1;
@@ -564,41 +1207,49 @@ function resolveBindingPath(path, context) {
   if (!source) {
     return void 0;
   }
-  let value = source;
-  for (let i = startIndex; i < parts.length; i++) {
-    if (value === null || value === void 0) {
-      return void 0;
-    }
-    value = value[parts[i]];
-  }
-  return value;
+  return navigatePath(source, parts.slice(startIndex));
 }
 function resolveExpression(expression, context) {
   const trimmed = expression.trim();
-  const defaultMatch = trimmed.match(/^(.+?)\|\|(.+)$/);
-  if (defaultMatch) {
-    const mainValue = resolveExpression(defaultMatch[1].trim(), context);
-    if (mainValue !== void 0 && mainValue !== null && mainValue !== "") {
-      return mainValue;
-    }
-    const defaultVal = defaultMatch[2].trim();
-    if (defaultVal.startsWith('"') && defaultVal.endsWith('"') || defaultVal.startsWith("'") && defaultVal.endsWith("'")) {
-      return defaultVal.slice(1, -1);
-    }
-    if (!isNaN(Number(defaultVal))) {
-      return Number(defaultVal);
+  const comparisonOperators = ["===", "!==", "==", "!=", ">=", "<=", ">", "<"];
+  for (const op of comparisonOperators) {
+    if (trimmed.includes(op)) {
+      const [left, right] = trimmed.split(op, 2);
+      const leftVal = resolveExpressionValue(left.trim(), context);
+      const rightVal = resolveExpressionValue(right.trim(), context);
+      switch (op) {
+        case "===":
+          return leftVal === rightVal;
+        case "!==":
+          return leftVal !== rightVal;
+        case "==":
+          return leftVal == rightVal;
+        case "!=":
+          return leftVal != rightVal;
+        case ">":
+          return leftVal > rightVal;
+        case "<":
+          return leftVal < rightVal;
+        case ">=":
+          return leftVal >= rightVal;
+        case "<=":
+          return leftVal <= rightVal;
+      }
     }
-    if (defaultVal === "true") return true;
-    if (defaultVal === "false") return false;
-    return resolveExpression(defaultVal, context);
   }
-  const ternaryMatch = trimmed.match(/^(.+?)\s*\?\s*(.+?)\s*:\s*(.+)$/);
-  if (ternaryMatch) {
-    const condition = resolveExpression(ternaryMatch[1].trim(), context);
-    if (condition) {
-      return resolveTernaryValue(ternaryMatch[2].trim(), context);
+  if (trimmed.startsWith("!") && !trimmed.startsWith("!=")) {
+    const innerValue = resolveExpression(trimmed.slice(1).trim(), context);
+    return !innerValue;
+  }
+  if (trimmed.includes("||")) {
+    const parts = trimmed.split("||");
+    for (let i = 0; i < parts.length; i++) {
+      const part = parts[i].trim();
+      const value = resolveExpressionValue(part, context);
+      if (value || i === parts.length - 1) {
+        return value;
+      }
     }
-    return resolveTernaryValue(ternaryMatch[3].trim(), context);
   }
   if (trimmed.includes("&&")) {
     const parts = trimmed.split("&&");
@@ -608,6 +1259,28 @@ function resolveExpression(expression, context) {
     }
     return resolveExpression(parts[parts.length - 1].trim(), context);
   }
+  const ternaryMatch = trimmed.match(/^(.+?)\s*\?\s*(.+?)\s*:\s*(.+)$/);
+  if (ternaryMatch) {
+    const condition = resolveExpression(ternaryMatch[1].trim(), context);
+    if (condition) {
+      return resolveTernaryValue(ternaryMatch[2].trim(), context);
+    }
+    return resolveTernaryValue(ternaryMatch[3].trim(), context);
+  }
+  return resolveExpressionValue(trimmed, context);
+}
+function resolveExpressionValue(value, context) {
+  const trimmed = value.trim();
+  if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'")) {
+    return trimmed.slice(1, -1);
+  }
+  if (!isNaN(Number(trimmed)) && trimmed !== "") {
+    return Number(trimmed);
+  }
+  if (trimmed === "true") return true;
+  if (trimmed === "false") return false;
+  if (trimmed === "null") return null;
+  if (trimmed === "undefined") return void 0;
   return resolveBindingPath(trimmed, context);
 }
 function resolveTernaryValue(value, context) {
@@ -639,7 +1312,7 @@ function resolveTemplate(template, context, componentId) {
       }
       return String(value);
     }
-    return template.replace(TEMPLATE_REGEX, (match, expression) => {
+    return template.replace(TEMPLATE_REGEX, (_match, expression) => {
       const value = resolveExpression(expression, context);
       if (value === void 0 || value === null) {
         return "";
@@ -739,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",
@@ -913,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();
   }
@@ -974,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();
   }
   /**
@@ -1021,55 +1696,1418 @@ var LongTaskObserver = class {
       this.isSupported = false;
     }
   }
-  /**
-   * Stop observing and return the count of long tasks
-   */
-  stop() {
-    if (!this.isObserving || !this.observer) {
-      return this.longTaskCount;
-    }
-    try {
-      this.observer.disconnect();
-    } catch {
+  /**
+   * Stop observing and return the count of long tasks
+   */
+  stop() {
+    if (!this.isObserving || !this.observer) {
+      return this.longTaskCount;
+    }
+    try {
+      this.observer.disconnect();
+    } catch {
+    }
+    this.observer = null;
+    this.isObserving = false;
+    return this.longTaskCount;
+  }
+  /**
+   * Reset the long task counter
+   */
+  reset() {
+    this.longTaskCount = 0;
+  }
+  /**
+   * Get current count without stopping observation
+   */
+  getCount() {
+    return this.longTaskCount;
+  }
+  /**
+   * Check if currently observing
+   */
+  isActive() {
+    return this.isObserving;
+  }
+};
+var longTaskObserverInstance = null;
+function getLongTaskObserver() {
+  if (!longTaskObserverInstance) {
+    longTaskObserverInstance = new LongTaskObserver();
+  }
+  return longTaskObserverInstance;
+}
+function resetLongTaskObserver() {
+  if (longTaskObserverInstance) {
+    longTaskObserverInstance.stop();
+  }
+  longTaskObserverInstance = null;
+}
+
+// packages/runtime-core/src/stateManager.ts
+var StateManager = class {
+  state = {};
+  listeners = /* @__PURE__ */ new Set();
+  config;
+  constructor(config = {}) {
+    this.config = config;
+    this.state = config.initialState || {};
+    if (config.persistToLocalStorage && typeof localStorage !== "undefined") {
+      this.loadFromLocalStorage();
+    }
+    if (config.onStateChange) {
+      this.listeners.add(config.onStateChange);
+    }
+  }
+  /**
+   * Get value by path from state
+   */
+  get(path) {
+    return getValueByPath(this.state, path);
+  }
+  /**
+   * Get the entire state object
+   */
+  getState() {
+    return { ...this.state };
+  }
+  /**
+   * Set a value in state
+   */
+  set(key, value, elementId) {
+    const previousValue = this.get(key);
+    setValueByPath(this.state, key, value);
+    this.notifyChange({
+      key,
+      value,
+      previousValue,
+      operation: "set",
+      elementId,
+      timestamp: Date.now()
+    });
+  }
+  /**
+   * Merge an object into state at the given path
+   */
+  merge(key, value, deep = false, elementId) {
+    const previousValue = this.get(key);
+    const currentValue = previousValue || {};
+    const newValue = deep ? deepMerge(currentValue, value) : { ...currentValue, ...value };
+    setValueByPath(this.state, key, newValue);
+    this.notifyChange({
+      key,
+      value: newValue,
+      previousValue,
+      operation: "merge",
+      elementId,
+      timestamp: Date.now()
+    });
+  }
+  /**
+   * Delete a key from state
+   */
+  delete(key, elementId) {
+    const previousValue = this.get(key);
+    deleteValueByPath(this.state, key);
+    this.notifyChange({
+      key,
+      value: void 0,
+      previousValue,
+      operation: "delete",
+      elementId,
+      timestamp: Date.now()
+    });
+  }
+  /**
+   * Append to an array in state
+   */
+  append(key, value, elementId) {
+    const previousValue = this.get(key);
+    const currentArray = Array.isArray(previousValue) ? [...previousValue] : [];
+    currentArray.push(value);
+    setValueByPath(this.state, key, currentArray);
+    this.notifyChange({
+      key,
+      value: currentArray,
+      previousValue,
+      operation: "append",
+      elementId,
+      timestamp: Date.now()
+    });
+  }
+  /**
+   * Prepend to an array in state
+   */
+  prepend(key, value, elementId) {
+    const previousValue = this.get(key);
+    const currentArray = Array.isArray(previousValue) ? [...previousValue] : [];
+    currentArray.unshift(value);
+    setValueByPath(this.state, key, currentArray);
+    this.notifyChange({
+      key,
+      value: currentArray,
+      previousValue,
+      operation: "prepend",
+      elementId,
+      timestamp: Date.now()
+    });
+  }
+  /**
+   * Toggle a boolean value in state
+   */
+  toggle(key, elementId) {
+    const previousValue = this.get(key);
+    const newValue = !previousValue;
+    setValueByPath(this.state, key, newValue);
+    this.notifyChange({
+      key,
+      value: newValue,
+      previousValue,
+      operation: "toggle",
+      elementId,
+      timestamp: Date.now()
+    });
+  }
+  /**
+   * Subscribe to state changes
+   */
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  /**
+   * Notify all listeners of a state change
+   */
+  notifyChange(event) {
+    if (this.config.persistToLocalStorage) {
+      this.saveToLocalStorage();
+    }
+    for (const listener of this.listeners) {
+      try {
+        listener(event);
+      } catch (error) {
+        console.error("State change listener error:", error);
+      }
+    }
+  }
+  /**
+   * Load state from localStorage
+   */
+  loadFromLocalStorage() {
+    try {
+      const prefix = this.config.localStoragePrefix || "servly_state_";
+      const stored = localStorage.getItem(`${prefix}state`);
+      if (stored) {
+        const parsed = JSON.parse(stored);
+        this.state = { ...this.state, ...parsed };
+      }
+    } catch (error) {
+      console.warn("Failed to load state from localStorage:", error);
+    }
+  }
+  /**
+   * Save state to localStorage
+   */
+  saveToLocalStorage() {
+    try {
+      const prefix = this.config.localStoragePrefix || "servly_state_";
+      localStorage.setItem(`${prefix}state`, JSON.stringify(this.state));
+    } catch (error) {
+      console.warn("Failed to save state to localStorage:", error);
+    }
+  }
+  /**
+   * Clear all state
+   */
+  clear() {
+    const previousState = { ...this.state };
+    this.state = {};
+    if (this.config.persistToLocalStorage) {
+      try {
+        const prefix = this.config.localStoragePrefix || "servly_state_";
+        localStorage.removeItem(`${prefix}state`);
+      } catch (error) {
+        console.warn("Failed to clear localStorage:", error);
+      }
+    }
+    this.notifyChange({
+      key: "",
+      value: {},
+      previousValue: previousState,
+      operation: "delete",
+      timestamp: Date.now()
+    });
+  }
+};
+function getValueByPath(obj, path) {
+  if (!obj || !path) return void 0;
+  const parts = path.split(".");
+  let current = obj;
+  for (const part of parts) {
+    if (current === null || current === void 0) return void 0;
+    const arrayMatch = part.match(/^(\w+)\[(\d+)\]$/);
+    if (arrayMatch) {
+      const [, propName, indexStr] = arrayMatch;
+      current = current[propName];
+      if (!Array.isArray(current)) return void 0;
+      current = current[parseInt(indexStr, 10)];
+    } else {
+      current = current[part];
+    }
+  }
+  return current;
+}
+function setValueByPath(obj, path, value) {
+  if (!obj || !path) return;
+  const parts = path.split(".");
+  let current = obj;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const part = parts[i];
+    const arrayMatch2 = part.match(/^(\w+)\[(\d+)\]$/);
+    if (arrayMatch2) {
+      const [, propName, indexStr] = arrayMatch2;
+      if (!current[propName]) current[propName] = [];
+      const index = parseInt(indexStr, 10);
+      if (!current[propName][index]) current[propName][index] = {};
+      current = current[propName][index];
+    } else {
+      if (!current[part]) current[part] = {};
+      current = current[part];
+    }
+  }
+  const lastPart = parts[parts.length - 1];
+  const arrayMatch = lastPart.match(/^(\w+)\[(\d+)\]$/);
+  if (arrayMatch) {
+    const [, propName, indexStr] = arrayMatch;
+    if (!current[propName]) current[propName] = [];
+    current[propName][parseInt(indexStr, 10)] = value;
+  } else {
+    current[lastPart] = value;
+  }
+}
+function deleteValueByPath(obj, path) {
+  if (!obj || !path) return;
+  const parts = path.split(".");
+  let current = obj;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const part = parts[i];
+    if (current[part] === void 0) return;
+    current = current[part];
+  }
+  const lastPart = parts[parts.length - 1];
+  delete current[lastPart];
+}
+function deepMerge(target, source) {
+  if (!source) return target;
+  if (!target) return source;
+  const result = { ...target };
+  for (const key of Object.keys(source)) {
+    if (source[key] && typeof source[key] === "object" && !Array.isArray(source[key]) && target[key] && typeof target[key] === "object" && !Array.isArray(target[key])) {
+      result[key] = deepMerge(target[key], source[key]);
+    } else {
+      result[key] = source[key];
+    }
+  }
+  return result;
+}
+function addClass(currentClasses, classToAdd) {
+  const classes = currentClasses.split(/\s+/).filter(Boolean);
+  if (!classes.includes(classToAdd)) {
+    classes.push(classToAdd);
+  }
+  return classes.join(" ");
+}
+function removeClass(currentClasses, classToRemove) {
+  return currentClasses.split(/\s+/).filter((cls) => cls && cls !== classToRemove).join(" ");
+}
+function toggleClass(currentClasses, classToToggle) {
+  const classes = currentClasses.split(/\s+/).filter(Boolean);
+  const index = classes.indexOf(classToToggle);
+  if (index > -1) {
+    classes.splice(index, 1);
+  } else {
+    classes.push(classToToggle);
+  }
+  return classes.join(" ");
+}
+function hasClass(currentClasses, classToCheck) {
+  return currentClasses.split(/\s+/).includes(classToCheck);
+}
+function getLocalStorage(key, defaultValue) {
+  if (typeof localStorage === "undefined") return defaultValue;
+  try {
+    const stored = localStorage.getItem(key);
+    if (stored === null) return defaultValue;
+    return JSON.parse(stored);
+  } catch {
+    return localStorage.getItem(key) ?? defaultValue;
+  }
+}
+function setLocalStorage(key, value) {
+  if (typeof localStorage === "undefined") return;
+  try {
+    localStorage.setItem(key, JSON.stringify(value));
+  } catch (error) {
+    console.warn("Failed to set localStorage:", error);
+  }
+}
+function removeLocalStorage(key) {
+  if (typeof localStorage === "undefined") return;
+  localStorage.removeItem(key);
+}
+function getSessionStorage(key, defaultValue) {
+  if (typeof sessionStorage === "undefined") return defaultValue;
+  try {
+    const stored = sessionStorage.getItem(key);
+    if (stored === null) return defaultValue;
+    return JSON.parse(stored);
+  } catch {
+    return sessionStorage.getItem(key) ?? defaultValue;
+  }
+}
+function setSessionStorage(key, value) {
+  if (typeof sessionStorage === "undefined") return;
+  try {
+    sessionStorage.setItem(key, JSON.stringify(value));
+  } catch (error) {
+    console.warn("Failed to set sessionStorage:", error);
+  }
+}
+function removeSessionStorage(key) {
+  if (typeof sessionStorage === "undefined") return;
+  sessionStorage.removeItem(key);
+}
+function navigateTo(url, options = {}) {
+  if (typeof window === "undefined") return;
+  const { replace = false, state, newTab = false } = options;
+  if (newTab) {
+    window.open(url, "_blank");
+    return;
+  }
+  if (url.startsWith("http://") || url.startsWith("https://")) {
+    if (replace) {
+      window.location.replace(url);
+    } else {
+      window.location.href = url;
+    }
+    return;
+  }
+  if (url.startsWith("#")) {
+    window.location.hash = url;
+    return;
+  }
+  if (replace) {
+    window.history.replaceState(state, "", url);
+  } else {
+    window.history.pushState(state, "", url);
+  }
+  window.dispatchEvent(new PopStateEvent("popstate", { state }));
+}
+function goBack() {
+  if (typeof window === "undefined") return;
+  window.history.back();
+}
+function goForward() {
+  if (typeof window === "undefined") return;
+  window.history.forward();
+}
+function getUrlInfo() {
+  if (typeof window === "undefined") {
+    return {
+      href: "",
+      pathname: "",
+      search: "",
+      hash: "",
+      searchParams: {}
+    };
+  }
+  const searchParams = {};
+  const urlSearchParams = new URLSearchParams(window.location.search);
+  urlSearchParams.forEach((value, key) => {
+    searchParams[key] = value;
+  });
+  return {
+    href: window.location.href,
+    pathname: window.location.pathname,
+    search: window.location.search,
+    hash: window.location.hash,
+    searchParams
+  };
+}
+
+// packages/runtime-core/src/eventSystem.ts
+var builtInPlugins = {
+  /**
+   * Set state value
+   * Mirrors: state-setState from actions.ts
+   */
+  "state-setState": (action, ctx) => {
+    const { stateConfig } = action.config || {};
+    if (!stateConfig || !ctx.stateManager) return;
+    const config = typeof stateConfig === "string" ? JSON.parse(stateConfig) : stateConfig;
+    const { key, value, operation = "set" } = config;
+    if (!key) return;
+    switch (operation) {
+      case "set":
+        ctx.stateManager.set(key, value, ctx.elementId);
+        break;
+      case "merge":
+        ctx.stateManager.merge(key, value, false, ctx.elementId);
+        break;
+      case "deepMerge":
+        ctx.stateManager.merge(key, value, true, ctx.elementId);
+        break;
+      case "toggle":
+        ctx.stateManager.toggle(key, ctx.elementId);
+        break;
+      case "append":
+        ctx.stateManager.append(key, value, ctx.elementId);
+        break;
+      case "prepend":
+        ctx.stateManager.prepend(key, value, ctx.elementId);
+        break;
+      case "delete":
+        ctx.stateManager.delete(key, ctx.elementId);
+        break;
+      case "increment":
+        const currentVal = ctx.stateManager.get(key) || 0;
+        ctx.stateManager.set(key, currentVal + (value || 1), ctx.elementId);
+        break;
+      case "decrement":
+        const currVal = ctx.stateManager.get(key) || 0;
+        ctx.stateManager.set(key, currVal - (value || 1), ctx.elementId);
+        break;
+    }
+    return { success: true, key, operation };
+  },
+  /**
+   * Navigate to URL
+   * Mirrors: navigateTo from actions.ts
+   */
+  "navigateTo": (action, ctx) => {
+    const { url, replace, newTab, state } = action.config || {};
+    if (!url) return;
+    navigateTo(url, { replace, newTab, state });
+    return { success: true, url };
+  },
+  /**
+   * Set localStorage value
+   */
+  "localStorage-set": (action, ctx) => {
+    const { key, value } = action.config || {};
+    if (!key) return;
+    setLocalStorage(key, value);
+    return { success: true, key };
+  },
+  /**
+   * Get localStorage value
+   */
+  "localStorage-get": (action, ctx) => {
+    const { key, defaultValue } = action.config || {};
+    if (!key) return defaultValue;
+    return getLocalStorage(key, defaultValue);
+  },
+  /**
+   * Remove localStorage value
+   */
+  "localStorage-remove": (action, ctx) => {
+    const { key } = action.config || {};
+    if (!key) return;
+    if (typeof localStorage !== "undefined") {
+      localStorage.removeItem(key);
+    }
+    return { success: true, key };
+  },
+  /**
+   * Set sessionStorage value
+   */
+  "sessionStorage-set": (action, ctx) => {
+    const { key, value } = action.config || {};
+    if (!key) return;
+    setSessionStorage(key, value);
+    return { success: true, key };
+  },
+  /**
+   * Get sessionStorage value
+   */
+  "sessionStorage-get": (action, ctx) => {
+    const { key, defaultValue } = action.config || {};
+    if (!key) return defaultValue;
+    return getSessionStorage(key, defaultValue);
+  },
+  /**
+   * Console log (for debugging)
+   */
+  "console-log": (action, ctx) => {
+    const { message, data } = action.config || {};
+    console.log("[Servly]", message, data);
+    return { success: true };
+  },
+  /**
+   * Show alert
+   */
+  "alert": (action, ctx) => {
+    const { message } = action.config || {};
+    if (typeof alert !== "undefined") {
+      alert(message);
+    }
+    return { success: true };
+  },
+  /**
+   * Copy to clipboard
+   */
+  "clipboard-copy": async (action, ctx) => {
+    const { text } = action.config || {};
+    if (!text || typeof navigator === "undefined") return { success: false };
+    try {
+      await navigator.clipboard.writeText(text);
+      return { success: true };
+    } catch (error) {
+      return { success: false, error };
+    }
+  },
+  /**
+   * Scroll to element
+   */
+  "scrollTo": (action, ctx) => {
+    const { selector, behavior = "smooth", block = "start" } = action.config || {};
+    if (!selector || typeof document === "undefined") return;
+    const element = document.querySelector(selector);
+    if (element) {
+      element.scrollIntoView({ behavior, block });
+      return { success: true };
+    }
+    return { success: false, error: "Element not found" };
+  },
+  /**
+   * Focus element
+   */
+  "focus": (action, ctx) => {
+    const { selector } = action.config || {};
+    if (!selector || typeof document === "undefined") return;
+    const element = document.querySelector(selector);
+    if (element && typeof element.focus === "function") {
+      element.focus();
+      return { success: true };
+    }
+    return { success: false, error: "Element not found" };
+  },
+  /**
+   * Blur element
+   */
+  "blur": (action, ctx) => {
+    const { selector } = action.config || {};
+    if (!selector || typeof document === "undefined") return;
+    const element = document.querySelector(selector);
+    if (element && typeof element.blur === "function") {
+      element.blur();
+      return { success: true };
+    }
+    return { success: false, error: "Element not found" };
+  },
+  /**
+   * Add class to element
+   */
+  "addClass": (action, ctx) => {
+    const { selector, className } = action.config || {};
+    if (!selector || !className || typeof document === "undefined") return;
+    const element = document.querySelector(selector);
+    if (element) {
+      element.classList.add(className);
+      return { success: true };
+    }
+    return { success: false, error: "Element not found" };
+  },
+  /**
+   * Remove class from element
+   */
+  "removeClass": (action, ctx) => {
+    const { selector, className } = action.config || {};
+    if (!selector || !className || typeof document === "undefined") return;
+    const element = document.querySelector(selector);
+    if (element) {
+      element.classList.remove(className);
+      return { success: true };
+    }
+    return { success: false, error: "Element not found" };
+  },
+  /**
+   * Toggle class on element
+   */
+  "toggleClass": (action, ctx) => {
+    const { selector, className } = action.config || {};
+    if (!selector || !className || typeof document === "undefined") return;
+    const element = document.querySelector(selector);
+    if (element) {
+      element.classList.toggle(className);
+      return { success: true };
+    }
+    return { success: false, error: "Element not found" };
+  },
+  /**
+   * Set element attribute
+   */
+  "setAttribute": (action, ctx) => {
+    const { selector, attribute, value } = action.config || {};
+    if (!selector || !attribute || typeof document === "undefined") return;
+    const element = document.querySelector(selector);
+    if (element) {
+      element.setAttribute(attribute, value);
+      return { success: true };
+    }
+    return { success: false, error: "Element not found" };
+  },
+  /**
+   * Remove element attribute
+   */
+  "removeAttribute": (action, ctx) => {
+    const { selector, attribute } = action.config || {};
+    if (!selector || !attribute || typeof document === "undefined") return;
+    const element = document.querySelector(selector);
+    if (element) {
+      element.removeAttribute(attribute);
+      return { success: true };
+    }
+    return { success: false, error: "Element not found" };
+  },
+  /**
+   * Dispatch custom event
+   */
+  "dispatchEvent": (action, ctx) => {
+    const { selector, eventName, detail } = action.config || {};
+    if (!eventName || typeof document === "undefined") return;
+    const target = selector ? document.querySelector(selector) : document;
+    if (target) {
+      const event = new CustomEvent(eventName, { detail, bubbles: true });
+      target.dispatchEvent(event);
+      return { success: true };
+    }
+    return { success: false, error: "Target not found" };
+  },
+  /**
+   * Delay execution
+   */
+  "delay": async (action, ctx) => {
+    const { ms = 0 } = action.config || {};
+    await new Promise((resolve) => setTimeout(resolve, ms));
+    return { success: true };
+  },
+  /**
+   * Conditional execution
+   */
+  "condition": (action, ctx) => {
+    const { condition, thenActions, elseActions } = action.config || {};
+    return { condition, thenActions, elseActions };
+  }
+};
+var EventSystem = class {
+  config;
+  pluginExecutors;
+  debounceTimers = /* @__PURE__ */ new Map();
+  throttleTimers = /* @__PURE__ */ new Map();
+  constructor(config = {}) {
+    this.config = config;
+    this.pluginExecutors = {
+      ...builtInPlugins,
+      ...config.pluginExecutors
+    };
+  }
+  /**
+   * Register a custom plugin executor
+   */
+  registerPlugin(key, executor) {
+    this.pluginExecutors[key] = executor;
+  }
+  /**
+   * Create an event handler from Servly plugin format
+   */
+  createHandler(elementId, handlerConfig, context, options = {}) {
+    return (event) => {
+      if (handlerConfig.preventDefault || options.preventDefault) {
+        event.preventDefault();
+      }
+      if (handlerConfig.stopPropagation || options.stopPropagation) {
+        event.stopPropagation();
+      }
+      if (this.config.onEvent) {
+        this.config.onEvent(event.type, elementId, event);
+      }
+      if (handlerConfig.plugins && handlerConfig.plugins.length > 0) {
+        this.executePlugins(handlerConfig.plugins, {
+          event,
+          elementId,
+          context,
+          stateManager: this.config.stateManager
+        });
+      }
+    };
+  }
+  /**
+   * Execute a sequence of plugin actions
+   */
+  async executePlugins(plugins, eventContext) {
+    const results = [];
+    for (const action of plugins) {
+      try {
+        const executor = this.pluginExecutors[action.key];
+        if (executor) {
+          const result = await executor(action, eventContext);
+          results.push(result);
+          if (this.config.onPluginExecute) {
+            this.config.onPluginExecute(action, result);
+          }
+        } else {
+          console.warn(`[EventSystem] Unknown plugin: ${action.key}`);
+          results.push({ error: `Unknown plugin: ${action.key}` });
+        }
+      } catch (error) {
+        console.error(`[EventSystem] Plugin error (${action.key}):`, error);
+        results.push({ error });
+      }
+    }
+    return results;
+  }
+  /**
+   * Create a debounced event handler
+   */
+  createDebouncedHandler(elementId, handler, delay) {
+    const key = `${elementId}-debounce`;
+    return (event) => {
+      const existingTimer = this.debounceTimers.get(key);
+      if (existingTimer) {
+        clearTimeout(existingTimer);
+      }
+      const timer = setTimeout(() => {
+        handler(event);
+        this.debounceTimers.delete(key);
+      }, delay);
+      this.debounceTimers.set(key, timer);
+    };
+  }
+  /**
+   * Create a throttled event handler
+   */
+  createThrottledHandler(elementId, handler, delay) {
+    const key = `${elementId}-throttle`;
+    return (event) => {
+      if (this.throttleTimers.get(key)) {
+        return;
+      }
+      handler(event);
+      this.throttleTimers.set(key, true);
+      setTimeout(() => {
+        this.throttleTimers.delete(key);
+      }, delay);
+    };
+  }
+  /**
+   * Clean up all timers
+   */
+  destroy() {
+    for (const timer of this.debounceTimers.values()) {
+      clearTimeout(timer);
+    }
+    this.debounceTimers.clear();
+    this.throttleTimers.clear();
+  }
+};
+var EVENT_HANDLERS = {
+  onClick: "click",
+  onDoubleClick: "dblclick",
+  onMouseDown: "mousedown",
+  onMouseUp: "mouseup",
+  onMouseEnter: "mouseenter",
+  onMouseLeave: "mouseleave",
+  onMouseMove: "mousemove",
+  onMouseOver: "mouseover",
+  onMouseOut: "mouseout",
+  onKeyDown: "keydown",
+  onKeyUp: "keyup",
+  onKeyPress: "keypress",
+  onFocus: "focus",
+  onBlur: "blur",
+  onChange: "change",
+  onInput: "input",
+  onSubmit: "submit",
+  onReset: "reset",
+  onScroll: "scroll",
+  onWheel: "wheel",
+  onDragStart: "dragstart",
+  onDrag: "drag",
+  onDragEnd: "dragend",
+  onDragEnter: "dragenter",
+  onDragLeave: "dragleave",
+  onDragOver: "dragover",
+  onDrop: "drop",
+  onTouchStart: "touchstart",
+  onTouchMove: "touchmove",
+  onTouchEnd: "touchend",
+  onTouchCancel: "touchcancel",
+  onContextMenu: "contextmenu",
+  onCopy: "copy",
+  onCut: "cut",
+  onPaste: "paste",
+  onLoad: "load",
+  onError: "error",
+  onAnimationStart: "animationstart",
+  onAnimationEnd: "animationend",
+  onAnimationIteration: "animationiteration",
+  onTransitionEnd: "transitionend"
+};
+function toDomEventName(reactEventName) {
+  return EVENT_HANDLERS[reactEventName] || reactEventName.replace(/^on/, "").toLowerCase();
+}
+function toReactEventName(domEventName) {
+  const entry = Object.entries(EVENT_HANDLERS).find(([, dom]) => dom === domEventName);
+  return entry ? entry[0] : `on${domEventName.charAt(0).toUpperCase()}${domEventName.slice(1)}`;
+}
+var defaultEventSystem = null;
+function getEventSystem(config) {
+  if (!defaultEventSystem || config) {
+    defaultEventSystem = new EventSystem(config);
+  }
+  return defaultEventSystem;
+}
+function resetEventSystem() {
+  if (defaultEventSystem) {
+    defaultEventSystem.destroy();
+    defaultEventSystem = null;
+  }
+}
+
+// packages/runtime-core/src/overrides.ts
+var OverrideSystem = class {
+  config;
+  elementStates = /* @__PURE__ */ new Map();
+  watchIntervals = /* @__PURE__ */ new Map();
+  constructor(config = {}) {
+    this.config = config;
+  }
+  /**
+   * Get overrides from an element
+   */
+  getOverrides(element) {
+    const rawOverrides = element.configuration?._overrides_;
+    if (!rawOverrides) return [];
+    if (Array.isArray(rawOverrides)) {
+      return rawOverrides.filter((o) => o && typeof o === "object");
+    }
+    if (typeof rawOverrides === "object") {
+      console.warn("[OverrideSystem] Legacy object override format detected, ignoring");
+      return [];
+    }
+    return [];
+  }
+  /**
+   * Initialize overrides for an element (called on mount)
+   */
+  async initializeElement(element, context) {
+    const elementId = element.i;
+    const overrides = this.getOverrides(element);
+    if (overrides.length === 0) return;
+    const state = {
+      previousValues: /* @__PURE__ */ new Map(),
+      initialized: false,
+      abortController: new AbortController()
+    };
+    this.elementStates.set(elementId, state);
+    const mountOverrides = overrides.filter((o) => !o.isCleanUp);
+    overrides.forEach((override, index) => {
+      if (override.isCleanUp) return;
+      if (!override.dependencies || override.dependencies.length === 0) return;
+      const initialValues = override.dependencies.map(
+        (dep) => resolveTemplate(dep, context)
+      );
+      state.previousValues.set(index, initialValues);
+    });
+    await this.processOverrides(elementId, mountOverrides, context, "onMount");
+    state.initialized = true;
+  }
+  /**
+   * Check and process dependency changes for an element
+   */
+  async checkDependencies(element, context) {
+    const elementId = element.i;
+    const overrides = this.getOverrides(element);
+    const state = this.elementStates.get(elementId);
+    if (!state || !state.initialized) return;
+    const overridesToTrigger = [];
+    overrides.forEach((override, index) => {
+      if (override.isCleanUp) return;
+      if (!override.dependencies || override.dependencies.length === 0) return;
+      const currentValues = override.dependencies.map(
+        (dep) => resolveTemplate(dep, context)
+      );
+      const previousValues = state.previousValues.get(index) || [];
+      let hasChanged = false;
+      if (previousValues.length !== currentValues.length) {
+        hasChanged = true;
+      } else {
+        for (let i = 0; i < currentValues.length; i++) {
+          if (JSON.stringify(previousValues[i]) !== JSON.stringify(currentValues[i])) {
+            hasChanged = true;
+            break;
+          }
+        }
+      }
+      if (hasChanged) {
+        overridesToTrigger.push(override);
+        state.previousValues.set(index, currentValues);
+        if (this.config.onDependencyChange) {
+          this.config.onDependencyChange(elementId, override.dependencies, currentValues);
+        }
+      }
+    });
+    if (overridesToTrigger.length > 0) {
+      await this.processOverrides(elementId, overridesToTrigger, context, "onDependencyChange");
+    }
+  }
+  /**
+   * Cleanup overrides for an element (called on unmount)
+   */
+  async cleanupElement(element, context) {
+    const elementId = element.i;
+    const overrides = this.getOverrides(element);
+    const state = this.elementStates.get(elementId);
+    if (state?.abortController) {
+      state.abortController.abort();
+    }
+    this.stopWatching(elementId);
+    const cleanupOverrides = overrides.filter((o) => o.isCleanUp);
+    if (cleanupOverrides.length > 0) {
+      await this.processOverrides(elementId, cleanupOverrides, context, "onUnmount");
+    }
+    this.elementStates.delete(elementId);
+  }
+  /**
+   * Process a list of overrides
+   */
+  async processOverrides(elementId, overrides, context, eventType) {
+    if (!overrides || overrides.length === 0) return;
+    const validOverrides = overrides.filter((o) => o.plugins && o.plugins.length > 0);
+    if (validOverrides.length === 0) return;
+    const results = await Promise.allSettled(
+      validOverrides.map(async (override) => {
+        if (this.config.onOverrideTrigger) {
+          this.config.onOverrideTrigger(elementId, override, eventType);
+        }
+        if (this.config.eventSystem && override.plugins) {
+          const eventContext = {
+            event: new CustomEvent(eventType),
+            elementId,
+            context,
+            stateManager: this.config.stateManager
+          };
+          return this.config.eventSystem.executePlugins(override.plugins, eventContext);
+        }
+        return null;
+      })
+    );
+    results.forEach((result, index) => {
+      if (result.status === "rejected") {
+        console.error(`[OverrideSystem] Override ${index} failed:`, result.reason);
+      }
+    });
+  }
+  /**
+   * Start watching an element for dependency changes
+   */
+  startWatching(element, context, intervalMs = 100) {
+    const elementId = element.i;
+    this.stopWatching(elementId);
+    const overrides = this.getOverrides(element);
+    const hasDependencies = overrides.some(
+      (o) => !o.isCleanUp && o.dependencies && o.dependencies.length > 0
+    );
+    if (!hasDependencies) return;
+    const interval = setInterval(() => {
+      this.checkDependencies(element, context);
+    }, intervalMs);
+    this.watchIntervals.set(elementId, interval);
+  }
+  /**
+   * Stop watching an element
+   */
+  stopWatching(elementId) {
+    const interval = this.watchIntervals.get(elementId);
+    if (interval) {
+      clearInterval(interval);
+      this.watchIntervals.delete(elementId);
+    }
+  }
+  /**
+   * Destroy the override system
+   */
+  destroy() {
+    for (const interval of this.watchIntervals.values()) {
+      clearInterval(interval);
+    }
+    this.watchIntervals.clear();
+    for (const state of this.elementStates.values()) {
+      if (state.abortController) {
+        state.abortController.abort();
+      }
+    }
+    this.elementStates.clear();
+  }
+};
+function extractOverrideDependencies(element) {
+  const overrides = element.configuration?._overrides_;
+  if (!Array.isArray(overrides)) return [];
+  const dependencies = [];
+  for (const override of overrides) {
+    if (override?.dependencies && Array.isArray(override.dependencies)) {
+      dependencies.push(...override.dependencies);
+    }
+  }
+  return [...new Set(dependencies)];
+}
+function hasOverrides(element) {
+  const overrides = element.configuration?._overrides_;
+  return Array.isArray(overrides) && overrides.length > 0;
+}
+function hasDependencyOverrides(element) {
+  const overrides = element.configuration?._overrides_;
+  if (!Array.isArray(overrides)) return false;
+  return overrides.some(
+    (o) => !o?.isCleanUp && o?.dependencies && o.dependencies.length > 0
+  );
+}
+function getMountOverrides(element) {
+  const overrides = element.configuration?._overrides_;
+  if (!Array.isArray(overrides)) return [];
+  return overrides.filter((o) => o && !o.isCleanUp);
+}
+function getCleanupOverrides(element) {
+  const overrides = element.configuration?._overrides_;
+  if (!Array.isArray(overrides)) return [];
+  return overrides.filter((o) => o && o.isCleanUp);
+}
+var defaultOverrideSystem = null;
+function getOverrideSystem(config) {
+  if (!defaultOverrideSystem || config) {
+    defaultOverrideSystem = new OverrideSystem(config);
+  }
+  return defaultOverrideSystem;
+}
+function resetOverrideSystem() {
+  if (defaultOverrideSystem) {
+    defaultOverrideSystem.destroy();
+    defaultOverrideSystem = null;
+  }
+}
+
+// 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;
     }
-    this.observer = null;
-    this.isObserving = false;
-    return this.longTaskCount;
+    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;
   }
-  /**
-   * Reset the long task counter
-   */
-  reset() {
-    this.longTaskCount = 0;
+}
+async function getIconData(icon) {
+  const key = `${icon.set}:${icon.name}`;
+  if (iconCache.has(key)) {
+    return iconCache.get(key);
   }
-  /**
-   * Get current count without stopping observation
-   */
-  getCount() {
-    return this.longTaskCount;
+  if (pendingFetches.has(key)) {
+    return pendingFetches.get(key);
   }
-  /**
-   * Check if currently observing
-   */
-  isActive() {
-    return this.isObserving;
+  if (!cdnEnabled) {
+    return null;
   }
-};
-var longTaskObserverInstance = null;
-function getLongTaskObserver() {
-  if (!longTaskObserverInstance) {
-    longTaskObserverInstance = new LongTaskObserver();
+  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 longTaskObserverInstance;
+  return data;
 }
-function resetLongTaskObserver() {
-  if (longTaskObserverInstance) {
-    longTaskObserverInstance.stop();
+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;
   }
-  longTaskObserverInstance = null;
+  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];
 }
 
-// src/renderer.ts
+// packages/runtime-core/src/renderer.ts
 var COMPONENT_TO_TAG = {
   container: "div",
   text: "span",
@@ -1218,7 +3256,7 @@ function resolveFunctionBinding(binding, context) {
   }
   return void 0;
 }
-function attachEventHandlers(domElement, element, eventHandlers, context, elementState, isRootElement = false) {
+function attachEventHandlers(domElement, element, eventHandlers, context, elementState, isRootElement = false, state) {
   const elementId = element.i;
   if (eventHandlers && eventHandlers[elementId]) {
     const handlers = eventHandlers[elementId];
@@ -1228,6 +3266,28 @@ function attachEventHandlers(domElement, element, eventHandlers, context, elemen
       domElement.addEventListener(domEventName, handler);
     }
   }
+  const config = element.configuration || {};
+  for (const eventPropName of Object.keys(EVENT_HANDLERS)) {
+    const handlerConfig = config[eventPropName];
+    if (handlerConfig && handlerConfig.plugins && handlerConfig.plugins.length > 0) {
+      const domEventName = toDomEventName(eventPropName);
+      if (!elementState.eventListeners.has(domEventName)) {
+        if (state?.eventSystem) {
+          const handler = state.eventSystem.createHandler(elementId, handlerConfig, context);
+          elementState.eventListeners.set(domEventName, handler);
+          domElement.addEventListener(domEventName, handler);
+        } else {
+          const handler = (e) => {
+            if (handlerConfig.preventDefault) e.preventDefault();
+            if (handlerConfig.stopPropagation) e.stopPropagation();
+            console.log(`[Servly] Event ${eventPropName} triggered on ${elementId}`, handlerConfig.plugins);
+          };
+          elementState.eventListeners.set(domEventName, handler);
+          domElement.addEventListener(domEventName, handler);
+        }
+      }
+    }
+  }
   const bindings = element.configuration?.bindings?.inputs;
   if (bindings) {
     for (const [propName, binding] of Object.entries(bindings)) {
@@ -1262,10 +3322,16 @@ function detachEventHandlers(elementState) {
   }
   elementState.eventListeners.clear();
 }
-function createElement(element, context, eventHandlers, isRootElement = false) {
+function createElement(element, context, eventHandlers, isRootElement = false, state) {
   const tag = getElementTag(element);
   const domElement = document.createElement(tag);
   domElement.setAttribute("data-servly-id", element.i);
+  const slotName = element.slotName || element.configuration?.slotName;
+  if (element.componentId === "slot" || slotName) {
+    const name = slotName || element.i;
+    domElement.setAttribute("data-slot", name);
+    domElement.setAttribute("data-servly-slot", "true");
+  }
   const styles = buildElementStyles(element, context);
   applyStyles(domElement, styles);
   const className = buildClassName(element, context);
@@ -1288,7 +3354,7 @@ function createElement(element, context, eventHandlers, isRootElement = false) {
     textContent,
     eventListeners: /* @__PURE__ */ new Map()
   };
-  attachEventHandlers(domElement, element, eventHandlers, context, elementState, isRootElement);
+  attachEventHandlers(domElement, element, eventHandlers, context, elementState, isRootElement, state);
   return elementState;
 }
 var globalRenderingStack = /* @__PURE__ */ new Set();
@@ -1349,8 +3415,84 @@ function renderComponentRef(element, container, context, state) {
     globalRenderingStack.delete(refId);
   }
 }
+function extractViewId(binding) {
+  if (!binding) return null;
+  if (typeof binding === "string") return binding;
+  if (binding.source === "static" && typeof binding.value === "string") return binding.value;
+  if (binding.source === "node" && binding.binding?.viewId) return binding.binding.viewId;
+  if (binding.source === "view" && typeof binding.value === "string") return binding.value;
+  if (binding.viewId) return binding.viewId;
+  if (binding.type === "view" && binding.viewId) return binding.viewId;
+  return null;
+}
+function resolveComponentViewInputs(bindings, context, parentInputs) {
+  if (!bindings) return {};
+  const resolved = {};
+  for (const [key, binding] of Object.entries(bindings)) {
+    if (!binding) continue;
+    const source = (binding.source || "").toLowerCase();
+    switch (source) {
+      case "static":
+      case "value":
+      case "constant":
+        resolved[key] = binding.value;
+        break;
+      case "state":
+        if (binding.path && context.state) {
+          resolved[key] = getValueByPath2(context.state, binding.path);
+        }
+        break;
+      case "props":
+      case "parent":
+      case "input":
+        if (binding.path) {
+          const source2 = parentInputs || context.props;
+          const resolvedValue = getValueByPath2(source2, binding.path);
+          if (resolvedValue !== void 0) {
+            resolved[key] = resolvedValue;
+          } else {
+            resolved[key] = binding.value;
+          }
+        } else {
+          resolved[key] = binding.value;
+        }
+        break;
+      case "node":
+        if (binding.binding?.viewId) {
+          resolved[key] = binding.binding.viewId;
+        } else if (binding.binding) {
+          resolved[key] = binding.binding;
+        } else {
+          resolved[key] = binding.value;
+        }
+        break;
+      default:
+        resolved[key] = binding.value;
+    }
+  }
+  return resolved;
+}
+function getValueByPath2(obj, path) {
+  if (!obj || !path) return void 0;
+  const parts = path.split(".");
+  let current = obj;
+  for (const part of parts) {
+    if (current === null || current === void 0) return void 0;
+    current = current[part];
+  }
+  return current;
+}
 function renderElement(element, tree, context, eventHandlers, elementStates, state, isRootElement = false) {
-  const elementState = createElement(element, context, eventHandlers, isRootElement);
+  if (element.isComponentView) {
+    return renderComponentViewElement(element, tree, context, eventHandlers, elementStates, state, isRootElement);
+  }
+  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;
   if (config?.componentViewRef) {
@@ -1367,8 +3509,201 @@ 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)) {
+    const placeholder = document.createElement("div");
+    placeholder.className = "border-2 border-red-500 border-dashed p-4 bg-red-50";
+    placeholder.innerHTML = `<p class="text-red-600 text-sm">Recursive component: ${element.componentId}</p>`;
+    return placeholder;
+  }
+  let viewLayout;
+  if (state.views?.has(element.componentId)) {
+    const view = state.views.get(element.componentId);
+    viewLayout = view?.layout;
+  }
+  if (!viewLayout && state.componentRegistry) {
+    const component = state.componentRegistry.get(element.componentId);
+    if (component) {
+      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>`;
+    return placeholder;
+  }
+  const bindings = element.configuration?.bindings?.inputs || {};
+  const resolvedInputs = resolveComponentViewInputs(bindings, context, context.props);
+  const componentContext = {
+    props: { ...context.props, ...resolvedInputs },
+    state: context.state,
+    context: context.context
+  };
+  globalRenderingStack.add(componentViewId);
+  try {
+    const wrapper = document.createElement("div");
+    wrapper.id = element.i;
+    wrapper.className = "contents";
+    const viewTree = buildTree(viewLayout);
+    const viewRoots = viewLayout.filter((el) => !el.parent || el.parent === null);
+    const nestedState = {
+      ...state,
+      elements: viewLayout,
+      context: componentContext,
+      elementStates: /* @__PURE__ */ new Map(),
+      rootElement: null,
+      renderingStack: new Set(state.renderingStack)
+    };
+    nestedState.renderingStack.add(componentViewId);
+    for (const root of viewRoots) {
+      const rootElement = renderElement(
+        root,
+        viewTree,
+        componentContext,
+        eventHandlers,
+        nestedState.elementStates,
+        nestedState,
+        true
+      );
+      wrapper.appendChild(rootElement);
+    }
+    const elementState = {
+      element,
+      domElement: wrapper,
+      styles: {},
+      className: "contents",
+      textContent: "",
+      eventListeners: /* @__PURE__ */ new Map()
+    };
+    elementStates.set(element.i, elementState);
+    return wrapper;
+  } finally {
+    globalRenderingStack.delete(componentViewId);
+  }
+}
+function renderSlotElement(element, tree, context, eventHandlers, elementStates, state, isRootElement) {
+  const elementState = createElement(element, context, eventHandlers, isRootElement, state);
+  elementStates.set(element.i, elementState);
+  const bindings = element.configuration?.bindings?.inputs || {};
+  let childViewId = extractViewId(bindings.child) || extractViewId(bindings.children) || extractViewId(bindings.content);
+  if (!childViewId && context.props) {
+    childViewId = extractViewId(context.props.child) || extractViewId(context.props.children) || extractViewId(context.props.content);
+  }
+  if (childViewId && typeof childViewId === "string") {
+    let viewLayout;
+    if (state.views?.has(childViewId)) {
+      const view = state.views.get(childViewId);
+      viewLayout = view?.layout;
+    }
+    if (!viewLayout && state.componentRegistry) {
+      const component = state.componentRegistry.get(childViewId);
+      if (component) {
+        viewLayout = component.layout;
+      }
+    }
+    if (viewLayout) {
+      const viewTree = buildTree(viewLayout);
+      const viewRoots = viewLayout.filter((el) => !el.parent || el.parent === null);
+      const nestedState = {
+        ...state,
+        elements: viewLayout,
+        elementStates: /* @__PURE__ */ new Map(),
+        rootElement: null
+      };
+      for (const root of viewRoots) {
+        const rootElement = renderElement(
+          root,
+          viewTree,
+          context,
+          eventHandlers,
+          nestedState.elementStates,
+          nestedState,
+          false
+        );
+        elementState.domElement.appendChild(rootElement);
+      }
+      return elementState.domElement;
+    }
+  }
+  const children = tree.get(element.i) || [];
+  for (const child of children) {
+    const childElement = renderElement(child, tree, context, eventHandlers, elementStates, state, false);
+    elementState.domElement.appendChild(childElement);
+  }
+  return elementState.domElement;
+}
 function render(options) {
-  const { container, elements, context, eventHandlers, componentRegistry, onDependencyNeeded } = options;
+  const {
+    container,
+    elements,
+    context,
+    eventHandlers,
+    componentRegistry,
+    onDependencyNeeded,
+    views: viewsInput,
+    enableStateManager,
+    initialState,
+    onStateChange,
+    pluginExecutors,
+    onNavigate,
+    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();
@@ -1377,6 +3712,29 @@ function render(options) {
   const rootElements = elements.filter((el) => !el.parent || el.parent === null);
   const componentId = rootElements[0]?.componentId || "unknown";
   const version = "latest";
+  let stateManager;
+  if (enableStateManager) {
+    stateManager = new StateManager({
+      initialState: initialState || context.state,
+      onStateChange: onStateChange ? (event) => onStateChange({
+        key: event.key,
+        value: event.value,
+        previousValue: event.previousValue
+      }) : void 0
+    });
+  }
+  const eventSystem = new EventSystem({
+    stateManager,
+    pluginExecutors,
+    onNavigate,
+    onApiCall
+  });
+  const overrideSystem = new OverrideSystem({
+    eventSystem,
+    stateManager
+  });
+  const hasAnyOverrides = elements.some((el) => hasOverrides(el));
+  const hasAnyDependencyOverrides = elements.some((el) => hasDependencyOverrides(el));
   try {
     const tree = buildTree(elements);
     const state = {
@@ -1388,7 +3746,13 @@ function render(options) {
       rootElement: null,
       componentRegistry,
       onDependencyNeeded,
-      renderingStack: /* @__PURE__ */ new Set()
+      renderingStack: /* @__PURE__ */ new Set(),
+      views,
+      eventSystem,
+      stateManager,
+      overrideSystem,
+      enableOverrides: hasAnyOverrides,
+      iconRenderer
     };
     container.innerHTML = "";
     if (rootElements.length === 0) {
@@ -1426,6 +3790,16 @@ function render(options) {
       state.rootElement = wrapper;
       container.appendChild(wrapper);
     }
+    if (hasAnyOverrides && overrideSystem) {
+      for (const element of elements) {
+        if (hasOverrides(element)) {
+          overrideSystem.initializeElement(element, context);
+          if (hasDependencyOverrides(element)) {
+            overrideSystem.startWatching(element, context);
+          }
+        }
+      }
+    }
     const duration = performance.now() - startTime;
     const memoryAfter = memorySampler.sample();
     const longTasks = longTaskObserver.stop();
@@ -1444,6 +3818,7 @@ function render(options) {
     };
   } catch (error) {
     longTaskObserver.stop();
+    overrideSystem.destroy();
     analytics.trackError(componentId, version, error, {
       errorType: "render"
     });
@@ -1474,12 +3849,23 @@ function update(state, newContext) {
   }
 }
 function destroy(state) {
+  if (state.overrideSystem && state.enableOverrides) {
+    for (const element of state.elements) {
+      if (hasOverrides(element)) {
+        state.overrideSystem.cleanupElement(element, state.context);
+      }
+    }
+    state.overrideSystem.destroy();
+  }
   for (const elementState of state.elementStates.values()) {
     detachEventHandlers(elementState);
     if (elementState.nestedRender) {
       elementState.nestedRender.destroy();
     }
   }
+  if (state.eventSystem) {
+    state.eventSystem.destroy();
+  }
   state.elementStates.clear();
   if (state.rootElement && state.rootElement.parentNode) {
     state.rootElement.parentNode.removeChild(state.rootElement);
@@ -1546,8 +3932,202 @@ function renderDynamicList(options) {
   }
   return results;
 }
+function renderNode(options) {
+  const {
+    container,
+    elements,
+    nodeId,
+    context,
+    includeChildren = true,
+    eventHandlers,
+    componentRegistry,
+    views
+  } = options;
+  const targetNode = elements.find((el) => el.i === nodeId);
+  if (!targetNode) {
+    console.error(`renderNode: Node not found: ${nodeId}`);
+    return null;
+  }
+  if (!includeChildren) {
+    const singleElementLayout = [targetNode];
+    return render({
+      container,
+      elements: singleElementLayout,
+      context,
+      eventHandlers,
+      componentRegistry,
+      views
+    });
+  }
+  const descendantIds = /* @__PURE__ */ new Set();
+  const collectDescendants = (parentId) => {
+    for (const el of elements) {
+      if (el.parent === parentId) {
+        descendantIds.add(el.i);
+        collectDescendants(el.i);
+      }
+    }
+  };
+  descendantIds.add(nodeId);
+  collectDescendants(nodeId);
+  const nodeElements = elements.filter((el) => descendantIds.has(el.i));
+  const rootedElements = nodeElements.map(
+    (el) => el.i === nodeId ? { ...el, parent: null } : el
+  );
+  return render({
+    container,
+    elements: rootedElements,
+    context,
+    eventHandlers,
+    componentRegistry,
+    views
+  });
+}
+function renderInShadow(options) {
+  const { container, mode = "open", styles, injectTailwind: shouldInjectTailwind, ...renderOptions } = options;
+  const shadowRoot = container.attachShadow({ mode });
+  const innerContainer = document.createElement("div");
+  innerContainer.className = "servly-shadow-container";
+  shadowRoot.appendChild(innerContainer);
+  if (styles) {
+    const styleEl = document.createElement("style");
+    styleEl.textContent = styles;
+    shadowRoot.insertBefore(styleEl, innerContainer);
+  }
+  if (shouldInjectTailwind) {
+    const tailwindLink = document.createElement("link");
+    tailwindLink.rel = "stylesheet";
+    tailwindLink.href = "https://cdn.tailwindcss.com";
+    shadowRoot.insertBefore(tailwindLink, innerContainer);
+  }
+  const result = render({
+    ...renderOptions,
+    container: innerContainer
+  });
+  return {
+    ...result,
+    shadowRoot
+  };
+}
+async function createServlyRenderer(options) {
+  const {
+    container: containerOption,
+    injectTailwind: shouldInjectTailwind = true,
+    tailwindConfig,
+    initialState,
+    onStateChange,
+    onNavigate
+  } = options;
+  let container;
+  if (typeof containerOption === "string") {
+    const el = document.querySelector(containerOption);
+    if (!el) {
+      throw new Error(`Container not found: ${containerOption}`);
+    }
+    container = el;
+  } else {
+    container = containerOption;
+  }
+  if (shouldInjectTailwind) {
+    const { initServlyTailwind: initServlyTailwind2 } = await Promise.resolve().then(() => (init_tailwind(), tailwind_exports));
+    await initServlyTailwind2(tailwindConfig);
+  }
+  const activeRenders = [];
+  return {
+    render: (elements, context = { props: {} }) => {
+      const result = render({
+        container,
+        elements,
+        context,
+        enableStateManager: true,
+        initialState,
+        onStateChange,
+        onNavigate
+      });
+      activeRenders.push(result);
+      return result;
+    },
+    renderNode: (elements, nodeId, context = { props: {} }) => {
+      const result = renderNode({
+        container,
+        elements,
+        nodeId,
+        context
+      });
+      if (result) {
+        activeRenders.push(result);
+      }
+      return result;
+    },
+    renderDynamicList,
+    destroy: () => {
+      for (const result of activeRenders) {
+        result.destroy();
+      }
+      activeRenders.length = 0;
+      container.innerHTML = "";
+    }
+  };
+}
+function createViewsMap(views) {
+  const viewsMap = /* @__PURE__ */ new Map();
+  for (const view of views) {
+    const id = view.id || view._id;
+    if (id && view.layout) {
+      viewsMap.set(id, {
+        id,
+        layout: view.layout,
+        props: view.props
+      });
+    }
+  }
+  return viewsMap;
+}
+function extractReferencedViewIds(elements) {
+  const viewIds = /* @__PURE__ */ new Set();
+  for (const element of elements) {
+    if (element.isComponentView && element.componentId) {
+      viewIds.add(element.componentId);
+    }
+    if (element.configuration?.componentViewRef) {
+      viewIds.add(element.configuration.componentViewRef);
+    }
+    const bindings = element.configuration?.bindings?.inputs;
+    if (bindings) {
+      for (const binding of Object.values(bindings)) {
+        if (binding && typeof binding === "object") {
+          if (binding.source === "node" && binding.binding?.viewId) {
+            viewIds.add(binding.binding.viewId);
+          }
+          if (binding.viewId) {
+            viewIds.add(binding.viewId);
+          }
+        }
+      }
+    }
+  }
+  return Array.from(viewIds);
+}
+function collectAllViewDependencies(views, startViewId) {
+  const collected = /* @__PURE__ */ new Set();
+  const toProcess = [startViewId];
+  while (toProcess.length > 0) {
+    const viewId = toProcess.pop();
+    if (collected.has(viewId)) continue;
+    collected.add(viewId);
+    const view = views.get(viewId);
+    if (!view) continue;
+    const referencedIds = extractReferencedViewIds(view.layout);
+    for (const refId of referencedIds) {
+      if (!collected.has(refId)) {
+        toProcess.push(refId);
+      }
+    }
+  }
+  return collected;
+}
 
-// src/cache.ts
+// packages/runtime-core/src/cache.ts
 var DEFAULT_CACHE_CONFIG = {
   maxEntries: 50,
   ttl: 5 * 60 * 1e3,
@@ -1791,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,
@@ -1819,6 +4400,18 @@ function calculateBackoffDelay(retryCount, config) {
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
+function buildViewsMap(views) {
+  if (!views || views.length === 0) return void 0;
+  const viewsMap = /* @__PURE__ */ new Map();
+  for (const view of views) {
+    viewsMap.set(view.id, {
+      id: view.id,
+      layout: view.layout,
+      props: view.props
+    });
+  }
+  return viewsMap;
+}
 async function resolveVersionFromApi(id, specifier, apiKey) {
   if (/^\d+\.\d+\.\d+$/.test(specifier)) {
     return specifier;
@@ -1848,7 +4441,7 @@ async function resolveVersionFromApi(id, specifier, apiKey) {
     return "latest";
   }
 }
-async function fetchFromRegistry(id, version, apiKey, includeBundle) {
+async function fetchFromRegistry(id, version, apiKey, includeBundle, includeViews) {
   const baseUrl = getRegistryUrl();
   const headers = {
     "Content-Type": "application/json"
@@ -1867,6 +4460,9 @@ async function fetchFromRegistry(id, version, apiKey, includeBundle) {
   if (includeBundle) {
     url += (url.includes("?") ? "&" : "?") + "bundle=true";
   }
+  if (includeViews) {
+    url += (url.includes("?") ? "&" : "?") + "includeViews=true";
+  }
   const response = await fetch(url, { headers });
   if (!response.ok) {
     if (response.status === 404) {
@@ -1900,7 +4496,9 @@ async function fetchComponent(id, options = {}) {
     forceRefresh = false,
     signal,
     bundleStrategy = "eager",
-    includeBundle = true
+    includeBundle = true,
+    includeViews = true
+    // Default to true - fetch all views needed
   } = options;
   const fullRetryConfig = {
     ...DEFAULT_RETRY_CONFIG,
@@ -1914,6 +4512,7 @@ async function fetchComponent(id, options = {}) {
       if (cached.bundle) {
         registry = buildRegistryFromBundle(cached);
       }
+      const views = buildViewsMap(cached.views);
       const duration = performance.now() - startTime;
       analytics.trackFetch(id, cached.version, duration, true, {
         cacheHit: true,
@@ -1923,7 +4522,8 @@ async function fetchComponent(id, options = {}) {
         data: cached,
         fromCache: true,
         version: cached.version,
-        registry
+        registry,
+        views
       };
     }
   }
@@ -1935,11 +4535,13 @@ async function fetchComponent(id, options = {}) {
       if (cached.bundle) {
         registry = buildRegistryFromBundle(cached);
       }
+      const views = buildViewsMap(cached.views);
       return {
         data: cached,
         fromCache: true,
         version: resolvedVersion,
-        registry
+        registry,
+        views
       };
     }
   }
@@ -1950,7 +4552,7 @@ async function fetchComponent(id, options = {}) {
       throw new Error("Fetch aborted");
     }
     try {
-      const data = await fetchFromRegistry(id, resolvedVersion, apiKey, shouldIncludeBundle);
+      const data = await fetchFromRegistry(id, resolvedVersion, apiKey, shouldIncludeBundle, includeViews);
       setInCache(id, resolvedVersion, data, cacheStrategy, cacheConfig);
       if (version !== resolvedVersion) {
         setInCache(id, version, data, cacheStrategy, cacheConfig);
@@ -1965,6 +4567,7 @@ async function fetchComponent(id, options = {}) {
           version: entry.resolved || entry.version
         }));
       }
+      const views = buildViewsMap(data.views);
       const duration = performance.now() - startTime;
       analytics.trackFetch(id, resolvedVersion, duration, false, {
         cacheHit: false,
@@ -1976,7 +4579,8 @@ async function fetchComponent(id, options = {}) {
         fromCache: false,
         version: resolvedVersion,
         registry,
-        pendingDependencies
+        pendingDependencies,
+        views
       };
     } catch (error) {
       lastError = error instanceof Error ? error : new Error(String(error));
@@ -1998,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) => {
@@ -2104,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;
@@ -2216,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 = [];
@@ -2347,13 +4951,13 @@ function validateAssertion(container, assertion) {
           message: `Element "${assertion.selector}" not found`
         };
       }
-      const hasClass = elements[0].classList.contains(assertion.expected);
+      const hasClass2 = elements[0].classList.contains(assertion.expected);
       return {
         assertion,
-        passed: hasClass,
+        passed: hasClass2,
         actual: Array.from(elements[0].classList),
         expected: assertion.expected,
-        message: hasClass ? `Element has class "${assertion.expected}"` : `Element does not have class "${assertion.expected}"`
+        message: hasClass2 ? `Element has class "${assertion.expected}"` : `Element does not have class "${assertion.expected}"`
       };
     case "style":
       if (elements.length === 0) {
@@ -2470,13 +5074,161 @@ 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,
+  DEFAULT_SERVLY_TAILWIND_CONFIG,
+  EVENT_HANDLERS,
+  EventSystem,
   LongTaskObserver,
   MemorySampler,
+  OverrideSystem,
   SessionManager,
+  StateManager,
+  addClass,
+  addCustomStyles,
   analytics,
   applyStyles,
   batchFetchComponents,
@@ -2486,43 +5238,96 @@ export {
   bumpVersion,
   camelToKebab,
   clearAllCaches,
+  clearIconCache,
   clearLocalStorageCache,
   clearMemoryCache,
   clearStyles,
   collectAllDependencies,
+  collectAllViewDependencies,
   compareVersions,
   configureAnalytics,
+  createIconSVG,
+  createPlaceholderIcon,
   createRegistry,
+  createServlyRenderer,
+  createViewsMap,
+  deepMerge,
+  deleteValueByPath,
   detectCircularDependencies,
   extractBindingKeys,
   extractDependencies,
   extractDependenciesFromCode,
+  extractIconFromReactIcons,
+  extractIconsForLayout,
+  extractOverrideDependencies,
+  extractReferencedViewIds,
   fetchComponent,
   fetchComponentWithDependencies,
+  findIconsInLayout,
   formatStyleValue,
   formatVersion,
+  generateIconBundle,
   generateTestCases,
   getAnalytics,
   getCacheKey,
+  getCleanupOverrides,
   getDependencyTree,
+  getEventSystem,
   getFromCache,
+  getIconData,
+  getIconDataSync,
+  getIconifyCollection,
+  getLocalStorage,
   getLongTaskObserver,
   getMemoryCacheSize,
   getMemorySampler,
+  getMountOverrides,
+  getOverrideSystem,
+  getRegisteredIconKeys,
   getRegistryUrl,
   getSessionManager,
+  getSessionStorage,
+  getSupportedIconSets,
+  getTailwind,
+  getUrlInfo,
+  getValueByPath,
+  goBack,
+  goForward,
+  hasClass,
+  hasDependencyOverrides,
+  hasOverrides,
   hasTemplateSyntax,
+  initServlyTailwind,
+  injectTailwind,
   invalidateCache,
   isComponentAvailable,
+  isIconCdnEnabled,
+  isIconRegistered,
+  isIconSetSupported,
+  isTailwindLoaded,
   isValidSpecifier,
+  navigateTo,
   parseVersion,
   prefetchComponents,
+  preloadIcons,
   processStyles,
+  registerIcon,
+  registerIcons,
+  removeClass,
+  removeCustomStyles,
+  removeLocalStorage,
+  removeSessionStorage,
+  removeTailwind,
   render,
   renderDynamicList,
+  renderIcon,
+  renderInShadow,
+  renderNode,
   resetAnalytics,
+  resetEventSystem,
   resetLongTaskObserver,
   resetMemorySampler,
+  resetOverrideSystem,
   resetSessionManager,
   resolveBindingPath,
   resolveTemplate,
@@ -2532,9 +5337,17 @@ export {
   runAllTests,
   runTestCase,
   satisfiesVersion,
+  setIconCdnEnabled,
   setInCache,
+  setLocalStorage,
   setRegistryUrl,
+  setSessionStorage,
+  setValueByPath,
+  toDomEventName,
+  toReactEventName,
+  toggleClass,
   updateStyles,
+  updateTailwindConfig,
   validateAssertion,
   validateProps
-};
+});