zero-query 0.9.8 → 1.0.0

package/src/core.js

@@ -1,5 +1,5 @@
 /**
- * zQuery Core — Selector engine & chainable DOM collection
+ * zQuery Core - Selector engine & chainable DOM collection
  * 
  * Extends the quick-ref pattern (Id, Class, Classes, Children)
  * into a full jQuery-like chainable wrapper with modern APIs.
@@ -8,7 +8,7 @@
 import { morph as _morph, morphElement as _morphElement } from './diff.js';
 
 // ---------------------------------------------------------------------------
-// ZQueryCollection — wraps an array of elements with chainable methods
+// ZQueryCollection - wraps an array of elements with chainable methods
 // ---------------------------------------------------------------------------
 export class ZQueryCollection {
   constructor(elements) {
@@ -228,7 +228,7 @@ export class ZQueryCollection {
   // --- Classes -------------------------------------------------------------
 
   addClass(...names) {
-    // Fast path: single class, no spaces — avoids flatMap + regex split allocation
+    // Fast path: single class, no spaces - avoids flatMap + regex split allocation
     if (names.length === 1 && names[0].indexOf(' ') === -1) {
       const c = names[0];
       for (let i = 0; i < this.elements.length; i++) this.elements[i].classList.add(c);
@@ -390,7 +390,7 @@ export class ZQueryCollection {
     if (content === undefined) return this.first()?.innerHTML;
     // Auto-morph: if the element already has children, use the diff engine
     // to patch the DOM (preserves focus, scroll, state, keyed reorder via LIS).
-    // Empty elements get raw innerHTML for fast first-paint — same strategy
+    // Empty elements get raw innerHTML for fast first-paint - same strategy
     // the component system uses (first render = innerHTML, updates = morph).
     return this.each((_, el) => {
       if (el.childNodes.length > 0) {
@@ -575,7 +575,7 @@ export class ZQueryCollection {
         if (typeof selectorOrHandler === 'function') {
           el.addEventListener(evt, selectorOrHandler);
         } else if (typeof selectorOrHandler === 'string') {
-          // Delegated event — store wrapper so off() can remove it
+          // Delegated event - store wrapper so off() can remove it
           const wrapper = (e) => {
             if (!e.target || typeof e.target.closest !== 'function') return;
             const target = e.target.closest(selectorOrHandler);
@@ -637,7 +637,7 @@ export class ZQueryCollection {
   // --- Animation -----------------------------------------------------------
 
   animate(props, duration = 300, easing = 'ease') {
-    // Empty collection — resolve immediately
+    // Empty collection - resolve immediately
     if (this.length === 0) return Promise.resolve(this);
     return new Promise(resolve => {
       let resolved = false;
@@ -763,7 +763,7 @@ export class ZQueryCollection {
 
 
 // ---------------------------------------------------------------------------
-// Helper — create document fragment from HTML string
+// Helper - create document fragment from HTML string
 // ---------------------------------------------------------------------------
 function createFragment(html) {
   const tpl = document.createElement('template');
@@ -773,21 +773,21 @@ function createFragment(html) {
 
 
 // ---------------------------------------------------------------------------
-// $() — main selector / creator (returns ZQueryCollection, like jQuery)
+// $() - main selector / creator (returns ZQueryCollection, like jQuery)
 // ---------------------------------------------------------------------------
 export function query(selector, context) {
   // null / undefined
   if (!selector) return new ZQueryCollection([]);
 
-  // Already a collection — return as-is
+  // Already a collection - return as-is
   if (selector instanceof ZQueryCollection) return selector;
 
-  // DOM element or Window — wrap in collection
+  // DOM element or Window - wrap in collection
   if (selector instanceof Node || selector === window) {
     return new ZQueryCollection([selector]);
   }
 
-  // NodeList / HTMLCollection / Array — wrap in collection
+  // NodeList / HTMLCollection / Array - wrap in collection
   if (selector instanceof NodeList || selector instanceof HTMLCollection || Array.isArray(selector)) {
     return new ZQueryCollection(Array.from(selector));
   }
@@ -811,7 +811,7 @@ export function query(selector, context) {
 
 
 // ---------------------------------------------------------------------------
-// $.all() — collection selector (returns ZQueryCollection for CSS selectors)
+// $.all() - collection selector (returns ZQueryCollection for CSS selectors)
 // ---------------------------------------------------------------------------
 export function queryAll(selector, context) {
   // null / undefined
@@ -866,7 +866,7 @@ query.children = (parentId) => {
 query.qs  = (sel, ctx = document) => ctx.querySelector(sel);
 query.qsa = (sel, ctx = document) => Array.from(ctx.querySelectorAll(sel));
 
-// Create element shorthand — returns ZQueryCollection for chaining
+// Create element shorthand - returns ZQueryCollection for chaining
 query.create = (tag, attrs = {}, ...children) => {
   const el = document.createElement(tag);
   for (const [k, v] of Object.entries(attrs)) {
@@ -889,7 +889,7 @@ query.ready = (fn) => {
   else document.addEventListener('DOMContentLoaded', fn);
 };
 
-// Global event listeners — supports direct, delegated, and target-bound forms
+// Global event listeners - supports direct, delegated, and target-bound forms
 //   $.on('keydown', handler)           → direct listener on document
 //   $.on('click', '.btn', handler)     → delegated via closest()
 //   $.on('scroll', window, handler)    → direct listener on target
@@ -899,7 +899,7 @@ query.on = (event, selectorOrHandler, handler) => {
     document.addEventListener(event, selectorOrHandler);
     return;
   }
-  // EventTarget (window, element, etc.) — direct listener on target
+  // EventTarget (window, element, etc.) - direct listener on target
   if (typeof selectorOrHandler === 'object' && typeof selectorOrHandler.addEventListener === 'function') {
     selectorOrHandler.addEventListener(event, handler);
     return;

package/src/diff.js

@@ -1,5 +1,5 @@
 /**
- * zQuery Diff — Lightweight DOM morphing engine
+ * zQuery Diff - Lightweight DOM morphing engine
  *
  * Patches an existing DOM tree to match new HTML without destroying nodes
  * that haven't changed. Preserves focus, scroll positions, third-party
@@ -9,17 +9,17 @@
  * Keyed elements (via `z-key`) get matched across position changes.
  *
  * Performance advantages over virtual DOM (React/Angular):
- *   - No virtual tree allocation or diffing — works directly on real DOM
+ *   - No virtual tree allocation or diffing - works directly on real DOM
  *   - Skips unchanged subtrees via fast isEqualNode() check
  *   - z-skip attribute to opt out of diffing entire subtrees
  *   - Reuses a single template element for HTML parsing (zero GC pressure)
  *   - Keyed reconciliation uses LIS (Longest Increasing Subsequence) to
- *     minimize DOM moves — same algorithm as Vue 3 / ivi
+ *     minimize DOM moves - same algorithm as Vue 3 / ivi
  *   - Minimal attribute diffing with early bail-out
  */
 
 // ---------------------------------------------------------------------------
