@servlyadmin/runtime-core 0.1.9 → 0.1.10

package/dist/index.mjs

@@ -1,4849 +0,0 @@
-import {
-  DEFAULT_SERVLY_TAILWIND_CONFIG,
-  addCustomStyles,
-  getTailwind,
-  initServlyTailwind,
-  injectTailwind,
-  isTailwindLoaded,
-  removeCustomStyles,
-  removeTailwind,
-  updateTailwindConfig
-} from "./chunk-RKUT63EF.mjs";
-import {
-  buildRegistryFromBundle,
-  collectAllDependencies,
-  createRegistry,
-  detectCircularDependencies,
-  extractDependencies,
-  extractDependenciesFromCode
-} from "./chunk-EQFZFPI7.mjs";
-
-// packages/runtime-core/src/analyticsTypes.ts
-var DEFAULT_ANALYTICS_CONFIG = {
-  enabled: true,
-  endpoint: "/api/v1/analytics/events",
-  batchSize: 50,
-  flushInterval: 3e4,
-  // 30 seconds
-  sampleRate: 1,
-  environment: "production",
-  debug: false
-};
-var MAX_ERROR_MESSAGE_LENGTH = 1e3;
-var MAX_STACK_TRACE_LENGTH = 500;
-var MAX_QUEUE_SIZE = 500;
-var MAX_RETRY_ATTEMPTS = 3;
-var SESSION_TIMEOUT_MS = 30 * 60 * 1e3;
-var SDK_VERSION = "1.0.0";
-
-// packages/runtime-core/src/sessionManager.ts
-var SESSION_STORAGE_KEY = "servly_analytics_session";
-function generateUUID() {
-  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
-    return crypto.randomUUID();
-  }
-  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
-    const r = Math.random() * 16 | 0;
-    const v = c === "x" ? r : r & 3 | 8;
-    return v.toString(16);
-  });
-}
-function isSessionStorageAvailable() {
-  try {
-    if (typeof sessionStorage === "undefined") {
-      return false;
-    }
-    const testKey = "__servly_test__";
-    sessionStorage.setItem(testKey, "test");
-    sessionStorage.removeItem(testKey);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function loadSession() {
-  if (!isSessionStorageAvailable()) {
-    return null;
-  }
-  try {
-    const stored = sessionStorage.getItem(SESSION_STORAGE_KEY);
-    if (!stored) {
-      return null;
-    }
-    return JSON.parse(stored);
-  } catch {
-    return null;
-  }
-}
-function saveSession(session) {
-  if (!isSessionStorageAvailable()) {
-    return;
-  }
-  try {
-    sessionStorage.setItem(SESSION_STORAGE_KEY, JSON.stringify(session));
-  } catch {
-  }
-}
-function clearSession() {
-  if (!isSessionStorageAvailable()) {
-    return;
-  }
-  try {
-    sessionStorage.removeItem(SESSION_STORAGE_KEY);
-  } catch {
-  }
-}
-function isSessionExpired(session) {
-  const now = Date.now();
-  return now - session.lastActivityAt > SESSION_TIMEOUT_MS;
-}
-var SessionManager = class {
-  session = null;
-  constructor() {
-    this.initialize();
-  }
-  /**
-   * Initialize session manager
-   */
-  initialize() {
-    const stored = loadSession();
-    if (stored && !isSessionExpired(stored)) {
-      this.session = stored;
-      this.touch();
-    } else {
-      this.createNewSession();
-    }
-  }
-  /**
-   * Create a new session
-   */
-  createNewSession() {
-    const now = Date.now();
-    this.session = {
-      id: generateUUID(),
-      createdAt: now,
-      lastActivityAt: now
-    };
-    saveSession(this.session);
-  }
-  /**
-   * Get current session ID
-   * Creates new session if expired
-   */
-  getSessionId() {
-    if (!this.session || isSessionExpired(this.session)) {
-      this.createNewSession();
-    }
-    return this.session.id;
-  }
-  /**
-   * Update last activity timestamp
-   */
-  touch() {
-    if (this.session) {
-      this.session.lastActivityAt = Date.now();
-      saveSession(this.session);
-    }
-  }
-  /**
-   * Force create a new session
-   */
-  rotate() {
-    this.createNewSession();
-  }
-  /**
-   * Clear current session
-   */
-  clear() {
-    this.session = null;
-    clearSession();
-  }
-  /**
-   * Get session info (for debugging)
-   */
-  getSessionInfo() {
-    return this.session ? { ...this.session } : null;
-  }
-};
-var sessionManagerInstance = null;
-function getSessionManager() {
-  if (!sessionManagerInstance) {
-    sessionManagerInstance = new SessionManager();
-  }
-  return sessionManagerInstance;
-}
-function resetSessionManager() {
-  if (sessionManagerInstance) {
-    sessionManagerInstance.clear();
-  }
-  sessionManagerInstance = null;
-}
-
-// packages/runtime-core/src/analytics.ts
-var AnalyticsCollector = class {
-  config;
-  eventQueue = [];
-  flushTimer = null;
-  isEnabled;
-  isFlushing = false;
-  retryDelay = 1e3;
-  constructor(config) {
-    this.config = { ...DEFAULT_ANALYTICS_CONFIG, ...config };
-    this.isEnabled = this.config.enabled;
-    this.startFlushTimer();
-  }
-  // ============================================
-  // Configuration
-  // ============================================
-  /**
-   * Configure analytics
-   */
-  configure(config) {
-    this.config = { ...this.config, ...config };
-    this.isEnabled = this.config.enabled;
-    this.stopFlushTimer();
-    if (this.isEnabled) {
-      this.startFlushTimer();
-    }
-  }
-  /**
-   * Disable analytics collection
-   */
-  disable() {
-    this.isEnabled = false;
-    this.stopFlushTimer();
-    this.eventQueue = [];
-  }
-  /**
-   * Enable analytics collection
-   */
-  enable() {
-    this.isEnabled = true;
-    this.startFlushTimer();
-  }
-  /**
-   * Destroy and cleanup
-   */
-  destroy() {
-    this.disable();
-  }
-  // ============================================
-  // Event Tracking
-  // ============================================
-  /**
-   * Track component render
-   */
-  trackRender(componentId, version, duration, metadata) {
-    if (!this.shouldTrack()) {
-      return;
-    }
-    const event = {
-      type: "render",
-      componentId,
-      version,
-      timestamp: Date.now(),
-      sessionId: getSessionManager().getSessionId(),
-      appId: this.config.appId,
-      duration: Math.round(duration),
-      metadata
-    };
-    this.queueEvent(event);
-  }
-  /**
-   * Track component fetch
-   */
-  trackFetch(componentId, version, duration, fromCache, metadata) {
-    if (!this.shouldTrack()) {
-      return;
-    }
-    const event = {
-      type: "fetch",
-      componentId,
-      version,
-      timestamp: Date.now(),
-      sessionId: getSessionManager().getSessionId(),
-      appId: this.config.appId,
-      duration: Math.round(duration),
-      metadata: {
-        cacheHit: fromCache,
-        fetchDuration: Math.round(duration),
-        ...metadata
-      }
-    };
-    this.queueEvent(event);
-  }
-  /**
-   * Track error
-   */
-  trackError(componentId, version, error, context) {
-    if (!this.shouldTrack()) {
-      return;
-    }
-    const errorMessage = this.truncateString(
-      error.message || "Unknown error",
-      MAX_ERROR_MESSAGE_LENGTH
-    );
-    const stackTrace = error.stack ? this.truncateString(error.stack, MAX_STACK_TRACE_LENGTH) : void 0;
-    const event = {
-      type: "error",
-      componentId,
-      version,
-      timestamp: Date.now(),
-      sessionId: getSessionManager().getSessionId(),
-      appId: this.config.appId,
-      metadata: {
-        errorType: context?.errorType || "render",
-        errorMessage,
-        stackTrace,
-        bindingPath: context?.bindingPath,
-        elementId: context?.elementId
-      }
-    };
-    this.queueEvent(event);
-  }
-  // ============================================
-  // Queue Management
-  // ============================================
-  /**
-   * Check if event should be tracked (sampling + enabled)
-   */
-  shouldTrack() {
-    if (!this.isEnabled) {
-      return false;
-    }
-    if (this.config.sampleRate < 1) {
-      return Math.random() < this.config.sampleRate;
-    }
-    return true;
-  }
-  /**
-   * Add event to queue
-   */
-  queueEvent(event) {
-    if (this.eventQueue.length >= MAX_QUEUE_SIZE) {
-      this.eventQueue.shift();
-      this.log("Queue full, dropping oldest event");
-    }
-    this.eventQueue.push({
-      event,
-      retryCount: 0,
-      addedAt: Date.now()
-    });
-    if (this.eventQueue.length >= this.config.batchSize) {
-      this.flush();
-    }
-  }
-  /**
-   * Get current queue size
-   */
-  getQueueSize() {
-    return this.eventQueue.length;
-  }
-  // ============================================
-  // Flush Logic
-  // ============================================
-  /**
-   * Start the flush timer
-   */
-  startFlushTimer() {
-    if (this.flushTimer) {
-      return;
-    }
-    this.flushTimer = setInterval(() => {
-      this.flush();
-    }, this.config.flushInterval);
-  }
-  /**
-   * Stop the flush timer
-   */
-  stopFlushTimer() {
-    if (this.flushTimer) {
-      clearInterval(this.flushTimer);
-      this.flushTimer = null;
-    }
-  }
-  /**
-   * Flush events to server
-   */
-  async flush() {
-    if (this.isFlushing || this.eventQueue.length === 0) {
-      return;
-    }
-    this.isFlushing = true;
-    if (typeof requestIdleCallback !== "undefined") {
-      requestIdleCallback(
-        () => {
-          this.doFlush();
-        },
-        { timeout: 5e3 }
-      );
-    } else {
-      setTimeout(() => {
-        this.doFlush();
-      }, 0);
-    }
-  }
-  /**
-   * Perform the actual flush
-   */
-  async doFlush() {
-    const eventsToSend = this.eventQueue.splice(0, this.config.batchSize);
-    if (eventsToSend.length === 0) {
-      this.isFlushing = false;
-      return;
-    }
-    const request = {
-      events: eventsToSend.map((q) => q.event),
-      clientInfo: {
-        sdkVersion: SDK_VERSION,
-        environment: this.config.environment
-      }
-    };
-    try {
-      const response = await this.sendEvents(request);
-      if (response.success) {
-        this.log(`Flushed ${response.accepted} events`);
-        this.retryDelay = 1e3;
-      } else {
-        this.handleFailedEvents(eventsToSend, response);
-      }
-    } catch (error) {
-      this.handleNetworkError(eventsToSend, error);
-    } finally {
-      this.isFlushing = false;
-    }
-  }
-  /**
-   * Send events to the API
-   */
-  async sendEvents(request) {
-    const headers = {
-      "Content-Type": "application/json"
-    };
-    if (this.config.apiKey) {
-      headers["Authorization"] = `Bearer ${this.config.apiKey}`;
-    }
-    const response = await fetch(this.config.endpoint, {
-      method: "POST",
-      headers,
-      body: JSON.stringify(request)
-    });
-    if (response.status === 429) {
-      const retryAfter = parseInt(response.headers.get("Retry-After") || "60", 10);
-      return {
-        success: false,
-        accepted: 0,
-        rejected: request.events.length,
-        retryAfter
-      };
-    }
-    if (!response.ok) {
-      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-    }
-    return await response.json();
-  }
-  /**
-   * Handle failed events (partial success)
-   */
-  handleFailedEvents(events, response) {
-    const eventsToRetry = events.filter((e) => e.retryCount < MAX_RETRY_ATTEMPTS);
-    eventsToRetry.forEach((e) => {
-      e.retryCount++;
-      this.eventQueue.unshift(e);
-    });
-    const dropped = events.length - eventsToRetry.length;
-    if (dropped > 0) {
-      this.log(`Dropped ${dropped} events after max retries`);
-    }
-    if (response.retryAfter) {
-      this.scheduleRetry(response.retryAfter * 1e3);
-    }
-  }
-  /**
-   * Handle network error
-   */
-  handleNetworkError(events, error) {
-    this.log(`Network error: ${error}`);
-    const eventsToRetry = events.filter((e) => e.retryCount < MAX_RETRY_ATTEMPTS);
-    eventsToRetry.forEach((e) => {
-      e.retryCount++;
-      this.eventQueue.unshift(e);
-    });
-    this.scheduleRetry(this.retryDelay);
-    this.retryDelay = Math.min(this.retryDelay * 2, 3e4);
-  }
-  /**
-   * Schedule a retry flush
-   */
-  scheduleRetry(delayMs) {
-    setTimeout(() => {
-      this.flush();
-    }, delayMs);
-  }
-  // ============================================
-  // Utilities
-  // ============================================
-  /**
-   * Truncate string to max length
-   */
-  truncateString(str, maxLength) {
-    if (str.length <= maxLength) {
-      return str;
-    }
-    return str.substring(0, maxLength - 3) + "...";
-  }
-  /**
-   * Log debug message
-   */
-  log(message) {
-    if (this.config.debug) {
-      console.log(`[Analytics] ${message}`);
-    }
-  }
-};
-var analyticsInstance = null;
-function getAnalytics() {
-  if (!analyticsInstance) {
-    analyticsInstance = new AnalyticsCollector();
-  }
-  return analyticsInstance;
-}
-function configureAnalytics(config) {
-  getAnalytics().configure(config);
-}
-function resetAnalytics() {
-  if (analyticsInstance) {
-    analyticsInstance.destroy();
-  }
-  analyticsInstance = null;
-}
-var analytics = {
-  get instance() {
-    return getAnalytics();
-  },
-  configure: configureAnalytics,
-  trackRender: (componentId, version, duration, metadata) => getAnalytics().trackRender(componentId, version, duration, metadata),
-  trackFetch: (componentId, version, duration, fromCache, metadata) => getAnalytics().trackFetch(componentId, version, duration, fromCache, metadata),
-  trackError: (componentId, version, error, context) => getAnalytics().trackError(componentId, version, error, context),
-  flush: () => getAnalytics().flush(),
-  disable: () => getAnalytics().disable(),
-  enable: () => getAnalytics().enable()
-};
-
-// packages/runtime-core/src/bindings.ts
-var BINDING_SOURCES = [
-  "props",
-  "state",
-  "appState",
-  "context",
-  "input",
-  "currentItem",
-  "localStore",
-  "localStorage",
-  "sessionStorage",
-  "config",
-  "element",
-  "self",
-  "params",
-  "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(".");
-  if (parts.length === 0) {
-    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" || 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" || 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;
-  } else {
-    source = context.props;
-    startIndex = 0;
-  }
-  if (!source) {
-    return void 0;
-  }
-  return navigatePath(source, parts.slice(startIndex));
-}
-function resolveExpression(expression, context) {
-  const trimmed = expression.trim();
-  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 (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;
-      }
-    }
-  }
-  if (trimmed.includes("&&")) {
-    const parts = trimmed.split("&&");
-    for (const part of parts) {
-      const value = resolveExpression(part.trim(), context);
-      if (!value) return value;
-    }
-    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) {
-  if (value.startsWith("'") && value.endsWith("'") || value.startsWith('"') && value.endsWith('"')) {
-    return value.slice(1, -1);
-  }
-  if (!isNaN(Number(value))) {
-    return Number(value);
-  }
-  if (value === "true") return true;
-  if (value === "false") return false;
-  if (value === "null") return null;
-  if (value === "undefined") return void 0;
-  return resolveExpression(value, context);
-}
-function resolveTemplate(template, context, componentId) {
-  if (!template || typeof template !== "string") {
-    return template;
-  }
-  if (!hasTemplateSyntax(template)) {
-    return template;
-  }
-  try {
-    const singleMatch = template.match(/^\{\{([^}]+)\}\}$/);
-    if (singleMatch) {
-      const value = resolveExpression(singleMatch[1], context);
-      if (value === void 0 || value === null) {
-        return "";
-      }
-      return String(value);
-    }
-    return template.replace(TEMPLATE_REGEX, (_match, expression) => {
-      const value = resolveExpression(expression, context);
-      if (value === void 0 || value === null) {
-        return "";
-      }
-      if (typeof value === "object") {
-        return JSON.stringify(value);
-      }
-      return String(value);
-    });
-  } catch (error) {
-    if (componentId) {
-      analytics.trackError(componentId, "latest", error, {
-        errorType: "binding",
-        bindingPath: template
-      });
-    }
-    return "";
-  }
-}
-function resolveTemplateValue(template, context, componentId) {
-  if (!template || typeof template !== "string") {
-    return template;
-  }
-  if (!hasTemplateSyntax(template)) {
-    return template;
-  }
-  try {
-    const singleMatch = template.match(/^\{\{([^}]+)\}\}$/);
-    if (singleMatch) {
-      return resolveExpression(singleMatch[1], context);
-    }
-    return resolveTemplate(template, context, componentId);
-  } catch (error) {
-    if (componentId) {
-      analytics.trackError(componentId, "latest", error, {
-        errorType: "binding",
-        bindingPath: template
-      });
-    }
-    return void 0;
-  }
-}
-function isPlainObject(value) {
-  return Object.prototype.toString.call(value) === "[object Object]";
-}
-function resolveTemplatesDeep(input, context) {
-  if (typeof input === "string") {
-    return resolveTemplateValue(input, context);
-  }
-  if (Array.isArray(input)) {
-    let changed = false;
-    const result = input.map((item) => {
-      const resolved = resolveTemplatesDeep(item, context);
-      if (resolved !== item) {
-        changed = true;
-      }
-      return resolved;
-    });
-    return changed ? result : input;
-  }
-  if (input && typeof input === "object") {
-    if (!isPlainObject(input)) {
-      return input;
-    }
-    let mutable = null;
-    const original = input;
-    for (const key of Object.keys(original)) {
-      const current = original[key];
-      const resolved = resolveTemplatesDeep(current, context);
-      if (resolved !== current) {
-        const target = mutable ?? (mutable = { ...original });
-        target[key] = resolved;
-      }
-    }
-    return mutable ?? input;
-  }
-  return input;
-}
-function extractBindingKeys(template) {
-  if (!template || typeof template !== "string") {
-    return [];
-  }
-  const keys = /* @__PURE__ */ new Set();
-  const matches = template.matchAll(TEMPLATE_REGEX);
-  for (const match of matches) {
-    const expression = match[1].trim();
-    const pathMatch = expression.match(/^([a-zA-Z_][a-zA-Z0-9_.]*)/);
-    if (pathMatch) {
-      const parts = pathMatch[1].split(".");
-      if (parts.length > 1 && BINDING_SOURCES.includes(parts[0].toLowerCase())) {
-        keys.add(parts[parts.length - 1]);
-      } else {
-        keys.add(parts[0]);
-      }
-    }
-  }
-  return Array.from(keys);
-}
-
-// packages/runtime-core/src/styles.ts
-var UNITLESS_PROPERTIES = /* @__PURE__ */ new Set([
-  "animationIterationCount",
-  "borderImageOutset",
-  "borderImageSlice",
-  "borderImageWidth",
-  "boxFlex",
-  "boxFlexGroup",
-  "boxOrdinalGroup",
-  "columnCount",
-  "columns",
-  "flex",
-  "flexGrow",
-  "flexPositive",
-  "flexShrink",
-  "flexNegative",
-  "flexOrder",
-  "gridRow",
-  "gridRowEnd",
-  "gridRowSpan",
-  "gridRowStart",
-  "gridColumn",
-  "gridColumnEnd",
-  "gridColumnSpan",
-  "gridColumnStart",
-  "fontWeight",
-  "lineClamp",
-  "lineHeight",
-  "opacity",
-  "order",
-  "orphans",
-  "tabSize",
-  "widows",
-  "zIndex",
-  "zoom",
-  "fillOpacity",
-  "floodOpacity",
-  "stopOpacity",
-  "strokeDasharray",
-  "strokeDashoffset",
-  "strokeMiterlimit",
-  "strokeOpacity",
-  "strokeWidth"
-]);
-function camelToKebab(str) {
-  return str.replace(/([A-Z])/g, "-$1").toLowerCase();
-}
-function needsUnits(property) {
-  if (property.startsWith("--")) {
-    return false;
-  }
-  return !UNITLESS_PROPERTIES.has(property);
-}
-function formatStyleValue(property, value) {
-  if (value === null || value === void 0) {
-    return "";
-  }
-  if (typeof value === "number" && needsUnits(property)) {
-    return `${value}px`;
-  }
-  return String(value);
-}
-function processStyles(style, context) {
-  if (!style || Object.keys(style).length === 0) {
-    return {};
-  }
-  const processed = {};
-  for (const [key, value] of Object.entries(style)) {
-    if (value === void 0 || value === null || value === "") {
-      continue;
-    }
-    let resolvedValue = value;
-    if (typeof value === "string" && hasTemplateSyntax(value)) {
-      resolvedValue = resolveTemplate(value, context);
-    }
-    if (resolvedValue === void 0 || resolvedValue === null || resolvedValue === "") {
-      continue;
-    }
-    const formattedValue = formatStyleValue(key, resolvedValue);
-    if (formattedValue) {
-      processed[key] = formattedValue;
-    }
-  }
-  return processed;
-}
-function applyStyles(element, styles) {
-  for (const [property, value] of Object.entries(styles)) {
-    if (property.startsWith("--")) {
-      element.style.setProperty(property, value);
-    } else {
-      element.style[property] = value;
-    }
-  }
-}
-var CANVAS_ONLY_STYLES = /* @__PURE__ */ new Set([
-  "transform",
-  "--translate-x",
-  "--translate-y",
-  "--width",
-  "--height",
-  "z-index",
-  "zIndex"
-]);
-function filterCanvasStyles(style) {
-  const filtered = {};
-  for (const [key, value] of Object.entries(style)) {
-    if (CANVAS_ONLY_STYLES.has(key)) {
-      continue;
-    }
-    if (key === "transform" && typeof value === "string" && value.includes("translate(")) {
-      continue;
-    }
-    filtered[key] = value;
-  }
-  return filtered;
-}
-function buildElementStyles(element, context) {
-  const config = element.configuration || {};
-  const combined = {};
-  if (element.style) {
-    Object.assign(combined, filterCanvasStyles(element.style));
-  }
-  if (config.style) {
-    Object.assign(combined, filterCanvasStyles(config.style));
-  }
-  if (config.cssVariables) {
-    Object.assign(combined, filterCanvasStyles(config.cssVariables));
-  }
-  return processStyles(combined, context);
-}
-function buildClassName(element, context) {
-  const config = element.configuration || {};
-  const classes = [];
-  if (element.className) {
-    classes.push(element.className);
-  }
-  if (config.className) {
-    const resolved = hasTemplateSyntax(config.className) ? resolveTemplate(config.className, context) : config.className;
-    if (resolved) classes.push(resolved);
-  }
-  if (config.classNames) {
-    const resolved = hasTemplateSyntax(config.classNames) ? resolveTemplate(config.classNames, context) : config.classNames;
-    if (resolved) classes.push(resolved);
-  }
-  if (config.dynamicClassName) {
-    const resolved = resolveTemplate(config.dynamicClassName, context);
-    if (resolved) classes.push(resolved);
-  }
-  return classes.filter(Boolean).join(" ").trim();
-}
-function clearStyles(element) {
-  element.removeAttribute("style");
-}
-function updateStyles(element, oldStyles, newStyles) {
-  for (const property of Object.keys(oldStyles)) {
-    if (!(property in newStyles)) {
-      if (property.startsWith("--")) {
-        element.style.removeProperty(property);
-      } else {
-        element.style[property] = "";
-      }
-    }
-  }
-  for (const [property, value] of Object.entries(newStyles)) {
-    if (oldStyles[property] !== value) {
-      if (property.startsWith("--")) {
-        element.style.setProperty(property, value);
-      } else {
-        element.style[property] = value;
-      }
-    }
-  }
-}
-
-// packages/runtime-core/src/memorySampler.ts
-var MemorySampler = class {
-  isSupported;
-  constructor() {
-    this.isSupported = this.checkSupport();
-  }
-  /**
-   * Check if memory API is available
-   */
-  checkSupport() {
-    if (typeof performance === "undefined") {
-      return false;
-    }
-    const perf = performance;
-    return typeof perf.memory !== "undefined";
-  }
-  /**
-   * Check if memory sampling is available
-   */
-  isAvailable() {
-    return this.isSupported;
-  }
-  /**
-   * Take a memory sample
-   * Returns null if memory API is not available
-   */
-  sample() {
-    if (!this.isSupported) {
-      return null;
-    }
-    const perf = performance;
-    if (!perf.memory) {
-      return null;
-    }
-    return {
-      heapUsedKB: Math.round(perf.memory.usedJSHeapSize / 1024),
-      heapTotalKB: Math.round(perf.memory.totalJSHeapSize / 1024),
-      timestamp: Date.now()
-    };
-  }
-  /**
-   * Calculate heap delta between two samples
-   * Returns the difference in KB (positive = memory increased)
-   */
-  calculateDelta(before, after) {
-    if (!before || !after) {
-      return null;
-    }
-    return after.heapUsedKB - before.heapUsedKB;
-  }
-};
-var memorySamplerInstance = null;
-function getMemorySampler() {
-  if (!memorySamplerInstance) {
-    memorySamplerInstance = new MemorySampler();
-  }
-  return memorySamplerInstance;
-}
-function resetMemorySampler() {
-  memorySamplerInstance = null;
-}
-
-// packages/runtime-core/src/longTaskObserver.ts
-var LongTaskObserver = class {
-  observer = null;
-  longTaskCount = 0;
-  isSupported;
-  isObserving = false;
-  constructor() {
-    this.isSupported = this.checkSupport();
-  }
-  /**
-   * Check if PerformanceObserver with longtask support is available
-   */
-  checkSupport() {
-    if (typeof PerformanceObserver === "undefined") {
-      return false;
-    }
-    try {
-      const supportedTypes = PerformanceObserver.supportedEntryTypes;
-      return Array.isArray(supportedTypes) && supportedTypes.includes("longtask");
-    } catch {
-      return false;
-    }
-  }
-  /**
-   * Check if long task observation is available
-   */
-  isAvailable() {
-    return this.isSupported;
-  }
-  /**
-   * Start observing long tasks
-   */
-  start() {
-    if (!this.isSupported || this.isObserving) {
-      return;
-    }
-    this.longTaskCount = 0;
-    try {
-      this.observer = new PerformanceObserver((list) => {
-        const entries = list.getEntries();
-        this.longTaskCount += entries.length;
-      });
-      this.observer.observe({ entryTypes: ["longtask"] });
-      this.isObserving = true;
-    } catch {
-      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 {
-    }
-    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;
-    }
-    const viewBox = svg.getAttribute("viewBox");
-    const width = parseInt(svg.getAttribute("width") || "24", 10);
-    const height = parseInt(svg.getAttribute("height") || "24", 10);
-    const body = svg.innerHTML;
-    return {
-      body,
-      width,
-      height,
-      viewBox: viewBox || `0 0 ${width} ${height}`
-    };
-  } catch {
-    return null;
-  }
-}
-async function getIconData(icon) {
-  const key = `${icon.set}:${icon.name}`;
-  if (iconCache.has(key)) {
-    return iconCache.get(key);
-  }
-  if (pendingFetches.has(key)) {
-    return pendingFetches.get(key);
-  }
-  if (!cdnEnabled) {
-    return null;
-  }
-  const fetchPromise = fetchIconFromIconify(icon.set, icon.name);
-  pendingFetches.set(key, fetchPromise);
-  const data = await fetchPromise;
-  pendingFetches.delete(key);
-  if (data) {
-    iconCache.set(key, data);
-  }
-  return data;
-}
-function getIconDataSync(icon) {
-  const key = `${icon.set}:${icon.name}`;
-  return iconCache.get(key) || null;
-}
-function createIconSVG(icon, data, size = 24, color = "currentColor") {
-  const svg = document.createElementNS("http://www.w3.org/2000/svg", "svg");
-  svg.setAttribute("width", String(size));
-  svg.setAttribute("height", String(size));
-  svg.setAttribute("viewBox", data.viewBox || "0 0 24 24");
-  svg.setAttribute("data-icon-name", icon.name);
-  svg.setAttribute("data-icon-set", icon.set);
-  svg.setAttribute("class", `servly-icon servly-icon-${icon.set.toLowerCase()}`);
-  const style = ICON_SET_STYLES[icon.set];
-  if (style?.stroke) {
-    svg.setAttribute("fill", "none");
-    svg.setAttribute("stroke", color);
-    svg.setAttribute("stroke-width", "2");
-    svg.setAttribute("stroke-linecap", "round");
-    svg.setAttribute("stroke-linejoin", "round");
-  } else {
-    svg.setAttribute("fill", color);
-  }
-  svg.innerHTML = data.body;
-  const paths = svg.querySelectorAll("path, circle, rect, polygon, line, polyline");
-  paths.forEach((el) => {
-    if (!el.getAttribute("fill") || el.getAttribute("fill") === "currentColor") {
-      if (style?.stroke) {
-        el.setAttribute("stroke", color);
-      } else {
-        el.setAttribute("fill", color);
-      }
-    }
-  });
-  return svg;
-}
-function createPlaceholderIcon(icon, size = 24, color = "currentColor") {
-  const svg = document.createElementNS("http://www.w3.org/2000/svg", "svg");
-  svg.setAttribute("width", String(size));
-  svg.setAttribute("height", String(size));
-  svg.setAttribute("viewBox", "0 0 24 24");
-  svg.setAttribute("fill", "none");
-  svg.setAttribute("stroke", color);
-  svg.setAttribute("stroke-width", "2");
-  svg.setAttribute("stroke-linecap", "round");
-  svg.setAttribute("stroke-linejoin", "round");
-  svg.setAttribute("data-icon-name", icon.name);
-  svg.setAttribute("data-icon-set", icon.set);
-  svg.setAttribute("data-icon-missing", "true");
-  svg.setAttribute("class", "servly-icon servly-icon-placeholder");
-  const circle = document.createElementNS("http://www.w3.org/2000/svg", "circle");
-  circle.setAttribute("cx", "12");
-  circle.setAttribute("cy", "12");
-  circle.setAttribute("r", "10");
-  const path = document.createElementNS("http://www.w3.org/2000/svg", "path");
-  path.setAttribute("d", "M9.09 9a3 3 0 0 1 5.83 1c0 2-3 3-3 3");
-  const dot = document.createElementNS("http://www.w3.org/2000/svg", "line");
-  dot.setAttribute("x1", "12");
-  dot.setAttribute("y1", "17");
-  dot.setAttribute("x2", "12.01");
-  dot.setAttribute("y2", "17");
-  svg.appendChild(circle);
-  svg.appendChild(path);
-  svg.appendChild(dot);
-  return svg;
-}
-function renderIcon(container, icon, size = 24, color = "currentColor") {
-  const cachedData = getIconDataSync(icon);
-  if (cachedData) {
-    const svg = createIconSVG(icon, cachedData, size, color);
-    container.innerHTML = "";
-    container.appendChild(svg);
-    return;
-  }
-  if (!cdnEnabled) {
-    const placeholder2 = createPlaceholderIcon(icon, size, color);
-    container.innerHTML = "";
-    container.appendChild(placeholder2);
-    console.warn(
-      `[Icons] Icon not bundled: ${icon.set}:${icon.name}. Use registerIcon() to bundle it, or enable CDN with setIconCdnEnabled(true).`
-    );
-    return;
-  }
-  const placeholder = createPlaceholderIcon(icon, size, color);
-  placeholder.setAttribute("data-icon-loading", "true");
-  placeholder.removeAttribute("data-icon-missing");
-  container.innerHTML = "";
-  container.appendChild(placeholder);
-  getIconData(icon).then((data) => {
-    if (data) {
-      const svg = createIconSVG(icon, data, size, color);
-      container.innerHTML = "";
-      container.appendChild(svg);
-    } else {
-      placeholder.setAttribute("data-icon-missing", "true");
-      placeholder.removeAttribute("data-icon-loading");
-    }
-  });
-}
-async function preloadIcons(icons) {
-  await Promise.all(icons.map((icon) => getIconData(icon)));
-}
-function clearIconCache() {
-  iconCache.clear();
-  pendingFetches.clear();
-  registeredIcons.forEach((data, key) => {
-    iconCache.set(key, data);
-  });
-}
-function isIconSetSupported(set) {
-  return set in ICONIFY_COLLECTIONS;
-}
-function getSupportedIconSets() {
-  return Object.keys(ICONIFY_COLLECTIONS);
-}
-function getIconifyCollection(set) {
-  return ICONIFY_COLLECTIONS[set];
-}
-
-// packages/runtime-core/src/renderer.ts
-var COMPONENT_TO_TAG = {
-  container: "div",
-  text: "span",
-  button: "button",
-  input: "input",
-  image: "img",
-  link: "a",
-  form: "form",
-  label: "label",
-  textarea: "textarea",
-  select: "select",
-  option: "option",
-  list: "ul",
-  listItem: "li",
-  heading: "h1",
-  paragraph: "p",
-  section: "section",
-  article: "article",
-  header: "header",
-  footer: "footer",
-  nav: "nav",
-  aside: "aside",
-  main: "main",
-  span: "span",
-  div: "div"
-};
-var SELF_CLOSING_TAGS = /* @__PURE__ */ new Set([
-  "input",
-  "img",
-  "br",
-  "hr",
-  "area",
-  "base",
-  "col",
-  "embed",
-  "link",
-  "meta",
-  "param",
-  "source",
-  "track",
-  "wbr"
-]);
-function getElementTag(element) {
-  const config = element.configuration;
-  if (config?.tag) {
-    return config.tag;
-  }
-  if (element.componentId && COMPONENT_TO_TAG[element.componentId]) {
-    return COMPONENT_TO_TAG[element.componentId];
-  }
-  if (element.isGroup) {
-    return "div";
-  }
-  return "div";
-}
-function isSelfClosing(tag) {
-  return SELF_CLOSING_TAGS.has(tag.toLowerCase());
-}
-function buildTree(elements) {
-  const tree = /* @__PURE__ */ new Map();
-  for (const element of elements) {
-    const parentId = element.parent || null;
-    if (!tree.has(parentId)) {
-      tree.set(parentId, []);
-    }
-    tree.get(parentId).push(element);
-  }
-  return tree;
-}
-function getTextContent(element, context) {
-  const config = element.configuration;
-  if (config?.dynamicText) {
-    return resolveTemplate(config.dynamicText, context);
-  }
-  if (config?.text) {
-    if (hasTemplateSyntax(config.text)) {
-      return resolveTemplate(config.text, context);
-    }
-    return config.text;
-  }
-  return "";
-}
-function applyAttributes(domElement, element, context) {
-  const config = element.configuration || {};
-  const attributeMap = [
-    { key: "id", attr: "id" },
-    { key: "src", dynamicKey: "dynamicSrc", attr: "src" },
-    { key: "alt", attr: "alt" },
-    { key: "href", dynamicKey: "dynamicHref", attr: "href" },
-    { key: "target", attr: "target" },
-    { key: "placeholder", attr: "placeholder" },
-    { key: "type", attr: "type" },
-    { key: "name", attr: "name" },
-    { key: "value", dynamicKey: "dynamicValue", attr: "value" }
-  ];
-  for (const { key, dynamicKey, attr } of attributeMap) {
-    const dynamicValue = dynamicKey ? config[dynamicKey] : void 0;
-    if (dynamicValue !== void 0 && dynamicValue !== null && dynamicValue !== "") {
-      const resolved = resolveTemplate(String(dynamicValue), context);
-      if (resolved) {
-        domElement.setAttribute(attr, resolved);
-      }
-      continue;
-    }
-    const staticValue = config[key];
-    if (staticValue !== void 0 && staticValue !== null && staticValue !== "") {
-      const resolved = hasTemplateSyntax(String(staticValue)) ? resolveTemplate(String(staticValue), context) : String(staticValue);
-      if (resolved) {
-        domElement.setAttribute(attr, resolved);
-      }
-    }
-  }
-  if (config.disabled) domElement.setAttribute("disabled", "");
-  if (config.required) domElement.setAttribute("required", "");
-  if (config.readOnly) domElement.setAttribute("readonly", "");
-  for (const [key, value] of Object.entries(config)) {
-    if (key.startsWith("data-") && value !== void 0) {
-      const resolved = hasTemplateSyntax(String(value)) ? resolveTemplate(String(value), context) : String(value);
-      domElement.setAttribute(key, resolved);
-    }
-  }
-  for (const [key, value] of Object.entries(config)) {
-    if (key.startsWith("aria-") && value !== void 0) {
-      const resolved = hasTemplateSyntax(String(value)) ? resolveTemplate(String(value), context) : String(value);
-      domElement.setAttribute(key, resolved);
-    }
-  }
-}
-function resolveFunctionBinding(binding, context) {
-  if (binding.source === "props" || binding.source === "parent") {
-    const path = binding.path;
-    if (!path) return void 0;
-    const parts = path.split(".");
-    let value = context.props;
-    for (const part of parts) {
-      if (value === null || value === void 0) return void 0;
-      value = value[part];
-    }
-    if (typeof value === "function") {
-      return value;
-    }
-    return void 0;
-  }
-  if (binding.source === "static" && typeof binding.value === "function") {
-    return binding.value;
-  }
-  return void 0;
-}
-function attachEventHandlers(domElement, element, eventHandlers, context, elementState, isRootElement = false, state) {
-  const elementId = element.i;
-  if (eventHandlers && eventHandlers[elementId]) {
-    const handlers = eventHandlers[elementId];
-    for (const [eventName, handler] of Object.entries(handlers)) {
-      const domEventName = eventName.replace(/^on/, "").toLowerCase();
-      elementState.eventListeners.set(domEventName, handler);
-      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)) {
-      if (propName.startsWith("on") && propName.length > 2) {
-        const handler = resolveFunctionBinding(binding, context);
-        if (handler) {
-          const domEventName = propName.slice(2).toLowerCase();
-          if (!elementState.eventListeners.has(domEventName)) {
-            elementState.eventListeners.set(domEventName, handler);
-            domElement.addEventListener(domEventName, handler);
-          }
-        }
-      }
-    }
-  }
-  if (isRootElement && context.props) {
-    for (const [propName, value] of Object.entries(context.props)) {
-      if (propName.startsWith("on") && propName.length > 2 && typeof value === "function") {
-        const domEventName = propName.slice(2).toLowerCase();
-        if (!elementState.eventListeners.has(domEventName)) {
-          const handler = value;
-          elementState.eventListeners.set(domEventName, handler);
-          domElement.addEventListener(domEventName, handler);
-        }
-      }
-    }
-  }
-}
-function detachEventHandlers(elementState) {
-  for (const [eventName, handler] of elementState.eventListeners) {
-    elementState.domElement.removeEventListener(eventName, handler);
-  }
-  elementState.eventListeners.clear();
-}
-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);
-  if (className) {
-    domElement.className = className;
-  }
-  applyAttributes(domElement, element, context);
-  let textContent = "";
-  if (element.componentId === "text" || !isSelfClosing(tag)) {
-    textContent = getTextContent(element, context);
-    if (textContent && !element.children?.length) {
-      domElement.textContent = textContent;
-    }
-  }
-  const elementState = {
-    element,
-    domElement,
-    styles,
-    className,
-    textContent,
-    eventListeners: /* @__PURE__ */ new Map()
-  };
-  attachEventHandlers(domElement, element, eventHandlers, context, elementState, isRootElement, state);
-  return elementState;
-}
-var globalRenderingStack = /* @__PURE__ */ new Set();
-function renderComponentRef(element, container, context, state) {
-  const config = element.configuration;
-  if (!config?.componentViewRef) return void 0;
-  const refId = config.componentViewRef;
-  const refVersion = config.componentViewVersion;
-  if (globalRenderingStack.has(refId)) {
-    console.warn(`Circular dependency detected: ${refId} is already being rendered`);
-    const placeholder = document.createElement("div");
-    placeholder.setAttribute("data-servly-circular", refId);
-    placeholder.textContent = `[Circular: ${refId}]`;
-    container.appendChild(placeholder);
-    return void 0;
-  }
-  let component;
-  if (state.componentRegistry) {
-    component = state.componentRegistry.get(refId, refVersion);
-  }
-  if (!component) {
-    const placeholder = document.createElement("div");
-    placeholder.setAttribute("data-servly-loading", refId);
-    placeholder.className = "servly-loading";
-    container.appendChild(placeholder);
-    if (state.onDependencyNeeded) {
-      state.onDependencyNeeded(refId, refVersion).then((loaded) => {
-        if (loaded && state.componentRegistry) {
-          state.componentRegistry.set(refId, refVersion || "latest", loaded);
-          container.innerHTML = "";
-          renderComponentRef(element, container, context, state);
-        }
-      }).catch((err) => {
-        console.error(`Failed to load dependency ${refId}:`, err);
-        placeholder.textContent = `[Failed to load: ${refId}]`;
-        placeholder.className = "servly-error";
-      });
-    }
-    return void 0;
-  }
-  const refProps = config.componentViewProps ? resolveTemplatesDeep(config.componentViewProps, context) : {};
-  globalRenderingStack.add(refId);
-  const refContext = {
-    props: refProps,
-    state: context.state,
-    context: context.context
-  };
-  try {
-    const result = render({
-      container,
-      elements: component.layout,
-      context: refContext,
-      componentRegistry: state.componentRegistry,
-      onDependencyNeeded: state.onDependencyNeeded
-    });
-    return result;
-  } finally {
-    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) {
-  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) {
-    const nestedResult = renderComponentRef(element, elementState.domElement, context, state);
-    if (nestedResult) {
-      elementState.nestedRender = nestedResult;
-    }
-    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 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,
-    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();
-  const memoryBefore = memorySampler.sample();
-  longTaskObserver.start();
-  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 = {
-      container,
-      elements,
-      context,
-      eventHandlers,
-      elementStates: /* @__PURE__ */ new Map(),
-      rootElement: null,
-      componentRegistry,
-      onDependencyNeeded,
-      renderingStack: /* @__PURE__ */ new Set(),
-      views,
-      eventSystem,
-      stateManager,
-      overrideSystem,
-      enableOverrides: hasAnyOverrides,
-      iconRenderer
-    };
-    container.innerHTML = "";
-    if (rootElements.length === 0) {
-      const duration2 = performance.now() - startTime;
-      const longTasks2 = longTaskObserver.stop();
-      analytics.trackRender(componentId, version, duration2, {
-        elementCount: 0,
-        longTaskCount: longTasks2
-      });
-      return {
-        rootElement: null,
-        update: (newContext) => update(state, newContext),
-        destroy: () => destroy(state)
-      };
-    }
-    if (rootElements.length === 1) {
-      state.rootElement = renderElement(
-        rootElements[0],
-        tree,
-        context,
-        eventHandlers,
-        state.elementStates,
-        state,
-        true
-        // isRootElement
-      );
-      container.appendChild(state.rootElement);
-    } else {
-      const wrapper = document.createElement("div");
-      wrapper.setAttribute("data-servly-wrapper", "true");
-      for (const root of rootElements) {
-        const rootElement = renderElement(root, tree, context, eventHandlers, state.elementStates, state, true);
-        wrapper.appendChild(rootElement);
-      }
-      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();
-    const heapDelta = memorySampler.calculateDelta(memoryBefore, memoryAfter);
-    analytics.trackRender(componentId, version, duration, {
-      elementCount: elements.length,
-      heapDeltaKB: heapDelta ?? void 0,
-      longTaskCount: longTasks,
-      hasEventHandlers: !!eventHandlers && Object.keys(eventHandlers).length > 0,
-      hasDependencies: !!componentRegistry
-    });
-    return {
-      rootElement: state.rootElement,
-      update: (newContext) => update(state, newContext),
-      destroy: () => destroy(state)
-    };
-  } catch (error) {
-    longTaskObserver.stop();
-    overrideSystem.destroy();
-    analytics.trackError(componentId, version, error, {
-      errorType: "render"
-    });
-    throw error;
-  }
-}
-function update(state, newContext) {
-  state.context = newContext;
-  for (const [elementId, elementState] of state.elementStates) {
-    const { element, domElement } = elementState;
-    const newStyles = buildElementStyles(element, newContext);
-    updateStyles(domElement, elementState.styles, newStyles);
-    elementState.styles = newStyles;
-    const newClassName = buildClassName(element, newContext);
-    if (newClassName !== elementState.className) {
-      domElement.className = newClassName;
-      elementState.className = newClassName;
-    }
-    const newTextContent = getTextContent(element, newContext);
-    if (newTextContent !== elementState.textContent) {
-      const children = state.elements.filter((el) => el.parent === elementId);
-      if (children.length === 0) {
-        domElement.textContent = newTextContent;
-      }
-      elementState.textContent = newTextContent;
-    }
-    applyAttributes(domElement, element, 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);
-  }
-  state.rootElement = null;
-}
-function renderDynamicList(options) {
-  const {
-    targetContainer,
-    blueprint,
-    blueprintVersion,
-    data,
-    renderType = "renderInto",
-    itemKey = "item",
-    indexKey = "index",
-    componentRegistry,
-    context = { props: {} }
-  } = options;
-  let container;
-  if (typeof targetContainer === "string") {
-    container = document.querySelector(targetContainer);
-  } else {
-    container = targetContainer;
-  }
-  if (!container) {
-    console.error(`renderDynamicList: Container not found: ${targetContainer}`);
-    return [];
-  }
-  const blueprintComponent = componentRegistry.get(blueprint, blueprintVersion);
-  if (!blueprintComponent) {
-    console.error(`renderDynamicList: Blueprint not found: ${blueprint}`);
-    return [];
-  }
-  if (renderType === "renderInto") {
-    container.innerHTML = "";
-  }
-  const results = [];
-  const fragment = document.createDocumentFragment();
-  data.forEach((item, index) => {
-    const itemContainer = document.createElement("div");
-    itemContainer.setAttribute("data-servly-list-item", String(index));
-    const itemContext = {
-      props: {
-        ...context.props,
-        [itemKey]: item,
-        [indexKey]: index
-      },
-      state: context.state,
-      context: context.context
-    };
-    const result = render({
-      container: itemContainer,
-      elements: blueprintComponent.layout,
-      context: itemContext,
-      componentRegistry
-    });
-    results.push(result);
-    fragment.appendChild(itemContainer);
-  });
-  if (renderType === "prepend") {
-    container.insertBefore(fragment, container.firstChild);
-  } else {
-    container.appendChild(fragment);
-  }
-  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 import("./tailwind-UHWJOUFF.mjs");
-    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;
-}
-
-// packages/runtime-core/src/cache.ts
-var DEFAULT_CACHE_CONFIG = {
-  maxEntries: 50,
-  ttl: 5 * 60 * 1e3,
-  // 5 minutes
-  storageKeyPrefix: "servly_component_"
-};
-var memoryCache = /* @__PURE__ */ new Map();
-function getCacheKey(id, version = "latest") {
-  return `${id}@${version}`;
-}
-function getFromMemoryCache(id, version = "latest", config = DEFAULT_CACHE_CONFIG) {
-  const key = getCacheKey(id, version);
-  const entry = memoryCache.get(key);
-  if (!entry) {
-    return null;
-  }
-  const ttl = config.ttl ?? DEFAULT_CACHE_CONFIG.ttl;
-  if (Date.now() - entry.timestamp > ttl) {
-    memoryCache.delete(key);
-    return null;
-  }
-  entry.accessCount++;
-  entry.lastAccessed = Date.now();
-  return entry.data;
-}
-function setInMemoryCache(id, version, data, config = DEFAULT_CACHE_CONFIG) {
-  const key = getCacheKey(id, version);
-  const maxEntries = config.maxEntries ?? DEFAULT_CACHE_CONFIG.maxEntries;
-  if (memoryCache.size >= maxEntries && !memoryCache.has(key)) {
-    evictLRUFromMemory();
-  }
-  memoryCache.set(key, {
-    data,
-    timestamp: Date.now(),
-    version,
-    accessCount: 1,
-    lastAccessed: Date.now()
-  });
-}
-function evictLRUFromMemory() {
-  let lruKey = null;
-  let lruTime = Infinity;
-  for (const [key, entry] of memoryCache.entries()) {
-    if (entry.lastAccessed < lruTime) {
-      lruTime = entry.lastAccessed;
-      lruKey = key;
-    }
-  }
-  if (lruKey) {
-    memoryCache.delete(lruKey);
-  }
-}
-function clearMemoryCache() {
-  memoryCache.clear();
-}
-function getMemoryCacheSize() {
-  return memoryCache.size;
-}
-function isLocalStorageAvailable() {
-  try {
-    const test = "__servly_test__";
-    localStorage.setItem(test, test);
-    localStorage.removeItem(test);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function getStorageKey(id, version, config) {
-  const prefix = config.storageKeyPrefix ?? DEFAULT_CACHE_CONFIG.storageKeyPrefix;
-  return `${prefix}${getCacheKey(id, version)}`;
-}
-function getFromLocalStorage(id, version = "latest", config = DEFAULT_CACHE_CONFIG) {
-  if (!isLocalStorageAvailable()) {
-    return null;
-  }
-  try {
-    const key = getStorageKey(id, version, config);
-    const stored = localStorage.getItem(key);
-    if (!stored) {
-      return null;
-    }
-    const entry = JSON.parse(stored);
-    const ttl = config.ttl ?? DEFAULT_CACHE_CONFIG.ttl;
-    if (Date.now() - entry.timestamp > ttl) {
-      localStorage.removeItem(key);
-      return null;
-    }
-    entry.accessCount++;
-    entry.lastAccessed = Date.now();
-    localStorage.setItem(key, JSON.stringify(entry));
-    return entry.data;
-  } catch (error) {
-    console.warn("Error reading from localStorage cache:", error);
-    return null;
-  }
-}
-function setInLocalStorage(id, version, data, config = DEFAULT_CACHE_CONFIG) {
-  if (!isLocalStorageAvailable()) {
-    return;
-  }
-  try {
-    const key = getStorageKey(id, version, config);
-    const maxEntries = config.maxEntries ?? DEFAULT_CACHE_CONFIG.maxEntries;
-    const currentCount = getLocalStorageCacheCount(config);
-    if (currentCount >= maxEntries) {
-      evictLRUFromLocalStorage(config);
-    }
-    const entry = {
-      data,
-      timestamp: Date.now(),
-      version,
-      accessCount: 1,
-      lastAccessed: Date.now()
-    };
-    localStorage.setItem(key, JSON.stringify(entry));
-  } catch (error) {
-    console.warn("Error writing to localStorage cache:", error);
-    if (error instanceof DOMException && error.name === "QuotaExceededError") {
-      evictLRUFromLocalStorage(config);
-      try {
-        const key = getStorageKey(id, version, config);
-        const entry = {
-          data,
-          timestamp: Date.now(),
-          version,
-          accessCount: 1,
-          lastAccessed: Date.now()
-        };
-        localStorage.setItem(key, JSON.stringify(entry));
-      } catch {
-      }
-    }
-  }
-}
-function getLocalStorageCacheCount(config) {
-  const prefix = config.storageKeyPrefix ?? DEFAULT_CACHE_CONFIG.storageKeyPrefix;
-  let count = 0;
-  for (let i = 0; i < localStorage.length; i++) {
-    const key = localStorage.key(i);
-    if (key?.startsWith(prefix)) {
-      count++;
-    }
-  }
-  return count;
-}
-function evictLRUFromLocalStorage(config) {
-  const prefix = config.storageKeyPrefix ?? DEFAULT_CACHE_CONFIG.storageKeyPrefix;
-  let lruKey = null;
-  let lruTime = Infinity;
-  for (let i = 0; i < localStorage.length; i++) {
-    const key = localStorage.key(i);
-    if (!key?.startsWith(prefix)) continue;
-    try {
-      const stored = localStorage.getItem(key);
-      if (stored) {
-        const entry = JSON.parse(stored);
-        if (entry.lastAccessed < lruTime) {
-          lruTime = entry.lastAccessed;
-          lruKey = key;
-        }
-      }
-    } catch {
-      if (key) localStorage.removeItem(key);
-    }
-  }
-  if (lruKey) {
-    localStorage.removeItem(lruKey);
-  }
-}
-function clearLocalStorageCache(config = DEFAULT_CACHE_CONFIG) {
-  if (!isLocalStorageAvailable()) {
-    return;
-  }
-  const prefix = config.storageKeyPrefix ?? DEFAULT_CACHE_CONFIG.storageKeyPrefix;
-  const keysToRemove = [];
-  for (let i = 0; i < localStorage.length; i++) {
-    const key = localStorage.key(i);
-    if (key?.startsWith(prefix)) {
-      keysToRemove.push(key);
-    }
-  }
-  keysToRemove.forEach((key) => localStorage.removeItem(key));
-}
-function getFromCache(id, version = "latest", strategy = "memory", config = DEFAULT_CACHE_CONFIG) {
-  if (strategy === "none") {
-    return null;
-  }
-  const memoryResult = getFromMemoryCache(id, version, config);
-  if (memoryResult) {
-    return memoryResult;
-  }
-  if (strategy === "localStorage") {
-    const localResult = getFromLocalStorage(id, version, config);
-    if (localResult) {
-      setInMemoryCache(id, version, localResult, config);
-      return localResult;
-    }
-  }
-  return null;
-}
-function setInCache(id, version, data, strategy = "memory", config = DEFAULT_CACHE_CONFIG) {
-  if (strategy === "none") {
-    return;
-  }
-  setInMemoryCache(id, version, data, config);
-  if (strategy === "localStorage") {
-    setInLocalStorage(id, version, data, config);
-  }
-}
-function clearAllCaches(config = DEFAULT_CACHE_CONFIG) {
-  clearMemoryCache();
-  clearLocalStorageCache(config);
-}
-function invalidateCache(id, version, config = DEFAULT_CACHE_CONFIG) {
-  if (version) {
-    const key = getCacheKey(id, version);
-    memoryCache.delete(key);
-    if (isLocalStorageAvailable()) {
-      const storageKey = getStorageKey(id, version, config);
-      localStorage.removeItem(storageKey);
-    }
-  } else {
-    const prefix = `${id}@`;
-    for (const key of memoryCache.keys()) {
-      if (key.startsWith(prefix)) {
-        memoryCache.delete(key);
-      }
-    }
-    if (isLocalStorageAvailable()) {
-      const storagePrefix = (config.storageKeyPrefix ?? DEFAULT_CACHE_CONFIG.storageKeyPrefix) + prefix;
-      const keysToRemove = [];
-      for (let i = 0; i < localStorage.length; i++) {
-        const key = localStorage.key(i);
-        if (key?.startsWith(storagePrefix)) {
-          keysToRemove.push(key);
-        }
-      }
-      keysToRemove.forEach((key) => localStorage.removeItem(key));
-    }
-  }
-}
-
-// packages/runtime-core/src/fetcher.ts
-var DEFAULT_RETRY_CONFIG = {
-  maxRetries: 3,
-  initialDelay: 1e3,
-  maxDelay: 1e4,
-  backoffMultiplier: 2
-};
-var registryBaseUrl = "/api/views/registry";
-function setRegistryUrl(url) {
-  registryBaseUrl = url;
-}
-function getRegistryUrl() {
-  if (typeof window !== "undefined") {
-    const envUrl = window.__SERVLY_REGISTRY_URL__;
-    if (envUrl) return envUrl;
-  }
-  if (typeof process !== "undefined" && process.env?.SERVLY_REGISTRY_URL) {
-    return process.env.SERVLY_REGISTRY_URL;
-  }
-  return registryBaseUrl;
-}
-function calculateBackoffDelay(retryCount, config) {
-  const delay = config.initialDelay * Math.pow(config.backoffMultiplier, retryCount);
-  return Math.min(delay, config.maxDelay);
-}
-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;
-  }
-  const baseUrl = getRegistryUrl();
-  const headers = {
-    "Content-Type": "application/json"
-  };
-  if (apiKey) {
-    headers["Authorization"] = `Bearer ${apiKey}`;
-  }
-  try {
-    const response = await fetch(
-      `${baseUrl}/${id}/resolve?specifier=${encodeURIComponent(specifier)}`,
-      { headers }
-    );
-    if (!response.ok) {
-      throw new Error(`Failed to resolve version: ${response.statusText}`);
-    }
-    const data = await response.json();
-    if (data.success && data.data?.resolved) {
-      return data.data.resolved;
-    }
-    throw new Error(data.error || "Failed to resolve version");
-  } catch (error) {
-    console.warn(`Failed to resolve version for ${id}@${specifier}:`, error);
-    return "latest";
-  }
-}
-async function fetchFromRegistry(id, version, apiKey, includeBundle, includeViews) {
-  const baseUrl = getRegistryUrl();
-  const headers = {
-    "Content-Type": "application/json"
-  };
-  if (apiKey) {
-    headers["Authorization"] = `Bearer ${apiKey}`;
-  }
-  let url;
-  if (version && version !== "latest" && /^\d+\.\d+\.\d+/.test(version)) {
-    url = `${baseUrl}/${id}/versions/${version}`;
-  } else if (version && version !== "latest") {
-    url = `${baseUrl}/${id}?version=${encodeURIComponent(version)}`;
-  } else {
-    url = `${baseUrl}/${id}`;
-  }
-  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) {
-      throw new Error(`View not found: ${id}@${version}`);
-    }
-    if (response.status === 401) {
-      throw new Error("Unauthorized: Invalid or missing API key");
-    }
-    if (response.status === 403) {
-      throw new Error("Forbidden: Access denied to this view");
-    }
-    throw new Error(`Failed to fetch view: ${response.statusText}`);
-  }
-  const data = await response.json();
-  if (!data.success || !data.data) {
-    throw new Error(data.error || "Failed to fetch view data");
-  }
-  const result = data.data;
-  if (result.viewId && !result.id) {
-    result.id = result.viewId;
-  }
-  return result;
-}
-async function fetchComponent(id, options = {}) {
-  const {
-    version = "latest",
-    apiKey,
-    cacheStrategy = "memory",
-    cacheConfig = DEFAULT_CACHE_CONFIG,
-    retryConfig = {},
-    forceRefresh = false,
-    signal,
-    bundleStrategy = "eager",
-    includeBundle = true,
-    includeViews = true
-    // Default to true - fetch all views needed
-  } = options;
-  const fullRetryConfig = {
-    ...DEFAULT_RETRY_CONFIG,
-    ...retryConfig
-  };
-  const startTime = performance.now();
-  if (!forceRefresh) {
-    const cached = getFromCache(id, version, cacheStrategy, cacheConfig);
-    if (cached) {
-      let registry;
-      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,
-        fetchDuration: Math.round(duration)
-      });
-      return {
-        data: cached,
-        fromCache: true,
-        version: cached.version,
-        registry,
-        views
-      };
-    }
-  }
-  const resolvedVersion = await resolveVersionFromApi(id, version, apiKey);
-  if (!forceRefresh && resolvedVersion !== version) {
-    const cached = getFromCache(id, resolvedVersion, cacheStrategy, cacheConfig);
-    if (cached) {
-      let registry;
-      if (cached.bundle) {
-        registry = buildRegistryFromBundle(cached);
-      }
-      const views = buildViewsMap(cached.views);
-      return {
-        data: cached,
-        fromCache: true,
-        version: resolvedVersion,
-        registry,
-        views
-      };
-    }
-  }
-  let lastError = null;
-  const shouldIncludeBundle = bundleStrategy !== "none" && includeBundle;
-  for (let attempt = 0; attempt <= fullRetryConfig.maxRetries; attempt++) {
-    if (signal?.aborted) {
-      throw new Error("Fetch aborted");
-    }
-    try {
-      const data = await fetchFromRegistry(id, resolvedVersion, apiKey, shouldIncludeBundle, includeViews);
-      setInCache(id, resolvedVersion, data, cacheStrategy, cacheConfig);
-      if (version !== resolvedVersion) {
-        setInCache(id, version, data, cacheStrategy, cacheConfig);
-      }
-      let registry;
-      let pendingDependencies;
-      if (data.bundle) {
-        registry = buildRegistryFromBundle(data);
-      } else if (data.dependencies && bundleStrategy === "lazy") {
-        pendingDependencies = Object.entries(data.dependencies).map(([depId, entry]) => ({
-          id: depId,
-          version: entry.resolved || entry.version
-        }));
-      }
-      const views = buildViewsMap(data.views);
-      const duration = performance.now() - startTime;
-      analytics.trackFetch(id, resolvedVersion, duration, false, {
-        cacheHit: false,
-        fetchDuration: Math.round(duration),
-        dependencyCount: data.dependencies ? Object.keys(data.dependencies).length : 0
-      });
-      return {
-        data,
-        fromCache: false,
-        version: resolvedVersion,
-        registry,
-        pendingDependencies,
-        views
-      };
-    } catch (error) {
-      lastError = error instanceof Error ? error : new Error(String(error));
-      if (lastError.message.includes("not found") || lastError.message.includes("Unauthorized") || lastError.message.includes("Forbidden")) {
-        throw lastError;
-      }
-      if (attempt < fullRetryConfig.maxRetries) {
-        const delay = calculateBackoffDelay(attempt, fullRetryConfig);
-        await sleep(delay);
-      }
-    }
-  }
-  const finalError = lastError || new Error("Failed to fetch component");
-  analytics.trackError(id, version, finalError, {
-    errorType: "fetch"
-  });
-  throw finalError;
-}
-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-HKUXXQ5V.mjs");
-    const registry = result.registry || createRegistry2();
-    await Promise.all(
-      result.pendingDependencies.map(async (dep) => {
-        try {
-          const depResult = await fetchComponent(dep.id, {
-            ...options,
-            version: dep.version,
-            bundleStrategy: "none"
-            // Don't recursively bundle
-          });
-          registry.set(dep.id, depResult.version, {
-            layout: depResult.data.layout,
-            propsInterface: depResult.data.propsInterface
-          });
-        } catch (err) {
-          console.warn(`Failed to fetch dependency ${dep.id}:`, err);
-        }
-      })
-    );
-    result.registry = registry;
-    result.pendingDependencies = void 0;
-  }
-  return result;
-}
-async function batchFetchComponents(components, options = {}) {
-  const baseUrl = getRegistryUrl();
-  const headers = {
-    "Content-Type": "application/json"
-  };
-  if (options.apiKey) {
-    headers["Authorization"] = `Bearer ${options.apiKey}`;
-  }
-  const response = await fetch(`${baseUrl}/batch`, {
-    method: "POST",
-    headers,
-    body: JSON.stringify({ components })
-  });
-  if (!response.ok) {
-    throw new Error(`Batch fetch failed: ${response.statusText}`);
-  }
-  const data = await response.json();
-  if (!data.success || !data.data) {
-    throw new Error(data.error || "Batch fetch failed");
-  }
-  return data.data;
-}
-async function prefetchComponents(ids, options = {}) {
-  const promises = ids.map(
-    ({ id, version }) => fetchComponent(id, { ...options, version }).catch((error) => {
-      console.warn(`Failed to prefetch view ${id}:`, error);
-    })
-  );
-  await Promise.all(promises);
-}
-async function isComponentAvailable(id, version = "latest", options = {}) {
-  const { cacheStrategy = "memory", cacheConfig = DEFAULT_CACHE_CONFIG } = options;
-  const cached = getFromCache(id, version, cacheStrategy, cacheConfig);
-  if (cached) {
-    return { available: true, cached: true, version: cached.version };
-  }
-  const baseUrl = getRegistryUrl();
-  const headers = {
-    "Content-Type": "application/json"
-  };
-  if (options.apiKey) {
-    headers["Authorization"] = `Bearer ${options.apiKey}`;
-  }
-  try {
-    const url = version && version !== "latest" ? `${baseUrl}/${id}/available?version=${encodeURIComponent(version)}` : `${baseUrl}/${id}/available`;
-    const response = await fetch(url, { headers });
-    if (!response.ok) {
-      return { available: false, cached: false };
-    }
-    const data = await response.json();
-    if (data.success && data.data) {
-      return data.data;
-    }
-    return { available: false, cached: false };
-  } catch {
-    return { available: false, cached: false };
-  }
-}
-async function getDependencyTree(id, options = {}) {
-  const baseUrl = getRegistryUrl();
-  const headers = {
-    "Content-Type": "application/json"
-  };
-  if (options.apiKey) {
-    headers["Authorization"] = `Bearer ${options.apiKey}`;
-  }
-  const params = new URLSearchParams();
-  if (options.version) params.set("version", options.version);
-  if (options.depth) params.set("depth", String(options.depth));
-  const url = `${baseUrl}/${id}/dependencies${params.toString() ? "?" + params.toString() : ""}`;
-  const response = await fetch(url, { headers });
-  if (!response.ok) {
-    throw new Error(`Failed to get dependency tree: ${response.statusText}`);
-  }
-  const data = await response.json();
-  if (!data.success || !data.data) {
-    throw new Error(data.error || "Failed to get dependency tree");
-  }
-  return data.data;
-}
-
-// packages/runtime-core/src/version.ts
-function parseVersion(version) {
-  const match = version.match(/^(\d+)\.(\d+)\.(\d+)$/);
-  if (!match) return null;
-  return {
-    major: parseInt(match[1], 10),
-    minor: parseInt(match[2], 10),
-    patch: parseInt(match[3], 10)
-  };
-}
-function compareVersions(a, b) {
-  const parsedA = parseVersion(a);
-  const parsedB = parseVersion(b);
-  if (!parsedA || !parsedB) return 0;
-  if (parsedA.major !== parsedB.major) {
-    return parsedA.major > parsedB.major ? 1 : -1;
-  }
-  if (parsedA.minor !== parsedB.minor) {
-    return parsedA.minor > parsedB.minor ? 1 : -1;
-  }
-  if (parsedA.patch !== parsedB.patch) {
-    return parsedA.patch > parsedB.patch ? 1 : -1;
-  }
-  return 0;
-}
-function satisfiesVersion(version, specifier) {
-  if (specifier === "latest" || specifier === "*") {
-    return true;
-  }
-  const parsed = parseVersion(version);
-  if (!parsed) return false;
-  if (/^\d+\.\d+\.\d+$/.test(specifier)) {
-    return version === specifier;
-  }
-  if (specifier.startsWith("^")) {
-    const specParsed = parseVersion(specifier.slice(1));
-    if (!specParsed) return false;
-    if (parsed.major !== specParsed.major) return false;
-    if (parsed.major === 0) {
-      return parsed.minor === specParsed.minor && parsed.patch >= specParsed.patch;
-    }
-    return compareVersions(version, specifier.slice(1)) >= 0;
-  }
-  if (specifier.startsWith("~")) {
-    const specParsed = parseVersion(specifier.slice(1));
-    if (!specParsed) return false;
-    return parsed.major === specParsed.major && parsed.minor === specParsed.minor && parsed.patch >= specParsed.patch;
-  }
-  if (specifier.startsWith(">=")) {
-    return compareVersions(version, specifier.slice(2)) >= 0;
-  }
-  if (specifier.startsWith(">")) {
-    return compareVersions(version, specifier.slice(1)) > 0;
-  }
-  if (specifier.startsWith("<=")) {
-    return compareVersions(version, specifier.slice(2)) <= 0;
-  }
-  if (specifier.startsWith("<")) {
-    return compareVersions(version, specifier.slice(1)) < 0;
-  }
-  return false;
-}
-function resolveVersion(versions, specifier = "latest") {
-  if (versions.length === 0) {
-    return null;
-  }
-  const sorted = [...versions].sort((a, b) => compareVersions(b, a));
-  if (specifier === "latest" || specifier === "*") {
-    return sorted[0];
-  }
-  if (/^\d+\.\d+\.\d+$/.test(specifier)) {
-    return versions.includes(specifier) ? specifier : null;
-  }
-  for (const version of sorted) {
-    if (satisfiesVersion(version, specifier)) {
-      return version;
-    }
-  }
-  return null;
-}
-function bumpVersion(currentVersion, bumpType) {
-  const parsed = parseVersion(currentVersion);
-  if (!parsed) return "1.0.0";
-  switch (bumpType) {
-    case "major":
-      return `${parsed.major + 1}.0.0`;
-    case "minor":
-      return `${parsed.major}.${parsed.minor + 1}.0`;
-    case "patch":
-      return `${parsed.major}.${parsed.minor}.${parsed.patch + 1}`;
-    default:
-      return currentVersion;
-  }
-}
-function isValidSpecifier(specifier) {
-  if (specifier === "latest" || specifier === "*") {
-    return true;
-  }
-  if (/^\d+\.\d+\.\d+$/.test(specifier)) {
-    return true;
-  }
-  if (/^[\^~><]=?\d+\.\d+\.\d+$/.test(specifier)) {
-    return true;
-  }
-  return false;
-}
-function formatVersion(version) {
-  const parsed = parseVersion(version);
-  if (!parsed) return version;
-  return `v${parsed.major}.${parsed.minor}.${parsed.patch}`;
-}
-
-// packages/runtime-core/src/testRunner.ts
-function runTestCase(elements, testCase, container) {
-  const startTime = performance.now();
-  const assertionResults = [];
-  let renderResult = null;
-  let error;
-  const testContainer = container || document.createElement("div");
-  if (!container) {
-    document.body.appendChild(testContainer);
-  }
-  try {
-    const context = {
-      props: testCase.props
-    };
-    renderResult = render({
-      container: testContainer,
-      elements,
-      context
-    });
-    for (const assertion of testCase.assertions) {
-      const result = validateAssertion(testContainer, assertion);
-      assertionResults.push(result);
-    }
-  } catch (err) {
-    error = err instanceof Error ? err.message : String(err);
-  } finally {
-    if (renderResult) {
-      renderResult.destroy();
-    }
-    if (!container) {
-      document.body.removeChild(testContainer);
-    }
-  }
-  const duration = performance.now() - startTime;
-  const passed = !error && assertionResults.every((r) => r.passed);
-  return {
-    testId: testCase.id,
-    testName: testCase.name,
-    passed,
-    assertions: assertionResults,
-    duration,
-    error
-  };
-}
-function runAllTests(elements, testCases) {
-  const startTime = performance.now();
-  const results = [];
-  for (const testCase of testCases) {
-    const result = runTestCase(elements, testCase);
-    results.push(result);
-  }
-  const duration = performance.now() - startTime;
-  const passed = results.filter((r) => r.passed).length;
-  const failed = results.filter((r) => !r.passed).length;
-  return {
-    total: testCases.length,
-    passed,
-    failed,
-    duration,
-    results
-  };
-}
-function validateAssertion(container, assertion) {
-  const elements = container.querySelectorAll(assertion.selector);
-  switch (assertion.type) {
-    case "exists":
-      return {
-        assertion,
-        passed: elements.length > 0,
-        actual: elements.length > 0,
-        expected: true,
-        message: elements.length > 0 ? `Element "${assertion.selector}" exists` : `Element "${assertion.selector}" not found`
-      };
-    case "count":
-      const count = elements.length;
-      const expectedCount = assertion.expected;
-      return {
-        assertion,
-        passed: count === expectedCount,
-        actual: count,
-        expected: expectedCount,
-        message: count === expectedCount ? `Found ${count} elements matching "${assertion.selector}"` : `Expected ${expectedCount} elements, found ${count}`
-      };
-    case "text":
-      if (elements.length === 0) {
-        return {
-          assertion,
-          passed: false,
-          actual: null,
-          expected: assertion.expected,
-          message: `Element "${assertion.selector}" not found`
-        };
-      }
-      const textContent = elements[0].textContent?.trim();
-      const expectedText = assertion.expected;
-      return {
-        assertion,
-        passed: textContent === expectedText,
-        actual: textContent,
-        expected: expectedText,
-        message: textContent === expectedText ? `Text matches: "${expectedText}"` : `Expected text "${expectedText}", got "${textContent}"`
-      };
-    case "attribute":
-      if (elements.length === 0) {
-        return {
-          assertion,
-          passed: false,
-          actual: null,
-          expected: assertion.expected,
-          message: `Element "${assertion.selector}" not found`
-        };
-      }
-      const attrValue = elements[0].getAttribute(assertion.attribute || "");
-      const expectedAttr = assertion.expected;
-      return {
-        assertion,
-        passed: attrValue === expectedAttr,
-        actual: attrValue,
-        expected: expectedAttr,
-        message: attrValue === expectedAttr ? `Attribute "${assertion.attribute}" matches` : `Expected attribute "${assertion.attribute}" to be "${expectedAttr}", got "${attrValue}"`
-      };
-    case "class":
-      if (elements.length === 0) {
-        return {
-          assertion,
-          passed: false,
-          actual: null,
-          expected: assertion.expected,
-          message: `Element "${assertion.selector}" not found`
-        };
-      }
-      const hasClass2 = elements[0].classList.contains(assertion.expected);
-      return {
-        assertion,
-        passed: hasClass2,
-        actual: Array.from(elements[0].classList),
-        expected: assertion.expected,
-        message: hasClass2 ? `Element has class "${assertion.expected}"` : `Element does not have class "${assertion.expected}"`
-      };
-    case "style":
-      if (elements.length === 0) {
-        return {
-          assertion,
-          passed: false,
-          actual: null,
-          expected: assertion.expected,
-          message: `Element "${assertion.selector}" not found`
-        };
-      }
-      const el = elements[0];
-      const styleValue = el.style.getPropertyValue(assertion.property || "");
-      const expectedStyle = assertion.expected;
-      return {
-        assertion,
-        passed: styleValue === expectedStyle,
-        actual: styleValue,
-        expected: expectedStyle,
-        message: styleValue === expectedStyle ? `Style "${assertion.property}" matches` : `Expected style "${assertion.property}" to be "${expectedStyle}", got "${styleValue}"`
-      };
-    case "visible":
-      if (elements.length === 0) {
-        return {
-          assertion,
-          passed: false,
-          actual: null,
-          expected: true,
-          message: `Element "${assertion.selector}" not found`
-        };
-      }
-      const visible = isElementVisible(elements[0]);
-      const expectedVisible = assertion.expected !== false;
-      return {
-        assertion,
-        passed: visible === expectedVisible,
-        actual: visible,
-        expected: expectedVisible,
-        message: visible === expectedVisible ? `Element visibility matches expected` : `Expected element to be ${expectedVisible ? "visible" : "hidden"}`
-      };
-    default:
-      return {
-        assertion,
-        passed: false,
-        message: `Unknown assertion type: ${assertion.type}`
-      };
-  }
-}
-function isElementVisible(element) {
-  const style = window.getComputedStyle(element);
-  return style.display !== "none" && style.visibility !== "hidden" && style.opacity !== "0" && element.offsetWidth > 0 && element.offsetHeight > 0;
-}
-function validateProps(props, definitions) {
-  const errors = [];
-  for (const def of definitions) {
-    const value = props[def.name];
-    if (def.required && (value === void 0 || value === null)) {
-      errors.push(`Required prop "${def.name}" is missing`);
-      continue;
-    }
-    if (value === void 0) continue;
-    const actualType = Array.isArray(value) ? "array" : typeof value;
-    if (def.type === "array" && !Array.isArray(value)) {
-      errors.push(`Prop "${def.name}" should be an array, got ${actualType}`);
-    } else if (def.type !== "array" && actualType !== def.type) {
-      errors.push(`Prop "${def.name}" should be ${def.type}, got ${actualType}`);
-    }
-  }
-  return {
-    valid: errors.length === 0,
-    errors
-  };
-}
-function generateTestCases(definitions) {
-  const testCases = [];
-  const defaultProps = {};
-  for (const def of definitions) {
-    if (def.defaultValue !== void 0) {
-      defaultProps[def.name] = def.defaultValue;
-    }
-  }
-  testCases.push({
-    id: "default-props",
-    name: "Render with default props",
-    props: defaultProps,
-    assertions: [{ type: "exists", selector: "*" }]
-  });
-  for (const def of definitions) {
-    const sampleValue = getSampleValue(def);
-    if (sampleValue !== void 0) {
-      testCases.push({
-        id: `prop-${def.name}`,
-        name: `Test prop: ${def.name}`,
-        props: { ...defaultProps, [def.name]: sampleValue },
-        assertions: [{ type: "exists", selector: "*" }]
-      });
-    }
-  }
-  return testCases;
-}
-function getSampleValue(def) {
-  switch (def.type) {
-    case "string":
-      return "Sample Text";
-    case "number":
-      return 42;
-    case "boolean":
-      return true;
-    case "array":
-      return [];
-    case "object":
-      return {};
-    default:
-      return def.defaultValue;
-  }
-}
-
-// 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");
-}
-export {
-  AnalyticsCollector,
-  DEFAULT_CACHE_CONFIG,
-  DEFAULT_RETRY_CONFIG,
-  DEFAULT_SERVLY_TAILWIND_CONFIG,
-  EVENT_HANDLERS,
-  EventSystem,
-  LongTaskObserver,
-  MemorySampler,
-  OverrideSystem,
-  SessionManager,
-  StateManager,
-  addClass,
-  addCustomStyles,
-  analytics,
-  applyStyles,
-  batchFetchComponents,
-  buildClassName,
-  buildElementStyles,
-  buildRegistryFromBundle,
-  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,
-  resolveTemplateValue,
-  resolveTemplatesDeep,
-  resolveVersion,
-  runAllTests,
-  runTestCase,
-  satisfiesVersion,
-  setIconCdnEnabled,
-  setInCache,
-  setLocalStorage,
-  setRegistryUrl,
-  setSessionStorage,
-  setValueByPath,
-  toDomEventName,
-  toReactEventName,
-  toggleClass,
-  updateStyles,
-  updateTailwindConfig,
-  validateAssertion,
-  validateProps
-};