@coherent.js/core 1.1.0 → 2.0.0-rc.0

package/dist/index.js

@@ -473,13 +473,25 @@ function createPerformanceMonitor(options = {}) {
     if (startTime !== void 0) {
       const duration = performance.now() - startTime;
       _renderTimers.delete(id);
-      recordMetric("render", duration);
+      recordMetric("renderTime", duration);
       return duration;
     }
     return 0;
   }
+  function recordRender(operation, duration, fromCache = false, metadata = {}) {
+    if (operation === "render") {
+      recordMetric("renderTime", duration, { fromCache, ...metadata });
+    } else {
+      recordMetric("componentCount", 1, { operation, fromCache });
+    }
+  }
+  function recordError(operation, error, metadata = {}) {
+    recordMetric("errorCount", 1, { operation, error: error?.message, ...metadata });
+  }
   return {
     recordMetric,
+    recordRender,
+    recordError,
     measure,
     measureAsync,
     addMetric,
@@ -506,95 +518,98 @@ function createPerformanceMonitor(options = {}) {
 var performanceMonitor = createPerformanceMonitor();
 
 // src/core/html-utils.js
+var HTML_ESCAPE_TEST = /[&<>"']/;
+var HTML_ESCAPE = /[&<>"']/g;
+var HTML_ESCAPES = { "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" };
 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;");
+  if (!HTML_ESCAPE_TEST.test(text)) return text;
+  return text.replace(HTML_ESCAPE, (ch) => HTML_ESCAPES[ch]);
+}
+var TRUSTED_CONTENT = /* @__PURE__ */ Symbol.for("coherent.js.trustedContent");
+function createTrustedContent(content) {
+  const marker = { __html: String(content), __trusted: true };
+  Object.defineProperty(marker, TRUSTED_CONTENT, { value: true });
+  return Object.freeze(marker);
 }
 function isTrustedContent(value) {
-  return Boolean(value) && typeof value === "object" && value.__trusted === true && typeof value.__html === "string";
+  return Boolean(value) && typeof value === "object" && value[TRUSTED_CONTENT] === true && typeof value.__html === "string";
+}
+var INVALID_ATTRIBUTE_NAME = /[\s"'<>/=\u0000-\u001F\u007F-\u009F]/;
+function isValidAttributeName(name) {
+  return typeof name === "string" && name.length > 0 && !INVALID_ATTRIBUTE_NAME.test(name);
 }
 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());
+  return voidElements.has(tagName) || voidElements.has(tagName.toLowerCase());
+}
+var ENUMERATED_BOOLEAN_ATTRIBUTES = /* @__PURE__ */ new Set(["spellcheck", "draggable", "contenteditable"]);
+function normalizeClassValue(value) {
+  if (Array.isArray(value)) {
+    return value.map(normalizeClassValue).filter(Boolean).join(" ");
+  }
+  if (value && typeof value === "object") {
+    return Object.keys(value).filter((name) => value[name]).join(" ");
+  }
+  if (value === null || value === void 0 || value === false) return "";
+  return String(value);
 }
-function formatAttributes(props) {
+function callAttribute(key, value) {
+  try {
+    return value();
+  } catch (_error) {
+    console.warn(`Error executing function for attribute '${key}':`, {
+      error: _error.message,
+      stack: _error.stack,
+      attributeKey: key
+    });
+    return "";
+  }
+}
+var ATTRIBUTE_NAMES = {
+  className: "class",
+  // Written as is, browsers read `htmlFor` as an unknown `htmlfor`
+  // attribute: the label was not associated with its control.
+  htmlFor: "for"
+};
+function styleToCss(style) {
+  return Object.entries(style).filter(([, val]) => val !== null && val !== void 0 && val !== false).map(([prop, val]) => {
+    const name = prop.startsWith("--") ? prop : prop.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`);
+    return `${name}: ${val}`;
+  }).join("; ");
+}
+function formatAttributes(props, skip) {
+  if (props && props.class !== void 0 && props.className !== void 0) {
+    const { className, ...rest } = props;
+    const resolve = (key, value) => normalizeClassValue(typeof value === "function" ? callAttribute(key, value) : value);
+    props = { ...rest, class: [resolve("class", props.class), resolve("className", className)].filter(Boolean).join(" ") };
+  }
   let formatted = "";
   for (const key in props) {
-    if (props.hasOwnProperty(key)) {
+    if (Object.prototype.hasOwnProperty.call(props, key) && !(skip && skip.has(key))) {
       let value = props[key];
-      const attributeName = key === "className" ? "class" : key;
+      const attributeName = ATTRIBUTE_NAMES[key] ?? key;
+      if (!isValidAttributeName(attributeName)) {
+        throw new Error(`Invalid attribute name ${JSON.stringify(key)}: attribute names cannot contain whitespace, quotes, '<', '>', '/', '=' or control characters`);
+      }
       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 = "";
-          }
+          value = callAttribute(key, value);
         }
       }
+      if (attributeName === "class" && typeof value === "object" && value !== null) {
+        value = normalizeClassValue(value);
+      }
+      if (typeof value === "boolean" && (attributeName.startsWith("aria-") || ENUMERATED_BOOLEAN_ATTRIBUTES.has(attributeName.toLowerCase()))) {
+        value = String(value);
+      }
       if (attributeName === "style" && typeof value === "object" && value !== null) {
-        const cssString = Object.entries(value).map(([prop, val]) => {
-          const kebabProp = prop.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`);
-          return `${kebabProp}: ${val}`;
-        }).join("; ");
-        formatted += ` ${attributeName}="${escapeHtml(cssString)}"`;
+        const cssString = styleToCss(value);
+        if (cssString) formatted += ` ${attributeName}="${escapeHtml(cssString)}"`;
       } else if (value === true) {
         formatted += ` ${attributeName}`;
       } else if (value !== false && value !== null && value !== void 0) {
@@ -604,10 +619,81 @@ function formatAttributes(props) {
   }
   return formatted.trim();
 }
+function stripComments(html) {
+  let out = "";
+  let cursor = 0;
+  for (; ; ) {
+    const start = html.indexOf("<!--", cursor);
+    if (start === -1) return out + html.slice(cursor);
+    out += html.slice(cursor, start);
+    const end = html.indexOf("-->", start + 4);
+    if (end === -1) return out;
+    cursor = end + 3;
+  }
+}
+function endsInComment(html) {
+  let cursor = 0;
+  for (; ; ) {
+    const start = html.indexOf("<!--", cursor);
+    if (start === -1) return false;
+    const end = html.indexOf("-->", start + 4);
+    if (end === -1 || end + 3 === html.length) return true;
+    cursor = end + 3;
+  }
+}
+function createStreamMinifier() {
+  let pending = "";
+  let started = false;
+  const minifyPiece = (text, last) => {
+    let out = stripComments(started ? `>${text}` : text).replace(/\s+/g, " ").replace(/>\s+</g, "><");
+    if (started) {
+      out = out.slice(1);
+    } else {
+      out = out.trimStart();
+    }
+    if (last) out = out.trimEnd();
+    started = true;
+    return out;
+  };
+  return {
+    push(chunk) {
+      pending += chunk;
+      let cut = pending.lastIndexOf(">");
+      while (cut !== -1 && endsInComment(pending.slice(0, cut + 1))) {
+        cut = cut === 0 ? -1 : pending.lastIndexOf(">", cut - 1);
+      }
+      if (cut === -1) return "";
+      const head = pending.slice(0, cut + 1);
+      pending = pending.slice(cut + 1);
+      return minifyPiece(head, false);
+    },
+    end() {
+      const rest = pending;
+      pending = "";
+      return rest || !started ? minifyPiece(rest, true) : "";
+    }
+  };
+}
 function minifyHtml(html, options = {}) {
   if (!options.minify) return html;
-  return html.replace(/<!--[\s\S]*?-->/g, "").replace(/\s+/g, " ").replace(/>\s+</g, "><").trim();
+  return stripComments(html).replace(/\s+/g, " ").replace(/>\s+</g, "><").trim();
 }
+var voidElements = /* @__PURE__ */ new Set([
+  "area",
+  "base",
+  "br",
+  "col",
+  "embed",
+  "hr",
+  "img",
+  "input",
+  "link",
+  "meta",
+  "param",
+  "source",
+  "track",
+  "wbr"
+]);
 
 // src/core/object-utils.js
 function deepClone(obj, seen = /* @__PURE__ */ new WeakMap()) {
@@ -694,6 +780,9 @@ function validateComponent(component, path = "root") {
   if (typeof component === "function") {
     return true;
   }
+  if (isTrustedContent(component)) {
+    return true;
+  }
   if (Array.isArray(component)) {
     component.forEach((child, index) => {
       validateComponent(child, `${path}[${index}]`);
@@ -735,22 +824,6 @@ function isCoherentObject(obj) {
     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;
@@ -772,6 +845,15 @@ function normalizeChildren(children) {
     return [];
   }
   if (Array.isArray(children)) {
+    let clean = true;
+    for (let i = 0; i < children.length; i++) {
+      const child = children[i];
+      if (child === null || child === void 0 || Array.isArray(child)) {
+        clean = false;
+        break;
+      }
+    }
+    if (clean) return children;
     return children.flat().filter((child) => child !== null && child !== void 0);
   }
   return [children];
@@ -785,7 +867,9 @@ var DEFAULT_RENDERER_CONFIG = {
   enableMonitoring: false,
   validateInput: true,
   // HTML Renderer specific options
-  enableCache: true,
+  // Off by default: keying a render on its content costs a full walk of
+  // the tree, which only pays off when identical trees are re-rendered.
+  enableCache: false,
   minify: false,
   cacheSize: 1e3,
   cacheTTL: 3e5,
@@ -871,7 +955,7 @@ var BaseRenderer = class {
         return {
           ...baseConfig,
           // HTML-specific defaults
-          enableCache: baseConfig.enableCache !== false,
+          enableCache: baseConfig.enableCache === true,
           enableMonitoring: baseConfig.enableMonitoring !== false
         };
       case "streaming":
@@ -904,11 +988,14 @@ var BaseRenderer = class {
   /**
    * Check if component is valid for rendering
    */
-  isValidComponent(component) {
+  isValidComponent(component, depth = 0) {
     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 (Array.isArray(component)) {
+      if (depth >= this.config.maxDepth) return true;
+      return component.every((child) => this.isValidComponent(child, depth + 1));
+    }
     if (isCoherentObject(component)) return true;
     return false;
   }
@@ -930,7 +1017,10 @@ var BaseRenderer = class {
     if (typeof component === "string") {
       return { type: "text", value: component };
     }
-    if (typeof component === "number" || typeof component === "boolean") {
+    if (typeof component === "boolean") {
+      return { type: "empty", value: "" };
+    }
+    if (typeof component === "number") {
       return { type: "text", value: String(component) };
     }
     if (typeof component === "function") {
@@ -945,31 +1035,23 @@ var BaseRenderer = class {
     return { type: "unknown", value: component };
   }
   /**
-   * Execute function components with _error handling
+   * Execute function components. Errors propagate: they used to be
+   * swallowed here (the component rendered as nothing, logged only when
+   * NODE_ENV=development), so a broken component produced a partial page
+   * with a 200 and error boundaries never saw nested failures.
    */
   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();
-      }
+      const result = func();
       if (typeof result === "function") {
         return this.executeFunctionComponent(result, depth);
       }
       return result;
-    } catch (_error) {
+    } 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);
+        performanceMonitor.recordError("functionComponent", error);
       }
-      return null;
+      throw error;
     }
   }
   /**
@@ -1070,88 +1152,43 @@ var BaseRenderer = class {
     throw new Error("render must be implemented by subclass");
   }
 };
-var RendererUtils = {
-  /**
-   * Check if element is static (no functions or circular references)
-   */
-  isStaticElement(element, visited = /* @__PURE__ */ new WeakSet()) {
-    if (!element || typeof element !== "object") {
-      return typeof element === "string" || typeof element === "number";
-    }
-    if (visited.has(element)) {
-      return false;
-    }
-    visited.add(element);
-    for (const [_key, value] of Object.entries(element)) {
-      if (typeof value === "function") return false;
-      if (Array.isArray(value)) {
-        const allStatic = value.every((child) => RendererUtils.isStaticElement(child, visited));
-        if (!allStatic) return false;
-      } else if (typeof value === "object" && value !== null) {
-        if (!RendererUtils.isStaticElement(value, visited)) return false;
-      }
-    }
-    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;
+var UNCACHEABLE = /* @__PURE__ */ Symbol("uncacheable");
+function serializeForCache(value) {
+  try {
+    return serialize(value, /* @__PURE__ */ new Set());
+  } catch (error) {
+    if (error === UNCACHEABLE) return null;
+    throw error;
+  }
+}
+function serialize(value, ancestors) {
+  switch (typeof value) {
+    case "string":
+      return JSON.stringify(value);
+    case "number":
+      return `n${value}`;
+    case "boolean":
+      return value ? "t" : "f";
+    case "undefined":
+      return "u";
+    case "object": {
+      if (value === null) return "z";
+      if (isTrustedContent(value)) return `T${JSON.stringify(value.__html)}`;
+      if (ancestors.has(value)) throw UNCACHEABLE;
+      const isArray = Array.isArray(value);
+      if (!isArray) {
+        const proto = Object.getPrototypeOf(value);
+        if (proto !== Object.prototype && proto !== null) throw UNCACHEABLE;
+      }
+      ancestors.add(value);
+      const body = isArray ? value.map((item) => serialize(item, ancestors)).join(",") : Object.keys(value).map((key) => `${JSON.stringify(key)}:${serialize(value[key], ancestors)}`).join(",");
+      ancestors.delete(value);
+      return isArray ? `[${body}]` : `{${body}}`;
     }
-  },
-  /**
-   * 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;
+    default:
+      throw UNCACHEABLE;
   }
-};
+}
 
 // src/core/html-nesting-rules.js
 var FORBIDDEN_CHILDREN = {
@@ -1237,12 +1274,13 @@ var HTMLNestingError = class extends Error {
 // src/performance/cache-manager.js
 function createCacheManager(options = {}) {
   const {
-    maxCacheSize = 1e3,
     maxMemoryMB = 100,
     ttlMs = 1e3 * 60 * 5,
     // 5 minutes
     enableStatistics = true
   } = options;
+  const maxCacheSize = options.maxCacheSize ?? options.maxSize ?? 1e3;
+  const maxMemoryBytes = maxMemoryMB * 1024 * 1024;
   const caches = {
     static: /* @__PURE__ */ new Map(),
     // Never-changing components
@@ -1285,51 +1323,57 @@ function createCacheManager(options = {}) {
     return `${extractComponentName(component)}_${hash}`;
   }
   function get(key, type = "component") {
-    const cache = caches[type] || caches.component;
+    const cacheType = caches[type] ? type : "component";
+    const cache = caches[cacheType];
     const entry = cache.get(key);
     if (!entry) {
       stats.misses++;
-      if (enableStatistics) stats.accessCount[type]++;
+      if (enableStatistics) stats.accessCount[cacheType]++;
       return null;
     }
-    if (Date.now() - entry.timestamp > ttlMs) {
+    if (Date.now() - entry.timestamp > entry.ttl) {
       cache.delete(key);
       updateMemoryUsage(-entry.size);
       stats.misses++;
-      if (enableStatistics) stats.accessCount[type]++;
+      if (enableStatistics) stats.accessCount[cacheType]++;
       return null;
     }
+    cache.delete(key);
+    cache.set(key, entry);
     entry.lastAccess = Date.now();
     entry.accessCount++;
     stats.hits++;
     if (enableStatistics) {
-      stats.accessCount[type]++;
-      stats.hitRate[type] = stats.hits / (stats.hits + stats.misses) * 100;
+      stats.accessCount[cacheType]++;
+      stats.hitRate[cacheType] = 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 cacheType = caches[type] ? type : "component";
+    const cache = caches[cacheType];
+    const size = calculateSize(value) + calculateSize(key);
+    if (size > maxMemoryBytes) return;
+    const existing = cache.get(key);
+    if (existing) {
+      cache.delete(key);
+      updateMemoryUsage(-existing.size);
     }
-    const entry = {
+    const now = Date.now();
+    cache.set(key, {
       value,
-      timestamp: Date.now(),
-      lastAccess: Date.now(),
+      timestamp: now,
+      lastAccess: now,
       size,
       metadata,
+      ttl: typeof metadata.ttlMs === "number" ? metadata.ttlMs : ttlMs,
       accessCount: 0
-    };
-    const existing = cache.get(key);
-    if (existing) {
-      updateMemoryUsage(-existing.size);
-    }
-    cache.set(key, entry);
+    });
     updateMemoryUsage(size);
-    if (cache.size > maxCacheSize) {
-      optimize(type);
+    evict(cache, () => cache.size > maxCacheSize);
+    for (const other of Object.values(caches)) {
+      if (memoryUsage <= maxMemoryBytes) break;
+      evict(other, () => memoryUsage > maxMemoryBytes);
     }
   }
   function remove(key, type) {
@@ -1356,11 +1400,14 @@ function createCacheManager(options = {}) {
     if (type) {
       const cache = caches[type];
       if (cache) {
+        for (const entry of cache.values()) {
+          updateMemoryUsage(-entry.size);
+        }
         cache.clear();
       }
-    } else {
-      Object.values(caches).forEach((cache) => cache.clear());
+      return;
     }
+    Object.values(caches).forEach((cache) => cache.clear());
     memoryUsage = 0;
   }
   function getStats() {
@@ -1379,7 +1426,7 @@ function createCacheManager(options = {}) {
     let freed = 0;
     for (const [, cache] of Object.entries(caches)) {
       for (const [key, entry] of cache.entries()) {
-        if (now - entry.timestamp > ttlMs) {
+        if (now - entry.timestamp > entry.ttl) {
           cache.delete(key);
           updateMemoryUsage(-entry.size);
           freed++;
@@ -1404,17 +1451,15 @@ function createCacheManager(options = {}) {
   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);
+  function evict(cache, shouldEvict) {
     let freed = 0;
-    for (const [key, entry] of entries) {
-      if (freed >= requiredSpace) break;
+    for (const [key, entry] of cache) {
+      if (!shouldEvict()) break;
       cache.delete(key);
       updateMemoryUsage(-entry.size);
       freed += entry.size;
     }
-    return { freed };
+    return freed;
   }
   function simpleHash(str) {
     let hash = 0;
@@ -1569,7 +1614,7 @@ var ErrorHandler = class {
       enableStackTrace: options.enableStackTrace !== false,
       enableSuggestions: options.enableSuggestions !== false,
       enableLogging: options.enableLogging ?? defaultEnableLogging,
-      logLevel: options.logLevel || "_error",
+      logLevel: options.logLevel || "error",
       maxErrorHistory: options.maxErrorHistory || 100,
       ...options
     };
@@ -1720,7 +1765,7 @@ var ErrorHandler = class {
     if (suggestions.length === 0) {
       suggestions.push(
         "Enable development tools for more detailed debugging",
-        "Check browser console for additional _error details",
+        "Check browser console for additional error details",
         "Use component validation tools to identify issues"
       );
     }
@@ -1862,15 +1907,34 @@ var ErrorHandler = class {
 var globalErrorHandler = new ErrorHandler();
 
 // src/rendering/html-renderer.js
+var RESERVED_PROPS = /* @__PURE__ */ new Set(["children", "text", "key", "html"]);
 var rendererCache = createCacheManager({
-  maxSize: 1e3,
+  maxCacheSize: 1e3,
   ttlMs: 3e5
   // 5 minutes
 });
+function assertNotThenable(value, path) {
+  if (value && (typeof value === "object" || typeof value === "function") && typeof value.then === "function") {
+    throw new RenderingError(
+      `Cannot render a Promise at ${path === "root" ? "root" : formatRenderPath(path)}: render() is synchronous. Await async components (and their data) before rendering.`,
+      void 0,
+      { path: path === "root" ? "root" : formatRenderPath(path), renderer: "html" }
+    );
+  }
+}
+function childPath(parent, segment) {
+  return { parent, segment };
+}
 function formatRenderPath(path) {
-  if (!path || path.length === 0) return "root";
+  const segments = [];
+  if (Array.isArray(path)) {
+    segments.push(...path);
+  } else {
+    for (let node = path; node; node = node.parent) segments.push(node.segment);
+    segments.reverse();
+  }
   let rendered = "root";
-  for (const segment of path) {
+  for (const segment of segments) {
     if (typeof segment !== "string" || segment.length === 0) continue;
     if (segment.startsWith("[")) {
       rendered += segment;
@@ -1883,15 +1947,15 @@ function formatRenderPath(path) {
 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
+      ...options,
+      enableCache: options.enableCache === true
     });
-    if (this.config.enableCache && !this.cache) {
-      this.cache = rendererCache;
+    if (this.config.enableCache) {
+      this.cache = options.cache || rendererCache;
     }
   }
   /**
@@ -1919,15 +1983,30 @@ var HTMLRenderer = class extends BaseRenderer {
     const config = { ...this.config, ...options };
     this.startTiming();
     try {
+      assertNotThenable(component, "root");
       if (config.validateInput && !this.isValidComponent(component)) {
         throw new Error("Invalid component structure");
       }
+      const cacheKey = this.cache && config.enableCache ? serializeForCache(component) : null;
+      const fullKey = cacheKey === null ? null : `render:${config.minify ? "min" : "raw"}:${cacheKey}`;
+      if (fullKey !== null) {
+        const cached = this.cache.get(fullKey);
+        if (cached !== null) {
+          this.endTiming();
+          return cached;
+        }
+      }
       const renderOptions = {
         ...config,
         seenObjects: /* @__PURE__ */ new WeakSet()
       };
-      const html = this.renderComponent(component, renderOptions, 0, []);
+      const html = this.renderComponent(component, renderOptions, 0, null);
       const finalHtml = config.minify ? minifyHtml(html, config) : html;
+      if (fullKey !== null) {
+        this.cache.set(fullKey, finalHtml, "component", {
+          ttlMs: typeof config.cacheTTL === "number" ? config.cacheTTL : void 0
+        });
+      }
       this.endTiming();
       this.recordPerformance("render", this.metrics.startTime, false, {
         cacheEnabled: config.enableCache
@@ -1947,7 +2026,7 @@ var HTMLRenderer = class extends BaseRenderer {
   /**
    * Render a single component with full optimization pipeline
    */
-  renderComponent(component, options, depth = 0, path = []) {
+  renderComponent(component, options, depth = 0, path = null) {
     if (component === null || component === void 0) {
       return "";
     }
@@ -1957,8 +2036,13 @@ var HTMLRenderer = class extends BaseRenderer {
     if (isTrustedContent(component)) {
       return component.__html;
     }
-    if (typeof component === "object" && component !== null && !Array.isArray(component)) {
-      if (options.seenObjects && options.seenObjects.has(component)) {
+    if (typeof component === "object" && component.__isLazy === true && typeof component.evaluate === "function") {
+      return this.renderComponent(component.evaluate(), options, depth + 1, childPath(path, "()"));
+    }
+    assertNotThenable(component, path);
+    const tracked = options.seenObjects && typeof component === "object" && component !== null ? component : null;
+    if (tracked) {
+      if (options.seenObjects.has(tracked)) {
         throw new RenderingError(
           "Circular reference detected in component tree",
           component,
@@ -1966,9 +2050,7 @@ var HTMLRenderer = class extends BaseRenderer {
           ["Remove the circular reference", "Use lazy loading to break the cycle"]
         );
       }
-      if (options.seenObjects) {
-        options.seenObjects.add(component);
-      }
+      options.seenObjects.add(tracked);
     }
     this.validateDepth(depth);
     try {
@@ -1979,8 +2061,8 @@ var HTMLRenderer = class extends BaseRenderer {
         case "text":
           return escapeHtml(value);
         case "function": {
-          const result = this.executeFunctionComponent(value, depth);
-          return this.renderComponent(result, options, depth + 1, [...path, "()"]);
+          const result = this.runFunctionComponent(value, options, depth, path);
+          return this.renderComponent(result, options, depth + 1, childPath(path, "()"));
         }
         case "array":
           if (typeof process !== "undefined" && process.env && true && value.length > 1) {
@@ -1998,11 +2080,23 @@ var HTMLRenderer = class extends BaseRenderer {
               );
             }
           }
-          return value.map((child, index) => this.renderComponent(child, options, depth + 1, [...path, `[${index}]`])).join("");
+          {
+            let html = "";
+            for (let index = 0; index < value.length; index++) {
+              html += this.renderComponent(value[index], options, depth + 1, childPath(path, `[${index}]`));
+            }
+            return html;
+          }
         case "element": {
-          const tagName = Object.keys(value)[0];
-          const elementContent = value[tagName];
-          return this.renderElement(tagName, elementContent, options, depth, [...path, tagName]);
+          const tagNames = Object.keys(value);
+          if (tagNames.length === 1) {
+            return this.renderElement(tagNames[0], value[tagNames[0]], options, depth, childPath(path, tagNames[0]));
+          }
+          let html = "";
+          for (const tagName of tagNames) {
+            html += this.renderElement(tagName, value[tagName], options, depth, childPath(path, tagName));
+          }
+          return html;
         }
         default:
           this.recordError("renderComponent", new Error(`Unknown component type: ${type}`));
@@ -2018,16 +2112,34 @@ var HTMLRenderer = class extends BaseRenderer {
         }
         throw _error;
       }
-      throw new RenderingError(_error.message, void 0, { path: renderPath, renderer: "html" });
+      const wrapped = new RenderingError(_error.message, void 0, { path: renderPath, renderer: "html" });
+      wrapped.cause = _error;
+      throw wrapped;
+    } finally {
+      if (tracked) options.seenObjects.delete(tracked);
+    }
+  }
+  /**
+   * Run a function component, giving `options.onError` the chance to
+   * replace a component that throws.
+   */
+  runFunctionComponent(func, options, depth, path) {
+    try {
+      return this.executeFunctionComponent(func, depth);
+    } catch (error) {
+      if (typeof options.onError === "function") {
+        return options.onError(error, { path: formatRenderPath(path) });
+      }
+      throw error;
     }
   }
   /**
    * Render an HTML element with advanced caching and optimization
    */
-  renderElement(tagName, element, options, depth = 0, path = []) {
-    const startTime = performance.now();
-    if (element && typeof element === "object" && !Array.isArray(element)) {
-      if (options.seenObjects && options.seenObjects.has(element)) {
+  renderElement(tagName, element, options, depth = 0, path = null) {
+    const tracked = options.seenObjects && element && typeof element === "object" && !Array.isArray(element) ? element : null;
+    if (tracked) {
+      if (options.seenObjects.has(tracked)) {
         throw new RenderingError(
           "Circular reference detected in component tree",
           element,
@@ -2035,32 +2147,31 @@ var HTMLRenderer = class extends BaseRenderer {
           ["Remove the circular reference", "Use lazy loading to break the cycle"]
         );
       }
-      if (options.seenObjects) {
-        options.seenObjects.add(element);
-      }
-    }
-    if (options.enableMonitoring && this.cache) {
+      options.seenObjects.add(tracked);
     }
-    if (options.enableCache && this.cache && RendererUtils.isStaticElement(element)) {
-      try {
-        const cacheKey = `static:${tagName}:${JSON.stringify(element)}`;
-        const cached = this.cache.get("static", cacheKey);
-        if (cached) {
-          this.recordPerformance(tagName, startTime, true);
-          return cached.value;
-        }
-      } catch {
-      }
+    try {
+      return this.renderElementContent(tagName, element, options, depth, path);
+    } finally {
+      if (tracked) options.seenObjects.delete(tracked);
     }
+  }
+  renderElementContent(tagName, element, options, depth = 0, path = null) {
+    const startTime = options.enableMonitoring ? performance.now() : 0;
     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, [...path, "()"]);
+      let result;
+      try {
+        result = this.executeFunctionComponent(element, depth);
+      } catch (error) {
+        if (typeof options.onError !== "function") throw error;
+        const replacement = options.onError(error, { path: formatRenderPath(path) });
+        return this.renderComponent(replacement, options, depth + 1, childPath(path, "()"));
+      }
+      return this.renderElement(tagName, result, options, depth, childPath(path, "()"));
     }
     if (element && typeof element === "object") {
       return this.renderObjectElement(tagName, element, options, depth, path);
@@ -2075,105 +2186,255 @@ var HTMLRenderer = class extends BaseRenderer {
     return html;
   }
   /**
-   * Cache element if it's static
+   * Render complex object elements with attributes and children
    */
-  cacheIfStatic(tagName, element, html) {
-    if (this.config.enableCache && this.cache && RendererUtils.isStaticElement(element)) {
-      try {
-        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
-        });
-      } catch {
+  renderObjectElement(tagName, element, options, depth = 0, path = null) {
+    const startTime = options.enableMonitoring ? performance.now() : 0;
+    const parts = elementParts(tagName, element);
+    let html = parts.open + parts.content;
+    if (parts.children) {
+      const forbidden = FORBIDDEN_CHILDREN[tagName.toLowerCase()];
+      for (let index = 0; index < parts.children.length; index++) {
+        const child = parts.children[index];
+        const segment = childPath(path, `children[${index}]`);
+        checkNesting(tagName, forbidden, child, segment);
+        html += this.renderComponent(child, options, depth + 1, segment);
       }
     }
+    html += parts.close;
+    this.recordPerformance(tagName, startTime, false);
+    return html;
   }
   /**
-   * Render complex object elements with attributes and children
+   * Streaming counterpart of renderComponent: yields HTML pieces. Elements
+   * with many children are streamed child by child; everything else goes
+   * through the synchronous renderer, which is exact and faster, so the
+   * streamed output is the same as render()'s by construction.
    */
-  renderObjectElement(tagName, element, options, depth = 0, path = []) {
-    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;
+  async *streamComponent(component, options, depth = 0, path = null) {
+    if (component === null || component === void 0) return;
+    this.validateDepth(depth);
+    if (typeof component === "function") {
+      const result = this.runFunctionComponent(component, options, depth, path);
+      yield* this.streamComponent(result, options, depth + 1, childPath(path, "()"));
+      return;
+    }
+    if (Array.isArray(component)) {
+      yield* this.streamTracked(component, options, path, async function* (renderer) {
+        for (let index = 0; index < component.length; index++) {
+          yield* renderer.streamComponent(component[index], options, depth + 1, childPath(path, `[${index}]`));
         }
+      });
+      return;
+    }
+    if (typeof component === "object" && !isTrustedContent(component) && component.__isLazy !== true) {
+      const { type, value } = this.processComponentType(component);
+      if (type === "element") {
+        yield* this.streamTracked(component, options, path, async function* (renderer) {
+          for (const tagName of Object.keys(value)) {
+            yield* renderer.streamElement(tagName, value[tagName], options, depth, childPath(path, tagName));
+          }
+        });
+        return;
       }
     }
-    const { children, text, key: _key, html: _rawHtml, ...attributes } = element || {};
-    const attributeString = formatAttributes(attributes);
-    const openingTag = attributeString ? `<${tagName} ${attributeString}>` : `<${tagName}>`;
-    if (isVoidElement(tagName)) {
-      if (options.enableCache && this.cache && RendererUtils.isCacheable(element, options)) {
-        const cacheKey = RendererUtils.generateCacheKey(tagName, element);
-        if (cacheKey) {
-          this.cache.set(cacheKey, openingTag);
+    yield this.renderComponent(component, options, depth, path);
+  }
+  async *streamElement(tagName, element, options, depth, path) {
+    if (!element || typeof element !== "object" || Array.isArray(element) || !shouldStream(element.children)) {
+      yield this.renderElement(tagName, element, options, depth, path);
+      return;
+    }
+    yield* this.streamTracked(element, options, path, async function* (renderer) {
+      const parts = elementParts(tagName, element);
+      yield parts.open + parts.content;
+      if (parts.children) {
+        const forbidden = FORBIDDEN_CHILDREN[tagName.toLowerCase()];
+        for (let index = 0; index < parts.children.length; index++) {
+          const child = parts.children[index];
+          const segment = childPath(path, `children[${index}]`);
+          checkNesting(tagName, forbidden, child, segment);
+          yield* renderer.streamComponent(child, options, depth + 1, segment);
         }
       }
-      this.recordPerformance(tagName, startTime, false);
-      return openingTag;
+      yield parts.close;
+    });
+  }
+  /**
+   * Run `body` with `value` on the ancestor path used for cycle detection.
+   */
+  async *streamTracked(value, options, path, body) {
+    if (options.seenObjects.has(value)) {
+      throw new RenderingError(
+        "Circular reference detected in component tree",
+        value,
+        { path: formatRenderPath(path) },
+        ["Remove the circular reference", "Use lazy loading to break the cycle"]
+      );
     }
-    if (_rawHtml !== void 0) {
-      const resolvedHtml = typeof _rawHtml === "function" ? _rawHtml() : _rawHtml;
-      const rawContent = isTrustedContent(resolvedHtml) ? resolvedHtml.__html : String(resolvedHtml);
-      const result = `${openingTag}${rawContent}</${tagName}>`;
-      return result;
+    options.seenObjects.add(value);
+    try {
+      yield* body(this);
+    } finally {
+      options.seenObjects.delete(value);
     }
-    if (isTrustedContent(text)) {
-      return `${openingTag}${text.__html}</${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);
+  }
+};
+var STREAM_MIN_CHILDREN = 8;
+function shouldStream(children) {
+  if (children === void 0 || children === null) return false;
+  const list = Array.isArray(children) ? children : [children];
+  if (list.length >= STREAM_MIN_CHILDREN) return true;
+  for (const child of list) {
+    if (typeof child === "function" || Array.isArray(child)) return true;
+    if (child && typeof child === "object") {
+      for (const key in child) {
+        const content = child[key];
+        if (typeof content === "function") return true;
+        if (content && typeof content === "object" && content.children !== void 0 && content.children !== null) return true;
       }
     }
-    let childrenHtml = "";
-    if (hasChildren(element)) {
-      const normalizedChildren = normalizeChildren(children);
-      childrenHtml = normalizedChildren.map((child, index) => {
-        if (child && typeof child === "object" && !Array.isArray(child)) {
-          const childTagName = Object.keys(child)[0];
-          if (childTagName) {
-            validateNesting(tagName, childTagName, formatRenderPath([...path, `children[${index}]`]));
-          }
-        }
-        return this.renderComponent(child, options, depth + 1, [...path, `children[${index}]`]);
-      }).join("");
+  }
+  return false;
+}
+function elementParts(tagName, element) {
+  const { children, text: rawText, html: rawHtml } = element || {};
+  const attributeString = formatAttributes(element, RESERVED_PROPS);
+  const open = attributeString ? `<${tagName} ${attributeString}>` : `<${tagName}>`;
+  if (isVoidElement(tagName)) {
+    return { open, content: "", children: null, close: "" };
+  }
+  const close = `</${tagName}>`;
+  const html = typeof rawHtml === "function" ? rawHtml() : rawHtml;
+  if (html !== void 0 && html !== null) {
+    return { open, content: isTrustedContent(html) ? html.__html : String(html), children: null, close };
+  }
+  const text = typeof rawText === "function" && !isTrustedContent(rawText) ? rawText() : rawText;
+  if (isTrustedContent(text)) {
+    return { open, content: text.__html, children: null, close };
+  }
+  let content = "";
+  if (text !== void 0 && text !== null) {
+    const raw = String(text);
+    if (tagName === "script" || tagName === "style") {
+      content = raw.replace(/<\/(script)/gi, "<\\/$1").replace(/<\/(style)/gi, "<\\/$1").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+    } else {
+      content = escapeHtml(raw);
     }
-    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);
-      }
+  }
+  const normalized = children !== void 0 && children !== null ? normalizeChildren(children) : null;
+  return { open, content, children: normalized && normalized.length > 0 ? normalized : null, close };
+}
+function checkNesting(tagName, forbidden, child, path) {
+  if (forbidden && child && typeof child === "object" && !Array.isArray(child)) {
+    const childTagName = Object.keys(child)[0];
+    if (childTagName && forbidden.has(childTagName.toLowerCase())) {
+      validateNesting(tagName, childTagName, formatRenderPath(path));
     }
-    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);
 }
+async function* renderToStream(component, options = {}) {
+  const { chunkSize = 8192, ...renderOptions } = options;
+  const renderer = new HTMLRenderer({ enableMonitoring: false, ...renderOptions, enableCache: false });
+  const config = { ...renderer.config, seenObjects: /* @__PURE__ */ new WeakSet() };
+  assertNotThenable(component, "root");
+  if (config.validateInput && !renderer.isValidComponent(component)) {
+    throw new Error("Invalid component structure");
+  }
+  const minifier = config.minify ? createStreamMinifier() : null;
+  let buffer = "";
+  for await (const piece of renderer.streamComponent(component, config, 0, null)) {
+    buffer += minifier ? minifier.push(piece) : piece;
+    if (buffer.length >= chunkSize) {
+      yield buffer;
+      buffer = "";
+      await yieldToEventLoop();
+    }
+  }
+  if (minifier) buffer += minifier.end();
+  if (buffer) yield buffer;
+}
+var yieldToEventLoop = typeof setImmediate === "function" ? () => new Promise((resolve) => setImmediate(resolve)) : () => new Promise((resolve) => setTimeout(resolve, 0));
+function waitForDrain(response) {
+  if (response.destroyed) return Promise.resolve(false);
+  return new Promise((resolve) => {
+    const settle = (drained) => () => {
+      response.off("drain", onDrain);
+      response.off("close", onClose);
+      response.off("error", onClose);
+      resolve(drained);
+    };
+    const onDrain = settle(true);
+    const onClose = settle(false);
+    response.on("drain", onDrain);
+    response.on("close", onClose);
+    response.on("error", onClose);
+  });
+}
+var streamingUtils = {
+  /**
+   * Collect all chunks into a single string
+   */
+  async collectChunks(chunkGenerator) {
+    let html = "";
+    for await (const chunk of chunkGenerator) {
+      html += chunk;
+    }
+    return html;
+  },
+  /**
+   * Stream directly to a Node.js response, with backpressure.
+   *
+   * Resolves with the number of bytes written once the response has ended.
+   * If the client disconnects first, rendering stops (the generator is
+   * closed) and it resolves with the bytes written so far without ending
+   * the response. If rendering fails, the response is destroyed and it
+   * rejects with the rendering error.
+   */
+  async streamToResponse(chunkGenerator, response) {
+    let totalBytes = 0;
+    if (!response.headersSent && !response.getHeader?.("Content-Type")) {
+      response.setHeader("Content-Type", "text/html; charset=utf-8");
+    }
+    try {
+      for await (const chunk of chunkGenerator) {
+        if (response.destroyed) return totalBytes;
+        totalBytes += Buffer.byteLength(chunk);
+        if (!response.write(chunk) && !await waitForDrain(response)) {
+          return totalBytes;
+        }
+      }
+    } catch (error) {
+      response.destroy(error);
+      throw error;
+    }
+    response.end();
+    return totalBytes;
+  },
+  /**
+   * Stream with progress callback
+   */
+  async *streamWithProgress(chunkGenerator, onProgress) {
+    let totalBytes = 0;
+    let chunkCount = 0;
+    for await (const chunk of chunkGenerator) {
+      totalBytes += Buffer.byteLength(chunk);
+      chunkCount++;
+      if (onProgress) {
+        onProgress({ chunkCount, totalBytes, chunk });
+      }
+      yield chunk;
+    }
+  }
+};
 
 // src/components/component-system.js
 var COMPONENT_REGISTRY = /* @__PURE__ */ new Map();
@@ -2220,7 +2481,7 @@ var ComponentState = class {
       try {
         listener(newState, oldState);
       } catch (_error) {
-        console.error("State listener _error:", _error);
+        console.error("State listener error:", _error);
       }
     });
     this.isUpdating = false;
@@ -2389,7 +2650,7 @@ var Component = class _Component {
       return this.rendered;
     } catch (_error) {
       this.handleError(_error);
-      return { div: { className: "component-_error", text: `Error in ${this.name}` } };
+      return { div: { className: "component-error", text: `Error in ${this.name}` } };
     }
   }
   /**
@@ -2635,7 +2896,7 @@ function lazy(factory, options = {}) {
         if (onError) {
           onError(_error);
         } else {
-          console.error("Lazy evaluation _error:", _error);
+          console.error("Lazy evaluation error:", _error);
         }
         return fallback;
       } finally {
@@ -2738,27 +2999,32 @@ function evaluateWithTimeout(factory, timeout, args, fallback) {
     }
   }).catch(() => fallback);
 }
+var functionIds = /* @__PURE__ */ new WeakMap();
+var nextFunctionId = 0;
+function functionId(fn) {
+  let id = functionIds.get(fn);
+  if (id === void 0) {
+    id = ++nextFunctionId;
+    functionIds.set(fn, id);
+  }
+  return id;
+}
+function serializeMemoKey(value) {
+  return JSON.stringify(value, (_key, v) => typeof v === "function" ? `\0fn:${functionId(v)}` : v);
+}
 function memo(fn, options = {}) {
   const {
     // Caching strategy
     strategy = "lru",
     // 'lru', 'ttl', 'weak', 'simple'
     maxSize = 100,
-    // Maximum cache entries
+    // Maximum cache entries ('lru' and 'ttl')
     ttl = null,
     // Time to live in milliseconds
     // Key generation
     keyFn = null,
     // Custom key function
-    keySerializer = JSON.stringify,
-    // Default serialization
-    // Comparison
-    // eslint-disable-next-line no-unused-vars
-    compareFn = null,
-    // Custom equality comparison
-    // eslint-disable-next-line no-unused-vars
-    shallow = false,
-    // Shallow comparison for objects
+    keySerializer = serializeMemoKey,
     // Lifecycle hooks
     onHit = null,
     // Called on cache hit
@@ -2773,63 +3039,74 @@ function memo(fn, options = {}) {
     debug = false
     // Debug logging
   } = options;
-  let cache;
-  const stats_data = stats ? { hits: 0, misses: 0, evictions: 0 } : null;
-  switch (strategy) {
-    case "lru":
-      cache = new LRUCache(maxSize, { onEvict });
-      break;
-    case "ttl":
-      cache = new TTLCache(ttl, { onEvict });
-      break;
-    case "weak":
-      cache = /* @__PURE__ */ new WeakMap();
-      break;
-    default:
-      cache = /* @__PURE__ */ new Map();
-  }
+  const statsData = { hits: 0, misses: 0, evictions: 0 };
+  const expiresIn = strategy === "ttl" && ttl === null ? 5e3 : ttl;
+  const store = strategy === "simple" ? /* @__PURE__ */ new Map() : new LRUCache(maxSize, {
+    onEvict: (key, entry) => {
+      statsData.evictions++;
+      if (onEvict) onEvict(key, entry.value);
+    }
+  });
+  const weakStore = strategy === "weak" ? /* @__PURE__ */ new WeakMap() : null;
   const generateKey = keyFn || ((...args) => {
     if (args.length === 0) return "__empty__";
     if (args.length === 1) return keySerializer(args[0]);
     return keySerializer(args);
   });
+  const isFresh = (entry) => entry.expires === null || Date.now() < entry.expires;
+  const lookup = (args) => {
+    if (weakStore) {
+      const [first] = args;
+      const cacheable = first !== null && (typeof first === "object" || typeof first === "function");
+      return { cacheable, key: first, entries: weakStore };
+    }
+    try {
+      return { cacheable: true, key: generateKey(...args), entries: store };
+    } catch {
+      return { cacheable: false };
+    }
+  };
   const memoizedFn = (...args) => {
-    const key = generateKey(...args);
-    if (cache.has(key)) {
-      const cached = cache.get(key);
-      if (cached && (!cached.expires || Date.now() < cached.expires)) {
-        if (debug) console.log(`Memo cache hit for key: ${key}`);
+    const { cacheable, key, entries } = lookup(args);
+    if (!cacheable) return fn(...args);
+    const cached = entries.get(key);
+    if (cached !== void 0) {
+      if (isFresh(cached)) {
+        if (debug) console.log(`Memo cache hit for key: ${String(key)}`);
         if (onHit) onHit(key, cached.value, args);
-        if (stats_data) stats_data.hits++;
-        return cached.value || cached;
-      } else {
-        cache.delete(key);
+        statsData.hits++;
+        return cached.value;
       }
+      entries.delete(key);
     }
-    if (debug) console.log(`Memo cache miss for key: ${key}`);
+    if (debug) console.log(`Memo cache miss for key: ${String(key)}`);
     if (onMiss) onMiss(key, args);
-    if (stats_data) stats_data.misses++;
-    const result = fn(...args);
-    const cacheEntry = ttl ? { value: result, expires: Date.now() + ttl } : result;
-    cache.set(key, cacheEntry);
-    return result;
+    statsData.misses++;
+    const value = fn(...args);
+    entries.set(key, { value, expires: expiresIn ? Date.now() + expiresIn : null });
+    return value;
+  };
+  memoizedFn.cache = weakStore || (store instanceof LRUCache ? store.cache : store);
+  memoizedFn.clear = () => {
+    if (!weakStore) store.clear();
+  };
+  memoizedFn.delete = (key) => (weakStore || store).delete(key);
+  memoizedFn.has = (key) => {
+    const entry = (weakStore || store).get(key);
+    return entry !== void 0 && isFresh(entry);
   };
-  memoizedFn.cache = cache;
-  memoizedFn.clear = () => cache.clear();
-  memoizedFn.delete = (key) => cache.delete(key);
-  memoizedFn.has = (key) => cache.has(key);
-  memoizedFn.size = () => cache.size;
-  if (stats_data) {
-    memoizedFn.stats = () => ({ ...stats_data });
+  memoizedFn.size = () => weakStore ? void 0 : store.size;
+  if (stats) {
+    memoizedFn.stats = () => ({ ...statsData });
     memoizedFn.resetStats = () => {
-      stats_data.hits = 0;
-      stats_data.misses = 0;
-      stats_data.evictions = 0;
+      statsData.hits = 0;
+      statsData.misses = 0;
+      statsData.evictions = 0;
     };
   }
   memoizedFn.refresh = (...args) => {
-    const key = generateKey(...args);
-    cache.delete(key);
+    const { cacheable, key, entries } = lookup(args);
+    if (cacheable) entries.delete(key);
     return memoizedFn(...args);
   };
   return memoizedFn;
@@ -2893,66 +3170,6 @@ var LRUCache = class {
     return this.cache.size;
   }
 };
-var TTLCache = class {
-  constructor(ttl, options = {}) {
-    this.ttl = ttl;
-    this.cache = /* @__PURE__ */ new Map();
-    this.timers = /* @__PURE__ */ new Map();
-    this.onEvict = options.onEvict;
-  }
-  get(key) {
-    if (this.cache.has(key)) {
-      const entry = this.cache.get(key);
-      if (Date.now() < entry.expires) {
-        return entry.value;
-      } else {
-        this.delete(key);
-      }
-    }
-    return void 0;
-  }
-  set(key, value) {
-    if (this.timers.has(key)) {
-      clearTimeout(this.timers.get(key));
-    }
-    const expires = Date.now() + this.ttl;
-    this.cache.set(key, { value, expires });
-    const timer = setTimeout(() => {
-      this.delete(key);
-    }, this.ttl);
-    this.timers.set(key, timer);
-  }
-  has(key) {
-    if (this.cache.has(key)) {
-      const entry = this.cache.get(key);
-      return Date.now() < entry.expires;
-    }
-    return false;
-  }
-  delete(key) {
-    const had = this.cache.has(key);
-    if (had) {
-      const entry = this.cache.get(key);
-      this.cache.delete(key);
-      if (this.timers.has(key)) {
-        clearTimeout(this.timers.get(key));
-        this.timers.delete(key);
-      }
-      if (this.onEvict) {
-        this.onEvict(key, entry.value);
-      }
-    }
-    return had;
-  }
-  clear() {
-    this.timers.forEach((timer) => clearTimeout(timer));
-    this.timers.clear();
-    this.cache.clear();
-  }
-  get size() {
-    return this.cache.size;
-  }
-};
 function shallowEqual(a, b) {
   if (a === b) return true;
   if (!a || !b) return false;
@@ -3146,7 +3363,9 @@ function createStateContainer(initialState, options) {
     storageKey,
     storage,
     reducer,
-    middleware,
+    // Defaulted here: withStateUtils.shared() passes {}, and spreading
+    // an undefined middleware list threw "middleware is not iterable".
+    middleware = [],
     validator,
     onStateChange,
     debug
@@ -3201,7 +3420,7 @@ function createStateContainer(initialState, options) {
           try {
             listener(state, prevState);
           } catch (_error) {
-            if (debug) console.error("State listener _error:", _error);
+            if (debug) console.error("State listener error:", _error);
           }
         });
         if (onStateChange) {
@@ -3345,8 +3564,10 @@ var withStateUtils = {
     }
   }),
   /**
-   * State with loading/_error handling
+   * State with loading/error handling
    */
+  // `_loading` / `_error` are the documented state keys (docs/components/state.md).
+  /* eslint-disable no-restricted-syntax */
   withLoading: async (initialState) => withState({
     ...initialState,
     _loading: false,
@@ -3376,6 +3597,7 @@ var withStateUtils = {
       }
     }
   }),
+  /* eslint-enable no-restricted-syntax */
   /**
    * State with undo/redo functionality
    */
@@ -3476,7 +3698,7 @@ var LIFECYCLE_PHASES = {
   UPDATED: "updated",
   BEFORE_UNMOUNT: "beforeUnmount",
   UNMOUNTED: "unmounted",
-  ERROR: "_error"
+  ERROR: "error"
 };
 var componentInstances = /* @__PURE__ */ new WeakMap();
 var componentRegistry = /* @__PURE__ */ new Map();
@@ -3796,7 +4018,7 @@ var ComponentEventSystem = class {
           handler(event);
         } catch (_error) {
           globalErrorHandler.handle(_error, {
-            type: "event-handler-_error",
+            type: "event-handler-error",
             context: { event, handler: handler.toString() }
           });
         }
@@ -3815,7 +4037,7 @@ var ComponentEventSystem = class {
           handler(event);
         } catch (_error) {
           globalErrorHandler.handle(_error, {
-            type: "global-event-handler-_error",
+            type: "global-event-handler-error",
             context: { event, handler: handler.toString() }
           });
         }
@@ -4138,6 +4360,7 @@ var ComponentCache = class {
       this.cleanupTimer = setInterval(() => {
         this.cleanup();
       }, this.options.cleanupInterval);
+      this.cleanupTimer.unref?.();
     }
   }
   /**
@@ -4427,6 +4650,37 @@ function memoize(component, keyGenerator, options = {}) {
 }
 
 // src/components/error-boundary.js
+function isBrowser() {
+  return typeof window !== "undefined" && typeof document !== "undefined";
+}
+function resolveNestedComponents(node, depth = 0) {
+  if (depth > 1e3) return node;
+  if (typeof node === "function") {
+    return resolveNestedComponents(node(), depth + 1);
+  }
+  if (Array.isArray(node)) {
+    let changed = false;
+    const resolved = node.map((child) => {
+      const result = resolveNestedComponents(child, depth + 1);
+      if (result !== child) changed = true;
+      return result;
+    });
+    return changed ? resolved : node;
+  }
+  if (node && typeof node === "object" && !isTrustedContent(node)) {
+    const keys = Object.keys(node);
+    if (keys.length !== 1) return node;
+    const tag = keys[0];
+    const props = node[tag];
+    if (props && typeof props === "object" && !Array.isArray(props) && props.children !== void 0) {
+      const children = resolveNestedComponents(props.children, depth + 1);
+      if (children !== props.children) {
+        return { [tag]: { ...props, children } };
+      }
+    }
+  }
+  return node;
+}
 var ErrorBoundaryState = class {
   constructor() {
     this.hasError = false;
@@ -4458,19 +4712,23 @@ function createErrorBoundary(options = {}) {
     maxErrors = Infinity,
     resetTimeout = null
   } = options;
-  const state = new ErrorBoundaryState();
+  const sharedState = new ErrorBoundaryState();
   let previousProps = {};
   let resetTimer = null;
   return function errorBoundaryWrapper(component) {
     return function wrappedComponent(props = {}) {
+      const persistent = isBrowser();
+      const state = persistent ? sharedState : new ErrorBoundaryState();
       try {
-        if (resetOnPropsChange && shouldReset(props, previousProps, resetKeys)) {
+        if (persistent && resetOnPropsChange && shouldReset(props, previousProps, resetKeys)) {
           state.reset();
           if (onReset) {
             onReset();
           }
         }
-        previousProps = { ...props };
+        if (persistent) {
+          previousProps = { ...props };
+        }
         if (state.hasError) {
           if (state.errorCount >= maxErrors) {
             return typeof fallback === "function" ? fallback(state.error, state.errorInfo, { permanent: true }) : fallback;
@@ -4487,7 +4745,7 @@ function createErrorBoundary(options = {}) {
           return fallbackComponent;
         }
         const result = typeof component === "function" ? component(props) : component;
-        return result;
+        return resolveNestedComponents(result);
       } catch (error) {
         const errorInfo = {
           componentStack: error.stack,
@@ -4502,7 +4760,7 @@ function createErrorBoundary(options = {}) {
             console.error("Error in onError callback:", callbackError);
           }
         }
-        if (resetTimeout && !resetTimer) {
+        if (persistent && resetTimeout && !resetTimer) {
           resetTimer = setTimeout(() => {
             state.reset();
             resetTimer = null;
@@ -4618,9 +4876,10 @@ function createAsyncErrorBoundary(options = {}) {
   } = options;
   return function asyncBoundaryWrapper(asyncComponent) {
     return async function wrappedAsyncComponent(props = {}) {
+      let timer;
       try {
         const timeoutPromise = new Promise((_, reject) => {
-          setTimeout(() => reject(new Error("Component load timeout")), timeout);
+          timer = setTimeout(() => reject(new Error("Component load timeout")), timeout);
         });
         const result = await Promise.race([
           typeof asyncComponent === "function" ? asyncComponent(props) : asyncComponent,
@@ -4632,6 +4891,8 @@ function createAsyncErrorBoundary(options = {}) {
           onError(error, { props, async: true });
         }
         return typeof errorFallback === "function" ? errorFallback(error, { props }) : errorFallback;
+      } finally {
+        clearTimeout(timer);
       }
     };
   };
@@ -4726,7 +4987,7 @@ function renderWithTemplate(component, options = {}) {
     template = "<!DOCTYPE html>\n{{content}}"
   } = options;
   const html = renderWithMonitoring(component, options);
-  return template.replace("{{content}}", html);
+  return template.replace("{{content}}", () => html);
 }
 async function renderComponentFactory(componentFactory, factoryArgs, options = {}) {
   const component = await Promise.resolve(
@@ -4914,7 +5175,8 @@ function renderComponentContent(obj) {
         if (value === true) return attrName;
         return `${attrName}="${escapeHTML(String(value))}"`;
       }).join(" ");
-      const openTag = attrsStr ? `<${tagName} ${attrsStr}>` : `<${tagName}>`;
+      const attrsPart = attrsStr ? ` ${attrsStr}` : "";
+      const openTag = `<${tagName}${attrsPart}>`;
       if ([
         "area",
         "base",
@@ -4931,7 +5193,7 @@ function renderComponentContent(obj) {
         "track",
         "wbr"
       ].includes(tagName)) {
-        return openTag.replace(">", " />");
+        return `<${tagName}${attrsPart} />`;
       }
       let content = "";
       if (text !== void 0) {
@@ -5263,6 +5525,29 @@ var EventBus = class {
     }
     return false;
   }
+  /**
+   * A view of this bus whose event and action names are prefixed with
+   * `${scope}:`. It shares listeners with the bus, so `scope:event` can
+   * still be observed from the unscoped bus. withEventBus({ scope }) and
+   * emitEvent(name, { scope }) called this, but it didn't exist, so any
+   * scoped usage threw "createScope is not a function".
+   *
+   * @param {string} scope - Scope name
+   * @returns {Object} Scoped event bus
+   */
+  createScope(scope) {
+    const prefix = `${scope}:`;
+    return {
+      emit: (event, data) => this.emit(prefix + event, data),
+      emitSync: (event, data) => this.emitSync(prefix + event, data),
+      on: (event, listener, options) => this.on(prefix + event, listener, options),
+      once: (event, listener, options) => this.once(prefix + event, listener, options),
+      off: (event, listenerId) => this.off(prefix + event, listenerId),
+      registerAction: (action, handler) => this.registerAction(prefix + action, handler),
+      handleAction: (action, element, event, data) => this.handleAction(prefix + action, element, event, data),
+      createScope: (child) => this.createScope(prefix + child)
+    };
+  }
   /**
    * Remove all listeners for an event
    */
@@ -5876,7 +6161,8 @@ function withEventBus(options = {}) {
     function EventBusComponent(props = {}, state = {}, context = {}) {
       const bus = scope ? eventBus.createScope(scope) : eventBus;
       const listenerIds = /* @__PURE__ */ new Map();
-      Object.entries(events).forEach(([event, handler]) => {
+      const interactive = typeof window !== "undefined" && typeof document !== "undefined";
+      if (interactive) Object.entries(events).forEach(([event, handler]) => {
         const listenerId = bus.on(event, (data, eventName) => {
           if (typeof handler === "function") {
             handler.call(this, data, eventName, { props, state, context });
@@ -5884,7 +6170,7 @@ function withEventBus(options = {}) {
         });
         listenerIds.set(event, listenerId);
       });
-      Object.entries(actions).forEach(([action, handler]) => {
+      if (interactive) Object.entries(actions).forEach(([action, handler]) => {
         bus.registerAction(action, (actionContext) => {
           if (typeof handler === "function") {
             handler.call(this, actionContext, { props, state, context });
@@ -5928,7 +6214,10 @@ function withEventBus(options = {}) {
             originalUnmount.call(this);
           };
         } else {
-          result.__eventBusCleanup = eventUtils.cleanup;
+          Object.defineProperty(result, "__eventBusCleanup", {
+            value: eventUtils.cleanup,
+            configurable: true
+          });
         }
       }
       return result;
@@ -6256,6 +6545,7 @@ var eventSystem2 = {
   registerAction: globalEventBus.registerAction.bind(globalEventBus),
   registerActions: globalEventBus.registerActions.bind(globalEventBus),
   handleAction: globalEventBus.handleAction.bind(globalEventBus),
+  createScope: globalEventBus.createScope.bind(globalEventBus),
   // Statistics and debugging
   getStats: globalEventBus.getStats.bind(globalEventBus),
   resetStats: globalEventBus.resetStats.bind(globalEventBus),
@@ -6359,23 +6649,74 @@ var compose = {
 };
 
 // src/index.js
-var scopeCounter = { value: 0 };
-function generateScopeId() {
-  return `coh-${scopeCounter.value++}`;
+function generateScopeId(cssText) {
+  let hash = 2166136261;
+  for (let i = 0; i < cssText.length; i++) {
+    hash ^= cssText.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return `coh-${(hash >>> 0).toString(36)}`;
+}
+var GROUPING_AT_RULES = /* @__PURE__ */ new Set(["media", "supports", "container", "layer", "document", "scope"]);
+function splitSelectorList(prelude) {
+  const parts = [];
+  let depth = 0;
+  let start = 0;
+  for (let i = 0; i < prelude.length; i++) {
+    const ch = prelude[i];
+    if (ch === "(" || ch === "[") depth++;
+    else if (ch === ")" || ch === "]") depth--;
+    else if (ch === "," && depth === 0) {
+      parts.push(prelude.slice(start, i));
+      start = i + 1;
+    }
+  }
+  parts.push(prelude.slice(start));
+  return parts;
+}
+function scopeSelector(selector, scopeId) {
+  const trimmed = selector.trim();
+  if (!trimmed) return selector;
+  if (trimmed.includes(":")) {
+    return trimmed.replace(/([^:]+)(:.*)?/, `$1[${scopeId}]$2`);
+  }
+  return `${trimmed}[${scopeId}]`;
 }
 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(", ")} {`;
-  });
+  let result = "";
+  let i = 0;
+  while (i < css.length) {
+    const open = css.indexOf("{", i);
+    if (open === -1) {
+      result += css.slice(i);
+      break;
+    }
+    let depth = 1;
+    let j = open + 1;
+    while (j < css.length && depth > 0) {
+      if (css[j] === "{") depth++;
+      else if (css[j] === "}") depth--;
+      j++;
+    }
+    const body = css.slice(open + 1, depth === 0 ? j - 1 : j);
+    const rawPrelude = css.slice(i, open);
+    const semicolon = rawPrelude.lastIndexOf(";");
+    const lead = semicolon === -1 ? "" : rawPrelude.slice(0, semicolon + 1);
+    const prelude = semicolon === -1 ? rawPrelude : rawPrelude.slice(semicolon + 1);
+    const trimmed = prelude.trim();
+    if (trimmed.startsWith("@")) {
+      const name = trimmed.slice(1).split(/[\s({]/)[0].toLowerCase();
+      const inner = GROUPING_AT_RULES.has(name) ? scopeCSS(body, scopeId) : body;
+      result += `${lead}${prelude}{${inner}}`;
+    } else {
+      const leading = prelude.match(/^\s*/)[0];
+      const scoped = splitSelectorList(prelude).map((part) => scopeSelector(part, scopeId)).join(", ");
+      result += `${lead}${leading}${scoped} {${body}}`;
+    }
+    i = j;
+  }
+  return result;
 }
 function applyScopeToElement(element, scopeId) {
   if (typeof element === "string" || typeof element === "number" || !element) {
@@ -6403,10 +6744,7 @@ function applyScopeToElement(element, scopeId) {
   return element;
 }
 function dangerouslySetInnerContent(content) {
-  return {
-    __html: content,
-    __trusted: true
-  };
+  return createTrustedContent(content);
 }
 function injectHydrationAttributes(component, options) {
   if (!component || typeof component !== "object" || Array.isArray(component)) {
@@ -6438,20 +6776,42 @@ function Island(componentFn) {
     });
   };
 }
-function render2(obj, options = {}) {
+function prepareRender(obj, options) {
   const scoped = options.scoped ?? options.encapsulate ?? false;
   const { scoped: _scoped, encapsulate: _encapsulate, hydratable: _hydratable, island: _island, ...rendererOptions } = options;
-  let component = scoped ? renderScopedComponent(obj) : obj;
-  if (typeof component === "function") {
-    component = component(options);
+  let component = typeof obj === "function" ? obj(options) : obj;
+  if (scoped) {
+    component = renderScopedComponent(component);
   }
   if (_hydratable || _island) {
     component = injectHydrationAttributes(component, { hydratable: _hydratable, island: _island });
   }
+  return { component, rendererOptions };
+}
+function render2(obj, options = {}) {
+  const { component, rendererOptions } = prepareRender(obj, options);
   return render(component, rendererOptions);
 }
+function renderToStream2(obj, options = {}) {
+  const { component, rendererOptions } = prepareRender(obj, options);
+  return renderToStream(component, rendererOptions);
+}
+function collectStyleText(element, out = []) {
+  if (Array.isArray(element)) {
+    element.forEach((item) => collectStyleText(item, out));
+  } else if (element && typeof element === "object") {
+    for (const [tagName, props] of Object.entries(element)) {
+      if (tagName === "style" && props && typeof props === "object" && typeof props.text === "string") {
+        out.push(props.text);
+      } else if (props && typeof props === "object" && props.children) {
+        collectStyleText(props.children, out);
+      }
+    }
+  }
+  return out;
+}
 function renderScopedComponent(component) {
-  const scopeId = generateScopeId();
+  const scopeId = generateScopeId(collectStyleText(component).join("\n"));
   function processScopedElement(element) {
     if (!element || typeof element !== "object") {
       return element;
@@ -6482,21 +6842,13 @@ function renderScopedComponent(component) {
   const scopedComponent = applyScopeToElement(processedComponent, scopeId);
   return scopedComponent;
 }
-var memoCache = /* @__PURE__ */ new Map();
-function memo2(component, keyGenerator) {
-  return function MemoizedComponent(props = {}) {
-    const key = keyGenerator ? keyGenerator(props) : JSON.stringify(props);
-    if (memoCache.has(key)) {
-      return memoCache.get(key);
-    }
-    const result = component(props);
-    memoCache.set(key, result);
-    if (memoCache.size > 100) {
-      const firstKey = memoCache.keys().next().value;
-      memoCache.delete(firstKey);
-    }
-    return result;
-  };
+function memo2(component, options = {}) {
+  const withDefaultProps = (props = {}, ...rest) => component(props, ...rest);
+  if (typeof options === "function") {
+    const keyGenerator = options;
+    return memo(withDefaultProps, { keyFn: (props = {}, ...rest) => keyGenerator(props, ...rest) });
+  }
+  return memo(withDefaultProps, options);
 }
 function validateComponent2(obj) {
   if (!obj || typeof obj !== "object") {
@@ -6517,7 +6869,7 @@ function deepClone2(obj) {
   }
   return cloned;
 }
-var VERSION = true ? "1.1.0" : JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8")).version;
+var VERSION = true ? "2.0.0-rc.0" : JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8")).version;
 var fp = {
   /**
    * Curried map: fp.map(fn)(array)
@@ -6529,6 +6881,7 @@ var fp = {
 var coherent = {
   // Core rendering
   render: render2,
+  renderToStream: renderToStream2,
   // Shadow DOM (client-side only)
   shadowDOM: shadow_dom_exports,
   // Component system
@@ -6646,6 +6999,7 @@ export {
   isLazy,
   isPeerDependencyAvailable,
   isTrustedContent,
+  isValidAttributeName,
   isVoidElement,
   lazy,
   componentUtils as lifecycleUtils,
@@ -6661,9 +7015,11 @@ export {
   registerComponent,
   render2 as render,
   renderComponentFactory,
+  renderToStream2 as renderToStream,
   renderWithMonitoring,
   renderWithTemplate,
   shadow_dom_exports as shadowDOM,
+  streamingUtils,
   useHooks,
   validateComponent2 as validateComponent,
   validateNesting,