@coherent.js/nextjs 1.0.0-beta.2

package/dist/index.cjs

@@ -0,0 +1,3822 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.js
+var index_exports = {};
+__export(index_exports, {
+  createCoherentAppRouterHandler: () => createCoherentAppRouterHandler,
+  createCoherentClientComponent: () => createCoherentClientComponent,
+  createCoherentNextHandler: () => createCoherentNextHandler,
+  createCoherentServerComponent: () => createCoherentServerComponent,
+  createNextIntegration: () => createNextIntegration,
+  default: () => coherent_nextjs_default
+});
+module.exports = __toCommonJS(index_exports);
+
+// ../core/src/performance/monitor.js
+function createPerformanceMonitor(options = {}) {
+  const opts = {
+    enabled: true,
+    metrics: {
+      custom: {}
+    },
+    sampling: {
+      enabled: false,
+      rate: 1,
+      strategy: "random"
+    },
+    reporting: {
+      enabled: false,
+      interval: 6e4,
+      format: "json",
+      batch: {
+        enabled: false,
+        maxSize: 100,
+        flushInterval: 5e3
+      },
+      onReport: null
+    },
+    alerts: {
+      enabled: true,
+      rules: []
+    },
+    resources: {
+      enabled: false,
+      track: ["memory"],
+      interval: 1e3
+    },
+    profiling: {
+      enabled: false,
+      mode: "production",
+      flamegraph: false,
+      tracing: {
+        enabled: false,
+        sampleRate: 0.01
+      }
+    },
+    ...options
+  };
+  opts.reporting.batch = {
+    enabled: false,
+    maxSize: 100,
+    flushInterval: 5e3,
+    ...options.reporting?.batch || {}
+  };
+  const metrics = {
+    builtin: {
+      renderTime: { type: "histogram", unit: "ms", values: [] },
+      componentCount: { type: "counter", unit: "renders", value: 0 },
+      errorCount: { type: "counter", unit: "errors", value: 0 },
+      memoryUsage: { type: "gauge", unit: "MB", values: [] }
+    },
+    custom: {}
+  };
+  Object.entries(opts.metrics.custom).forEach(([name, config]) => {
+    metrics.custom[name] = {
+      type: config.type || "counter",
+      unit: config.unit || "",
+      threshold: config.threshold,
+      values: config.type === "histogram" ? [] : void 0,
+      value: config.type === "counter" || config.type === "gauge" ? 0 : void 0
+    };
+  });
+  const samplingState = {
+    count: 0,
+    sampled: 0,
+    adaptiveRate: opts.sampling.rate
+  };
+  const reportingState = {
+    batch: [],
+    lastReport: Date.now(),
+    reportTimer: null,
+    flushTimer: null
+  };
+  const alertState = {
+    triggered: /* @__PURE__ */ new Map(),
+    history: []
+  };
+  const resourceState = {
+    samples: [],
+    timer: null
+  };
+  const profilingState = {
+    traces: [],
+    flamegraphData: []
+  };
+  const stats = {
+    metricsRecorded: 0,
+    sampleRate: opts.sampling.rate,
+    reportsGenerated: 0,
+    alertsTriggered: 0
+  };
+  function shouldSample() {
+    if (!opts.sampling.enabled) return true;
+    samplingState.count++;
+    if (opts.sampling.strategy === "random") {
+      return Math.random() < samplingState.adaptiveRate;
+    } else if (opts.sampling.strategy === "deterministic") {
+      return samplingState.count % Math.ceil(1 / samplingState.adaptiveRate) === 0;
+    } else if (opts.sampling.strategy === "adaptive") {
+      const recentRenderTimes = metrics.builtin.renderTime.values.slice(-10);
+      if (recentRenderTimes.length > 0) {
+        const avgTime = recentRenderTimes.reduce((a, b) => a + b, 0) / recentRenderTimes.length;
+        samplingState.adaptiveRate = avgTime > 16 ? Math.min(1, opts.sampling.rate * 2) : opts.sampling.rate;
+      }
+      return Math.random() < samplingState.adaptiveRate;
+    }
+    return true;
+  }
+  function recordMetric(name, value, metadata = {}) {
+    if (!opts.enabled) return;
+    if (!shouldSample()) return;
+    stats.metricsRecorded++;
+    const builtinMetric = metrics.builtin[name];
+    if (builtinMetric) {
+      if (builtinMetric.type === "histogram") {
+        builtinMetric.values.push(value);
+        if (builtinMetric.values.length > 1e3) {
+          builtinMetric.values = builtinMetric.values.slice(-1e3);
+        }
+      } else if (builtinMetric.type === "counter") {
+        builtinMetric.value += value;
+      } else if (builtinMetric.type === "gauge") {
+        builtinMetric.values.push(value);
+        if (builtinMetric.values.length > 100) {
+          builtinMetric.values = builtinMetric.values.slice(-100);
+        }
+      }
+    }
+    const customMetric = metrics.custom[name];
+    if (customMetric) {
+      if (customMetric.type === "histogram") {
+        customMetric.values = customMetric.values || [];
+        customMetric.values.push(value);
+        if (customMetric.values.length > 1e3) {
+          customMetric.values = customMetric.values.slice(-1e3);
+        }
+      } else if (customMetric.type === "counter") {
+        customMetric.value = (customMetric.value || 0) + value;
+      } else if (customMetric.type === "gauge") {
+        customMetric.values = customMetric.values || [];
+        customMetric.values.push(value);
+        if (customMetric.values.length > 100) {
+          customMetric.values = customMetric.values.slice(-100);
+        }
+      }
+      if (customMetric.threshold) {
+        const currentValue = customMetric.type === "histogram" || customMetric.type === "gauge" ? customMetric.values[customMetric.values.length - 1] : customMetric.value;
+        if (currentValue > customMetric.threshold) {
+          checkAlerts(name, currentValue);
+        }
+      }
+    }
+    if (opts.reporting.enabled && opts.reporting.batch.enabled) {
+      reportingState.batch.push({
+        metric: name,
+        value,
+        metadata,
+        timestamp: Date.now()
+      });
+      if (reportingState.batch.length >= opts.reporting.batch.maxSize) {
+        flushBatch();
+      }
+    }
+    checkAlerts(name, value);
+  }
+  function checkAlerts(metric, value) {
+    if (!opts.alerts.enabled) return;
+    opts.alerts.rules.forEach((rule) => {
+      if (rule.metric !== metric) return;
+      let triggered = false;
+      if (rule.condition === "exceeds" && value > rule.threshold) {
+        triggered = true;
+      } else if (rule.condition === "below" && value < rule.threshold) {
+        triggered = true;
+      } else if (rule.condition === "equals" && value === rule.threshold) {
+        triggered = true;
+      }
+      if (triggered) {
+        const alertKey = `${rule.metric}-${rule.condition}-${rule.threshold}`;
+        const lastTriggered = alertState.triggered.get(alertKey);
+        const now = Date.now();
+        if (!lastTriggered || now - lastTriggered > 5e3) {
+          alertState.triggered.set(alertKey, now);
+          alertState.history.push({
+            rule,
+            value,
+            timestamp: now
+          });
+          stats.alertsTriggered++;
+          if (rule.action) {
+            rule.action(value, rule);
+          }
+        }
+      }
+    });
+  }
+  function flushBatch() {
+    if (reportingState.batch.length === 0) return;
+    const batch = [...reportingState.batch];
+    reportingState.batch = [];
+    if (opts.reporting.onReport) {
+      opts.reporting.onReport({ type: "batch", data: batch });
+    }
+  }
+  function generateReport() {
+    const report = {
+      timestamp: Date.now(),
+      statistics: { ...stats },
+      metrics: {}
+    };
+    Object.entries(metrics.builtin).forEach(([name, metric]) => {
+      if (metric.type === "histogram") {
+        report.metrics[name] = {
+          type: "histogram",
+          unit: metric.unit,
+          count: metric.values.length,
+          min: metric.values.length > 0 ? Math.min(...metric.values) : 0,
+          max: metric.values.length > 0 ? Math.max(...metric.values) : 0,
+          avg: metric.values.length > 0 ? metric.values.reduce((a, b) => a + b, 0) / metric.values.length : 0,
+          p50: percentile(metric.values, 0.5),
+          p95: percentile(metric.values, 0.95),
+          p99: percentile(metric.values, 0.99)
+        };
+      } else if (metric.type === "counter") {
+        report.metrics[name] = {
+          type: "counter",
+          unit: metric.unit,
+          value: metric.value
+        };
+      } else if (metric.type === "gauge") {
+        report.metrics[name] = {
+          type: "gauge",
+          unit: metric.unit,
+          current: metric.values.length > 0 ? metric.values[metric.values.length - 1] : 0,
+          avg: metric.values.length > 0 ? metric.values.reduce((a, b) => a + b, 0) / metric.values.length : 0
+        };
+      }
+    });
+    Object.entries(metrics.custom).forEach(([name, metric]) => {
+      if (metric.type === "histogram") {
+        report.metrics[name] = {
+          type: "histogram",
+          unit: metric.unit,
+          count: metric.values?.length || 0,
+          min: metric.values?.length > 0 ? Math.min(...metric.values) : 0,
+          max: metric.values?.length > 0 ? Math.max(...metric.values) : 0,
+          avg: metric.values?.length > 0 ? metric.values.reduce((a, b) => a + b, 0) / metric.values.length : 0,
+          p95: percentile(metric.values || [], 0.95),
+          p99: percentile(metric.values || [], 0.99)
+        };
+      } else if (metric.type === "counter") {
+        report.metrics[name] = {
+          type: "counter",
+          unit: metric.unit,
+          value: metric.value || 0
+        };
+      } else if (metric.type === "gauge") {
+        report.metrics[name] = {
+          type: "gauge",
+          unit: metric.unit,
+          current: metric.values?.length > 0 ? metric.values[metric.values.length - 1] : 0,
+          avg: metric.values?.length > 0 ? metric.values.reduce((a, b) => a + b, 0) / metric.values.length : 0
+        };
+      }
+    });
+    report.alerts = {
+      total: alertState.history.length,
+      recent: alertState.history.slice(-10)
+    };
+    if (opts.resources.enabled) {
+      report.resources = {
+        samples: resourceState.samples.slice(-20)
+      };
+    }
+    stats.reportsGenerated++;
+    if (opts.reporting.onReport) {
+      opts.reporting.onReport({ type: "report", data: report });
+    }
+    return report;
+  }
+  function percentile(values, p) {
+    if (values.length === 0) return 0;
+    const sorted = [...values].sort((a, b) => a - b);
+    const index = Math.ceil(sorted.length * p) - 1;
+    return sorted[Math.max(0, index)];
+  }
+  function startResourceMonitoring() {
+    if (!opts.resources.enabled) return;
+    const collectResources = () => {
+      const sample = {
+        timestamp: Date.now()
+      };
+      if (opts.resources.track.includes("memory")) {
+        if (typeof process !== "undefined" && process.memoryUsage) {
+          const mem = process.memoryUsage();
+          sample.memory = {
+            heapUsed: mem.heapUsed / 1024 / 1024,
+            heapTotal: mem.heapTotal / 1024 / 1024,
+            external: mem.external / 1024 / 1024,
+            rss: mem.rss / 1024 / 1024
+          };
+        } else if (typeof performance !== "undefined" && performance.memory) {
+          sample.memory = {
+            heapUsed: performance.memory.usedJSHeapSize / 1024 / 1024,
+            heapTotal: performance.memory.totalJSHeapSize / 1024 / 1024
+          };
+        }
+      }
+      resourceState.samples.push(sample);
+      if (resourceState.samples.length > 100) {
+        resourceState.samples = resourceState.samples.slice(-100);
+      }
+      resourceState.timer = setTimeout(collectResources, opts.resources.interval);
+    };
+    collectResources();
+  }
+  function stopResourceMonitoring() {
+    if (resourceState.timer) {
+      clearTimeout(resourceState.timer);
+      resourceState.timer = null;
+    }
+  }
+  function startReporting() {
+    if (!opts.reporting.enabled) return;
+    reportingState.reportTimer = setInterval(() => {
+      generateReport();
+    }, opts.reporting.interval);
+    if (opts.reporting.batch.enabled) {
+      reportingState.flushTimer = setInterval(() => {
+        flushBatch();
+      }, opts.reporting.batch.flushInterval);
+    }
+  }
+  function stopReporting() {
+    if (reportingState.reportTimer) {
+      clearInterval(reportingState.reportTimer);
+      reportingState.reportTimer = null;
+    }
+    if (reportingState.flushTimer) {
+      clearInterval(reportingState.flushTimer);
+      reportingState.flushTimer = null;
+    }
+    flushBatch();
+  }
+  function startProfiling() {
+    if (!opts.profiling.enabled) return;
+  }
+  function recordTrace(name, duration, metadata = {}) {
+    if (!opts.profiling.enabled || !opts.profiling.tracing.enabled) return;
+    if (Math.random() < opts.profiling.tracing.sampleRate) {
+      profilingState.traces.push({
+        name,
+        duration,
+        metadata,
+        timestamp: Date.now()
+      });
+      if (profilingState.traces.length > 1e3) {
+        profilingState.traces = profilingState.traces.slice(-1e3);
+      }
+    }
+  }
+  function measure(name, fn, metadata = {}) {
+    if (!opts.enabled) return fn();
+    const start = performance.now();
+    try {
+      const result = fn();
+      const duration = performance.now() - start;
+      recordMetric("renderTime", duration, { name, ...metadata });
+      recordTrace(name, duration, metadata);
+      return result;
+    } catch (error) {
+      recordMetric("errorCount", 1, { name, error: error.message });
+      throw error;
+    }
+  }
+  async function measureAsync(name, fn, metadata = {}) {
+    if (!opts.enabled) return fn();
+    const start = performance.now();
+    try {
+      const result = await fn();
+      const duration = performance.now() - start;
+      recordMetric("renderTime", duration, { name, ...metadata });
+      recordTrace(name, duration, metadata);
+      return result;
+    } catch (error) {
+      recordMetric("errorCount", 1, { name, error: error.message });
+      throw error;
+    }
+  }
+  function addMetric(name, config) {
+    metrics.custom[name] = {
+      type: config.type || "counter",
+      unit: config.unit || "",
+      threshold: config.threshold,
+      values: config.type === "histogram" ? [] : void 0,
+      value: config.type === "counter" || config.type === "gauge" ? 0 : void 0
+    };
+  }
+  function addAlertRule(rule) {
+    opts.alerts.rules.push(rule);
+  }
+  function getStats() {
+    return {
+      ...stats,
+      sampleRate: samplingState.adaptiveRate,
+      batchSize: reportingState.batch.length,
+      resourceSamples: resourceState.samples.length,
+      traces: profilingState.traces.length,
+      alerts: {
+        total: alertState.history.length,
+        unique: alertState.triggered.size
+      }
+    };
+  }
+  function reset() {
+    Object.values(metrics.builtin).forEach((metric) => {
+      if (metric.type === "histogram" || metric.type === "gauge") {
+        metric.values = [];
+      } else if (metric.type === "counter") {
+        metric.value = 0;
+      }
+    });
+    Object.values(metrics.custom).forEach((metric) => {
+      if (metric.type === "histogram" || metric.type === "gauge") {
+        metric.values = [];
+      } else if (metric.type === "counter") {
+        metric.value = 0;
+      }
+    });
+    samplingState.count = 0;
+    samplingState.sampled = 0;
+    reportingState.batch = [];
+    alertState.history = [];
+    alertState.triggered.clear();
+    resourceState.samples = [];
+    profilingState.traces = [];
+    stats.metricsRecorded = 0;
+    stats.reportsGenerated = 0;
+    stats.alertsTriggered = 0;
+  }
+  if (opts.enabled) {
+    startResourceMonitoring();
+    startReporting();
+    startProfiling();
+  }
+  return {
+    recordMetric,
+    measure,
+    measureAsync,
+    addMetric,
+    addAlertRule,
+    generateReport,
+    getStats,
+    reset,
+    start() {
+      opts.enabled = true;
+      startResourceMonitoring();
+      startReporting();
+      startProfiling();
+    },
+    stop() {
+      opts.enabled = false;
+      stopResourceMonitoring();
+      stopReporting();
+      return generateReport();
+    }
+  };
+}
+var performanceMonitor2 = createPerformanceMonitor();
+
+// ../core/src/core/object-utils.js
+function deepClone(obj, seen = /* @__PURE__ */ new WeakMap()) {
+  if (obj === null || typeof obj !== "object") {
+    return obj;
+  }
+  if (seen.has(obj)) {
+    return seen.get(obj);
+  }
+  if (obj instanceof Date) {
+    return new Date(obj.getTime());
+  }
+  if (obj instanceof RegExp) {
+    return new RegExp(obj.source, obj.flags);
+  }
+  if (Array.isArray(obj)) {
+    const clonedArray = [];
+    seen.set(obj, clonedArray);
+    for (let i = 0; i < obj.length; i++) {
+      clonedArray[i] = deepClone(obj[i], seen);
+    }
+    return clonedArray;
+  }
+  if (typeof obj === "function") {
+    return obj;
+  }
+  if (obj instanceof Map) {
+    const clonedMap = /* @__PURE__ */ new Map();
+    seen.set(obj, clonedMap);
+    for (const [key, value] of obj) {
+      clonedMap.set(deepClone(key, seen), deepClone(value, seen));
+    }
+    return clonedMap;
+  }
+  if (obj instanceof Set) {
+    const clonedSet = /* @__PURE__ */ new Set();
+    seen.set(obj, clonedSet);
+    for (const value of obj) {
+      clonedSet.add(deepClone(value, seen));
+    }
+    return clonedSet;
+  }
+  if (obj instanceof WeakMap) {
+    return /* @__PURE__ */ new WeakMap();
+  }
+  if (obj instanceof WeakSet) {
+    return /* @__PURE__ */ new WeakSet();
+  }
+  const clonedObj = {};
+  seen.set(obj, clonedObj);
+  if (obj.constructor && obj.constructor !== Object) {
+    try {
+      clonedObj.__proto__ = obj.__proto__;
+    } catch {
+      Object.setPrototypeOf(clonedObj, Object.getPrototypeOf(obj));
+    }
+  }
+  for (const key in obj) {
+    if (obj.hasOwnProperty(key)) {
+      clonedObj[key] = deepClone(obj[key], seen);
+    }
+  }
+  const descriptors = Object.getOwnPropertyDescriptors(obj);
+  for (const key of Object.keys(descriptors)) {
+    if (!descriptors[key].enumerable && descriptors[key].configurable) {
+      try {
+        Object.defineProperty(clonedObj, key, {
+          ...descriptors[key],
+          value: deepClone(descriptors[key].value, seen)
+        });
+      } catch {
+      }
+    }
+  }
+  return clonedObj;
+}
+function validateComponent(component, path2 = "root") {
+  if (component === null || component === void 0) {
+    throw new Error(`Invalid component at ${path2}: null or undefined`);
+  }
+  if (["string", "number", "boolean"].includes(typeof component)) {
+    return true;
+  }
+  if (typeof component === "function") {
+    return true;
+  }
+  if (Array.isArray(component)) {
+    component.forEach((child, index) => {
+      validateComponent(child, `${path2}[${index}]`);
+    });
+    return true;
+  }
+  if (typeof component === "object") {
+    const keys = Object.keys(component);
+    if (keys.length === 0) {
+      throw new Error(`Empty object at ${path2}`);
+    }
+    keys.forEach((key) => {
+      const value = component[key];
+      if (!/^[a-zA-Z][a-zA-Z0-9-]*$/.test(key) && key !== "text") {
+        console.warn(`Potentially invalid tag name at ${path2}: ${key}`);
+      }
+      if (value && typeof value === "object" && !Array.isArray(value)) {
+        if (value.children) {
+          validateComponent(value.children, `${path2}.${key}.children`);
+        }
+      } else if (value && typeof value !== "string" && typeof value !== "number" && typeof value !== "function") {
+        throw new Error(`Invalid value type at ${path2}.${key}: ${typeof value}`);
+      }
+    });
+    return true;
+  }
+  throw new Error(`Invalid component type at ${path2}: ${typeof component}`);
+}
+function isCoherentObject(obj) {
+  if (!obj || typeof obj !== "object" || Array.isArray(obj)) {
+    return false;
+  }
+  const keys = Object.keys(obj);
+  if (keys.length === 0) {
+    return false;
+  }
+  return keys.every((key) => {
+    if (key === "text") return true;
+    return /^[a-zA-Z][a-zA-Z0-9-]*$/.test(key);
+  });
+}
+function extractProps(coherentObj) {
+  if (!isCoherentObject(coherentObj)) {
+    return {};
+  }
+  const props = {};
+  const keys = Object.keys(coherentObj);
+  keys.forEach((tag) => {
+    const value = coherentObj[tag];
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+      props[tag] = { ...value };
+    } else {
+      props[tag] = { text: value };
+    }
+  });
+  return props;
+}
+function hasChildren(component) {
+  if (Array.isArray(component)) {
+    return component.length > 0;
+  }
+  if (isCoherentObject(component)) {
+    if (component.children !== void 0 && component.children !== null) {
+      return Array.isArray(component.children) ? component.children.length > 0 : true;
+    }
+    const keys = Object.keys(component);
+    return keys.some((key) => {
+      const value = component[key];
+      return value && typeof value === "object" && value.children;
+    });
+  }
+  return false;
+}
+function normalizeChildren(children) {
+  if (children === null || children === void 0) {
+    return [];
+  }
+  if (Array.isArray(children)) {
+    return children.flat().filter((child) => child !== null && child !== void 0);
+  }
+  return [children];
+}
+
+// ../core/src/components/component-system.js
+var COMPONENT_METADATA = /* @__PURE__ */ new WeakMap();
+var ComponentState = class {
+  constructor(initialState = {}) {
+    this.state = { ...initialState };
+    this.listeners = /* @__PURE__ */ new Set();
+    this.isUpdating = false;
+  }
+  /**
+   * Get state value by key or entire state
+   * 
+   * @param {string} [key] - State key to retrieve
+   * @returns {*} State value or entire state object
+   */
+  get(key) {
+    return key ? this.state[key] : { ...this.state };
+  }
+  /**
+   * Update state with new values
+   * 
+   * @param {Object} updates - State updates to apply
+   * @returns {ComponentState} This instance for chaining
+   */
+  set(updates) {
+    if (this.isUpdating) return this;
+    const oldState = { ...this.state };
+    if (typeof updates === "function") {
+      updates = updates(oldState);
+    }
+    this.state = { ...this.state, ...updates };
+    this.notifyListeners(oldState, this.state);
+    return this;
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  notifyListeners(oldState, newState) {
+    if (this.listeners.size === 0) return;
+    this.isUpdating = true;
+    this.listeners.forEach((listener) => {
+      try {
+        listener(newState, oldState);
+      } catch (_error) {
+        console.error("State listener _error:", _error);
+      }
+    });
+    this.isUpdating = false;
+  }
+};
+var Component = class _Component {
+  constructor(definition = {}) {
+    this.definition = definition;
+    this.name = definition.name || "AnonymousComponent";
+    this.props = {};
+    this.state = new ComponentState(definition.state || {});
+    this.children = [];
+    this.parent = null;
+    this.rendered = null;
+    this.isMounted = false;
+    this.isDestroyed = false;
+    this.hooks = {
+      beforeCreate: definition.beforeCreate || (() => {
+      }),
+      created: definition.created || (() => {
+      }),
+      beforeMount: definition.beforeMount || (() => {
+      }),
+      mounted: definition.mounted || (() => {
+      }),
+      beforeUpdate: definition.beforeUpdate || (() => {
+      }),
+      updated: definition.updated || (() => {
+      }),
+      beforeDestroy: definition.beforeDestroy || (() => {
+      }),
+      destroyed: definition.destroyed || (() => {
+      }),
+      errorCaptured: definition.errorCaptured || (() => {
+      })
+    };
+    this.methods = definition.methods || {};
+    Object.keys(this.methods).forEach((methodName) => {
+      if (typeof this.methods[methodName] === "function") {
+        this[methodName] = this.methods[methodName].bind(this);
+      }
+    });
+    this.computed = definition.computed || {};
+    this.computedCache = /* @__PURE__ */ new Map();
+    this.watchers = definition.watch || {};
+    this.setupWatchers();
+    COMPONENT_METADATA.set(this, {
+      createdAt: Date.now(),
+      updateCount: 0,
+      renderCount: 0
+    });
+    this.callHook("beforeCreate");
+    this.initialize();
+    this.callHook("created");
+  }
+  /**
+   * Initialize component
+   */
+  initialize() {
+    this.unsubscribeState = this.state.subscribe((newState, oldState) => {
+      this.onStateChange(newState, oldState);
+    });
+    this.initializeComputed();
+  }
+  /**
+   * Set up watchers for reactive data
+   */
+  setupWatchers() {
+    Object.keys(this.watchers).forEach((key) => {
+      const handler = this.watchers[key];
+      this.state.subscribe((newState, oldState) => {
+        if (newState[key] !== oldState[key]) {
+          handler.call(this, newState[key], oldState[key]);
+        }
+      });
+    });
+  }
+  /**
+   * Initialize computed properties
+   */
+  initializeComputed() {
+    Object.keys(this.computed).forEach((key) => {
+      Object.defineProperty(this, key, {
+        get: () => {
+          if (!this.computedCache.has(key)) {
+            const value = this.computed[key].call(this);
+            this.computedCache.set(key, value);
+          }
+          return this.computedCache.get(key);
+        },
+        enumerable: true
+      });
+    });
+  }
+  /**
+   * Handle state changes
+   */
+  onStateChange() {
+    if (this.isDestroyed) return;
+    this.computedCache.clear();
+    if (this.isMounted) {
+      this.update();
+    }
+  }
+  /**
+   * Call lifecycle hook
+   */
+  callHook(hookName, ...args) {
+    try {
+      if (this.hooks[hookName]) {
+        return this.hooks[hookName].call(this, ...args);
+      }
+    } catch (_error) {
+      this.handleError(_error, `${hookName} hook`);
+    }
+  }
+  /**
+   * Handle component errors
+   */
+  handleError(_error) {
+    console.error(`Component Error in ${this.name}:`, _error);
+    this.callHook("errorCaptured", _error);
+    if (this.parent && this.parent.handleError) {
+      this.parent.handleError(_error, `${this.name} -> ${context}`);
+    }
+  }
+  /**
+   * Render the component
+   */
+  render(props = {}) {
+    if (this.isDestroyed) {
+      console.warn(`Attempting to render destroyed component: ${this.name}`);
+      return null;
+    }
+    try {
+      const metadata = COMPONENT_METADATA.get(this);
+      if (metadata) {
+        metadata.renderCount++;
+      }
+      this.props = { ...props };
+      if (typeof this.definition.render === "function") {
+        this.rendered = this.definition.render.call(this, this.props, this.state.get());
+      } else if (typeof this.definition.template !== "undefined") {
+        this.rendered = this.processTemplate(this.definition.template, this.props, this.state.get());
+      } else {
+        throw new Error(`Component ${this.name} must have either render method or template`);
+      }
+      if (this.rendered !== null) {
+        validateComponent(this.rendered, this.name);
+      }
+      return this.rendered;
+    } catch (_error) {
+      this.handleError(_error);
+      return { div: { className: "component-_error", text: `Error in ${this.name}` } };
+    }
+  }
+  /**
+   * Process template with data
+   */
+  processTemplate(template, props, state) {
+    if (typeof template === "function") {
+      return template.call(this, props, state);
+    }
+    if (typeof template === "string") {
+      return template.replace(/\{\{(\w+)\}\}/g, (match, key) => {
+        return props[key] || state[key] || "";
+      });
+    }
+    const processed = deepClone(template);
+    this.interpolateObject(processed, { ...props, ...state });
+    return processed;
+  }
+  /**
+   * Interpolate object with data
+   */
+  interpolateObject(obj, data) {
+    if (typeof obj === "string") {
+      return obj.replace(/\{\{(\w+)\}\}/g, (match, key) => data[key] || "");
+    }
+    if (Array.isArray(obj)) {
+      return obj.map((item) => this.interpolateObject(item, data));
+    }
+    if (obj && typeof obj === "object") {
+      Object.keys(obj).forEach((key) => {
+        obj[key] = this.interpolateObject(obj[key], data);
+      });
+    }
+    return obj;
+  }
+  /**
+   * Mount the component
+   */
+  mount() {
+    if (this.isMounted || this.isDestroyed) return this;
+    this.callHook("beforeMount");
+    this.isMounted = true;
+    this.callHook("mounted");
+    return this;
+  }
+  /**
+   * Update the component
+   */
+  update() {
+    if (!this.isMounted || this.isDestroyed) return this;
+    const metadata = COMPONENT_METADATA.get(this);
+    if (metadata) {
+      metadata.updateCount++;
+    }
+    this.callHook("beforeUpdate");
+    this.callHook("updated");
+    return this;
+  }
+  /**
+   * Destroy the component
+   */
+  destroy() {
+    if (this.isDestroyed) return this;
+    this.callHook("beforeDestroy");
+    if (this.unsubscribeState) {
+      this.unsubscribeState();
+    }
+    this.children.forEach((child) => {
+      if (child.destroy) {
+        child.destroy();
+      }
+    });
+    this.isMounted = false;
+    this.isDestroyed = true;
+    this.children = [];
+    this.parent = null;
+    this.callHook("destroyed");
+    return this;
+  }
+  /**
+   * Get component metadata
+   */
+  getMetadata() {
+    return COMPONENT_METADATA.get(this) || {};
+  }
+  /**
+   * Clone component with new props/state
+   */
+  clone(overrides = {}) {
+    const newDefinition = { ...this.definition, ...overrides };
+    return new _Component(newDefinition);
+  }
+};
+if (performanceMonitor2) {
+  const originalRender = Component.prototype.render;
+  Component.prototype.render = function(...args) {
+    const start = performance.now();
+    const result = originalRender.apply(this, args);
+    const duration = performance.now() - start;
+    performanceMonitor2.recordMetric("renderTime", duration, {
+      type: "component",
+      name: this.name,
+      propsSize: JSON.stringify(this.props || {}).length,
+      hasState: Object.keys(this.state?.get() || {}).length > 0
+    });
+    return result;
+  };
+}
+
+// ../core/src/utils/error-handler.js
+var CoherentError = class _CoherentError extends Error {
+  constructor(message, options = {}) {
+    super(message);
+    this.name = "CoherentError";
+    this.type = options.type || "generic";
+    this.component = options.component;
+    this.context = options.context;
+    this.suggestions = options.suggestions || [];
+    this.timestamp = Date.now();
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _CoherentError);
+    }
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      type: this.type,
+      component: this.component,
+      context: this.context,
+      suggestions: this.suggestions,
+      timestamp: this.timestamp,
+      stack: this.stack
+    };
+  }
+};
+var ComponentValidationError = class extends CoherentError {
+  constructor(message, component, suggestions = []) {
+    super(message, {
+      type: "validation",
+      component,
+      suggestions: [
+        "Check component structure and syntax",
+        "Ensure all required properties are present",
+        "Validate prop types and values",
+        ...suggestions
+      ]
+    });
+    this.name = "ComponentValidationError";
+  }
+};
+var RenderingError = class extends CoherentError {
+  constructor(message, component, context2, suggestions = []) {
+    super(message, {
+      type: "rendering",
+      component,
+      context: context2,
+      suggestions: [
+        "Check for circular references",
+        "Validate component depth",
+        "Ensure all functions return valid components",
+        ...suggestions
+      ]
+    });
+    this.name = "RenderingError";
+  }
+};
+var PerformanceError = class extends CoherentError {
+  constructor(message, metrics, suggestions = []) {
+    super(message, {
+      type: "performance",
+      context: metrics,
+      suggestions: [
+        "Consider component memoization",
+        "Reduce component complexity",
+        "Enable caching",
+        ...suggestions
+      ]
+    });
+    this.name = "PerformanceError";
+  }
+};
+var StateError = class extends CoherentError {
+  constructor(message, state, suggestions = []) {
+    super(message, {
+      type: "state",
+      context: state,
+      suggestions: [
+        "Check state mutations",
+        "Ensure proper state initialization",
+        "Validate state transitions",
+        ...suggestions
+      ]
+    });
+    this.name = "StateError";
+  }
+};
+var ErrorHandler = class {
+  constructor(options = {}) {
+    this.options = {
+      enableStackTrace: options.enableStackTrace !== false,
+      enableSuggestions: options.enableSuggestions !== false,
+      enableLogging: options.enableLogging !== false,
+      logLevel: options.logLevel || "_error",
+      maxErrorHistory: options.maxErrorHistory || 100,
+      ...options
+    };
+    this.errorHistory = [];
+    this.errorCounts = /* @__PURE__ */ new Map();
+    this.suppressedErrors = /* @__PURE__ */ new Set();
+  }
+  /**
+   * Handle and report errors with detailed context
+   */
+  handle(_error, context2 = {}) {
+    const enhancedError = this.enhanceError(_error, context2);
+    this.addToHistory(enhancedError);
+    if (this.options.enableLogging) {
+      this.logError(enhancedError);
+    }
+    return enhancedError;
+  }
+  /**
+   * Enhance existing errors with more context
+   */
+  enhanceError(_error, context2 = {}) {
+    if (_error instanceof CoherentError) {
+      return _error;
+    }
+    const errorType = this.classifyError(_error, context2);
+    switch (errorType) {
+      case "validation":
+        return new ComponentValidationError(
+          _error.message,
+          context2.component,
+          this.generateSuggestions(_error, context2)
+        );
+      case "rendering":
+        return new RenderingError(
+          _error.message,
+          context2.component,
+          context2.renderContext,
+          this.generateSuggestions(_error, context2)
+        );
+      case "performance":
+        return new PerformanceError(
+          _error.message,
+          context2.metrics,
+          this.generateSuggestions(_error, context2)
+        );
+      case "state":
+        return new StateError(
+          _error.message,
+          context2.state,
+          this.generateSuggestions(_error, context2)
+        );
+      default:
+        return new CoherentError(_error.message, {
+          type: errorType,
+          component: context2.component,
+          context: context2.context,
+          suggestions: this.generateSuggestions(_error, context2)
+        });
+    }
+  }
+  /**
+   * Classify _error type based on message and context
+   */
+  classifyError(_error, context2) {
+    const message = _error.message.toLowerCase();
+    if (message.includes("invalid") || message.includes("validation") || message.includes("required") || message.includes("type")) {
+      return "validation";
+    }
+    if (message.includes("render") || message.includes("circular") || message.includes("depth") || message.includes("cannot render")) {
+      return "rendering";
+    }
+    if (message.includes("slow") || message.includes("memory") || message.includes("performance") || message.includes("timeout")) {
+      return "performance";
+    }
+    if (message.includes("state") || message.includes("mutation") || message.includes("store") || context2.state) {
+      return "state";
+    }
+    if (context2.component) return "validation";
+    if (context2.renderContext) return "rendering";
+    if (context2.metrics) return "performance";
+    return "generic";
+  }
+  /**
+   * Generate helpful suggestions based on _error
+   */
+  generateSuggestions(_error, context2 = {}) {
+    const suggestions = [];
+    const message = _error.message.toLowerCase();
+    const patterns = [
+      {
+        pattern: /cannot render|render.*failed/,
+        suggestions: [
+          "Check if component returns a valid object structure",
+          "Ensure all properties are properly defined",
+          "Look for undefined variables or null references"
+        ]
+      },
+      {
+        pattern: /circular.*reference/,
+        suggestions: [
+          "Remove circular references between components",
+          "Use lazy loading or memoization to break cycles",
+          "Check for self-referencing components"
+        ]
+      },
+      {
+        pattern: /maximum.*depth/,
+        suggestions: [
+          "Reduce component nesting depth",
+          "Break complex components into smaller parts",
+          "Check for infinite recursion in component functions"
+        ]
+      },
+      {
+        pattern: /invalid.*component/,
+        suggestions: [
+          "Ensure component follows the expected object structure",
+          "Check property names and values for typos",
+          "Verify component is not null or undefined"
+        ]
+      },
+      {
+        pattern: /performance|slow|timeout/,
+        suggestions: [
+          "Enable component caching",
+          "Use memoization for expensive operations",
+          "Reduce component complexity",
+          "Consider lazy loading for large components"
+        ]
+      }
+    ];
+    patterns.forEach(({ pattern, suggestions: patternSuggestions }) => {
+      if (pattern.test(message)) {
+        suggestions.push(...patternSuggestions);
+      }
+    });
+    if (context2.component) {
+      const componentType = typeof context2.component;
+      if (componentType === "function") {
+        suggestions.push("Check function component return value");
+      } else if (componentType === "object" && context2.component === null) {
+        suggestions.push("Component is null - ensure proper initialization");
+      } else if (Array.isArray(context2.component)) {
+        suggestions.push("Arrays should contain valid component objects");
+      }
+    }
+    if (suggestions.length === 0) {
+      suggestions.push(
+        "Enable development tools for more detailed debugging",
+        "Check browser console for additional _error details",
+        "Use component validation tools to identify issues"
+      );
+    }
+    return [...new Set(suggestions)];
+  }
+  /**
+   * Add _error to history with deduplication
+   */
+  addToHistory(_error) {
+    const errorKey = `${_error.name}:${_error.message}`;
+    this.errorCounts.set(errorKey, (this.errorCounts.get(errorKey) || 0) + 1);
+    const historyEntry = {
+      ..._error.toJSON(),
+      count: this.errorCounts.get(errorKey),
+      firstSeen: this.errorHistory.find((e) => e.key === errorKey)?.firstSeen || _error.timestamp,
+      key: errorKey
+    };
+    this.errorHistory = this.errorHistory.filter((e) => e.key !== errorKey);
+    this.errorHistory.unshift(historyEntry);
+    if (this.errorHistory.length > this.options.maxErrorHistory) {
+      this.errorHistory = this.errorHistory.slice(0, this.options.maxErrorHistory);
+    }
+  }
+  /**
+   * Log _error with enhanced formatting
+   */
+  logError(_error) {
+    if (this.suppressedErrors.has(`${_error.name}:${_error.message}`)) {
+      return;
+    }
+    const isRepeated = this.errorCounts.get(`${_error.name}:${_error.message}`) > 1;
+    const errorGroup = `\u{1F6A8} ${_error.name}${isRepeated ? ` (\xD7${this.errorCounts.get(`${_error.name}:${_error.message}`)})` : ""}`;
+    console.group(errorGroup);
+    console.error(`\u274C ${_error.message}`);
+    if (_error.component) {
+      console.log("\u{1F50D} Component:", this.formatComponent(_error.component));
+    }
+    if (_error.context) {
+      console.log("\u{1F4CB} Context:", _error.context);
+    }
+    if (this.options.enableSuggestions && _error.suggestions.length > 0) {
+      console.group("\u{1F4A1} Suggestions:");
+      _error.suggestions.forEach((suggestion, index) => {
+        console.log(`${index + 1}. ${suggestion}`);
+      });
+      console.groupEnd();
+    }
+    if (this.options.enableStackTrace && _error.stack) {
+      console.log("\u{1F4DA} Stack trace:", _error.stack);
+    }
+    console.groupEnd();
+  }
+  /**
+   * Format component for logging
+   */
+  formatComponent(component, maxDepth = 2, currentDepth = 0) {
+    if (currentDepth > maxDepth) {
+      return "[...deep]";
+    }
+    if (typeof component === "function") {
+      return `[Function: ${component.name || "anonymous"}]`;
+    }
+    if (Array.isArray(component)) {
+      return component.slice(0, 3).map(
+        (item) => this.formatComponent(item, maxDepth, currentDepth + 1)
+      );
+    }
+    if (component && typeof component === "object") {
+      const formatted = {};
+      const keys = Object.keys(component).slice(0, 5);
+      for (const key of keys) {
+        if (key === "children" && component[key]) {
+          formatted[key] = this.formatComponent(component[key], maxDepth, currentDepth + 1);
+        } else {
+          formatted[key] = component[key];
+        }
+      }
+      if (Object.keys(component).length > 5) {
+        formatted["..."] = `(${Object.keys(component).length - 5} more)`;
+      }
+      return formatted;
+    }
+    return component;
+  }
+  /**
+   * Suppress specific _error types
+   */
+  suppress(errorPattern) {
+    this.suppressedErrors.add(errorPattern);
+  }
+  /**
+   * Clear _error history
+   */
+  clearHistory() {
+    this.errorHistory = [];
+    this.errorCounts.clear();
+  }
+  /**
+   * Get _error statistics
+   */
+  getStats() {
+    const errorsByType = {};
+    const errorsByTime = {};
+    this.errorHistory.forEach((_error) => {
+      errorsByType[_error.type] = (errorsByType[_error.type] || 0) + _error.count;
+      const hour = new Date(_error.timestamp).toISOString().slice(0, 13);
+      errorsByTime[hour] = (errorsByTime[hour] || 0) + _error.count;
+    });
+    return {
+      totalErrors: this.errorHistory.reduce((sum, e) => sum + e.count, 0),
+      uniqueErrors: this.errorHistory.length,
+      errorsByType,
+      errorsByTime,
+      mostCommonErrors: this.getMostCommonErrors(5),
+      recentErrors: this.errorHistory.slice(0, 10)
+    };
+  }
+  /**
+   * Get most common errors
+   */
+  getMostCommonErrors(limit = 10) {
+    return this.errorHistory.sort((a, b) => b.count - a.count).slice(0, limit).map(({ name, message, count, type }) => ({
+      name,
+      message,
+      count,
+      type
+    }));
+  }
+};
+var globalErrorHandler = new ErrorHandler();
+
+// ../core/src/components/lifecycle.js
+var LIFECYCLE_PHASES = {
+  BEFORE_CREATE: "beforeCreate",
+  CREATED: "created",
+  BEFORE_MOUNT: "beforeMount",
+  MOUNTED: "mounted",
+  BEFORE_UPDATE: "beforeUpdate",
+  UPDATED: "updated",
+  BEFORE_UNMOUNT: "beforeUnmount",
+  UNMOUNTED: "unmounted",
+  ERROR: "_error"
+};
+var componentInstances = /* @__PURE__ */ new WeakMap();
+var ComponentEventSystem = class {
+  constructor() {
+    this.events = /* @__PURE__ */ new Map();
+    this.globalHandlers = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Emit event to component or globally
+   */
+  emit(eventName, data = {}, target = null) {
+    const event = {
+      name: eventName,
+      data,
+      target,
+      timestamp: Date.now(),
+      stopped: false,
+      preventDefault: false
+    };
+    if (target) {
+      const instance = componentInstances.get(target);
+      if (instance) {
+        this._notifyHandlers(instance.id, event);
+      }
+    } else {
+      this._notifyGlobalHandlers(event);
+    }
+    return event;
+  }
+  /**
+   * Listen for events on component or globally
+   */
+  on(eventName, handler, componentId = null) {
+    if (componentId) {
+      if (!this.events.has(componentId)) {
+        this.events.set(componentId, /* @__PURE__ */ new Map());
+      }
+      const componentEvents = this.events.get(componentId);
+      if (!componentEvents.has(eventName)) {
+        componentEvents.set(eventName, /* @__PURE__ */ new Set());
+      }
+      componentEvents.get(eventName).add(handler);
+    } else {
+      if (!this.globalHandlers.has(eventName)) {
+        this.globalHandlers.set(eventName, /* @__PURE__ */ new Set());
+      }
+      this.globalHandlers.get(eventName).add(handler);
+    }
+    return () => this.off(eventName, handler, componentId);
+  }
+  /**
+   * Remove event handler
+   */
+  off(eventName, handler, componentId = null) {
+    if (componentId) {
+      const componentEvents = this.events.get(componentId);
+      if (componentEvents && componentEvents.has(eventName)) {
+        componentEvents.get(eventName).delete(handler);
+        if (componentEvents.get(eventName).size === 0) {
+          componentEvents.delete(eventName);
+          if (componentEvents.size === 0) {
+            this.events.delete(componentId);
+          }
+        }
+      }
+    } else {
+      const handlers = this.globalHandlers.get(eventName);
+      if (handlers) {
+        handlers.delete(handler);
+        if (handlers.size === 0) {
+          this.globalHandlers.delete(eventName);
+        }
+      }
+    }
+  }
+  /**
+   * Listen once
+   */
+  once(eventName, handler, componentId = null) {
+    const onceHandler = (event) => {
+      handler(event);
+      this.off(eventName, onceHandler, componentId);
+    };
+    return this.on(eventName, onceHandler, componentId);
+  }
+  /**
+   * Notify component handlers
+   */
+  _notifyHandlers(componentId, event) {
+    const componentEvents = this.events.get(componentId);
+    if (componentEvents && componentEvents.has(event.name)) {
+      const handlers = componentEvents.get(event.name);
+      for (const handler of handlers) {
+        if (event.stopped) break;
+        try {
+          handler(event);
+        } catch (_error) {
+          globalErrorHandler.handle(_error, {
+            type: "event-handler-_error",
+            context: { event, handler: handler.toString() }
+          });
+        }
+      }
+    }
+  }
+  /**
+   * Notify global handlers
+   */
+  _notifyGlobalHandlers(event) {
+    const handlers = this.globalHandlers.get(event.name);
+    if (handlers) {
+      for (const handler of handlers) {
+        if (event.stopped) break;
+        try {
+          handler(event);
+        } catch (_error) {
+          globalErrorHandler.handle(_error, {
+            type: "global-event-handler-_error",
+            context: { event, handler: handler.toString() }
+          });
+        }
+      }
+    }
+  }
+  /**
+   * Clean up events for a component
+   */
+  cleanup(componentId) {
+    this.events.delete(componentId);
+  }
+  /**
+   * Get event statistics
+   */
+  getStats() {
+    return {
+      componentEvents: this.events.size,
+      globalEvents: this.globalHandlers.size,
+      totalHandlers: Array.from(this.events.values()).reduce((sum, events) => {
+        return sum + Array.from(events.values()).reduce((eventSum, handlers) => {
+          return eventSum + handlers.size;
+        }, 0);
+      }, 0) + Array.from(this.globalHandlers.values()).reduce((sum, handlers) => {
+        return sum + handlers.size;
+      }, 0)
+    };
+  }
+};
+var eventSystem = new ComponentEventSystem();
+function createLifecycleHooks() {
+  const hooks = {};
+  Object.values(LIFECYCLE_PHASES).forEach((phase) => {
+    hooks[phase] = (callback) => {
+      const instance = getCurrentInstance();
+      if (instance) {
+        instance.hook(phase, callback);
+      }
+    };
+  });
+  return hooks;
+}
+var currentInstance = null;
+function getCurrentInstance() {
+  return currentInstance;
+}
+var useHooks = createLifecycleHooks();
+
+// ../core/src/events/event-bus.js
+function throttle(func, delay) {
+  let lastCall = 0;
+  let timeoutId = null;
+  return function throttled(...args) {
+    const now = Date.now();
+    const timeSinceLastCall = now - lastCall;
+    if (timeSinceLastCall >= delay) {
+      lastCall = now;
+      return func.apply(this, args);
+    } else {
+      if (timeoutId) clearTimeout(timeoutId);
+      timeoutId = setTimeout(() => {
+        lastCall = Date.now();
+        func.apply(this, args);
+      }, delay - timeSinceLastCall);
+    }
+  };
+}
+var EventBus = class {
+  constructor(options = {}) {
+    this.listeners = /* @__PURE__ */ new Map();
+    this.handlers = /* @__PURE__ */ new Map();
+    this.actionHandlers = /* @__PURE__ */ new Map();
+    this.middleware = [];
+    this.throttledEmitters = /* @__PURE__ */ new Map();
+    this.debouncedEmitters = /* @__PURE__ */ new Map();
+    this.options = {
+      debug: false,
+      performance: true,
+      maxListeners: 100,
+      enableWildcards: true,
+      enableAsync: true,
+      wildcardSeparator: ":",
+      enablePriority: true,
+      defaultPriority: 0,
+      errorHandler: null,
+      filters: {
+        allowList: null,
+        // null means allow all
+        blockList: []
+      },
+      throttle: {
+        enabled: false,
+        defaultDelay: 100,
+        events: {}
+      },
+      batching: {
+        enabled: false,
+        maxBatchSize: 10,
+        flushInterval: 16
+      },
+      ...options
+    };
+    this.stats = {
+      eventsEmitted: 0,
+      listenersExecuted: 0,
+      errorsOccurred: 0,
+      averageEmitTime: 0,
+      throttledEvents: 0,
+      filteredEvents: 0
+    };
+    if (this.options.batching.enabled) {
+      this.batchQueue = [];
+      this.batchTimer = null;
+    }
+    if (this.options.debug) {
+      this.use((event, data, next) => {
+        console.log(`[EventBus] ${event}:`, data);
+        next();
+      });
+    }
+  }
+  /**
+   * Add middleware
+   */
+  use(middleware) {
+    if (typeof middleware !== "function") {
+      throw new Error("Middleware must be a function");
+    }
+    this.middleware.push(middleware);
+    return this;
+  }
+  /**
+   * Check if event passes filters
+   */
+  passesFilters(event) {
+    const { allowList, blockList } = this.options.filters;
+    if (blockList && blockList.length > 0) {
+      for (const pattern of blockList) {
+        if (this.matchPattern(pattern, event)) {
+          this.stats.filteredEvents++;
+          return false;
+        }
+      }
+    }
+    if (allowList && allowList.length > 0) {
+      for (const pattern of allowList) {
+        if (this.matchPattern(pattern, event)) {
+          return true;
+        }
+      }
+      this.stats.filteredEvents++;
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Match event against pattern
+   */
+  matchPattern(pattern, event) {
+    const sep = this.options.wildcardSeparator;
+    const patternParts = pattern.split(sep);
+    const eventParts = event.split(sep);
+    if (pattern.includes("*")) {
+      if (patternParts.length !== eventParts.length) {
+        return false;
+      }
+      return patternParts.every((part, i) => part === "*" || part === eventParts[i]);
+    }
+    return pattern === event;
+  }
+  /**
+   * Emit an event
+   */
+  async emit(event, data = null) {
+    if (!this.passesFilters(event)) {
+      if (this.options.debug) {
+        console.warn(`[EventBus] Event filtered: ${event}`);
+      }
+      return;
+    }
+    if (this.options.batching.enabled) {
+      return this.addToBatch(event, data);
+    }
+    if (this.options.throttle.enabled) {
+      const throttleDelay = this.options.throttle.events && this.options.throttle.events[event] || this.options.throttle.defaultDelay;
+      if (throttleDelay > 0) {
+        return this.emitThrottled(event, data, throttleDelay);
+      }
+    }
+    return this.emitImmediate(event, data);
+  }
+  /**
+   * Emit immediately without throttling
+   */
+  async emitImmediate(event, data = null) {
+    const startTime = this.options.performance ? performance.now() : 0;
+    try {
+      await this.runMiddleware(event, data);
+      const listeners = this.getEventListeners(event);
+      if (listeners.length === 0) {
+        if (this.options.debug) {
+          console.warn(`[EventBus] No listeners for event: ${event}`);
+        }
+        return;
+      }
+      const promises = listeners.map(
+        (listenerObj) => this.executeListener(listenerObj.listener, event, data, listenerObj.options)
+      );
+      if (this.options.enableAsync) {
+        await Promise.allSettled(promises);
+      } else {
+        for (const promise of promises) {
+          await promise;
+        }
+      }
+      this.stats.eventsEmitted++;
+      this.stats.listenersExecuted += listeners.length;
+    } catch (error) {
+      this.stats.errorsOccurred++;
+      this.handleError(error, event, data);
+    } finally {
+      if (this.options.performance) {
+        const duration = performance.now() - startTime;
+        this.updatePerformanceStats(duration);
+      }
+    }
+  }
+  /**
+   * Emit with throttling
+   */
+  emitThrottled(event, data, delay) {
+    if (!this.throttledEmitters.has(event)) {
+      const throttled = throttle((evt, d) => this.emitImmediate(evt, d), delay);
+      this.throttledEmitters.set(event, throttled);
+    }
+    this.stats.throttledEvents++;
+    return this.throttledEmitters.get(event)(event, data);
+  }
+  /**
+   * Add event to batch queue
+   */
+  addToBatch(event, data) {
+    this.batchQueue.push({ event, data, timestamp: Date.now() });
+    if (this.batchQueue.length >= this.options.batching.maxBatchSize) {
+      this.flushBatch();
+    } else if (!this.batchTimer) {
+      this.batchTimer = setTimeout(() => {
+        this.flushBatch();
+      }, this.options.batching.flushInterval);
+    }
+  }
+  /**
+   * Flush batch queue
+   */
+  async flushBatch() {
+    if (this.batchTimer) {
+      clearTimeout(this.batchTimer);
+      this.batchTimer = null;
+    }
+    const batch = this.batchQueue.splice(0);
+    for (const { event, data } of batch) {
+      await this.emitImmediate(event, data);
+    }
+  }
+  /**
+   * Register event listener with options
+   */
+  on(event, listener, options = {}) {
+    if (typeof listener !== "function") {
+      throw new Error("Listener must be a function");
+    }
+    if (!this.listeners.has(event)) {
+      this.listeners.set(event, []);
+    }
+    const listeners = this.listeners.get(event);
+    if (listeners.length >= this.options.maxListeners) {
+      console.warn(`[EventBus] Max listeners (${this.options.maxListeners}) reached for event: ${event}`);
+    }
+    const listenerId = this.generateListenerId(event);
+    const listenerObj = {
+      listener,
+      listenerId,
+      priority: options.priority !== void 0 ? options.priority : this.options.defaultPriority,
+      condition: options.condition || null,
+      timeout: options.timeout || null,
+      options
+    };
+    listener.__listenerId = listenerId;
+    listener.__event = event;
+    if (this.options.enablePriority) {
+      const insertIndex = listeners.findIndex((l) => l.priority < listenerObj.priority);
+      if (insertIndex === -1) {
+        listeners.push(listenerObj);
+      } else {
+        listeners.splice(insertIndex, 0, listenerObj);
+      }
+    } else {
+      listeners.push(listenerObj);
+    }
+    return listenerId;
+  }
+  /**
+   * Register one-time listener
+   */
+  once(event, listener, options = {}) {
+    const onceListener = (...args) => {
+      this.off(event, onceListener.__listenerId);
+      return listener.call(this, ...args);
+    };
+    if (options.timeout) {
+      const timeoutId = setTimeout(() => {
+        this.off(event, onceListener.__listenerId);
+        if (this.options.debug) {
+          console.warn(`[EventBus] Listener timeout for event: ${event}`);
+        }
+      }, options.timeout);
+      onceListener.__cleanup = () => clearTimeout(timeoutId);
+    }
+    return this.on(event, onceListener, options);
+  }
+  /**
+   * Remove listener
+   */
+  off(event, listenerId) {
+    if (!this.listeners.has(event)) {
+      return false;
+    }
+    const listeners = this.listeners.get(event);
+    const index = listeners.findIndex((l) => l.listenerId === listenerId);
+    if (index !== -1) {
+      const listenerObj = listeners[index];
+      if (listenerObj.listener.__cleanup) {
+        listenerObj.listener.__cleanup();
+      }
+      listeners.splice(index, 1);
+      if (listeners.length === 0) {
+        this.listeners.delete(event);
+      }
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Remove all listeners for an event
+   */
+  removeAllListeners(event) {
+    if (event) {
+      this.listeners.delete(event);
+    } else {
+      this.listeners.clear();
+    }
+  }
+  /**
+   * Get event listeners with wildcard support
+   */
+  getEventListeners(event) {
+    const listeners = [];
+    if (this.listeners.has(event)) {
+      listeners.push(...this.listeners.get(event));
+    }
+    if (this.options.enableWildcards) {
+      for (const [pattern, patternListeners] of this.listeners) {
+        if (pattern.includes("*") && this.matchPattern(pattern, event)) {
+          listeners.push(...patternListeners);
+        }
+      }
+    }
+    if (this.options.enablePriority) {
+      listeners.sort((a, b) => b.priority - a.priority);
+    }
+    return listeners;
+  }
+  /**
+   * Execute listener with options
+   */
+  async executeListener(listener, event, data, options = {}) {
+    try {
+      if (options.condition && !options.condition(data)) {
+        return;
+      }
+      const result = listener.call(this, data, event);
+      if (result && typeof result.then === "function") {
+        await result;
+      }
+      return result;
+    } catch (error) {
+      this.handleError(error, event, data);
+    }
+  }
+  /**
+   * Run middleware chain
+   */
+  async runMiddleware(event, data) {
+    if (this.middleware.length === 0) return;
+    let index = 0;
+    const next = async () => {
+      if (index < this.middleware.length) {
+        const middleware = this.middleware[index++];
+        await middleware(event, data, next);
+      }
+    };
+    await next();
+  }
+  /**
+   * Handle errors
+   */
+  handleError(error, event, data) {
+    if (this.options.errorHandler) {
+      this.options.errorHandler(error, event, data);
+    } else if (this.options.debug) {
+      console.error(`[EventBus] Error in event ${event}:`, error, data);
+    }
+    this.emitSync("eventbus:error", { error, event, data });
+  }
+  /**
+   * Synchronous emit
+   */
+  emitSync(event, data = null) {
+    try {
+      const listeners = this.getEventListeners(event);
+      listeners.forEach((listenerObj) => {
+        try {
+          if (!listenerObj.options.condition || listenerObj.options.condition(data)) {
+            listenerObj.listener.call(this, data, event);
+          }
+        } catch (error) {
+          this.handleError(error, event, data);
+        }
+      });
+      this.stats.eventsEmitted++;
+      this.stats.listenersExecuted += listeners.length;
+    } catch (error) {
+      this.stats.errorsOccurred++;
+      this.handleError(error, event, data);
+    }
+  }
+  /**
+   * Register action handler
+   */
+  registerAction(action, handler) {
+    if (typeof handler !== "function") {
+      throw new Error("Action handler must be a function");
+    }
+    this.actionHandlers.set(action, handler);
+    if (this.options.debug) {
+      console.log(`[EventBus] Registered action: ${action}`);
+    }
+  }
+  /**
+   * Register multiple actions
+   */
+  registerActions(actions) {
+    Object.entries(actions).forEach(([action, handler]) => {
+      this.registerAction(action, handler);
+    });
+  }
+  /**
+   * Get registered actions
+   */
+  getRegisteredActions() {
+    return Array.from(this.actionHandlers.keys());
+  }
+  /**
+   * Handle action event (called by DOM integration)
+   */
+  handleAction(action, element, event, data) {
+    const handler = this.actionHandlers.get(action);
+    if (!handler) {
+      if (this.options.debug) {
+        console.warn(`[EventBus] No handler registered for action: ${action}`);
+      }
+      return;
+    }
+    try {
+      handler.call(element, {
+        element,
+        event,
+        data,
+        emit: this.emit.bind(this),
+        emitSync: this.emitSync.bind(this)
+      });
+    } catch (error) {
+      this.handleError(error, `action:${action}`, { element, event, data });
+    }
+  }
+  /**
+   * Generate unique listener ID
+   */
+  generateListenerId(event) {
+    return `${event}_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+  }
+  /**
+   * Update performance stats
+   */
+  updatePerformanceStats(duration) {
+    const count = this.stats.eventsEmitted;
+    this.stats.averageEmitTime = (this.stats.averageEmitTime * (count - 1) + duration) / count;
+  }
+  /**
+   * Get statistics
+   */
+  getStats() {
+    return { ...this.stats };
+  }
+  /**
+   * Reset statistics
+   */
+  resetStats() {
+    this.stats = {
+      eventsEmitted: 0,
+      listenersExecuted: 0,
+      errorsOccurred: 0,
+      averageEmitTime: 0,
+      throttledEvents: 0,
+      filteredEvents: 0
+    };
+  }
+  /**
+   * Destroy event bus
+   */
+  destroy() {
+    this.removeAllListeners();
+    this.actionHandlers.clear();
+    this.handlers.clear();
+    this.middleware = [];
+    this.throttledEmitters.clear();
+    this.debouncedEmitters.clear();
+    if (this.batchTimer) {
+      clearTimeout(this.batchTimer);
+    }
+  }
+};
+function createEventBus(options = {}) {
+  return new EventBus(options);
+}
+var globalEventBus = createEventBus();
+var emit = globalEventBus.emit.bind(globalEventBus);
+var emitSync = globalEventBus.emitSync.bind(globalEventBus);
+var on = globalEventBus.on.bind(globalEventBus);
+var once = globalEventBus.once.bind(globalEventBus);
+var off = globalEventBus.off.bind(globalEventBus);
+var registerAction = globalEventBus.registerAction.bind(globalEventBus);
+var handleAction = globalEventBus.handleAction.bind(globalEventBus);
+
+// ../core/src/events/dom-integration.js
+var DOMEventIntegration = class {
+  constructor(eventBus = globalEventBus, options = {}) {
+    this.eventBus = eventBus;
+    this.options = {
+      debug: false,
+      debounceDelay: 150,
+      throttleDelay: 100,
+      enableDelegation: true,
+      enableDebounce: true,
+      enableThrottle: false,
+      ...options
+    };
+    this.boundHandlers = /* @__PURE__ */ new Map();
+    this.activeElement = null;
+    this.isInitialized = false;
+    this.handleClick = this.handleClick.bind(this);
+    this.handleChange = this.handleChange.bind(this);
+    this.handleInput = this.handleInput.bind(this);
+    this.handleSubmit = this.handleSubmit.bind(this);
+    this.handleKeydown = this.handleKeydown.bind(this);
+    this.handleFocus = this.handleFocus.bind(this);
+    this.handleBlur = this.handleBlur.bind(this);
+  }
+  /**
+   * Initialize DOM event listeners
+   * @param {HTMLElement} rootElement - Root element to attach listeners to (default: document)
+   */
+  initialize(rootElement = document) {
+    if (this.isInitialized) {
+      console.warn("[DOMEventIntegration] Already initialized");
+      return;
+    }
+    if (typeof window === "undefined" || !rootElement) {
+      console.warn("[DOMEventIntegration] Cannot initialize: no DOM environment");
+      return;
+    }
+    this.rootElement = rootElement;
+    this.setupDOMEventListeners();
+    this.isInitialized = true;
+    if (this.options.debug) {
+      console.log("[DOMEventIntegration] Initialized with options:", this.options);
+    }
+  }
+  /**
+   * Set up delegated DOM event listeners
+   * @private
+   */
+  setupDOMEventListeners() {
+    const clickHandler = this.createDelegatedHandler("click", this.handleClick);
+    this.rootElement.addEventListener("click", clickHandler, { passive: false });
+    this.boundHandlers.set("click", clickHandler);
+    const changeHandler = this.options.enableDebounce ? this.debounce(this.createDelegatedHandler("change", this.handleChange), this.options.debounceDelay) : this.createDelegatedHandler("change", this.handleChange);
+    this.rootElement.addEventListener("change", changeHandler, { passive: true });
+    this.boundHandlers.set("change", changeHandler);
+    const inputHandler = this.options.enableDebounce ? this.debounce(this.createDelegatedHandler("input", this.handleInput), this.options.debounceDelay) : this.createDelegatedHandler("input", this.handleInput);
+    this.rootElement.addEventListener("input", inputHandler, { passive: true });
+    this.boundHandlers.set("input", inputHandler);
+    const submitHandler = this.createDelegatedHandler("submit", this.handleSubmit);
+    this.rootElement.addEventListener("submit", submitHandler, { passive: false });
+    this.boundHandlers.set("submit", submitHandler);
+    const keydownHandler = this.createDelegatedHandler("keydown", this.handleKeydown);
+    this.rootElement.addEventListener("keydown", keydownHandler, { passive: false });
+    this.boundHandlers.set("keydown", keydownHandler);
+    const focusHandler = this.createDelegatedHandler("focus", this.handleFocus);
+    this.rootElement.addEventListener("focus", focusHandler, { passive: true, capture: true });
+    this.boundHandlers.set("focus", focusHandler);
+    const blurHandler = this.createDelegatedHandler("blur", this.handleBlur);
+    this.rootElement.addEventListener("blur", blurHandler, { passive: true, capture: true });
+    this.boundHandlers.set("blur", blurHandler);
+  }
+  /**
+   * Create a delegated event handler
+   * @private
+   */
+  createDelegatedHandler(eventType, handler) {
+    return (event) => {
+      const target = event.target;
+      if (!target) return;
+      const actionElement = this.options.enableDelegation ? target.closest("[data-action]") : target.hasAttribute?.("data-action") ? target : null;
+      if (actionElement) {
+        handler(actionElement, event);
+      } else {
+        handler(target, event);
+      }
+    };
+  }
+  /**
+   * Handle click events
+   * @private
+   */
+  handleClick(element, event) {
+    const action = element.getAttribute?.("data-action");
+    if (action) {
+      this.handleDataAction(element, event, action);
+    }
+    this.eventBus.emitSync("dom:click", {
+      element,
+      event,
+      action,
+      data: this.parseDataAttributes(element)
+    });
+  }
+  /**
+   * Handle change events
+   * @private
+   */
+  handleChange(element, event) {
+    const action = element.getAttribute?.("data-action");
+    if (action) {
+      this.handleDataAction(element, event, action);
+    }
+    this.eventBus.emitSync("dom:change", {
+      element,
+      event,
+      value: element.value,
+      action,
+      data: this.parseDataAttributes(element)
+    });
+  }
+  /**
+   * Handle input events
+   * @private
+   */
+  handleInput(element, event) {
+    const action = element.getAttribute?.("data-action");
+    if (action) {
+      this.handleDataAction(element, event, action);
+    }
+    this.eventBus.emitSync("dom:input", {
+      element,
+      event,
+      value: element.value,
+      action,
+      data: this.parseDataAttributes(element)
+    });
+  }
+  /**
+   * Handle submit events
+   * @private
+   */
+  handleSubmit(element, event) {
+    const action = element.getAttribute?.("data-action");
+    if (action) {
+      event.preventDefault();
+      this.handleDataAction(element, event, action);
+    }
+    this.eventBus.emitSync("dom:submit", {
+      element,
+      event,
+      action,
+      formData: this.extractFormData(element),
+      data: this.parseDataAttributes(element)
+    });
+  }
+  /**
+   * Handle keydown events
+   * @private
+   */
+  handleKeydown(element, event) {
+    const action = element.getAttribute?.("data-action");
+    const keyAction = element.getAttribute?.(`data-key-${event.key.toLowerCase()}`);
+    if (action && this.shouldTriggerKeyAction(event)) {
+      this.handleDataAction(element, event, action);
+    }
+    if (keyAction) {
+      this.handleDataAction(element, event, keyAction);
+    }
+    this.eventBus.emitSync("dom:keydown", {
+      element,
+      event,
+      key: event.key,
+      code: event.code,
+      action,
+      keyAction,
+      data: this.parseDataAttributes(element)
+    });
+  }
+  /**
+   * Handle focus events
+   * @private
+   */
+  handleFocus(element, event) {
+    this.activeElement = element;
+    this.eventBus.emitSync("dom:focus", {
+      element,
+      event,
+      data: this.parseDataAttributes(element)
+    });
+  }
+  /**
+   * Handle blur events
+   * @private
+   */
+  handleBlur(element, event) {
+    if (this.activeElement === element) {
+      this.activeElement = null;
+    }
+    this.eventBus.emitSync("dom:blur", {
+      element,
+      event,
+      data: this.parseDataAttributes(element)
+    });
+  }
+  /**
+   * Handle data-action attributes
+   * @private
+   */
+  handleDataAction(element, event, action) {
+    if (!action) return;
+    const data = this.parseDataAttributes(element);
+    this.eventBus.emitSync("dom:action", {
+      action,
+      element,
+      event,
+      data
+    });
+    this.eventBus.handleAction(action, element, event, data);
+    if (this.options.debug) {
+      console.log(`[DOMEventIntegration] Action triggered: ${action}`, {
+        element,
+        event: event.type,
+        data
+      });
+    }
+  }
+  /**
+   * Parse data attributes from an element
+   * @private
+   */
+  parseDataAttributes(element) {
+    if (!element?.attributes) return {};
+    const data = {};
+    Array.from(element.attributes).forEach((attr) => {
+      if (attr.name.startsWith("data-") && attr.name !== "data-action") {
+        const key = attr.name.slice(5).replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
+        let value = attr.value;
+        try {
+          if (value === "true") value = true;
+          else if (value === "false") value = false;
+          else if (value === "null") value = null;
+          else if (value === "undefined") value = void 0;
+          else if (/^\d+$/.test(value)) value = parseInt(value, 10);
+          else if (/^\d*\.\d+$/.test(value)) value = parseFloat(value);
+          else if (value.startsWith("{") && value.endsWith("}") || value.startsWith("[") && value.endsWith("]")) {
+            value = JSON.parse(value);
+          }
+        } catch {
+        }
+        data[key] = value;
+      }
+    });
+    return data;
+  }
+  /**
+   * Extract form data from a form element
+   * @private
+   */
+  extractFormData(formElement) {
+    if (!formElement || formElement.tagName !== "FORM") {
+      return {};
+    }
+    const formData = new FormData(formElement);
+    const data = {};
+    for (const [key, value] of formData.entries()) {
+      if (data[key]) {
+        if (Array.isArray(data[key])) {
+          data[key].push(value);
+        } else {
+          data[key] = [data[key], value];
+        }
+      } else {
+        data[key] = value;
+      }
+    }
+    return data;
+  }
+  /**
+   * Check if a key event should trigger an action
+   * @private
+   */
+  shouldTriggerKeyAction(event) {
+    const triggerKeys = ["Enter", "Space", "Escape"];
+    return triggerKeys.includes(event.key);
+  }
+  /**
+   * Debounce utility function
+   * @private
+   */
+  debounce(func, wait) {
+    let timeout;
+    return function executedFunction(...args) {
+      const later = () => {
+        clearTimeout(timeout);
+        func.apply(this, args);
+      };
+      clearTimeout(timeout);
+      timeout = setTimeout(later, wait);
+    };
+  }
+  /**
+   * Throttle utility function
+   * @private
+   */
+  throttle(func, limit) {
+    let inThrottle;
+    return function executedFunction(...args) {
+      if (!inThrottle) {
+        func.apply(this, args);
+        inThrottle = true;
+        setTimeout(() => inThrottle = false, limit);
+      }
+    };
+  }
+  /**
+   * Add custom event listener
+   * @param {string} eventType - Event type
+   * @param {Function} handler - Event handler
+   * @param {Object} options - Event listener options
+   */
+  addCustomListener(eventType, handler, options = {}) {
+    const wrappedHandler = this.createDelegatedHandler(eventType, handler);
+    this.rootElement.addEventListener(eventType, wrappedHandler, options);
+    this.boundHandlers.set(`custom:${eventType}`, wrappedHandler);
+  }
+  /**
+   * Remove custom event listener
+   * @param {string} eventType - Event type
+   */
+  removeCustomListener(eventType) {
+    const handler = this.boundHandlers.get(`custom:${eventType}`);
+    if (handler) {
+      this.rootElement.removeEventListener(eventType, handler);
+      this.boundHandlers.delete(`custom:${eventType}`);
+    }
+  }
+  /**
+   * Register action handlers in bulk
+   * @param {Object} actions - Object mapping action names to handlers
+   */
+  registerActions(actions) {
+    this.eventBus.registerActions(actions);
+  }
+  /**
+   * Get the currently active (focused) element
+   * @returns {HTMLElement|null}
+   */
+  getActiveElement() {
+    return this.activeElement;
+  }
+  /**
+   * Trigger an action programmatically
+   * @param {string} action - Action name
+   * @param {HTMLElement} element - Target element
+   * @param {Object} data - Additional data
+   */
+  triggerAction(action, element, data = {}) {
+    const syntheticEvent = new CustomEvent("synthetic", {
+      bubbles: true,
+      cancelable: true,
+      detail: data
+    });
+    this.eventBus.handleAction(action, element, syntheticEvent, data);
+  }
+  /**
+   * Clean up event listeners
+   */
+  destroy() {
+    if (!this.isInitialized) return;
+    this.boundHandlers.forEach((handler, eventType) => {
+      this.rootElement.removeEventListener(
+        eventType.replace("custom:", ""),
+        handler
+      );
+    });
+    this.boundHandlers.clear();
+    this.activeElement = null;
+    this.isInitialized = false;
+    if (this.options.debug) {
+      console.log("[DOMEventIntegration] Destroyed");
+    }
+  }
+};
+var globalDOMIntegration = new DOMEventIntegration(globalEventBus, {
+  debug: typeof process !== "undefined" && true
+});
+if (typeof window !== "undefined") {
+  if (document.readyState === "loading") {
+    document.addEventListener("DOMContentLoaded", () => {
+      globalDOMIntegration.initialize();
+    });
+  } else {
+    globalDOMIntegration.initialize();
+  }
+}
+
+// ../core/src/events/index.js
+var eventSystem2 = {
+  // Core bus
+  bus: globalEventBus,
+  dom: globalDOMIntegration,
+  // Quick access methods
+  emit: globalEventBus.emit.bind(globalEventBus),
+  emitSync: globalEventBus.emitSync.bind(globalEventBus),
+  on: globalEventBus.on.bind(globalEventBus),
+  once: globalEventBus.once.bind(globalEventBus),
+  off: globalEventBus.off.bind(globalEventBus),
+  // Action methods
+  registerAction: globalEventBus.registerAction.bind(globalEventBus),
+  registerActions: globalEventBus.registerActions.bind(globalEventBus),
+  handleAction: globalEventBus.handleAction.bind(globalEventBus),
+  // Statistics and debugging
+  getStats: globalEventBus.getStats.bind(globalEventBus),
+  resetStats: globalEventBus.resetStats.bind(globalEventBus),
+  // Lifecycle
+  destroy() {
+    globalEventBus.destroy();
+    globalDOMIntegration.destroy();
+  }
+};
+
+// ../core/src/index.js
+var scopeCounter = { value: 0 };
+function generateScopeId() {
+  return `coh-${scopeCounter.value++}`;
+}
+function scopeCSS(css, scopeId) {
+  if (!css || typeof css !== "string") return css;
+  return css.replace(/([^{}]*)\s*{/g, (match, selector) => {
+    const selectors = selector.split(",").map((s) => {
+      const trimmed = s.trim();
+      if (!trimmed) return s;
+      if (trimmed.includes(":")) {
+        return trimmed.replace(/([^:]+)(:.*)?/, `$1[${scopeId}]$2`);
+      }
+      return `${trimmed}[${scopeId}]`;
+    });
+    return `${selectors.join(", ")} {`;
+  });
+}
+function applyScopeToElement(element, scopeId) {
+  if (typeof element === "string" || typeof element === "number" || !element) {
+    return element;
+  }
+  if (Array.isArray(element)) {
+    return element.map((item) => applyScopeToElement(item, scopeId));
+  }
+  if (typeof element === "object") {
+    const scoped = {};
+    for (const [tagName, props] of Object.entries(element)) {
+      if (typeof props === "object" && props !== null) {
+        const scopedProps = { ...props };
+        scopedProps[scopeId] = "";
+        if (scopedProps.children) {
+          scopedProps.children = applyScopeToElement(scopedProps.children, scopeId);
+        }
+        scoped[tagName] = scopedProps;
+      } else {
+        scoped[tagName] = props;
+      }
+    }
+    return scoped;
+  }
+  return element;
+}
+function escapeHtml(text) {
+  if (typeof text !== "string") return text;
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#x27;");
+}
+function isTrustedContent(value) {
+  return value && typeof value === "object" && value.__trusted === true && typeof value.__html === "string";
+}
+function isVoidElement(tagName) {
+  const voidElements = /* @__PURE__ */ new Set([
+    "area",
+    "base",
+    "br",
+    "col",
+    "embed",
+    "hr",
+    "img",
+    "input",
+    "link",
+    "meta",
+    "param",
+    "source",
+    "track",
+    "wbr"
+  ]);
+  return voidElements.has(tagName.toLowerCase());
+}
+function formatAttributes(attrs) {
+  if (!attrs || typeof attrs !== "object") return "";
+  return Object.entries(attrs).filter(([, value]) => value !== null && value !== void 0 && value !== false).map(([key, value]) => {
+    if (typeof value === "function") {
+      value = value();
+    }
+    const attrName = key === "className" ? "class" : key;
+    if (value === true) return attrName;
+    return `${attrName}="${escapeHtml(String(value))}"`;
+  }).join(" ");
+}
+function renderRaw(obj) {
+  if (obj === null || obj === void 0) return "";
+  if (typeof obj === "string" || typeof obj === "number") return escapeHtml(String(obj));
+  if (Array.isArray(obj)) return obj.map(renderRaw).join("");
+  if (typeof obj === "function") {
+    const result = obj(renderRaw);
+    return renderRaw(result);
+  }
+  if (typeof obj !== "object") return escapeHtml(String(obj));
+  if (obj.text !== void 0) {
+    return escapeHtml(String(obj.text));
+  }
+  for (const [tagName, props] of Object.entries(obj)) {
+    if (typeof props === "object" && props !== null) {
+      const { children, text, ...attributes } = props;
+      const attrsStr = formatAttributes(attributes);
+      const openTag = attrsStr ? `<${tagName} ${attrsStr}>` : `<${tagName}>`;
+      if (isVoidElement(tagName)) {
+        return openTag.replace(">", " />");
+      }
+      let content = "";
+      if (text !== void 0) {
+        if (isTrustedContent(text)) {
+          content = text.__html;
+        } else {
+          content = escapeHtml(String(text));
+        }
+      } else if (children) {
+        content = renderRaw(children);
+      }
+      return `${openTag}${content}</${tagName}>`;
+    } else if (typeof props === "string") {
+      const content = isTrustedContent(props) ? props.__html : escapeHtml(props);
+      return isVoidElement(tagName) ? `<${tagName} />` : `<${tagName}>${content}</${tagName}>`;
+    }
+  }
+  return "";
+}
+function render(obj, options = {}) {
+  const { scoped = false } = options;
+  if (scoped) {
+    return renderScopedComponent(obj);
+  }
+  return renderRaw(obj);
+}
+function renderScopedComponent(component) {
+  const scopeId = generateScopeId();
+  function processScopedElement(element) {
+    if (!element || typeof element !== "object") {
+      return element;
+    }
+    if (Array.isArray(element)) {
+      return element.map(processScopedElement);
+    }
+    const result = {};
+    for (const [tagName, props] of Object.entries(element)) {
+      if (tagName === "style" && typeof props === "object" && props.text) {
+        result[tagName] = {
+          ...props,
+          text: scopeCSS(props.text, scopeId)
+        };
+      } else if (typeof props === "object" && props !== null) {
+        const scopedProps = { ...props };
+        if (scopedProps.children) {
+          scopedProps.children = processScopedElement(scopedProps.children);
+        }
+        result[tagName] = scopedProps;
+      } else {
+        result[tagName] = props;
+      }
+    }
+    return result;
+  }
+  const processedComponent = processScopedElement(component);
+  const scopedComponent = applyScopeToElement(processedComponent, scopeId);
+  return renderRaw(scopedComponent);
+}
+
+// ../core/src/utils/dependency-utils.js
+async function importPeerDependency(packageName, integrationName) {
+  try {
+    return await import(packageName);
+  } catch {
+    throw new Error(
+      `${integrationName} integration requires the '${packageName}' package to be installed.
+Please install it with: npm install ${packageName}
+Or with pnpm: pnpm add ${packageName}
+Or with yarn: yarn add ${packageName}`
+    );
+  }
+}
+
+// ../core/src/rendering/base-renderer.js
+var DEFAULT_RENDERER_CONFIG = {
+  // Core rendering options
+  maxDepth: 100,
+  enableValidation: true,
+  enableMonitoring: false,
+  validateInput: true,
+  // HTML Renderer specific options
+  enableCache: true,
+  minify: false,
+  cacheSize: 1e3,
+  cacheTTL: 3e5,
+  // 5 minutes
+  // Streaming Renderer specific options
+  chunkSize: 1024,
+  // Size of each chunk in bytes
+  bufferSize: 4096,
+  // Internal buffer size
+  enableMetrics: false,
+  // Track streaming metrics
+  yieldThreshold: 100,
+  // Yield control after N elements
+  encoding: "utf8",
+  // Output encoding
+  // DOM Renderer specific options
+  enableHydration: true,
+  // Enable hydration support
+  namespace: null,
+  // SVG namespace support
+  // Performance options
+  enablePerformanceTracking: false,
+  performanceThreshold: 10,
+  // ms threshold for slow renders
+  // Development options
+  enableDevWarnings: typeof process !== "undefined" && process.env && true,
+  enableDebugLogging: false,
+  // Error handling options
+  errorFallback: "",
+  // Fallback content on errors
+  throwOnError: true
+  // Whether to throw or return fallback
+};
+var BaseRenderer = class {
+  constructor(options = {}) {
+    this.config = this.validateAndMergeConfig(options);
+    this.metrics = {
+      startTime: null,
+      endTime: null,
+      elementsProcessed: 0
+    };
+  }
+  /**
+   * Validate and merge configuration options
+   */
+  validateAndMergeConfig(options) {
+    const config = { ...DEFAULT_RENDERER_CONFIG, ...options };
+    if (typeof config.maxDepth !== "number") {
+      throw new Error("maxDepth must be a number");
+    }
+    if (config.maxDepth <= 0) {
+      throw new Error("maxDepth must be a positive number");
+    }
+    if (typeof config.chunkSize !== "number") {
+      throw new Error("chunkSize must be a number");
+    }
+    if (config.chunkSize <= 0) {
+      throw new Error("chunkSize must be a positive number");
+    }
+    if (typeof config.yieldThreshold !== "number") {
+      throw new Error("yieldThreshold must be a number");
+    }
+    if (config.yieldThreshold <= 0) {
+      throw new Error("yieldThreshold must be a positive number");
+    }
+    if (config.enableDevWarnings) {
+      if (config.maxDepth > 1e3) {
+        console.warn("Coherent.js: maxDepth > 1000 may cause performance issues");
+      }
+      if (config.chunkSize > 16384) {
+        console.warn("Coherent.js: Large chunkSize may increase memory usage");
+      }
+    }
+    return config;
+  }
+  /**
+   * Get configuration for specific renderer type
+   */
+  getRendererConfig(rendererType) {
+    const baseConfig = { ...this.config };
+    switch (rendererType) {
+      case "html":
+        return {
+          ...baseConfig,
+          // HTML-specific defaults
+          enableCache: baseConfig.enableCache !== false,
+          enableMonitoring: baseConfig.enableMonitoring !== false
+        };
+      case "streaming":
+        return {
+          ...baseConfig,
+          // Streaming-specific defaults
+          enableMetrics: baseConfig.enableMetrics ?? false,
+          maxDepth: baseConfig.maxDepth ?? 1e3
+          // Higher default for streaming
+        };
+      case "dom":
+        return {
+          ...baseConfig,
+          // DOM-specific defaults
+          enableHydration: baseConfig.enableHydration !== false
+        };
+      default:
+        return baseConfig;
+    }
+  }
+  /**
+   * Validate component structure
+   */
+  validateComponent(component) {
+    if (this.config.validateInput !== false) {
+      return validateComponent(component);
+    }
+    return true;
+  }
+  /**
+   * Check if component is valid for rendering
+   */
+  isValidComponent(component) {
+    if (component === null || component === void 0) return true;
+    if (typeof component === "string" || typeof component === "number") return true;
+    if (typeof component === "function") return true;
+    if (Array.isArray(component)) return component.every((child) => this.isValidComponent(child));
+    if (isCoherentObject(component)) return true;
+    return false;
+  }
+  /**
+   * Validate rendering depth to prevent stack overflow
+   */
+  validateDepth(depth) {
+    if (depth > this.config.maxDepth) {
+      throw new Error(`Maximum render depth (${this.config.maxDepth}) exceeded`);
+    }
+  }
+  /**
+   * Handle different component types with consistent logic
+   */
+  processComponentType(component) {
+    if (component === null || component === void 0) {
+      return { type: "empty", value: "" };
+    }
+    if (typeof component === "string") {
+      return { type: "text", value: component };
+    }
+    if (typeof component === "number" || typeof component === "boolean") {
+      return { type: "text", value: String(component) };
+    }
+    if (typeof component === "function") {
+      return { type: "function", value: component };
+    }
+    if (Array.isArray(component)) {
+      return { type: "array", value: component };
+    }
+    if (isCoherentObject(component)) {
+      return { type: "element", value: component };
+    }
+    return { type: "unknown", value: component };
+  }
+  /**
+   * Execute function components with _error handling
+   */
+  executeFunctionComponent(func, depth = 0) {
+    try {
+      const isContextProvider = func.length > 0 || func.isContextProvider;
+      let result;
+      if (isContextProvider) {
+        result = func((children) => {
+          return this.renderComponent(children, this.config, depth + 1);
+        });
+      } else {
+        result = func();
+      }
+      if (typeof result === "function") {
+        return this.executeFunctionComponent(result, depth);
+      }
+      return result;
+    } catch (_error) {
+      if (this.config.enableMonitoring) {
+        performanceMonitor2.recordError("functionComponent", _error);
+      }
+      if (typeof process !== "undefined" && process.env && true) {
+        console.warn("Coherent.js Function Component Error:", _error.message);
+      }
+      return null;
+    }
+  }
+  /**
+   * Process element children consistently
+   */
+  processChildren(children, options, depth) {
+    if (!hasChildren({ children })) {
+      return [];
+    }
+    const normalizedChildren = normalizeChildren(children);
+    return normalizedChildren.map(
+      (child) => this.renderComponent(child, options, depth + 1)
+    );
+  }
+  /**
+   * Extract and process element attributes
+   */
+  extractElementAttributes(props) {
+    if (!props || typeof props !== "object") return {};
+    const attributes = { ...props };
+    delete attributes.children;
+    delete attributes.text;
+    return attributes;
+  }
+  /**
+   * Record performance metrics
+   */
+  recordPerformance(operation, startTime, fromCache = false, metadata = {}) {
+    if (this.config.enableMonitoring) {
+      performanceMonitor2.recordRender(
+        operation,
+        this.getCurrentTime() - startTime,
+        fromCache,
+        metadata
+      );
+    }
+  }
+  /**
+   * Record _error for monitoring
+   */
+  recordError(operation, _error, metadata = {}) {
+    if (this.config.enableMonitoring) {
+      performanceMonitor2.recordError(operation, _error, metadata);
+    }
+  }
+  /**
+   * Get current timestamp with fallback
+   */
+  getCurrentTime() {
+    if (typeof performance !== "undefined" && performance.now) {
+      return performance.now();
+    }
+    return Date.now();
+  }
+  /**
+   * Start performance timing
+   */
+  startTiming() {
+    this.metrics.startTime = this.getCurrentTime();
+  }
+  /**
+   * End performance timing
+   */
+  endTiming() {
+    this.metrics.endTime = this.getCurrentTime();
+  }
+  /**
+   * Get performance metrics
+   */
+  getMetrics() {
+    const duration = this.metrics.endTime ? this.metrics.endTime - this.metrics.startTime : this.getCurrentTime() - this.metrics.startTime;
+    return {
+      ...this.metrics,
+      duration,
+      elementsPerSecond: this.metrics.elementsProcessed / (duration / 1e3)
+    };
+  }
+  /**
+   * Reset metrics for new render
+   */
+  resetMetrics() {
+    this.metrics = {
+      startTime: null,
+      endTime: null,
+      elementsProcessed: 0
+    };
+  }
+  /**
+   * Abstract method - must be implemented by subclasses
+   */
+  renderComponent() {
+    throw new Error("renderComponent must be implemented by subclass");
+  }
+  /**
+   * Abstract method - must be implemented by subclasses
+   */
+  render() {
+    throw new Error("render must be implemented by subclass");
+  }
+};
+var RendererUtils = {
+  /**
+   * Check if element is static (no functions)
+   */
+  isStaticElement(element) {
+    if (!element || typeof element !== "object") {
+      return typeof element === "string" || typeof element === "number";
+    }
+    for (const [key, value] of Object.entries(element)) {
+      if (typeof value === "function") return false;
+      if (key === "children" && Array.isArray(value)) {
+        return value.every((child) => RendererUtils.isStaticElement(child));
+      }
+      if (key === "children" && typeof value === "object" && value !== null) {
+        return RendererUtils.isStaticElement(value);
+      }
+    }
+    return true;
+  },
+  /**
+   * Check if object has functions (for caching decisions)
+   */
+  hasFunctions(obj, visited = /* @__PURE__ */ new WeakSet()) {
+    if (visited.has(obj)) return false;
+    visited.add(obj);
+    for (const value of Object.values(obj)) {
+      if (typeof value === "function") return true;
+      if (typeof value === "object" && value !== null && RendererUtils.hasFunctions(value, visited)) {
+        return true;
+      }
+    }
+    return false;
+  },
+  /**
+   * Get element complexity score
+   */
+  getElementComplexity(element) {
+    if (!element || typeof element !== "object") return 1;
+    let complexity = Object.keys(element).length;
+    if (element.children && Array.isArray(element.children)) {
+      complexity += element.children.reduce(
+        (sum, child) => sum + RendererUtils.getElementComplexity(child),
+        0
+      );
+    }
+    return complexity;
+  },
+  /**
+   * Generate cache key for element
+   */
+  generateCacheKey(tagName, element) {
+    try {
+      const keyData = {
+        tag: tagName,
+        props: extractProps(element),
+        hasChildren: hasChildren(element),
+        childrenType: Array.isArray(element.children) ? "array" : typeof element.children
+      };
+      return `element:${JSON.stringify(keyData)}`;
+    } catch (_error) {
+      if (typeof process !== "undefined" && process.env && true) {
+        console.warn("Failed to generate cache key:", _error);
+      }
+      return null;
+    }
+  },
+  /**
+   * Check if element is cacheable
+   */
+  isCacheable(element, options) {
+    if (!options.enableCache) return false;
+    if (RendererUtils.hasFunctions(element)) return false;
+    if (RendererUtils.getElementComplexity(element) > 1e3) return false;
+    const cacheKey = RendererUtils.generateCacheKey(element.tagName || "unknown", element);
+    if (!cacheKey) return false;
+    return true;
+  }
+};
+
+// ../core/src/core/html-utils.js
+function escapeHtml2(text) {
+  if (typeof text !== "string") return text;
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function isVoidElement2(tagName) {
+  if (typeof tagName !== "string") {
+    return false;
+  }
+  const voidElements = /* @__PURE__ */ new Set([
+    "area",
+    "base",
+    "br",
+    "col",
+    "embed",
+    "hr",
+    "img",
+    "input",
+    "link",
+    "meta",
+    "param",
+    "source",
+    "track",
+    "wbr"
+  ]);
+  return voidElements.has(tagName.toLowerCase());
+}
+function formatAttributes2(props) {
+  let formatted = "";
+  for (const key in props) {
+    if (props.hasOwnProperty(key)) {
+      let value = props[key];
+      const attributeName = key === "className" ? "class" : key;
+      if (typeof value === "function") {
+        if (attributeName.startsWith("on")) {
+          const actionId = `__coherent_action_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+          const DEBUG = typeof process !== "undefined" && process && process.env && (process.env.COHERENT_DEBUG === "1" || true) || typeof window !== "undefined" && window && window.COHERENT_DEBUG === true;
+          if (typeof global !== "undefined") {
+            if (!global.__coherentActionRegistry) {
+              global.__coherentActionRegistry = {};
+              if (DEBUG) console.log("Initialized global action registry");
+            }
+            global.__coherentActionRegistry[actionId] = value;
+            if (DEBUG) console.log(`Added action ${actionId} to global registry, total: ${Object.keys(global.__coherentActionRegistry).length}`);
+            if (DEBUG) console.log(`Global registry keys: ${Object.keys(global.__coherentActionRegistry).join(", ")}`);
+            if (DEBUG) {
+              if (typeof global.__coherentActionRegistryLog === "undefined") {
+                global.__coherentActionRegistryLog = [];
+              }
+              global.__coherentActionRegistryLog.push({
+                action: "add",
+                actionId,
+                timestamp: Date.now(),
+                registrySize: Object.keys(global.__coherentActionRegistry).length
+              });
+            }
+          } else if (typeof window !== "undefined") {
+            if (!window.__coherentActionRegistry) {
+              window.__coherentActionRegistry = {};
+              if (DEBUG) console.log("Initialized window action registry");
+            }
+            window.__coherentActionRegistry[actionId] = value;
+            if (DEBUG) console.log(`Added action ${actionId} to window registry, total: ${Object.keys(window.__coherentActionRegistry).length}`);
+            if (DEBUG) console.log(`Window registry keys: ${Object.keys(window.__coherentActionRegistry).join(", ")}`);
+          }
+          const eventType = attributeName.substring(2);
+          formatted += ` data-action="${actionId}" data-event="${eventType}"`;
+          continue;
+        } else {
+          try {
+            value = value();
+          } catch (_error) {
+            console.warn(`Error executing function for attribute '${key}':`, {
+              _error: _error.message,
+              stack: _error.stack,
+              attributeKey: key
+            });
+            value = "";
+          }
+        }
+      }
+      if (value === true) {
+        formatted += ` ${attributeName}`;
+      } else if (value !== false && value !== null && value !== void 0) {
+        formatted += ` ${attributeName}="${escapeHtml2(String(value))}"`;
+      }
+    }
+  }
+  return formatted.trim();
+}
+function minifyHtml(html, options = {}) {
+  if (!options.minify) return html;
+  return html.replace(/<!--[\s\S]*?-->/g, "").replace(/\s+/g, " ").replace(/>\s+</g, "><").trim();
+}
+
+// ../core/src/performance/cache-manager.js
+function createCacheManager(options = {}) {
+  const {
+    maxCacheSize = 1e3,
+    maxMemoryMB = 100,
+    ttlMs = 1e3 * 60 * 5,
+    // 5 minutes
+    enableStatistics = true
+  } = options;
+  const caches = {
+    static: /* @__PURE__ */ new Map(),
+    // Never-changing components
+    component: /* @__PURE__ */ new Map(),
+    // Component results with deps
+    template: /* @__PURE__ */ new Map(),
+    // Template strings
+    data: /* @__PURE__ */ new Map()
+    // General purpose data
+  };
+  let memoryUsage = 0;
+  const stats = {
+    hits: 0,
+    misses: 0,
+    hitRate: {
+      static: 0,
+      component: 0,
+      template: 0,
+      data: 0
+    },
+    accessCount: {
+      static: 0,
+      component: 0,
+      template: 0,
+      data: 0
+    }
+  };
+  let cleanupInterval;
+  if (typeof setInterval === "function") {
+    cleanupInterval = setInterval(() => cleanup(), 3e4);
+    if (cleanupInterval.unref) {
+      cleanupInterval.unref();
+    }
+  }
+  function generateCacheKey(component, props = {}, context2 = {}) {
+    const componentStr = typeof component === "function" ? component.name || component.toString() : JSON.stringify(component);
+    const propsStr = JSON.stringify(props, Object.keys(props).sort());
+    const contextStr = JSON.stringify(context2);
+    const hash = simpleHash(componentStr + propsStr + contextStr);
+    return `${extractComponentName(component)}_${hash}`;
+  }
+  function get(key, type = "component") {
+    const cache = caches[type] || caches.component;
+    const entry = cache.get(key);
+    if (!entry) {
+      stats.misses++;
+      if (enableStatistics) stats.accessCount[type]++;
+      return null;
+    }
+    if (Date.now() - entry.timestamp > ttlMs) {
+      cache.delete(key);
+      updateMemoryUsage(-entry.size);
+      stats.misses++;
+      if (enableStatistics) stats.accessCount[type]++;
+      return null;
+    }
+    entry.lastAccess = Date.now();
+    entry.accessCount++;
+    stats.hits++;
+    if (enableStatistics) {
+      stats.accessCount[type]++;
+      stats.hitRate[type] = stats.hits / (stats.hits + stats.misses) * 100;
+    }
+    return entry.value;
+  }
+  function set(key, value, type = "component", metadata = {}) {
+    const cache = caches[type] || caches.component;
+    const size = calculateSize(value);
+    if (memoryUsage + size > maxMemoryMB * 1024 * 1024) {
+      optimize(type, size);
+    }
+    const entry = {
+      value,
+      timestamp: Date.now(),
+      lastAccess: Date.now(),
+      size,
+      metadata,
+      accessCount: 0
+    };
+    const existing = cache.get(key);
+    if (existing) {
+      updateMemoryUsage(-existing.size);
+    }
+    cache.set(key, entry);
+    updateMemoryUsage(size);
+    if (cache.size > maxCacheSize) {
+      optimize(type);
+    }
+  }
+  function remove(key, type) {
+    if (type) {
+      const cache = caches[type];
+      if (!cache) return false;
+      const entry = cache.get(key);
+      if (entry) {
+        updateMemoryUsage(-entry.size);
+        return cache.delete(key);
+      }
+      return false;
+    }
+    for (const [, cache] of Object.entries(caches)) {
+      const entry = cache.get(key);
+      if (entry) {
+        updateMemoryUsage(-entry.size);
+        return cache.delete(key);
+      }
+    }
+    return false;
+  }
+  function clear(type) {
+    if (type) {
+      const cache = caches[type];
+      if (cache) {
+        cache.clear();
+      }
+    } else {
+      Object.values(caches).forEach((cache) => cache.clear());
+    }
+    memoryUsage = 0;
+  }
+  function getStats() {
+    const entries = Object.values(caches).reduce((sum, cache) => sum + cache.size, 0);
+    return {
+      hits: stats.hits,
+      misses: stats.misses,
+      size: memoryUsage,
+      entries,
+      hitRate: stats.hitRate,
+      accessCount: stats.accessCount
+    };
+  }
+  function cleanup() {
+    const now = Date.now();
+    let freed = 0;
+    for (const [, cache] of Object.entries(caches)) {
+      for (const [key, entry] of cache.entries()) {
+        if (now - entry.timestamp > ttlMs) {
+          cache.delete(key);
+          updateMemoryUsage(-entry.size);
+          freed++;
+        }
+      }
+    }
+    return { freed };
+  }
+  function calculateSize(value) {
+    if (value === null || value === void 0) return 0;
+    if (typeof value === "string") return value.length * 2;
+    if (typeof value === "number") return 8;
+    if (typeof value === "boolean") return 4;
+    if (Array.isArray(value)) {
+      return value.reduce((sum, item) => sum + calculateSize(item), 0);
+    }
+    if (typeof value === "object") {
+      return Object.values(value).reduce((sum, val) => sum + calculateSize(val), 0);
+    }
+    return 0;
+  }
+  function updateMemoryUsage(delta) {
+    memoryUsage = Math.max(0, memoryUsage + delta);
+  }
+  function optimize(type, requiredSpace = 0) {
+    const cache = caches[type] || caches.component;
+    const entries = Array.from(cache.entries()).sort(([, a], [, b]) => a.lastAccess - b.lastAccess);
+    let freed = 0;
+    for (const [key, entry] of entries) {
+      if (freed >= requiredSpace) break;
+      cache.delete(key);
+      updateMemoryUsage(-entry.size);
+      freed += entry.size;
+    }
+    return { freed };
+  }
+  function simpleHash(str) {
+    let hash = 0;
+    for (let i = 0; i < str.length; i++) {
+      const char = str.charCodeAt(i);
+      hash = (hash << 5) - hash + char;
+      hash = hash & hash;
+    }
+    return Math.abs(hash).toString(36);
+  }
+  function extractComponentName(component) {
+    if (typeof component === "function") {
+      return component.name || "AnonymousComponent";
+    }
+    if (component && typeof component === "object") {
+      const keys = Object.keys(component);
+      return keys.length > 0 ? keys[0] : "ObjectComponent";
+    }
+    return "UnknownComponent";
+  }
+  function destroy() {
+    if (cleanupInterval) {
+      clearInterval(cleanupInterval);
+    }
+    clear();
+  }
+  return {
+    get,
+    set,
+    remove,
+    clear,
+    getStats,
+    cleanup,
+    destroy,
+    generateCacheKey,
+    get memoryUsage() {
+      return memoryUsage;
+    },
+    get maxMemory() {
+      return maxMemoryMB * 1024 * 1024;
+    }
+  };
+}
+var cacheManager = createCacheManager();
+
+// ../core/src/rendering/css-manager.js
+var import_promises = __toESM(require("node:fs/promises"), 1);
+var import_node_path = __toESM(require("node:path"), 1);
+var CSSManager = class {
+  constructor(options = {}) {
+    this.options = {
+      basePath: process.cwd(),
+      minify: false,
+      cache: true,
+      autoprefixer: false,
+      ...options
+    };
+    this.cache = /* @__PURE__ */ new Map();
+    this.loadedFiles = /* @__PURE__ */ new Set();
+  }
+  /**
+   * Load CSS file content
+   */
+  async loadCSSFile(filePath) {
+    const fullPath = import_node_path.default.resolve(this.options.basePath, filePath);
+    const cacheKey = fullPath;
+    if (this.options.cache && this.cache.has(cacheKey)) {
+      return this.cache.get(cacheKey);
+    }
+    try {
+      let content = await import_promises.default.readFile(fullPath, "utf8");
+      if (this.options.minify) {
+        content = this.minifyCSS(content);
+      }
+      if (this.options.cache) {
+        this.cache.set(cacheKey, content);
+      }
+      this.loadedFiles.add(filePath);
+      return content;
+    } catch (_error) {
+      console.warn(`Failed to load CSS file: ${filePath}`, _error.message);
+      return "";
+    }
+  }
+  /**
+   * Load multiple CSS files
+   */
+  async loadCSSFiles(filePaths) {
+    if (!Array.isArray(filePaths)) {
+      filePaths = [filePaths];
+    }
+    const cssContents = await Promise.all(
+      filePaths.map((filePath) => this.loadCSSFile(filePath))
+    );
+    return cssContents.join("\n");
+  }
+  /**
+   * Generate CSS link tags for external files
+   */
+  generateCSSLinks(filePaths, baseUrl = "/") {
+    if (!Array.isArray(filePaths)) {
+      filePaths = [filePaths];
+    }
+    return filePaths.map((filePath) => {
+      const href = filePath.startsWith("http") ? filePath : `${baseUrl}${filePath}`.replace(/\/+/g, "/");
+      return `<link rel="stylesheet" href="${this.escapeHtml(href)}" />`;
+    }).join("\n");
+  }
+  /**
+   * Generate inline style tag with CSS content
+   */
+  generateInlineStyles(cssContent) {
+    if (!cssContent) return "";
+    return `<style type="text/css">
+${cssContent}
+</style>`;
+  }
+  /**
+   * Basic CSS minification
+   */
+  minifyCSS(css) {
+    return css.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\s+/g, " ").replace(/;\s*}/g, "}").replace(/{\s+/g, "{").replace(/;\s+/g, ";").trim();
+  }
+  /**
+   * Escape HTML entities
+   */
+  escapeHtml(text) {
+    const div = { textContent: text };
+    return div.innerHTML || text;
+  }
+  /**
+   * Clear cache
+   */
+  clearCache() {
+    this.cache.clear();
+    this.loadedFiles.clear();
+  }
+  /**
+   * Get loaded file list
+   */
+  getLoadedFiles() {
+    return Array.from(this.loadedFiles);
+  }
+};
+var defaultCSSManager = new CSSManager();
+
+// ../core/src/rendering/html-renderer.js
+var rendererCache = createCacheManager({
+  maxSize: 1e3,
+  ttlMs: 3e5
+  // 5 minutes
+});
+var HTMLRenderer = class extends BaseRenderer {
+  constructor(options = {}) {
+    super({
+      enableCache: options.enableCache !== false,
+      enableMonitoring: options.enableMonitoring !== false,
+      minify: options.minify || false,
+      streaming: options.streaming || false,
+      maxDepth: options.maxDepth || 100,
+      ...options
+    });
+    if (this.config.enableCache && !this.cache) {
+      this.cache = rendererCache;
+    }
+  }
+  /**
+   * Main render method - converts components to HTML string
+   * 
+   * @param {Object|Array|string|Function} component - Component to render
+   * @param {Object} [options={}] - Rendering options
+   * @param {Object} [options.context] - Rendering context
+   * @param {boolean} [options.enableCache] - Override cache setting
+   * @param {number} [options.depth=0] - Current rendering depth
+   * @returns {string} Rendered HTML string
+   * 
+   * @example
+   * const html = renderer.render({
+   *   div: {
+   *     className: 'container',
+   *     children: [
+   *       { h1: { text: 'Title' } },
+   *       { p: { text: 'Content' } }
+   *     ]
+   *   }
+   * });
+   */
+  render(component, options = {}) {
+    const config = { ...this.config, ...options };
+    this.startTiming();
+    try {
+      if (config.validateInput && !this.isValidComponent(component)) {
+        throw new Error("Invalid component structure");
+      }
+      const html = this.renderComponent(component, config, 0);
+      const finalHtml = config.minify ? minifyHtml(html, config) : html;
+      this.endTiming();
+      this.recordPerformance("render", this.metrics.startTime, false, {
+        cacheEnabled: config.enableCache
+      });
+      return finalHtml;
+    } catch (_error) {
+      this.recordError("render", _error);
+      throw _error;
+    }
+  }
+  /**
+   * Render a single component with full optimization pipeline
+   */
+  renderComponent(component, options, depth = 0) {
+    this.validateDepth(depth);
+    const { type, value } = this.processComponentType(component);
+    switch (type) {
+      case "empty":
+        return "";
+      case "text":
+        return escapeHtml2(value);
+      case "function":
+        const result = this.executeFunctionComponent(value, depth);
+        return this.renderComponent(result, options, depth + 1);
+      case "array":
+        return value.map((child) => this.renderComponent(child, options, depth + 1)).join("");
+      case "element":
+        const tagName = Object.keys(value)[0];
+        const elementContent = value[tagName];
+        return this.renderElement(tagName, elementContent, options, depth);
+      default:
+        this.recordError("renderComponent", new Error(`Unknown component type: ${type}`));
+        return "";
+    }
+  }
+  /**
+   * Render an HTML element with advanced caching and optimization
+   */
+  renderElement(tagName, element, options, depth = 0) {
+    const startTime = performance.now();
+    if (options.enableMonitoring && this.cache) {
+    }
+    if (options.enableCache && this.cache && RendererUtils.isStaticElement(element)) {
+      const cacheKey = `static:${tagName}:${JSON.stringify(element)}`;
+      const cached = this.cache.get("static", cacheKey);
+      if (cached) {
+        this.recordPerformance(tagName, startTime, true);
+        return cached.value;
+      }
+    }
+    if (typeof element === "string" || typeof element === "number" || typeof element === "boolean") {
+      const html2 = isVoidElement2(tagName) ? `<${tagName}>` : `<${tagName}>${escapeHtml2(String(element))}</${tagName}>`;
+      this.cacheIfStatic(tagName, element, html2, options);
+      this.recordPerformance(tagName, startTime, false);
+      return html2;
+    }
+    if (typeof element === "function") {
+      const result = this.executeFunctionComponent(element, depth);
+      return this.renderElement(tagName, result, options, depth);
+    }
+    if (element && typeof element === "object") {
+      return this.renderObjectElement(tagName, element, options, depth);
+    }
+    if (element === null || element === void 0) {
+      const html2 = isVoidElement2(tagName) ? `<${tagName}>` : `<${tagName}></${tagName}>`;
+      this.recordPerformance(tagName, startTime, false);
+      return html2;
+    }
+    const html = `<${tagName}>${escapeHtml2(String(element))}</${tagName}>`;
+    this.recordPerformance(tagName, startTime, false);
+    return html;
+  }
+  /**
+   * Cache element if it's static
+   */
+  cacheIfStatic(tagName, element, html) {
+    if (this.config.enableCache && this.cache && RendererUtils.isStaticElement(element)) {
+      const cacheKey = `static:${tagName}:${JSON.stringify(element)}`;
+      this.cache.set("static", cacheKey, html, {
+        ttlMs: this.config.cacheTTL || 5 * 60 * 1e3,
+        // 5 minutes default
+        size: html.length
+        // Approximate size
+      });
+    }
+  }
+  /**
+   * Render complex object elements with attributes and children
+   */
+  renderObjectElement(tagName, element, options, depth = 0) {
+    const startTime = performance.now();
+    if (options.enableCache && this.cache) {
+      const cacheKey = RendererUtils.generateCacheKey(tagName, element);
+      if (cacheKey) {
+        const cached = this.cache.get(cacheKey);
+        if (cached) {
+          this.recordPerformance(tagName, startTime, true);
+          return cached;
+        }
+      }
+    }
+    const { children, text, ...attributes } = element || {};
+    const attributeString = formatAttributes2(attributes);
+    const openingTag = attributeString ? `<${tagName} ${attributeString}>` : `<${tagName}>`;
+    let textContent = "";
+    if (text !== void 0) {
+      const isScript = tagName === "script";
+      const isStyle = tagName === "style";
+      const isRawTag = isScript || isStyle;
+      const raw = typeof text === "function" ? String(text()) : String(text);
+      if (isRawTag) {
+        const safe = raw.replace(/<\/(script)/gi, "<\\/$1").replace(/<\/(style)/gi, "<\\/$1").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+        textContent = safe;
+      } else {
+        textContent = escapeHtml2(raw);
+      }
+    }
+    let childrenHtml = "";
+    if (hasChildren(element)) {
+      const normalizedChildren = normalizeChildren(children);
+      childrenHtml = normalizedChildren.map((child) => this.renderComponent(child, options, depth + 1)).join("");
+    }
+    const html = `${openingTag}${textContent}${childrenHtml}</${tagName}>`;
+    if (options.enableCache && this.cache && RendererUtils.isCacheable(element, options)) {
+      const cacheKey = RendererUtils.generateCacheKey(tagName, element);
+      if (cacheKey) {
+        this.cache.set(cacheKey, html);
+      }
+    }
+    this.recordPerformance(tagName, startTime, false);
+    return html;
+  }
+};
+function render2(component, options = {}) {
+  const mergedOptions = {
+    enableCache: true,
+    enableMonitoring: false,
+    ...options
+  };
+  const renderer = new HTMLRenderer(mergedOptions);
+  return renderer.render(component, mergedOptions);
+}
+
+// ../core/src/utils/render-utils.js
+function renderWithMonitoring(component, options = {}) {
+  const {
+    enablePerformanceMonitoring = false
+  } = options;
+  let html;
+  if (enablePerformanceMonitoring) {
+    const renderId = performanceMonitor2.startRender();
+    html = render2(component);
+    performanceMonitor2.endRender(renderId);
+  } else {
+    html = render2(component);
+  }
+  return html;
+}
+function renderWithTemplate(component, options = {}) {
+  const {
+    template = "<!DOCTYPE html>\n{{content}}"
+  } = options;
+  const html = renderWithMonitoring(component, options);
+  return template.replace("{{content}}", html);
+}
+async function renderComponentFactory(componentFactory, factoryArgs, options = {}) {
+  const component = await Promise.resolve(
+    componentFactory(...factoryArgs)
+  );
+  if (!component) {
+    throw new Error("Component factory returned null/undefined");
+  }
+  return renderWithTemplate(component, options);
+}
+
+// src/coherent-nextjs.js
+function createCoherentNextHandler(componentFactory, options = {}) {
+  return async (req, res) => {
+    try {
+      const finalHtml = await renderComponentFactory(
+        componentFactory,
+        [req, res],
+        options
+      );
+      res.setHeader("Content-Type", "text/html; charset=utf-8");
+      res.status(200).send(finalHtml);
+    } catch (_error) {
+      console.error("Coherent.js Next.js handler _error:", _error);
+      res.status(500).json({ _error: _error.message });
+    }
+  };
+}
+function createCoherentAppRouterHandler(componentFactory, options = {}) {
+  return async function handler(request) {
+    try {
+      const finalHtml = await renderComponentFactory(
+        componentFactory,
+        [request],
+        options
+      );
+      return new Response(finalHtml, {
+        status: 200,
+        headers: { "Content-Type": "text/html; charset=utf-8" }
+      });
+    } catch (_error) {
+      console.error("Coherent.js Next.js App Router handler _error:", _error);
+      return new Response(
+        JSON.stringify({ _error: _error.message }),
+        {
+          status: 500,
+          headers: { "Content-Type": "application/json" }
+        }
+      );
+    }
+  };
+}
+async function createCoherentServerComponent(componentFactory, options = {}) {
+  const {
+    enablePerformanceMonitoring = false
+  } = options;
+  let React;
+  try {
+    React = await importPeerDependency("react", "React");
+  } catch (_error) {
+    throw new Error(
+      `Next.js Server Component integration requires React. ${_error.message}`
+    );
+  }
+  return async function CoherentServerComponent(props) {
+    try {
+      const component = await Promise.resolve(
+        componentFactory(props)
+      );
+      if (!component) {
+        return React.default.createElement("div", null, "Error: Component factory returned null/undefined");
+      }
+      let html;
+      if (enablePerformanceMonitoring) {
+        const renderId = performanceMonitor.startRender();
+        html = render(component);
+        performanceMonitor.endRender(renderId);
+      } else {
+        html = render(component);
+      }
+      return React.default.createElement("div", {
+        dangerouslySetInnerHTML: { __html: html }
+      });
+    } catch (_error) {
+      console.error("Coherent.js Next.js Server Component _error:", _error);
+      return React.default.createElement("div", null, `Error: ${_error.message}`);
+    }
+  };
+}
+async function createCoherentClientComponent(componentFactory, options = {}) {
+  const {
+    enablePerformanceMonitoring = false
+  } = options;
+  let React;
+  try {
+    React = await importPeerDependency("react", "React");
+  } catch (_error) {
+    throw new Error(
+      `Next.js Client Component integration requires React. ${_error.message}`
+    );
+  }
+  return function CoherentClientComponent(props) {
+    const [html, setHtml] = React.useState("");
+    React.useEffect(() => {
+      async function renderComponent() {
+        try {
+          const component = await Promise.resolve(
+            componentFactory(props)
+          );
+          if (!component) {
+            setHtml("Error: Component factory returned null/undefined");
+            return;
+          }
+          let renderedHtml;
+          if (enablePerformanceMonitoring) {
+            const renderId = performanceMonitor.startRender();
+            renderedHtml = render(component);
+            performanceMonitor.endRender(renderId);
+          } else {
+            renderedHtml = render(component);
+          }
+          setHtml(renderedHtml);
+        } catch (_error) {
+          console.error("Coherent.js Next.js Client Component _error:", _error);
+          setHtml(`Error: ${_error.message}`);
+        }
+      }
+      renderComponent();
+    }, [props]);
+    return React.createElement("div", {
+      dangerouslySetInnerHTML: { __html: html }
+    });
+  };
+}
+async function createNextIntegration(options = {}) {
+  try {
+    await importPeerDependency("next", "Next.js");
+    await importPeerDependency("react", "React");
+    return {
+      createCoherentNextHandler: (componentFactory, handlerOptions = {}) => createCoherentNextHandler(componentFactory, { ...options, ...handlerOptions }),
+      createCoherentAppRouterHandler: (componentFactory, handlerOptions = {}) => createCoherentAppRouterHandler(componentFactory, { ...options, ...handlerOptions }),
+      createCoherentServerComponent: (componentFactory, componentOptions = {}) => createCoherentServerComponent(componentFactory, { ...options, ...componentOptions }),
+      createCoherentClientComponent: (componentFactory, componentOptions = {}) => createCoherentClientComponent(componentFactory, { ...options, ...componentOptions })
+    };
+  } catch (_error) {
+    throw _error;
+  }
+}
+var coherent_nextjs_default = {
+  createCoherentNextHandler,
+  createCoherentAppRouterHandler,
+  createCoherentServerComponent,
+  createCoherentClientComponent,
+  createNextIntegration
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createCoherentAppRouterHandler,
+  createCoherentClientComponent,
+  createCoherentNextHandler,
+  createCoherentServerComponent,
+  createNextIntegration
+});
+/**
+ * Coherent.js - Object-Based Rendering Framework
+ * A pure JavaScript framework for server-side rendering using natural object syntax
+ *
+ * @version 2.0.0
+ * @author Coherent Framework Team
+ * @license MIT
+ */
+/**
+ * Advanced caching system with memory management and smart invalidation for Coherent.js
+ * 
+ * @module @coherent/performance/cache-manager
+ * @license MIT
+ */
+//# sourceMappingURL=index.cjs.map