@coherent.js/fastify 1.0.0-beta.5 → 1.0.0-beta.6

package/dist/index.js

@@ -1,1492 +1,8 @@
-// ../core/src/core/object-utils.js
-function validateComponent(component, path = "root") {
-  if (component === null || component === void 0) {
-    throw new Error(`Invalid component at ${path}: 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, `${path}[${index}]`);
-    });
-    return true;
-  }
-  if (typeof component === "object") {
-    const keys = Object.keys(component);
-    if (keys.length === 0) {
-      throw new Error(`Empty object at ${path}`);
-    }
-    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 ${path}: ${key}`);
-      }
-      if (value && typeof value === "object" && !Array.isArray(value)) {
-        if (value.children) {
-          validateComponent(value.children, `${path}.${key}.children`);
-        }
-      } else if (value && typeof value !== "string" && typeof value !== "number" && typeof value !== "function") {
-        throw new Error(`Invalid value type at ${path}.${key}: ${typeof value}`);
-      }
-    });
-    return true;
-  }
-  throw new Error(`Invalid component type at ${path}: ${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/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,
-      debounceMs: 5e3,
-      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 > opts.alerts.debounceMs) {
-          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 performanceMonitor = createPerformanceMonitor();
-
-// ../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) {
-        performanceMonitor.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) {
-      performanceMonitor.recordRender(
-        operation,
-        this.getCurrentTime() - startTime,
-        fromCache,
-        metadata
-      );
-    }
-  }
-  /**
-   * Record _error for monitoring
-   */
-  recordError(operation, _error, metadata = {}) {
-    if (this.config.enableMonitoring) {
-      performanceMonitor.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 escapeHtml(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 isVoidElement(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 formatAttributes(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}="${escapeHtml(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 = {}, context = {}) {
-    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(context);
-    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/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 escapeHtml(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 = isVoidElement(tagName) ? `<${tagName}>` : `<${tagName}>${escapeHtml(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 = isVoidElement(tagName) ? `<${tagName}>` : `<${tagName}></${tagName}>`;
-      this.recordPerformance(tagName, startTime, false);
-      return html2;
-    }
-    const html = `<${tagName}>${escapeHtml(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 = formatAttributes(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 = escapeHtml(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 render(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 = performanceMonitor.startRender();
-    html = render(component);
-    performanceMonitor.endRender(renderId);
-  } else {
-    html = render(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-fastify.js
+import {
+  renderWithTemplate,
+  renderComponentFactory
+} from "@coherent.js/core";
 function coherentFastify(fastify, options, done) {
   const {
     enablePerformanceMonitoring = false,
@@ -1560,10 +76,4 @@ export {
   coherent_fastify_default as default,
   setupCoherent
 };
-/**
- * Advanced caching system with memory management and smart invalidation for Coherent.js
- * 
- * @module @coherent/performance/cache-manager
- * @license MIT
- */
 //# sourceMappingURL=index.js.map