-// Reusable template element — avoids per-call allocation
+// Reusable template element - avoids per-call allocation
 // ---------------------------------------------------------------------------
 let _tpl = null;
 
@@ -29,15 +29,15 @@ function _getTemplate() {
 }
 
 // ---------------------------------------------------------------------------
-// morph(existingRoot, newHTML) — patch existing DOM to match newHTML
+// morph(existingRoot, newHTML) - patch existing DOM to match newHTML
 // ---------------------------------------------------------------------------
 
 /**
  * Morph an existing DOM element's children to match new HTML.
  * Only touches nodes that actually differ.
  *
- * @param {Element} rootEl — The live DOM container to patch
- * @param {string} newHTML — The desired HTML string
+ * @param {Element} rootEl - The live DOM container to patch
+ * @param {string} newHTML - The desired HTML string
  */
 export function morph(rootEl, newHTML) {
   const start = typeof window !== 'undefined' && window.__zqMorphHook ? performance.now() : 0;
@@ -46,7 +46,7 @@ export function morph(rootEl, newHTML) {
   const newRoot = tpl.content;
 
   // Move children into a wrapper for consistent handling.
-  // We move (not clone) from the template — cheaper than cloning.
+  // We move (not clone) from the template - cheaper than cloning.
   const tempDiv = document.createElement('div');
   while (newRoot.firstChild) tempDiv.appendChild(newRoot.firstChild);
 
@@ -56,16 +56,16 @@ export function morph(rootEl, newHTML) {
 }
 
 /**
- * Morph a single element in place — diffs attributes and children
+ * Morph a single element in place - diffs attributes and children
  * without replacing the node reference. Useful for replaceWith-style
  * updates where you want to keep the element identity when the tag
  * name matches.
  *
  * If the new HTML produces a different tag, falls back to native replace.
  *
- * @param {Element} oldEl — The live DOM element to patch
- * @param {string} newHTML — HTML string for the replacement element
- * @returns {Element} — The resulting element (same ref if morphed, new if replaced)
+ * @param {Element} oldEl - The live DOM element to patch
+ * @param {string} newHTML - HTML string for the replacement element
+ * @returns {Element} - The resulting element (same ref if morphed, new if replaced)
  */
 export function morphElement(oldEl, newHTML) {
   const start = typeof window !== 'undefined' && window.__zqMorphHook ? performance.now() : 0;
@@ -74,7 +74,7 @@ export function morphElement(oldEl, newHTML) {
   const newEl = tpl.content.firstElementChild;
   if (!newEl) return oldEl;
 
-  // Same tag — morph in place (preserves identity, event listeners, refs)
+  // Same tag - morph in place (preserves identity, event listeners, refs)
   if (oldEl.nodeName === newEl.nodeName) {
     _morphAttributes(oldEl, newEl);
     _morphChildren(oldEl, newEl);
@@ -82,14 +82,14 @@ export function morphElement(oldEl, newHTML) {
     return oldEl;
   }
 
-  // Different tag — must replace (can't morph <div> into <span>)
+  // Different tag - must replace (can't morph <div> into <span>)
   const clone = newEl.cloneNode(true);
   oldEl.parentNode.replaceChild(clone, oldEl);
   if (start) window.__zqMorphHook(clone, performance.now() - start);
   return clone;
 }
 
-// Aliases for the concat build — core.js imports these as _morph / _morphElement,
+// Aliases for the concat build - core.js imports these as _morph / _morphElement,
 // but the build strips `import … as` lines, so the aliases must exist at runtime.
 const _morph = morph;
 const _morphElement = morphElement;
@@ -97,11 +97,11 @@ const _morphElement = morphElement;
 /**
  * Reconcile children of `oldParent` to match `newParent`.
  *
- * @param {Element} oldParent — live DOM parent
- * @param {Element} newParent — desired state parent
+ * @param {Element} oldParent - live DOM parent
+ * @param {Element} newParent - desired state parent
  */
 function _morphChildren(oldParent, newParent) {
-  // Snapshot live NodeLists into arrays — childNodes is live and
+  // Snapshot live NodeLists into arrays - childNodes is live and
   // mutates during insertBefore/removeChild. Using a for loop to push
   // avoids spread operator overhead for large child lists.
   const oldCN = oldParent.childNodes;
@@ -113,7 +113,7 @@ function _morphChildren(oldParent, newParent) {
   for (let i = 0; i < oldLen; i++) oldChildren[i] = oldCN[i];
   for (let i = 0; i < newLen; i++) newChildren[i] = newCN[i];
 
-  // Scan for keyed elements — only build maps if keys exist
+  // Scan for keyed elements - only build maps if keys exist
   let hasKeys = false;
   let oldKeyMap, newKeyMap;
 
@@ -144,7 +144,7 @@ function _morphChildren(oldParent, newParent) {
 }
 
 /**
- * Unkeyed reconciliation — positional matching.
+ * Unkeyed reconciliation - positional matching.
  */
 function _morphChildrenUnkeyed(oldParent, oldChildren, newChildren) {
   const oldLen = oldChildren.length;
@@ -172,7 +172,7 @@ function _morphChildrenUnkeyed(oldParent, oldChildren, newChildren) {
 }
 
 /**
- * Keyed reconciliation — match by z-key, reorder with minimal moves
+ * Keyed reconciliation - match by z-key, reorder with minimal moves
  * using Longest Increasing Subsequence (LIS) to find the maximum set
  * of nodes that are already in the correct relative order, then only
  * move the remaining nodes.
@@ -206,7 +206,7 @@ function _morphChildrenKeyed(oldParent, oldChildren, newChildren, oldKeyMap, new
 
   // Step 3: Build index array for LIS of matched old indices.
   // This finds the largest set of keyed nodes already in order,
-  // so we only need to move the rest — O(n log n) instead of O(n²).
+  // so we only need to move the rest - O(n log n) instead of O(n²).
   const oldIndices = [];      // Maps new-position → old-position (or -1)
   for (let i = 0; i < newLen; i++) {
     if (matched[i]) {
@@ -219,7 +219,7 @@ function _morphChildrenKeyed(oldParent, oldChildren, newChildren, oldKeyMap, new
 
   const lisSet = _lis(oldIndices);
 
-  // Step 4: Insert / reorder / morph — walk new children forward,
+  // Step 4: Insert / reorder / morph - walk new children forward,
   // using LIS to decide which nodes stay in place.
   let cursor = oldParent.firstChild;
   const unkeyedOld = [];
@@ -244,7 +244,7 @@ function _morphChildrenKeyed(oldParent, oldChildren, newChildren, oldKeyMap, new
       if (!lisSet.has(i)) {
         oldParent.insertBefore(oldNode, cursor);
       }
-      // Capture next sibling BEFORE _morphNode — if _morphNode calls
+      // Capture next sibling BEFORE _morphNode - if _morphNode calls
       // replaceChild, oldNode is removed and nextSibling becomes stale.
       const nextSib = oldNode.nextSibling;
       _morphNode(oldParent, oldNode, newNode);
@@ -284,10 +284,10 @@ function _morphChildrenKeyed(oldParent, oldChildren, newChildren, oldKeyMap, new
  * Returns a Set of positions (in the input) that form the LIS.
  * Entries with value -1 (unmatched) are excluded.
  *
- * O(n log n) — same algorithm used by Vue 3 and ivi.
+ * O(n log n) - same algorithm used by Vue 3 and ivi.
  *
- * @param {number[]} arr — array of old-tree indices (-1 = unmatched)
- * @returns {Set<number>} — positions in arr belonging to the LIS
+ * @param {number[]} arr - array of old-tree indices (-1 = unmatched)
+ * @returns {Set<number>} - positions in arr belonging to the LIS
  */
 function _lis(arr) {
   const len = arr.length;
@@ -331,7 +331,7 @@ function _lis(arr) {
  * Morph a single node in place.
  */
 function _morphNode(parent, oldNode, newNode) {
-  // Text / comment nodes — just update content
+  // Text / comment nodes - just update content
   if (oldNode.nodeType === 3 || oldNode.nodeType === 8) {
     if (newNode.nodeType === oldNode.nodeType) {
       if (oldNode.nodeValue !== newNode.nodeValue) {
@@ -339,26 +339,26 @@ function _morphNode(parent, oldNode, newNode) {
       }
       return;
     }
-    // Different node types — replace
+    // Different node types - replace
     parent.replaceChild(newNode.cloneNode(true), oldNode);
     return;
   }
 
-  // Different node types or tag names — replace entirely
+  // Different node types or tag names - replace entirely
   if (oldNode.nodeType !== newNode.nodeType ||
       oldNode.nodeName !== newNode.nodeName) {
     parent.replaceChild(newNode.cloneNode(true), oldNode);
     return;
   }
 
-  // Both are elements — diff attributes then recurse children
+  // Both are elements - diff attributes then recurse children
   if (oldNode.nodeType === 1) {
-    // z-skip: developer opt-out — skip diffing this subtree entirely.
+    // z-skip: developer opt-out - skip diffing this subtree entirely.
     // Useful for third-party widgets, canvas, video, or large static content.
     if (oldNode.hasAttribute('z-skip')) return;
 
     // Fast bail-out: if the elements are identical, skip everything.
-    // isEqualNode() is a native C++ comparison — much faster than walking
+    // isEqualNode() is a native C++ comparison - much faster than walking
     // attributes + children in JS when trees haven't changed.
     if (oldNode.isEqualNode(newNode)) return;
 
@@ -384,7 +384,7 @@ function _morphNode(parent, oldNode, newNode) {
       return;
     }
 
-    // Generic element — recurse children
+    // Generic element - recurse children
     _morphChildren(oldNode, newNode);
   }
 }
@@ -426,7 +426,7 @@ function _morphAttributes(oldEl, newEl) {
     }
   }
 
-  // Remove stale attributes — snapshot names first because oldAttrs
+  // Remove stale attributes - snapshot names first because oldAttrs
   // is a live NamedNodeMap that mutates on removeAttribute().
   const oldNames = new Array(oldLen);
   for (let i = 0; i < oldLen; i++) oldNames[i] = oldAttrs[i].name;
@@ -442,7 +442,7 @@ function _morphAttributes(oldEl, newEl) {
  *
  * Only updates the value when the new HTML explicitly carries a `value`
  * attribute.  Templates that use z-model manage values through reactive
- * state + _bindModels — the morph engine should not interfere by wiping
+ * state + _bindModels - the morph engine should not interfere by wiping
  * a live input's content to '' just because the template has no `value`
  * attr.  This prevents the wipe-then-restore cycle that resets cursor
  * position on every keystroke.
@@ -472,14 +472,14 @@ function _syncInputValue(oldEl, newEl) {
  *
  * This means the LIS-optimised keyed path activates automatically
  * whenever elements carry `id` or `data-id` / `data-key` attributes
- * — no extra markup required.
+ * - no extra markup required.
  *
  * @returns {string|null}
  */
 function _getKey(node) {
   if (node.nodeType !== 1) return null;
 
-  // Explicit z-key — highest priority
+  // Explicit z-key - highest priority
   const zk = node.getAttribute('z-key');
   if (zk) return zk;
 

package/src/errors.js

@@ -1,5 +1,5 @@
 /**
- * zQuery Errors — Structured error handling system
+ * zQuery Errors - Structured error handling system
  *
  * Provides typed error classes and a configurable error handler so that
  * errors surface consistently across all modules (reactive, component,
@@ -11,7 +11,7 @@
  */
 
 // ---------------------------------------------------------------------------
-// Error codes — every zQuery error has a unique code for programmatic use
+// Error codes - every zQuery error has a unique code for programmatic use
 // ---------------------------------------------------------------------------
 export const ErrorCode = Object.freeze({
   // Reactive
@@ -49,20 +49,26 @@ export const ErrorCode = Object.freeze({
   HTTP_INTERCEPTOR:    'ZQ_HTTP_INTERCEPTOR',
   HTTP_PARSE:          'ZQ_HTTP_PARSE',
 
+  // SSR
+  SSR_RENDER:          'ZQ_SSR_RENDER',
+  SSR_COMPONENT:       'ZQ_SSR_COMPONENT',
+  SSR_HYDRATION:       'ZQ_SSR_HYDRATION',
+  SSR_PAGE:            'ZQ_SSR_PAGE',
+
   // General
   INVALID_ARGUMENT:    'ZQ_INVALID_ARGUMENT',
 });
 
 
 // ---------------------------------------------------------------------------
-// ZQueryError — custom error class
+// ZQueryError - custom error class
 // ---------------------------------------------------------------------------
 export class ZQueryError extends Error {
   /**
-   * @param {string} code    — one of ErrorCode values
-   * @param {string} message — human-readable description
-   * @param {object} [context] — extra data (component name, expression, etc.)
-   * @param {Error}  [cause]   — original error
+   * @param {string} code    - one of ErrorCode values
+   * @param {string} message - human-readable description
+   * @param {object} [context] - extra data (component name, expression, etc.)
+   * @param {Error}  [cause]   - original error
    */
   constructor(code, message, context = {}, cause) {
     super(message);
@@ -77,23 +83,35 @@ export class ZQueryError extends Error {
 // ---------------------------------------------------------------------------
 // Global error handler
 // ---------------------------------------------------------------------------
-let _errorHandler = null;
+let _errorHandlers = [];
 
 /**
  * Register a global error handler.
  * Called whenever zQuery catches an error internally.
+ * Multiple handlers are supported - each receives the error.
+ * Pass `null` to clear all handlers.
  *
- * @param {Function|null} handler — (error: ZQueryError) => void
+ * @param {Function|null} handler - (error: ZQueryError) => void
+ * @returns {Function} unsubscribe function to remove this handler
  */
 export function onError(handler) {
-  _errorHandler = typeof handler === 'function' ? handler : null;
+  if (handler === null) {
+    _errorHandlers = [];
+    return () => {};
+  }
+  if (typeof handler !== 'function') return () => {};
+  _errorHandlers.push(handler);
+  return () => {
+    const idx = _errorHandlers.indexOf(handler);
+    if (idx !== -1) _errorHandlers.splice(idx, 1);
+  };
 }
 
 /**
  * Report an error through the global handler and console.
- * Non-throwing — used for recoverable errors in callbacks, lifecycle hooks, etc.
+ * Non-throwing - used for recoverable errors in callbacks, lifecycle hooks, etc.
  *
- * @param {string} code — ErrorCode
+ * @param {string} code - ErrorCode
  * @param {string} message
  * @param {object} [context]
  * @param {Error} [cause]
@@ -103,9 +121,9 @@ export function reportError(code, message, context = {}, cause) {
     ? cause
     : new ZQueryError(code, message, context, cause);
 
-  // User handler gets first crack
-  if (_errorHandler) {
-    try { _errorHandler(err); } catch { /* prevent handler from crashing framework */ }
+  // Notify all registered handlers
+  for (const handler of _errorHandlers) {
+    try { handler(err); } catch { /* prevent handler from crashing framework */ }
   }
 
   // Always log for developer visibility
@@ -117,7 +135,7 @@ export function reportError(code, message, context = {}, cause) {
  * the current execution context.
  *
  * @param {Function} fn
- * @param {string} code — ErrorCode to use if the callback throws
+ * @param {string} code - ErrorCode to use if the callback throws
  * @param {object} [context]
  * @returns {Function}
  */
@@ -136,8 +154,8 @@ export function guardCallback(fn, code, context = {}) {
  * Throws ZQueryError on failure (for fast-fail at API boundaries).
  *
  * @param {*} value
- * @param {string} name — parameter name for error message
- * @param {string} expectedType — 'string', 'function', 'object', etc.
+ * @param {string} name - parameter name for error message
+ * @param {string} expectedType - 'string', 'function', 'object', etc.
  */
 export function validate(value, name, expectedType) {
   if (value === undefined || value === null) {
@@ -153,3 +171,39 @@ export function validate(value, name, expectedType) {
     );
   }
 }
+
+/**
+ * Format a ZQueryError into a structured object suitable for overlays/logging.
+ * @param {ZQueryError|Error} err
+ * @returns {{ code: string, type: string, message: string, context: object, stack: string }}
+ */
+export function formatError(err) {
+  const isZQ = err instanceof ZQueryError;
+  return {
+    code: isZQ ? err.code : '',
+    type: isZQ ? 'ZQueryError' : (err.name || 'Error'),
+    message: err.message || 'Unknown error',
+    context: isZQ ? err.context : {},
+    stack: err.stack || '',
+    cause: err.cause ? formatError(err.cause) : null,
+  };
+}
+
+/**
+ * Async version of guardCallback - wraps an async function so that
+ * rejections are caught, reported, and don't crash execution.
+ *
+ * @param {Function} fn - async function
+ * @param {string} code - ErrorCode to use
+ * @param {object} [context]
+ * @returns {Function}
+ */
+export function guardAsync(fn, code, context = {}) {
+  return async (...args) => {
+    try {
+      return await fn(...args);
+    } catch (err) {
+      reportError(code, err.message || 'Async callback error', context, err);
+    }
+  };
+}

package/src/expression.js

@@ -1,5 +1,5 @@
 /**
- * zQuery Expression Parser — CSP-safe expression evaluator
+ * zQuery Expression Parser - CSP-safe expression evaluator
  *
  * Replaces `new Function()` / `eval()` with a hand-written parser that
  * evaluates expressions safely without violating Content Security Policy.
@@ -179,7 +179,7 @@ function tokenize(expr) {
       i++; continue;
     }
 
-    // Unknown — skip
+    // Unknown - skip
     i++;
   }
 
@@ -188,7 +188,7 @@ function tokenize(expr) {
 }
 
 // ---------------------------------------------------------------------------
-// Parser — Pratt (precedence climbing)
+// Parser - Pratt (precedence climbing)
 // ---------------------------------------------------------------------------
 class Parser {
   constructor(tokens, scope) {
@@ -420,7 +420,7 @@ class Parser {
       let couldBeArrow = true;
 
       if (this.peek().t === T.PUNC && this.peek().v === ')') {
-        // () => ... — no params
+        // () => ... - no params
       } else {
         while (couldBeArrow) {
           const p = this.peek();
@@ -446,7 +446,7 @@ class Parser {
         }
       }
 
-      // Not an arrow — restore and parse as grouping
+      // Not an arrow - restore and parse as grouping
       this.pos = savedPos;
       this.next(); // consume (
       const expr = this.parseExpression(0);
@@ -539,14 +539,14 @@ class Parser {
       return { type: 'ident', name: tok.v };
     }
 
-    // Fallback — return undefined for unparseable
+    // Fallback - return undefined for unparseable
     this.next();
     return { type: 'literal', value: undefined };
   }
 }
 
 // ---------------------------------------------------------------------------
-// Evaluator — walks the AST, resolves against scope
+// Evaluator - walks the AST, resolves against scope
 // ---------------------------------------------------------------------------
 
 /** Safe property access whitelist for built-in prototypes */
@@ -635,8 +635,6 @@ function evaluate(node, scope) {
       if (name === 'console') return console;
       if (name === 'Map') return Map;
       if (name === 'Set') return Set;
-      if (name === 'RegExp') return RegExp;
-      if (name === 'Error') return Error;
       if (name === 'URL') return URL;
       if (name === 'URLSearchParams') return URLSearchParams;
       return undefined;
@@ -679,7 +677,7 @@ function evaluate(node, scope) {
     case 'optional_call': {
       const calleeNode = node.callee;
       const args = _evalArgs(node.args, scope);
-      // Method call: obj?.method() — bind `this` to obj
+      // Method call: obj?.method() - bind `this` to obj
       if (calleeNode.type === 'member' || calleeNode.type === 'optional_member') {
         const obj = evaluate(calleeNode.obj, scope);
         if (obj == null) return undefined;
@@ -698,9 +696,9 @@ function evaluate(node, scope) {
     case 'new': {
       const Ctor = evaluate(node.callee, scope);
       if (typeof Ctor !== 'function') return undefined;
-      // Only allow safe constructors
+      // Only allow safe constructors (no RegExp - ReDoS risk, no Error - info leak)
       if (Ctor === Date || Ctor === Array || Ctor === Map || Ctor === Set ||
-          Ctor === RegExp || Ctor === Error || Ctor === URL || Ctor === URLSearchParams) {
+          Ctor === URL || Ctor === URLSearchParams) {
         const args = _evalArgs(node.args, scope);
         return new Ctor(...args);
       }
@@ -802,7 +800,7 @@ function _resolveCall(node, scope) {
   const callee = node.callee;
   const args = _evalArgs(node.args, scope);
 
-  // Method call: obj.method() — bind `this` to obj
+  // Method call: obj.method() - bind `this` to obj
   if (callee.type === 'member' || callee.type === 'optional_member') {
     const obj = evaluate(callee.obj, scope);
     if (obj == null) return undefined;
@@ -868,13 +866,13 @@ function _evalBinary(node, scope) {
 /**
  * Safely evaluate a JS expression string against scope layers.
  *
- * @param {string} expr — expression string
- * @param {object[]} scope — array of scope objects, checked in order
+ * @param {string} expr - expression string
+ * @param {object[]} scope - array of scope objects, checked in order
  *   Typical: [loopVars, state, { props, refs, $ }]
- * @returns {*} — evaluation result, or undefined on error
+ * @returns {*} - evaluation result, or undefined on error
  */
 
-// AST cache (LRU) — avoids re-tokenizing and re-parsing the same expression.
+// AST cache (LRU) - avoids re-tokenizing and re-parsing the same expression.
 // Uses Map insertion-order: on hit, delete + re-set moves entry to the end.
 // Eviction removes the least-recently-used (first) entry when at capacity.
 const _astCache = new Map();