@coherent.js/core 1.0.0-rc.6 → 1.0.0

package/dist/index.js

@@ -505,6 +505,110 @@ function createPerformanceMonitor(options = {}) {
 }
 var performanceMonitor = createPerformanceMonitor();
 
+// 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 isTrustedContent(value) {
+  return Boolean(value) && typeof value === "object" && value.__trusted === true && typeof value.__html === "string";
+}
+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 (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)}"`;
+      } else 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();
+}
+
 // src/core/object-utils.js
 function deepClone(obj, seen = /* @__PURE__ */ new WeakMap()) {
   if (obj === null || typeof obj !== "object") {
@@ -1086,13 +1190,15 @@ var FORBIDDEN_CHILDREN = {
   // Links cannot nest
   button: /* @__PURE__ */ new Set(["button", "a", "input", "select", "textarea", "label"]),
   label: /* @__PURE__ */ new Set(["label"]),
-  // Table structure restrictions
-  thead: /* @__PURE__ */ new Set(["thead", "tbody", "tfoot", "caption", "colgroup", "tr"]),
+  // Table structure restrictions.
+  // thead/tbody/tfoot take "zero or more tr elements", so <tr> is allowed.
+  thead: /* @__PURE__ */ new Set(["thead", "tbody", "tfoot", "caption", "colgroup"]),
   tbody: /* @__PURE__ */ new Set(["thead", "tbody", "tfoot", "caption", "colgroup"]),
   tfoot: /* @__PURE__ */ new Set(["thead", "tbody", "tfoot", "caption", "colgroup"]),
   tr: /* @__PURE__ */ new Set(["tr", "thead", "tbody", "tfoot", "table"]),
-  td: /* @__PURE__ */ new Set(["td", "th", "tr", "thead", "tbody", "tfoot", "table"]),
-  th: /* @__PURE__ */ new Set(["td", "th", "tr", "thead", "tbody", "tfoot", "table"]),
+  // td/th take flow content, which includes <table> -- nested tables are valid.
+  td: /* @__PURE__ */ new Set(["td", "th", "tr", "thead", "tbody", "tfoot"]),
+  th: /* @__PURE__ */ new Set(["td", "th", "tr", "thead", "tbody", "tfoot"]),
   // Other common restrictions
   select: /* @__PURE__ */ new Set(["select", "input", "textarea"]),
   option: /* @__PURE__ */ new Set(["option", "optgroup"])
@@ -1119,116 +1225,15 @@ function validateNesting(parentTag, childTag, path = "", options = {}) {
   return false;
 }
 var HTMLNestingError = class extends Error {
-  constructor(message, context2 = {}) {
+  constructor(message, context = {}) {
     super(message);
     this.name = "HTMLNestingError";
-    this.parent = context2.parent;
-    this.child = context2.child;
-    this.path = context2.path;
+    this.parent = context.parent;
+    this.child = context.child;
+    this.path = context.path;
   }
 };
 
-// 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 (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)}"`;
-      } else 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();
-}
-
 // src/performance/cache-manager.js
 function createCacheManager(options = {}) {
   const {
@@ -1272,10 +1277,10 @@ function createCacheManager(options = {}) {
       cleanupInterval.unref();
     }
   }
-  function generateCacheKey(component, props = {}, context2 = {}) {
+  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(context2);
+    const contextStr = JSON.stringify(context);
     const hash = simpleHash(componentStr + propsStr + contextStr);
     return `${extractComponentName(component)}_${hash}`;
   }
@@ -1506,11 +1511,11 @@ var ComponentValidationError = class extends CoherentError {
   }
 };
 var RenderingError = class extends CoherentError {
-  constructor(message, component, context2, suggestions = []) {
+  constructor(message, component, context, suggestions = []) {
     super(message, {
       type: "rendering",
       component,
-      context: context2,
+      context,
       suggestions: [
         "Check for circular references",
         "Validate component depth",
@@ -1519,8 +1524,8 @@ var RenderingError = class extends CoherentError {
       ]
     });
     this.name = "RenderingError";
-    if (context2 && context2.path) {
-      this.renderPath = context2.path;
+    if (context && context.path) {
+      this.renderPath = context.path;
     }
   }
 };
@@ -1575,8 +1580,8 @@ var ErrorHandler = class {
   /**
    * Handle and report errors with detailed context
    */
-  handle(_error, context2 = {}) {
-    const enhancedError = this.enhanceError(_error, context2);
+  handle(_error, context = {}) {
+    const enhancedError = this.enhanceError(_error, context);
     this.addToHistory(enhancedError);
     if (this.options.enableLogging) {
       this.logError(enhancedError);
@@ -1586,50 +1591,50 @@ var ErrorHandler = class {
   /**
    * Enhance existing errors with more context
    */
-  enhanceError(_error, context2 = {}) {
+  enhanceError(_error, context = {}) {
     if (_error instanceof CoherentError) {
       return _error;
     }
-    const errorType = this.classifyError(_error, context2);
+    const errorType = this.classifyError(_error, context);
     switch (errorType) {
       case "validation":
         return new ComponentValidationError(
           _error.message,
-          context2.component,
-          this.generateSuggestions(_error, context2)
+          context.component,
+          this.generateSuggestions(_error, context)
         );
       case "rendering":
         return new RenderingError(
           _error.message,
-          context2.component,
-          context2.renderContext,
-          this.generateSuggestions(_error, context2)
+          context.component,
+          context.renderContext,
+          this.generateSuggestions(_error, context)
         );
       case "performance":
         return new PerformanceError(
           _error.message,
-          context2.metrics,
-          this.generateSuggestions(_error, context2)
+          context.metrics,
+          this.generateSuggestions(_error, context)
         );
       case "state":
         return new StateError(
           _error.message,
-          context2.state,
-          this.generateSuggestions(_error, context2)
+          context.state,
+          this.generateSuggestions(_error, context)
         );
       default:
         return new CoherentError(_error.message, {
           type: errorType,
-          component: context2.component,
-          context: context2.context,
-          suggestions: this.generateSuggestions(_error, context2)
+          component: context.component,
+          context: context.context,
+          suggestions: this.generateSuggestions(_error, context)
         });
     }
   }
   /**
    * Classify _error type based on message and context
    */
-  classifyError(_error, context2) {
+  classifyError(_error, context) {
     const message = _error.message.toLowerCase();
     if (message.includes("invalid") || message.includes("validation") || message.includes("required") || message.includes("type")) {
       return "validation";
@@ -1640,18 +1645,18 @@ var ErrorHandler = class {
     if (message.includes("slow") || message.includes("memory") || message.includes("performance") || message.includes("timeout")) {
       return "performance";
     }
-    if (message.includes("state") || message.includes("mutation") || message.includes("store") || context2.state) {
+    if (message.includes("state") || message.includes("mutation") || message.includes("store") || context.state) {
       return "state";
     }
-    if (context2.component) return "validation";
-    if (context2.renderContext) return "rendering";
-    if (context2.metrics) return "performance";
+    if (context.component) return "validation";
+    if (context.renderContext) return "rendering";
+    if (context.metrics) return "performance";
     return "generic";
   }
   /**
    * Generate helpful suggestions based on _error
    */
-  generateSuggestions(_error, context2 = {}) {
+  generateSuggestions(_error, context = {}) {
     const suggestions = [];
     const message = _error.message.toLowerCase();
     const patterns = [
@@ -1702,13 +1707,13 @@ var ErrorHandler = class {
         suggestions.push(...patternSuggestions);
       }
     });
-    if (context2.component) {
-      const componentType = typeof context2.component;
+    if (context.component) {
+      const componentType = typeof context.component;
       if (componentType === "function") {
         suggestions.push("Check function component return value");
-      } else if (componentType === "object" && context2.component === null) {
+      } else if (componentType === "object" && context.component === null) {
         suggestions.push("Component is null - ensure proper initialization");
-      } else if (Array.isArray(context2.component)) {
+      } else if (Array.isArray(context.component)) {
         suggestions.push("Arrays should contain valid component objects");
       }
     }
@@ -1949,6 +1954,9 @@ var HTMLRenderer = class extends BaseRenderer {
     if (Array.isArray(component) && component.length === 0) {
       return "";
     }
+    if (isTrustedContent(component)) {
+      return component.__html;
+    }
     if (typeof component === "object" && component !== null && !Array.isArray(component)) {
       if (options.seenObjects && options.seenObjects.has(component)) {
         throw new RenderingError(
@@ -2112,10 +2120,14 @@ var HTMLRenderer = class extends BaseRenderer {
       return openingTag;
     }
     if (_rawHtml !== void 0) {
-      const rawContent = typeof _rawHtml === "function" ? String(_rawHtml()) : String(_rawHtml);
+      const resolvedHtml = typeof _rawHtml === "function" ? _rawHtml() : _rawHtml;
+      const rawContent = isTrustedContent(resolvedHtml) ? resolvedHtml.__html : String(resolvedHtml);
       const result = `${openingTag}${rawContent}</${tagName}>`;
       return result;
     }
+    if (isTrustedContent(text)) {
+      return `${openingTag}${text.__html}</${tagName}>`;
+    }
     let textContent = "";
     if (text !== void 0) {
       const isScript = tagName === "script";
@@ -2225,6 +2237,7 @@ var Component = class _Component {
     this.rendered = null;
     this.isMounted = false;
     this.isDestroyed = false;
+    this.isHandlingError = false;
     this.hooks = {
       beforeCreate: definition.beforeCreate || (() => {
       }),
@@ -2327,12 +2340,26 @@ var Component = class _Component {
   }
   /**
    * Handle component errors
+   *
+   * @param {Error} _error - The error to handle
+   * @param {string} [context] - Where the error came from, accumulated as it
+   *   propagates up so the parent sees the full "Child -> render" trail
    */
-  handleError(_error) {
-    console.error(`Component Error in ${this.name}:`, _error);
-    this.callHook("errorCaptured", _error);
-    if (this.parent && this.parent.handleError) {
-      this.parent.handleError(_error, `${this.name} -> ${context}`);
+  handleError(_error, context = "") {
+    if (this.isHandlingError) {
+      console.error(`Component Error in ${this.name} (errorCaptured hook):`, _error);
+      return;
+    }
+    this.isHandlingError = true;
+    try {
+      const origin = context ? `${this.name} (${context})` : this.name;
+      console.error(`Component Error in ${origin}:`, _error);
+      this.callHook("errorCaptured", _error);
+      if (this.parent && this.parent.handleError) {
+        this.parent.handleError(_error, context ? `${this.name} -> ${context}` : this.name);
+      }
+    } finally {
+      this.isHandlingError = false;
     }
   }
   /**
@@ -2463,7 +2490,40 @@ function createComponent(definition) {
       render: definition
     };
   }
-  return new Component(definition);
+  const instance = new Component(definition);
+  const callable = (props = {}) => instance.render(props);
+  const CHAINABLE = /* @__PURE__ */ new Set(["mount", "update", "destroy"]);
+  return new Proxy(callable, {
+    get(target, key, receiver) {
+      if (key === "clone") {
+        return (overrides = {}) => createComponent({ ...instance.definition, ...overrides });
+      }
+      const value = Reflect.get(instance, key, instance);
+      if (typeof value === "function") {
+        return CHAINABLE.has(key) ? (...args) => {
+          value.apply(instance, args);
+          return receiver;
+        } : value.bind(instance);
+      }
+      return value !== void 0 || Reflect.has(instance, key) ? value : Reflect.get(target, key, receiver);
+    },
+    set(target, key, value) {
+      return Reflect.set(instance, key, value, instance);
+    },
+    has(target, key) {
+      return Reflect.has(instance, key) || Reflect.has(target, key);
+    },
+    deleteProperty(target, key) {
+      return Reflect.deleteProperty(instance, key);
+    },
+    ownKeys() {
+      return Reflect.ownKeys(instance);
+    },
+    getOwnPropertyDescriptor(target, key) {
+      const descriptor = Reflect.getOwnPropertyDescriptor(instance, key);
+      return descriptor ? { ...descriptor, configurable: true } : Reflect.getOwnPropertyDescriptor(target, key);
+    }
+  });
 }
 function defineComponent(definition) {
   const componentFactory = (props) => {
@@ -2488,6 +2548,16 @@ function getComponent(name) {
 function getRegisteredComponents() {
   return new Map(COMPONENT_REGISTRY);
 }
+function createHOC(enhancer) {
+  return (WrappedComponent) => {
+    return defineComponent({
+      name: `HOC(${WrappedComponent.componentName || "Component"})`,
+      render(props) {
+        return enhancer(WrappedComponent, props);
+      }
+    });
+  };
+}
 if (performanceMonitor) {
   const originalRender = Component.prototype.render;
   Component.prototype.render = function(...args) {
@@ -2764,6 +2834,24 @@ function memo(fn, options = {}) {
   };
   return memoizedFn;
 }
+function memoComponent(component, options = {}) {
+  const {
+    propsEqual = shallowEqual,
+    stateEqual = shallowEqual,
+    name = component.name || "AnonymousComponent"
+  } = options;
+  return memo((props = {}, state = {}, context = {}) => {
+    return typeof component === "function" ? component(props, state, context) : component;
+  }, {
+    keyFn: (props, state) => {
+      return `${name}:${JSON.stringify(props)}:${JSON.stringify(state)}`;
+    },
+    compareFn: (a, b) => {
+      return propsEqual(a.props, b.props) && stateEqual(a.state, b.state);
+    },
+    ...options
+  });
+}
 var LRUCache = class {
   constructor(maxSize = 100, options = {}) {
     this.maxSize = maxSize;
@@ -2865,6 +2953,22 @@ var TTLCache = class {
     return this.cache.size;
   }
 };
+function shallowEqual(a, b) {
+  if (a === b) return true;
+  if (!a || !b) return false;
+  if (typeof a !== typeof b) return false;
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length) return false;
+    return a.every((item, index) => item === b[index]);
+  }
+  if (typeof a === "object") {
+    const keysA = Object.keys(a);
+    const keysB = Object.keys(b);
+    if (keysA.length !== keysB.length) return false;
+    return keysA.every((key) => a[key] === b[key]);
+  }
+  return false;
+}
 function withState(initialState = {}, options = {}) {
   const {
     // State options
@@ -2942,21 +3046,21 @@ function withState(initialState = {}, options = {}) {
       onStateChange,
       debug
     });
-    function WithStateComponent(props = {}, globalState = {}, context2 = {}) {
+    function WithStateComponent(props = {}, globalState = {}, context = {}) {
       if (!stateContainer.initialized) {
         stateContainer.initialize();
         if (onMount) {
-          onMount(stateContainer.getState(), props, context2);
+          onMount(stateContainer.getState(), props, context);
         }
       }
       const currentState = stateContainer.getState();
       let transformedState = currentState;
       if (stateTransform) {
-        transformedState = stateTransform(currentState, props, context2);
+        transformedState = stateTransform(currentState, props, context);
       }
       const boundActions = createBoundActions(actions, stateContainer, {
         props,
-        context: context2,
+        context,
         supportAsync,
         debug
       });
@@ -3018,7 +3122,7 @@ function withState(initialState = {}, options = {}) {
           props: enhancedProps
         });
       }
-      return typeof WrappedComponent === "function" ? WrappedComponent(enhancedProps, globalState, context2) : WrappedComponent;
+      return typeof WrappedComponent === "function" ? WrappedComponent(enhancedProps, globalState, context) : WrappedComponent;
     }
     WithStateComponent.displayName = displayName || `withState(${getComponentName(WrappedComponent)})`;
     WithStateComponent.__isHOC = true;
@@ -3137,7 +3241,7 @@ function createStateContainer(initialState, options) {
   return container;
 }
 function createBoundActions(actions, stateContainer, options) {
-  const { props, context: context2, supportAsync, debug } = options;
+  const { props, context, supportAsync, debug } = options;
   const boundActions = {};
   Object.entries(actions).forEach(([actionName, actionCreator]) => {
     boundActions[actionName] = (...args) => {
@@ -3145,7 +3249,7 @@ function createBoundActions(actions, stateContainer, options) {
         const result = actionCreator(
           stateContainer.getState(),
           stateContainer.setState.bind(stateContainer),
-          { props, context: context2, args }
+          { props, context, args }
         );
         if (supportAsync && result && typeof result.then === "function") {
           return result.catch((_error) => {
@@ -3205,7 +3309,7 @@ var withStateUtils = {
     }
     return (WrappedComponent) => {
       const sharedContainer = sharedStates.get(sharedKey);
-      function SharedStateComponent(props, globalState, context2) {
+      function SharedStateComponent(props, globalState, context) {
         const currentState = sharedContainer.getState();
         const enhancedProps = {
           ...props,
@@ -3213,7 +3317,7 @@ var withStateUtils = {
           setState: sharedContainer.setState.bind(sharedContainer),
           subscribe: sharedContainer.subscribe.bind(sharedContainer)
         };
-        return typeof WrappedComponent === "function" ? WrappedComponent(enhancedProps, globalState, context2) : WrappedComponent;
+        return typeof WrappedComponent === "function" ? WrappedComponent(enhancedProps, globalState, context) : WrappedComponent;
       }
       SharedStateComponent.displayName = `withSharedState(${getComponentName(WrappedComponent)})`;
       return SharedStateComponent;
@@ -4039,7 +4143,7 @@ var ComponentCache = class {
   /**
    * Generate cache key from component and props
    */
-  generateKey(component, props = {}, context2 = {}) {
+  generateKey(component, props = {}, context = {}) {
     if (typeof component === "string") {
       return `str:${component}`;
     }
@@ -4049,7 +4153,7 @@ var ComponentCache = class {
     if (typeof component === "object" && component !== null) {
       const serialized = this.serializeComponent(component);
       const propsHash = Object.keys(props).length > 0 ? `:${JSON.stringify(props)}` : "";
-      const contextHash = Object.keys(context2).length > 0 ? `:${JSON.stringify(context2)}` : "";
+      const contextHash = Object.keys(context).length > 0 ? `:${JSON.stringify(context)}` : "";
       return `obj:${serialized}${propsHash}${contextHash}`;
     }
     return `primitive:${String(component)}`;
@@ -4439,7 +4543,7 @@ function createErrorFallback(options = {}) {
     className = "error-boundary-fallback",
     style = {}
   } = options;
-  return function errorFallback(error, errorInfo, context2 = {}) {
+  return function errorFallback(error, errorInfo, context = {}) {
     const children = [
       {
         h2: {
@@ -4464,20 +4568,20 @@ function createErrorFallback(options = {}) {
         }
       });
     }
-    if (showReset && context2.reset && !context2.permanent) {
+    if (showReset && context.reset && !context.permanent) {
       children.push({
         button: {
           className: "error-reset-button",
           text: "Try Again",
-          onclick: context2.reset
+          onclick: context.reset
         }
       });
     }
-    if (context2.errorCount > 1) {
+    if (context.errorCount > 1) {
       children.push({
         p: {
           className: "error-count",
-          text: `Error occurred ${context2.errorCount} times`
+          text: `Error occurred ${context.errorCount} times`
         }
       });
     }
@@ -4543,11 +4647,11 @@ var GlobalErrorHandler = class {
   /**
    * Capture an error
    */
-  captureError(error, context2 = {}) {
+  captureError(error, context = {}) {
     if (!this.enabled) return;
     const errorEntry = {
       error,
-      context: context2,
+      context,
       timestamp: Date.now(),
       stack: error.stack
     };
@@ -4557,7 +4661,7 @@ var GlobalErrorHandler = class {
     }
     if (this.onError) {
       try {
-        this.onError(error, context2);
+        this.onError(error, context);
       } catch (callbackError) {
         console.error("Error in global error handler callback:", callbackError);
       }
@@ -4640,11 +4744,11 @@ function isCoherentComponent(obj) {
   const keys = Object.keys(obj);
   return keys.length === 1;
 }
-function createErrorResponse(error, context2 = "rendering") {
+function createErrorResponse(error, context = "rendering") {
   return {
     error: "Internal Server Error",
     message: error.message,
-    context: context2,
+    context,
     timestamp: (/* @__PURE__ */ new Date()).toISOString()
   };
 }
@@ -5769,13 +5873,13 @@ function withEventBus(options = {}) {
     autoCleanup = true
   } = options;
   return function withEventBusHOC(WrappedComponent) {
-    function EventBusComponent(props = {}, state = {}, context2 = {}) {
+    function EventBusComponent(props = {}, state = {}, context = {}) {
       const bus = scope ? eventBus.createScope(scope) : eventBus;
       const listenerIds = /* @__PURE__ */ new Map();
       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: context2 });
+            handler.call(this, data, eventName, { props, state, context });
           }
         });
         listenerIds.set(event, listenerId);
@@ -5783,7 +5887,7 @@ function withEventBus(options = {}) {
       Object.entries(actions).forEach(([action, handler]) => {
         bus.registerAction(action, (actionContext) => {
           if (typeof handler === "function") {
-            handler.call(this, actionContext, { props, state, context: context2 });
+            handler.call(this, actionContext, { props, state, context });
           }
         });
       });
@@ -5815,7 +5919,7 @@ function withEventBus(options = {}) {
           registeredActions: Object.keys(actions)
         });
       }
-      const result = typeof WrappedComponent === "function" ? WrappedComponent(enhancedProps, state, context2) : WrappedComponent;
+      const result = typeof WrappedComponent === "function" ? WrappedComponent(enhancedProps, state, context) : WrappedComponent;
       if (autoCleanup && result && typeof result === "object") {
         if (result.componentWillUnmount) {
           const originalUnmount = result.componentWillUnmount;
@@ -5856,10 +5960,10 @@ function withEventState(initialState = {}, options = {}) {
         ...events,
         // Add state-aware event handlers
         ...Object.entries(events).reduce((acc, [event, handler]) => {
-          acc[event] = function(data, eventName, context2) {
+          acc[event] = function(data, eventName, context) {
             return handler.call(this, data, eventName, {
-              ...context2,
-              stateUtils: context2.props.stateUtils
+              ...context,
+              stateUtils: context.props.stateUtils
             });
           };
           return acc;
@@ -6298,10 +6402,6 @@ function applyScopeToElement(element, scopeId) {
   }
   return element;
 }
-function escapeHtml2(text) {
-  if (typeof text !== "string") return text;
-  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#x27;");
-}
 function dangerouslySetInnerContent(content) {
   return {
     __html: content,
@@ -6417,7 +6517,7 @@ function deepClone2(obj) {
   }
   return cloned;
 }
-var VERSION = true ? "1.0.0-rc.6" : JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8")).version;
+var VERSION = true ? "1.0.0" : JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8")).version;
 var fp = {
   /**
    * Curried map: fp.map(fn)(array)
@@ -6482,12 +6582,13 @@ var coherent = {
   validateComponent: validateComponent2,
   isCoherentObject: isCoherentObject2,
   deepClone: deepClone2,
-  escapeHtml: escapeHtml2,
+  escapeHtml,
   performanceMonitor,
   VERSION
 };
 var index_default = coherent;
 export {
+  Component,
   ComponentCache,
   ComponentLifecycle,
   DOMEventIntegration,
@@ -6498,10 +6599,12 @@ export {
   Island,
   LIFECYCLE_PHASES,
   VERSION,
+  cacheManager,
   checkPeerDependencies,
   compose,
   createActionHandlers,
   createAsyncErrorBoundary,
+  createCacheManager,
   createComponent,
   createComponentCache,
   createElement,
@@ -6512,6 +6615,7 @@ export {
   createEventComponent,
   createEventHandlers,
   createGlobalErrorHandler,
+  createHOC,
   createLazyIntegration,
   createLifecycleHooks,
   createStateManager,
@@ -6522,8 +6626,10 @@ export {
   defineComponent,
   emit,
   emitSync,
+  escapeHtml,
   evaluateLazy,
   events_default as eventSystem,
+  formatAttributes,
   fp,
   getComponent,
   getRegisteredComponents,
@@ -6539,9 +6645,12 @@ export {
   isCoherentObject2 as isCoherentObject,
   isLazy,
   isPeerDependencyAvailable,
+  isTrustedContent,
+  isVoidElement,
   lazy,
   componentUtils as lifecycleUtils,
   memo2 as memo,
+  memoComponent,
   memoize,
   normalizeChildren,
   off,