@servlyadmin/runtime-core 0.1.7 → 0.1.9

package/dist/index.cjs

@@ -1,2818 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/registry.ts
-var registry_exports = {};
-__export(registry_exports, {
-  buildRegistryFromBundle: () => buildRegistryFromBundle,
-  collectAllDependencies: () => collectAllDependencies,
-  createRegistry: () => createRegistry,
-  detectCircularDependencies: () => detectCircularDependencies,
-  extractDependencies: () => extractDependencies,
-  extractDependenciesFromCode: () => extractDependenciesFromCode
-});
-function createRegistry() {
-  const components = /* @__PURE__ */ new Map();
-  return {
-    get(id, version) {
-      if (version) {
-        const key = `${id}@${version}`;
-        if (components.has(key)) {
-          return components.get(key);
-        }
-      }
-      for (const [key, component] of components) {
-        if (key.startsWith(`${id}@`)) {
-          return component;
-        }
-      }
-      return components.get(id);
-    },
-    has(id, version) {
-      if (version) {
-        return components.has(`${id}@${version}`);
-      }
-      for (const key of components.keys()) {
-        if (key.startsWith(`${id}@`) || key === id) {
-          return true;
-        }
-      }
-      return false;
-    },
-    set(id, version, component) {
-      components.set(`${id}@${version}`, component);
-    }
-  };
-}
-function buildRegistryFromBundle(data) {
-  const registry = createRegistry();
-  registry.set(data.id, data.version, {
-    layout: data.layout,
-    propsInterface: data.propsInterface
-  });
-  if (data.bundle) {
-    for (const [key, component] of Object.entries(data.bundle)) {
-      const [id, version] = key.split("@");
-      if (id && version) {
-        registry.set(id, version, component);
-      }
-    }
-  }
-  return registry;
-}
-function extractDependencies(elements) {
-  const dependencies = [];
-  for (const element of elements) {
-    const config = element.configuration;
-    if (!config) continue;
-    if (config.componentViewRef) {
-      dependencies.push({
-        id: config.componentViewRef,
-        version: config.componentViewVersion,
-        type: "viewRef",
-        elementId: element.i
-      });
-    }
-    if (config.blueprint) {
-      dependencies.push({
-        id: config.blueprint,
-        version: config.blueprintVersion,
-        type: "blueprint",
-        elementId: element.i
-      });
-    }
-  }
-  return dependencies;
-}
-function extractDependenciesFromCode(code) {
-  const dependencies = [];
-  const pattern = /renderDynamicList\s*\(\s*\{[^}]*blueprint\s*:\s*["']([^"']+)["']/g;
-  let match;
-  while ((match = pattern.exec(code)) !== null) {
-    dependencies.push({
-      id: match[1],
-      type: "blueprint"
-    });
-  }
-  return dependencies;
-}
-async function collectAllDependencies(rootId, rootVersion, fetchComponent2, maxDepth = 10) {
-  const manifest = {};
-  const visited = /* @__PURE__ */ new Set();
-  async function collect(id, version, via, depth) {
-    if (depth > maxDepth) {
-      console.warn(`Max dependency depth (${maxDepth}) reached for ${id}`);
-      return;
-    }
-    const key = `${id}@${version || "latest"}`;
-    if (visited.has(key)) {
-      return;
-    }
-    visited.add(key);
-    try {
-      const component = await fetchComponent2(id, version);
-      if (!component) {
-        console.warn(`Dependency not found: ${id}@${version || "latest"}`);
-        return;
-      }
-      manifest[id] = {
-        version: version || "latest",
-        resolved: component.version,
-        type: via ? "viewRef" : "viewRef",
-        // Will be set by caller
-        via
-      };
-      const nestedDeps = extractDependencies(component.layout);
-      for (const dep of nestedDeps) {
-        await collect(dep.id, dep.version, id, depth + 1);
-      }
-    } catch (error) {
-      console.error(`Failed to fetch dependency ${id}:`, error);
-    }
-  }
-  const rootComponent = await fetchComponent2(rootId, rootVersion);
-  if (rootComponent) {
-    const rootDeps = extractDependencies(rootComponent.layout);
-    for (const dep of rootDeps) {
-      manifest[dep.id] = {
-        version: dep.version || "latest",
-        resolved: "",
-        // Will be filled when fetched
-        type: dep.type
-      };
-      await collect(dep.id, dep.version, void 0, 1);
-    }
-  }
-  return manifest;
-}
-function detectCircularDependencies(manifest) {
-  const graph = /* @__PURE__ */ new Map();
-  for (const [id, entry] of Object.entries(manifest)) {
-    if (entry.via) {
-      const deps = graph.get(entry.via) || [];
-      deps.push(id);
-      graph.set(entry.via, deps);
-    }
-  }
-  const visited = /* @__PURE__ */ new Set();
-  const stack = /* @__PURE__ */ new Set();
-  const path = [];
-  function dfs(node) {
-    if (stack.has(node)) {
-      const cycleStart = path.indexOf(node);
-      return [...path.slice(cycleStart), node];
-    }
-    if (visited.has(node)) {
-      return null;
-    }
-    visited.add(node);
-    stack.add(node);
-    path.push(node);
-    const neighbors = graph.get(node) || [];
-    for (const neighbor of neighbors) {
-      const cycle = dfs(neighbor);
-      if (cycle) return cycle;
-    }
-    stack.delete(node);
-    path.pop();
-    return null;
-  }
-  for (const node of graph.keys()) {
-    const cycle = dfs(node);
-    if (cycle) return cycle;
-  }
-  return null;
-}
-var init_registry = __esm({
-  "src/registry.ts"() {
-    "use strict";
-  }
-});
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  AnalyticsCollector: () => AnalyticsCollector,
-  DEFAULT_CACHE_CONFIG: () => DEFAULT_CACHE_CONFIG,
-  DEFAULT_RETRY_CONFIG: () => DEFAULT_RETRY_CONFIG,
-  LongTaskObserver: () => LongTaskObserver,
-  MemorySampler: () => MemorySampler,
-  SessionManager: () => SessionManager,
-  analytics: () => analytics,
-  applyStyles: () => applyStyles,
-  batchFetchComponents: () => batchFetchComponents,
-  buildClassName: () => buildClassName,
-  buildElementStyles: () => buildElementStyles,
-  buildRegistryFromBundle: () => buildRegistryFromBundle,
-  bumpVersion: () => bumpVersion,
-  camelToKebab: () => camelToKebab,
-  clearAllCaches: () => clearAllCaches,
-  clearLocalStorageCache: () => clearLocalStorageCache,
-  clearMemoryCache: () => clearMemoryCache,
-  clearStyles: () => clearStyles,
-  collectAllDependencies: () => collectAllDependencies,
-  compareVersions: () => compareVersions,
-  configureAnalytics: () => configureAnalytics,
-  createRegistry: () => createRegistry,
-  detectCircularDependencies: () => detectCircularDependencies,
-  extractBindingKeys: () => extractBindingKeys,
-  extractDependencies: () => extractDependencies,
-  extractDependenciesFromCode: () => extractDependenciesFromCode,
-  fetchComponent: () => fetchComponent,
-  fetchComponentWithDependencies: () => fetchComponentWithDependencies,
-  formatStyleValue: () => formatStyleValue,
-  formatVersion: () => formatVersion,
-  generateTestCases: () => generateTestCases,
-  getAnalytics: () => getAnalytics,
-  getCacheKey: () => getCacheKey,
-  getDependencyTree: () => getDependencyTree,
-  getFromCache: () => getFromCache,
-  getLongTaskObserver: () => getLongTaskObserver,
-  getMemoryCacheSize: () => getMemoryCacheSize,
-  getMemorySampler: () => getMemorySampler,
-  getRegistryUrl: () => getRegistryUrl,
-  getSessionManager: () => getSessionManager,
-  hasTemplateSyntax: () => hasTemplateSyntax,
-  invalidateCache: () => invalidateCache,
-  isComponentAvailable: () => isComponentAvailable,
-  isValidSpecifier: () => isValidSpecifier,
-  parseVersion: () => parseVersion,
-  prefetchComponents: () => prefetchComponents,
-  processStyles: () => processStyles,
-  render: () => render,
-  renderDynamicList: () => renderDynamicList,
-  resetAnalytics: () => resetAnalytics,
-  resetLongTaskObserver: () => resetLongTaskObserver,
-  resetMemorySampler: () => resetMemorySampler,
-  resetSessionManager: () => resetSessionManager,
-  resolveBindingPath: () => resolveBindingPath,
-  resolveTemplate: () => resolveTemplate,
-  resolveTemplateValue: () => resolveTemplateValue,
-  resolveTemplatesDeep: () => resolveTemplatesDeep,
-  resolveVersion: () => resolveVersion,
-  runAllTests: () => runAllTests,
-  runTestCase: () => runTestCase,
-  satisfiesVersion: () => satisfiesVersion,
-  setInCache: () => setInCache,
-  setRegistryUrl: () => setRegistryUrl,
-  updateStyles: () => updateStyles,
-  validateAssertion: () => validateAssertion,
-  validateProps: () => validateProps
-});
-module.exports = __toCommonJS(index_exports);
-
-// 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";
-
-// 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 {
-  constructor() {
-    this.session = null;
-    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;
-}
-
-// src/analytics.ts
-var AnalyticsCollector = class {
-  constructor(config) {
-    this.eventQueue = [];
-    this.flushTimer = null;
-    this.isFlushing = false;
-    this.retryDelay = 1e3;
-    this.config = { ...DEFAULT_ANALYTICS_CONFIG, ...config };
-    this.isEnabled = this.config.enabled;
-    this.startFlushTimer();
-  }
-  // ============================================
-  // 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()
-};
-
-// src/bindings.ts
-var BINDING_SOURCES = [
-  "props",
-  "state",
-  "appState",
-  "context",
-  "input",
-  "currentItem",
-  "localStore",
-  "config",
-  "element",
-  "self",
-  "params",
-  "query"
-];
-var TEMPLATE_REGEX = /\{\{([^}]+)\}\}/g;
-function hasTemplateSyntax(value) {
-  return typeof value === "string" && value.includes("{{") && value.includes("}}");
-}
-function resolveBindingPath(path, context) {
-  const trimmed = path.trim();
-  const parts = trimmed.split(".");
-  if (parts.length === 0) {
-    return void 0;
-  }
-  const prefix = parts[0].toLowerCase();
-  let source;
-  let startIndex = 0;
-  if (prefix === "props" || prefix === "input") {
-    source = context.props;
-    startIndex = 1;
-  } else if (prefix === "state" || prefix === "appstate") {
-    source = context.state;
-    startIndex = 1;
-  } else if (prefix === "context") {
-    source = context.context;
-    startIndex = 1;
-  } else if (BINDING_SOURCES.includes(prefix)) {
-    source = context.props;
-    startIndex = 1;
-  } else {
-    source = context.props;
-    startIndex = 0;
-  }
-  if (!source) {
-    return void 0;
-  }
-  let value = source;
-  for (let i = startIndex; i < parts.length; i++) {
-    if (value === null || value === void 0) {
-      return void 0;
-    }
-    value = value[parts[i]];
-  }
-  return value;
-}
-function resolveExpression(expression, context) {
-  const trimmed = expression.trim();
-  const defaultMatch = trimmed.match(/^(.+?)\|\|(.+)$/);
-  if (defaultMatch) {
-    const mainValue = resolveExpression(defaultMatch[1].trim(), context);
-    if (mainValue !== void 0 && mainValue !== null && mainValue !== "") {
-      return mainValue;
-    }
-    const defaultVal = defaultMatch[2].trim();
-    if (defaultVal.startsWith('"') && defaultVal.endsWith('"') || defaultVal.startsWith("'") && defaultVal.endsWith("'")) {
-      return defaultVal.slice(1, -1);
-    }
-    if (!isNaN(Number(defaultVal))) {
-      return Number(defaultVal);
-    }
-    if (defaultVal === "true") return true;
-    if (defaultVal === "false") return false;
-    return resolveExpression(defaultVal, context);
-  }
-  const ternaryMatch = trimmed.match(/^(.+?)\s*\?\s*(.+?)\s*:\s*(.+)$/);
-  if (ternaryMatch) {
-    const condition = resolveExpression(ternaryMatch[1].trim(), context);
-    if (condition) {
-      return resolveTernaryValue(ternaryMatch[2].trim(), context);
-    }
-    return resolveTernaryValue(ternaryMatch[3].trim(), context);
-  }
-  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);
-  }
-  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);
-}
-
-// 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;
-      }
-    }
-  }
-}
-
-// src/memorySampler.ts
-var MemorySampler = class {
-  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;
-}
-
-// src/longTaskObserver.ts
-var LongTaskObserver = class {
-  constructor() {
-    this.observer = null;
-    this.longTaskCount = 0;
-    this.isObserving = false;
-    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;
-}
-
-// 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) {
-  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 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) {
-  const tag = getElementTag(element);
-  const domElement = document.createElement(tag);
-  domElement.setAttribute("data-servly-id", element.i);
-  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);
-  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 renderElement(element, tree, context, eventHandlers, elementStates, state, isRootElement = false) {
-  const elementState = createElement(element, context, eventHandlers, isRootElement);
-  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 render(options) {
-  const { container, elements, context, eventHandlers, componentRegistry, onDependencyNeeded } = options;
-  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";
-  try {
-    const tree = buildTree(elements);
-    const state = {
-      container,
-      elements,
-      context,
-      eventHandlers,
-      elementStates: /* @__PURE__ */ new Map(),
-      rootElement: null,
-      componentRegistry,
-      onDependencyNeeded,
-      renderingStack: /* @__PURE__ */ new Set()
-    };
-    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);
-    }
-    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();
-    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) {
-  for (const elementState of state.elementStates.values()) {
-    detachEventHandlers(elementState);
-    if (elementState.nestedRender) {
-      elementState.nestedRender.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;
-}
-
-// 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));
-    }
-  }
-}
-
-// src/fetcher.ts
-init_registry();
-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));
-}
-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) {
-  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";
-  }
-  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
-  } = 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 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
-      };
-    }
-  }
-  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);
-      }
-      return {
-        data: cached,
-        fromCache: true,
-        version: resolvedVersion,
-        registry
-      };
-    }
-  }
-  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);
-      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 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
-      };
-    } 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 Promise.resolve().then(() => (init_registry(), registry_exports));
-    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;
-}
-
-// 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}`;
-}
-
-// 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 hasClass = elements[0].classList.contains(assertion.expected);
-      return {
-        assertion,
-        passed: hasClass,
-        actual: Array.from(elements[0].classList),
-        expected: assertion.expected,
-        message: hasClass ? `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;
-  }
-}
-
-// src/index.ts
-init_registry();
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  AnalyticsCollector,
-  DEFAULT_CACHE_CONFIG,
-  DEFAULT_RETRY_CONFIG,
-  LongTaskObserver,
-  MemorySampler,
-  SessionManager,
-  analytics,
-  applyStyles,
-  batchFetchComponents,
-  buildClassName,
-  buildElementStyles,
-  buildRegistryFromBundle,
-  bumpVersion,
-  camelToKebab,
-  clearAllCaches,
-  clearLocalStorageCache,
-  clearMemoryCache,
-  clearStyles,
-  collectAllDependencies,
-  compareVersions,
-  configureAnalytics,
-  createRegistry,
-  detectCircularDependencies,
-  extractBindingKeys,
-  extractDependencies,
-  extractDependenciesFromCode,
-  fetchComponent,
-  fetchComponentWithDependencies,
-  formatStyleValue,
-  formatVersion,
-  generateTestCases,
-  getAnalytics,
-  getCacheKey,
-  getDependencyTree,
-  getFromCache,
-  getLongTaskObserver,
-  getMemoryCacheSize,
-  getMemorySampler,
-  getRegistryUrl,
-  getSessionManager,
-  hasTemplateSyntax,
-  invalidateCache,
-  isComponentAvailable,
-  isValidSpecifier,
-  parseVersion,
-  prefetchComponents,
-  processStyles,
-  render,
-  renderDynamicList,
-  resetAnalytics,
-  resetLongTaskObserver,
-  resetMemorySampler,
-  resetSessionManager,
-  resolveBindingPath,
-  resolveTemplate,
-  resolveTemplateValue,
-  resolveTemplatesDeep,
-  resolveVersion,
-  runAllTests,
-  runTestCase,
-  satisfiesVersion,
-  setInCache,
-  setRegistryUrl,
-  updateStyles,
-  validateAssertion,
-  validateProps
-});