@hyperfixi/core 2.3.1 → 2.5.0

package/dist/expressions/index.js

@@ -1,80 +1,14 @@
 'use strict';
 
-function ok(value) {
-    return { ok: true, value };
-}
-function err(error) {
-    return { ok: false, error };
-}
-
-function checkDebugEnabled() {
-    if (typeof localStorage !== 'undefined') {
-        try {
-            const ls = localStorage;
-            const setting = ls.getItem('hyperfixi:debug') || ls.getItem('lokascript:debug');
-            if (setting === '*' || setting === 'true')
-                return true;
-        }
-        catch {
+function createExpressionRegistry(...categories) {
+    const map = new Map();
+    for (const category of categories) {
+        for (const [name, impl] of Object.entries(category)) {
+            map.set(name, impl);
         }
     }
-    if (typeof window !== 'undefined' && window.__HYPERFIXI_DEBUG__) {
-        return true;
-    }
-    if (typeof process !== 'undefined' && process.env?.HYPERFIXI_DEBUG === 'true') {
-        return true;
-    }
-    return false;
+    return map;
 }
-const isDebugEnabled = checkDebugEnabled();
-const DEBUG = {
-    commands: isDebugEnabled,
-    events: isDebugEnabled,
-    parsing: isDebugEnabled,
-    expressions: isDebugEnabled,
-    styles: isDebugEnabled,
-    runtime: isDebugEnabled,
-    loops: isDebugEnabled,
-    async: isDebugEnabled,
-};
-const debug = {
-    command: (...args) => {
-        if (DEBUG.commands)
-            console.log('🔧', ...args);
-    },
-    event: (...args) => {
-        if (DEBUG.events)
-            console.log('🎯', ...args);
-    },
-    parse: (...args) => {
-        if (DEBUG.parsing)
-            console.log('📝', ...args);
-    },
-    expr: (...args) => {
-        if (DEBUG.expressions)
-            console.log('🔍', ...args);
-    },
-    expressions: (...args) => {
-        if (DEBUG.expressions)
-            console.log('🔍', ...args);
-    },
-    style: (...args) => {
-        if (DEBUG.styles)
-            console.log('🎨', ...args);
-    },
-    runtime: (...args) => {
-        if (DEBUG.runtime)
-            console.log('🚀', ...args);
-    },
-    loop: (...args) => {
-        if (DEBUG.loops)
-            console.log('🔁', ...args);
-    },
-    async: (...args) => {
-        if (DEBUG.async)
-            console.log('⏳', ...args);
-    },
-};
 
 class ExpressionTypeRegistry {
     constructor(config = {}) {
@@ -329,1473 +263,104 @@ class ExpressionTypeRegistry {
             isType: (v) => typeof v === 'object' && v !== null && !Array.isArray(v) && !(v instanceof Element),
             defaultValue: {},
             description: 'Plain JavaScript object',
-            coerceFrom: {
-                String: v => {
-                    try {
-                        const parsed = JSON.parse(v);
-                        if (typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed)) {
-                            return parsed;
-                        }
-                    }
-                    catch {
-                    }
-                    return null;
-                },
-                Array: v => {
-                    const arr = v;
-                    const obj = {};
-                    arr.forEach((item, index) => {
-                        obj[String(index)] = item;
-                    });
-                    return obj;
-                },
-            },
-        });
-        this.register({
-            name: 'Null',
-            hyperscriptType: 'null',
-            tsType: 'null',
-            isType: (v) => v === null,
-            defaultValue: null,
-            description: 'Null value',
-        });
-        this.register({
-            name: 'Undefined',
-            hyperscriptType: 'undefined',
-            tsType: 'undefined',
-            isType: (v) => v === undefined,
-            defaultValue: undefined,
-            description: 'Undefined value',
-        });
-        this.register({
-            name: 'Function',
-            hyperscriptType: 'function',
-            tsType: 'Function',
-            isType: (v) => typeof v === 'function',
-            defaultValue: null,
-            description: 'JavaScript function',
-        });
-        this.register({
-            name: 'Event',
-            hyperscriptType: 'event',
-            tsType: 'Event',
-            isType: (v) => v instanceof Event,
-            defaultValue: null,
-            description: 'DOM Event',
-        });
-        this.register({
-            name: 'NodeList',
-            hyperscriptType: 'element-list',
-            tsType: 'NodeList',
-            isType: (v) => v instanceof NodeList,
-            defaultValue: null,
-            description: 'DOM NodeList (typically from querySelectorAll)',
-            coerceFrom: {
-                Array: v => {
-                    return null;
-                },
-            },
-        });
-        this.register({
-            name: 'Unknown',
-            hyperscriptType: 'unknown',
-            tsType: 'unknown',
-            isType: (_v) => true,
-            defaultValue: null,
-            description: 'Unknown/any value type',
-        });
-    }
-}
-const expressionTypeRegistry = new ExpressionTypeRegistry();
-
-function isString(value) {
-    const stringType = expressionTypeRegistry.get('String');
-    return stringType ? stringType.isType(value) : typeof value === 'string';
-}
-function isNumber(value) {
-    const numberType = expressionTypeRegistry.get('Number');
-    return numberType ? numberType.isType(value) : typeof value === 'number';
-}
-function isBoolean(value) {
-    const boolType = expressionTypeRegistry.get('Boolean');
-    return boolType ? boolType.isType(value) : typeof value === 'boolean';
-}
-function isObject(value) {
-    const objectType = expressionTypeRegistry.get('Object');
-    return objectType ? objectType.isType(value) : typeof value === 'object' && value !== null;
-}
-function isFunction(value) {
-    const funcType = expressionTypeRegistry.get('Function');
-    return funcType ? funcType.isType(value) : typeof value === 'function';
-}
-
-function isInputElement(el) {
-    return (el !== null && typeof el === 'object' && 'tagName' in el && el.tagName === 'INPUT');
-}
-function isFormElement(el) {
-    if (el === null || typeof el !== 'object' || !('tagName' in el)) {
-        return false;
-    }
-    const tag = el.tagName;
-    return tag === 'INPUT' || tag === 'SELECT' || tag === 'TEXTAREA';
-}
-function isHTMLElement$1(el) {
-    return (el !== null &&
-        typeof el === 'object' &&
-        'nodeType' in el &&
-        el.nodeType === 1 &&
-        'style' in el);
-}
-function isOptionElement(el) {
-    return (el !== null &&
-        typeof el !== 'undefined' &&
-        typeof el === 'object' &&
-        'tagName' in el &&
-        el.tagName === 'OPTION');
-}
-
-function isElement(value) {
-    return value instanceof Element;
-}
-function isHTMLElement(value) {
-    return value instanceof HTMLElement;
-}
-const BOOLEAN_ATTRIBUTES = new Set([
-    'disabled',
-    'readonly',
-    'required',
-    'checked',
-    'selected',
-    'hidden',
-    'open',
-    'autofocus',
-    'autoplay',
-    'controls',
-    'loop',
-    'muted',
-    'multiple',
-    'reversed',
-    'defer',
-    'async',
-    'novalidate',
-    'formnovalidate',
-    'ismap',
-]);
-function accessAttribute(element, attrName) {
-    if (BOOLEAN_ATTRIBUTES.has(attrName.toLowerCase())) {
-        return element.hasAttribute(attrName);
-    }
-    return element.getAttribute(attrName);
-}
-function hasAttribute(element, attrName) {
-    return element.hasAttribute(attrName);
-}
-const SPECIAL_DOM_PROPERTIES = {
-    id: el => el.id,
-    classname: el => el.className,
-    class: el => el.className,
-    tagname: el => el.tagName.toLowerCase(),
-    innertext: el => el.textContent?.trim(),
-    innerHTML: el => el.innerHTML,
-    outerhtml: el => el.outerHTML,
-    value: el => (isFormElement(el) ? el.value : undefined),
-    checked: el => (isInputElement(el) ? el.checked : undefined),
-    disabled: el => ('disabled' in el ? el.disabled : undefined),
-    selected: el => (isOptionElement(el) ? el.selected : undefined),
-    tabindex: el => (isHTMLElement$1(el) ? el.tabIndex : undefined),
-    hidden: el => (isHTMLElement$1(el) ? el.hidden : undefined),
-    style: el => getComputedStyle(el),
-    children: el => Array.from(el.children),
-    parent: el => el.parentElement,
-    firstchild: el => el.firstElementChild,
-    lastchild: el => el.lastElementChild,
-    nextsibling: el => el.nextElementSibling,
-    previoussibling: el => el.previousElementSibling,
-    values: el => collectFormValues(el),
-};
-function collectFormValues(el) {
-    if (el instanceof HTMLFormElement)
-        return new FormData(el);
-    const fd = new FormData();
-    el.querySelectorAll('input, select, textarea').forEach((input) => {
-        const name = input.getAttribute('name');
-        if (name && 'value' in input)
-            fd.append(name, input.value);
-    });
-    return fd;
-}
-function getElementProperty(element, property) {
-    if (property.startsWith('computed-')) {
-        const cssProperty = property.slice('computed-'.length);
-        if (isHTMLElement(element)) {
-            const computedStyle = getComputedStyle(element);
-            return computedStyle.getPropertyValue(cssProperty);
-        }
-        return undefined;
-    }
-    if (property.startsWith('@')) {
-        const attrName = property.slice(1);
-        return accessAttribute(element, attrName);
-    }
-    const specialHandler = SPECIAL_DOM_PROPERTIES[property.toLowerCase()];
-    if (specialHandler) {
-        return specialHandler(element);
-    }
-    if (hasAttribute(element, property)) {
-        return accessAttribute(element, property);
-    }
-    const value = element[property];
-    if (isFunction(value)) {
-        return value.bind(element);
-    }
-    return value;
-}
-
-function extractPropertyName(property) {
-    if (typeof property === 'string')
-        return property;
-    if (property && typeof property === 'object') {
-        if (typeof property.name === 'string')
-            return property.name;
-        if (typeof property.value === 'string')
-            return property.value;
-    }
-    return property;
-}
-
-function getDoc(context) {
-    return context.me?.ownerDocument ?? (typeof document !== 'undefined' ? document : null);
-}
-function evaluateSelector(node, context) {
-    let selector = node.value;
-    if (selector.startsWith('<') && selector.endsWith('/>')) {
-        selector = selector.slice(1, -2).trim();
-    }
-    const doc = getDoc(context);
-    if (!doc) {
-        return [];
-    }
-    const elements = doc.querySelectorAll(selector);
-    const isEl = (el) => el && typeof el === 'object' && el.nodeType === 1 && typeof el.tagName === 'string';
-    return Array.from(elements).filter(isEl);
-}
-function evaluateCSSSelector(node, context) {
-    let selector = node.selector;
-    if (selector.startsWith('<') && selector.endsWith('/>')) {
-        selector = selector.slice(1, -2).trim();
-    }
-    const doc = getDoc(context);
-    if (!doc) {
-        return node.selectorType === 'id' ? null : [];
-    }
-    if (node.selectorType === 'id') {
-        const id = selector.startsWith('#') ? selector.slice(1) : selector;
-        return doc.getElementById(id);
-    }
-    else if (node.selectorType === 'class') {
-        const escapedSelector = selector.replace(/:/g, '\\:');
-        const elements = doc.querySelectorAll(escapedSelector);
-        return Array.from(elements).filter((el) => el instanceof HTMLElement);
-    }
-    const elements = doc.querySelectorAll(selector);
-    return Array.from(elements).filter((el) => el instanceof HTMLElement);
-}
-function evaluateIdSelector(node, context) {
-    const doc = getDoc(context);
-    if (!doc) {
-        return null;
-    }
-    const id = node.value.startsWith('#') ? node.value.slice(1) : node.value;
-    return doc.getElementById(id);
-}
-function evaluateQueryReference(node, context) {
-    let selector = node.selector;
-    if (selector.startsWith('<') && selector.endsWith('/>')) {
-        selector = selector.slice(1, -2).trim();
-    }
-    const doc = getDoc(context);
-    if (!doc) {
-        return [];
-    }
-    try {
-        return doc.querySelectorAll(selector);
-    }
-    catch {
-        return doc.createDocumentFragment().childNodes;
-    }
-}
-
-function lookupTemplateVariable(name, context) {
-    if (context.locals?.has(name))
-        return context.locals.get(name);
-    if (context.globals?.has(name))
-        return context.globals.get(name);
-    if (context.variables?.has(name))
-        return context.variables.get(name);
-    if (name === 'me')
-        return context.me;
-    if (name === 'it')
-        return context.it;
-    if (name === 'result')
-        return context.result;
-    return undefined;
-}
-async function resolveTemplateVariable(varName, context) {
-    if (varName.includes('.')) {
-        const parts = varName.split('.');
-        let value = lookupTemplateVariable(parts[0], context);
-        for (let i = 1; i < parts.length && value != null; i++) {
-            value = value[parts[i]];
-        }
-        return value;
-    }
-    return lookupTemplateVariable(varName, context);
-}
-async function resolveValue(name, context) {
-    debug.expressions(`RESOLVE: Looking for '${name}' in context`, {
-        hasInLocals: context.locals.has(name),
-        localsKeys: Array.from(context.locals.keys()),
-        value: context.locals.get(name),
-    });
-    if (context.locals.has(name)) {
-        const value = context.locals.get(name);
-        debug.expressions(`RESOLVE: Found '${name}' in locals:`, value);
-        return value;
-    }
-    if (context.globals && context.globals.has(name)) {
-        const value = context.globals.get(name);
-        debug.expressions(`RESOLVE: Found '${name}' in globals:`, value);
-        return value;
-    }
-    if (context.variables && context.variables.has(name)) {
-        const value = context.variables.get(name);
-        debug.expressions(`RESOLVE: Found '${name}' in variables (legacy):`, value);
-        return value;
-    }
-    const num = Number(name);
-    if (!isNaN(num)) {
-        return num;
-    }
-    if ((name.startsWith('"') && name.endsWith('"')) ||
-        (name.startsWith("'") && name.endsWith("'"))) {
-        return name.slice(1, -1);
-    }
-    if (name.includes('.')) {
-        const parts = name.split('.');
-        const baseName = parts[0];
-        let obj = null;
-        if (context.locals.has(baseName)) {
-            obj = context.locals.get(baseName);
-        }
-        else if (context.globals && context.globals.has(baseName)) {
-            obj = context.globals.get(baseName);
-        }
-        else if (context.variables && context.variables.has(baseName)) {
-            obj = context.variables.get(baseName);
-        }
-        if (obj !== null && obj !== undefined) {
-            for (let i = 1; i < parts.length; i++) {
-                if (obj === null || obj === undefined) {
-                    debug.expressions(`RESOLVE: Property access failed at '${parts[i - 1]}'`);
-                    return undefined;
-                }
-                obj = obj[parts[i]];
-            }
-            debug.expressions(`RESOLVE: Property access '${name}' =`, obj);
-            return obj;
-        }
-    }
-    return name;
-}
-async function evaluateSimpleExpression(exprCode, context) {
-    debug.expressions('EVAL: Evaluating expression:', exprCode);
-    const ternaryMatch = exprCode.match(/^(.+?)\s*\?(?![\.\[])\s*(.+?)\s*:\s*(.+)$/);
-    if (ternaryMatch) {
-        const [, conditionExpr, trueExpr, falseExpr] = ternaryMatch;
-        debug.expressions('EVAL: Parsed ternary:', { conditionExpr, trueExpr, falseExpr });
-        const conditionValue = await resolveValue(conditionExpr.trim(), context);
-        debug.expressions('EVAL: Ternary condition value:', conditionValue);
-        if (conditionValue) {
-            const trueValue = await resolveValue(trueExpr.trim(), context);
-            debug.expressions('EVAL: Ternary returned true branch:', trueValue);
-            return trueValue;
-        }
-        else {
-            const falseValue = await resolveValue(falseExpr.trim(), context);
-            debug.expressions('EVAL: Ternary returned false branch:', falseValue);
-            return falseValue;
-        }
-    }
-    const arithmeticMatch = exprCode.match(/^([a-zA-Z_$][a-zA-Z0-9_$]*|\d+(?:\.\d+)?)\s*([\+\-\*\/\%])\s*([a-zA-Z_$][a-zA-Z0-9_$]*|\d+(?:\.\d+)?)$/);
-    if (arithmeticMatch) {
-        const [, left, operator, right] = arithmeticMatch;
-        debug.expressions('EVAL: Parsed arithmetic:', { left, operator, right });
-        const leftValue = await resolveValue(left.trim(), context);
-        const rightValue = await resolveValue(right.trim(), context);
-        debug.expressions('EVAL: Resolved values:', { leftValue, rightValue });
-        const leftNum = Number(leftValue);
-        const rightNum = Number(rightValue);
-        if (!isNaN(leftNum) && !isNaN(rightNum)) {
-            let result;
-            switch (operator) {
-                case '+':
-                    result = leftNum + rightNum;
-                    break;
-                case '-':
-                    result = leftNum - rightNum;
-                    break;
-                case '*':
-                    result = leftNum * rightNum;
-                    break;
-                case '/':
-                    result = leftNum / rightNum;
-                    break;
-                case '%':
-                    result = leftNum % rightNum;
-                    break;
-                default:
-                    result = leftNum;
-            }
-            debug.expressions('EVAL: Arithmetic result:', result);
-            return result;
-        }
-    }
-    const fallback = await resolveValue(exprCode.trim(), context);
-    debug.expressions('EVAL: Fallback result:', fallback);
-    return fallback;
-}
-async function evaluateTemplateLiteral(node, context) {
-    let template = node.value || '';
-    debug.expressions('TEMPLATE LITERAL: Evaluating', { template, node });
-    const varPattern = /\$([a-zA-Z_][a-zA-Z0-9_]*(?:\.[a-zA-Z_][a-zA-Z0-9_]*)*)/g;
-    const matches = [];
-    let m;
-    while ((m = varPattern.exec(template)) !== null) {
-        if (template[m.index + 1] === '{')
-            continue;
-        matches.push({ match: m[0], varName: m[1], index: m.index });
-    }
-    for (let i = matches.length - 1; i >= 0; i--) {
-        const { match, varName, index } = matches[i];
-        const value = await resolveTemplateVariable(varName, context);
-        debug.expressions(`TEMPLATE: $${varName} resolved to`, value);
-        template =
-            template.slice(0, index) + String(value ?? '') + template.slice(index + match.length);
-    }
-    let result = '';
-    let j = 0;
-    while (j < template.length) {
-        const exprStart = template.indexOf('${', j);
-        if (exprStart === -1) {
-            result += template.slice(j);
-            break;
-        }
-        result += template.slice(j, exprStart);
-        let depth = 1;
-        let exprEnd = exprStart + 2;
-        while (exprEnd < template.length && depth > 0) {
-            if (template[exprEnd] === '{')
-                depth++;
-            if (template[exprEnd] === '}')
-                depth--;
-            if (depth > 0)
-                exprEnd++;
-        }
-        if (depth !== 0) {
-            throw new Error(`Unterminated template expression in: ${template}`);
-        }
-        const exprCode = template.slice(exprStart + 2, exprEnd);
-        debug.expressions('TEMPLATE: Evaluating expression:', exprCode);
-        let value;
-        const trimmed = exprCode.trim();
-        if (context.locals.has(trimmed)) {
-            value = context.locals.get(trimmed);
-            debug.expressions(`TEMPLATE: Found in locals: ${trimmed} =`, value);
-        }
-        else if (context.globals && context.globals.has(trimmed)) {
-            value = context.globals.get(trimmed);
-            debug.expressions(`TEMPLATE: Found in globals: ${trimmed} =`, value);
-        }
-        else if (context.variables && context.variables.has(trimmed)) {
-            value = context.variables.get(trimmed);
-            debug.expressions(`TEMPLATE: Found in variables (legacy): ${trimmed} =`, value);
-        }
-        else {
-            value = await evaluateSimpleExpression(exprCode, context);
-            debug.expressions(`TEMPLATE: Evaluated expression "${exprCode}" =`, value);
-        }
-        result += String(value);
-        j = exprEnd + 1;
-    }
-    return result;
-}
-
-function coerceArithmeticOperand(value) {
-    if (Array.isArray(value) && value.length === 1) {
-        value = value[0];
-    }
-    if (value !== null &&
-        typeof value === 'object' &&
-        typeof value.textContent === 'string') {
-        const text = value.value ?? value.textContent;
-        if (text !== null && text !== undefined) {
-            const trimmed = String(text).trim();
-            if (trimmed === '')
-                return 0;
-            const num = parseFloat(trimmed);
-            return isNaN(num) ? trimmed : num;
-        }
-        return 0;
-    }
-    return value;
-}
-async function evaluateBinaryExpression(node, context, evaluate, unwrap, expressionRegistry, evaluateSelector) {
-    const { operator, left, right } = node;
-    if (operator === 'in' && left.type === 'selector') {
-        let selector = left.value;
-        if (selector.startsWith('<') && selector.endsWith('/>')) {
-            selector = selector.slice(1, -2).trim();
-        }
-        const contextElement = unwrap(await evaluate(right, context));
-        if (!contextElement || typeof contextElement.querySelector !== 'function') {
-            throw new Error(`'in' operator requires a DOM element as the right operand (got: ${typeof contextElement})`);
-        }
-        const nodeList = contextElement.querySelectorAll(selector);
-        return Array.from(nodeList);
-    }
-    if (operator === 'in' && left.type === 'queryReference') {
-        let selector = left.selector;
-        if (selector.startsWith('<') && selector.endsWith('/>')) {
-            selector = selector.slice(1, -2).trim();
-        }
-        const contextElement = unwrap(await evaluate(right, context));
-        if (!contextElement || typeof contextElement.querySelector !== 'function') {
-            throw new Error(`'in' operator requires a DOM element as the right operand (got: ${typeof contextElement})`);
-        }
-        const nodeList = contextElement.querySelectorAll(selector);
-        return Array.from(nodeList);
-    }
-    if (operator === 'in') {
-        let positionalOp = null;
-        let selector = null;
-        if (left.type === 'positionalExpression') {
-            positionalOp = left.operator;
-            const selectorArg = left.argument;
-            if (selectorArg?.type === 'cssSelector') {
-                selector = selectorArg.selector;
-            }
-            else if (selectorArg?.type === 'selector') {
-                selector = selectorArg.value;
-            }
-            else if (selectorArg?.type === 'classSelector') {
-                selector = '.' + selectorArg.className;
-            }
-            else if (selectorArg?.type === 'idSelector') {
-                selector = '#' + selectorArg.id;
-            }
-            else if (selectorArg) {
-                selector = String(await evaluate(selectorArg, context));
-            }
-        }
-        else if (left.type === 'memberExpression' &&
-            left.object?.type === 'identifier' &&
-            (left.object.name === 'first' || left.object.name === 'last')) {
-            positionalOp = left.object.name;
-            if (left.property?.type === 'identifier' && left.property.name) {
-                selector = '.' + left.property.name;
-            }
-        }
-        else if (left.type === 'callExpression' &&
-            left.callee?.type === 'identifier' &&
-            (left.callee.name === 'first' || left.callee.name === 'last')) {
-            positionalOp = left.callee.name;
-            const selectorArg = left.arguments?.[0];
-            if (selectorArg?.type === 'selector') {
-                selector = selectorArg.value;
-            }
-            else if (selectorArg?.type === 'cssSelector') {
-                selector = selectorArg.selector;
-            }
-            else if (selectorArg?.type === 'classSelector') {
-                selector = '.' + selectorArg.className;
-            }
-            else if (selectorArg?.type === 'idSelector') {
-                selector = '#' + selectorArg.id;
-            }
-            else if (selectorArg) {
-                selector = String(await evaluate(selectorArg, context));
-            }
-        }
-        if (positionalOp && selector) {
-            const scopeElement = unwrap(await evaluate(right, context));
-            if (!scopeElement || typeof scopeElement.querySelectorAll !== 'function') {
-                return undefined;
-            }
-            const nodeList = scopeElement.querySelectorAll(selector);
-            const elements = Array.from(nodeList);
-            if (positionalOp === 'first') {
-                return elements.length > 0 ? elements[0] : undefined;
-            }
-            else if (positionalOp === 'last') {
-                return elements.length > 0 ? elements[elements.length - 1] : undefined;
-            }
-            return elements;
-        }
-    }
-    if (operator === 'matches' &&
-        (right.type === 'selector' || right.type === 'cssSelector' || right.type === 'classSelector')) {
-        const leftValue = await evaluate(left, context);
-        const selectorStr = right.value || right.selector;
-        if (leftValue && typeof leftValue.matches === 'function') {
-            try {
-                return leftValue.matches(selectorStr);
-            }
-            catch {
-                return false;
-            }
-        }
-        return false;
-    }
-    const leftValue = await evaluate(left, context);
-    const rightValue = await evaluate(right, context);
-    if (operator === 'has' || operator === 'have') {
-        if (leftValue instanceof Element) {
-            if ((right.type === 'cssSelector' && right.selectorType === 'class') ||
-                (right.type === 'selector' && right.value?.startsWith('.'))) {
-                const className = right.selector?.slice(1) || right.value?.slice(1) || '';
-                return leftValue.classList.contains(className);
-            }
-            if (right.type === 'attributeAccess' || right.type === 'attributeRef') {
-                const attrName = right.attributeName || right.name || right.value?.replace(/^@/, '') || '';
-                return leftValue.hasAttribute(attrName);
-            }
-            if (right.type === 'cssSelector' && right.selectorType === 'attribute') {
-                const attrName = (right.selector || right.value || '').replace(/^@/, '');
-                return leftValue.hasAttribute(attrName);
-            }
-            if ((right.type === 'cssSelector' && right.selectorType === 'id') ||
-                right.type === 'idSelector') {
-                const id = (right.selector || right.value || '').replace(/^#/, '');
-                return leftValue.querySelector(`#${CSS.escape(id)}`) !== null;
-            }
-            if (right.type === 'selector' || right.type === 'queryReference') {
-                let sel = right.value || right.selector || '';
-                if (sel.startsWith('<') && sel.endsWith('/>')) {
-                    sel = sel.slice(1, -2).trim();
-                }
-                try {
-                    return leftValue.querySelector(sel) !== null;
-                }
-                catch {
-                    return false;
-                }
-            }
-            if (right.type === 'cssSelector') {
-                const sel = right.selector || '';
-                try {
-                    return leftValue.querySelector(sel) !== null;
-                }
-                catch {
-                    return false;
-                }
-            }
-        }
-        if (Array.isArray(leftValue)) {
-            return leftValue.includes(rightValue);
-        }
-        if (typeof leftValue === 'string') {
-            return leftValue.includes(String(rightValue));
-        }
-        return false;
-    }
-    switch (operator) {
-        case '>':
-        case 'is greater than':
-            return leftValue > rightValue;
-        case '<':
-        case 'is less than':
-            return leftValue < rightValue;
-        case '>=':
-        case 'is greater than or equal to':
-            return leftValue >= rightValue;
-        case '<=':
-        case 'is less than or equal to':
-            return leftValue <= rightValue;
-        case '==':
-        case 'equals':
-        case 'is equal to':
-            return leftValue == rightValue;
-        case '===':
-        case 'is really equal to':
-        case 'really equals':
-            return leftValue === rightValue;
-        case '!=':
-        case 'is not equal to':
-            return leftValue != rightValue;
-        case '!==':
-        case 'is not really equal to':
-            return leftValue !== rightValue;
-        case '+': {
-            const coercedLeft = coerceArithmeticOperand(leftValue);
-            const coercedRight = coerceArithmeticOperand(rightValue);
-            const shouldUseStringConcatenation = typeof coercedLeft === 'string' || typeof coercedRight === 'string';
-            if (shouldUseStringConcatenation) {
-                const stringConcatExpr = expressionRegistry.get('stringConcatenation');
-                if (stringConcatExpr) {
-                    debug.expressions('Using string concatenation for:', {
-                        leftValue: coercedLeft,
-                        rightValue: coercedRight,
-                    });
-                    const result = await stringConcatExpr.evaluate(context, {
-                        left: coercedLeft,
-                        right: coercedRight,
-                    });
-                    return result.success ? result.value : coercedLeft + coercedRight;
-                }
-            }
-            else {
-                const additionExpr = expressionRegistry.get('addition');
-                if (additionExpr) {
-                    debug.expressions('Using numeric addition for:', {
-                        leftValue: coercedLeft,
-                        rightValue: coercedRight,
-                    });
-                    const result = await additionExpr.evaluate(context, {
-                        left: coercedLeft,
-                        right: coercedRight,
-                    });
-                    return result.success ? result.value : coercedLeft + coercedRight;
-                }
-            }
-            return coercedLeft + coercedRight;
-        }
-        case '-':
-            return (coerceArithmeticOperand(leftValue) - coerceArithmeticOperand(rightValue));
-        case '*':
-            return (coerceArithmeticOperand(leftValue) * coerceArithmeticOperand(rightValue));
-        case '/':
-            return (coerceArithmeticOperand(leftValue) / coerceArithmeticOperand(rightValue));
-        case '%':
-        case 'mod':
-            return (coerceArithmeticOperand(leftValue) % coerceArithmeticOperand(rightValue));
-        case 'as':
-            const typeName = typeof rightValue === 'string'
-                ? rightValue
-                : right.type === 'identifier'
-                    ? right.name
-                    : right.type === 'literal'
-                        ? right.value
-                        : String(rightValue);
-            const asExpr = expressionRegistry.get('as');
-            return asExpr ? asExpr.evaluate(context, leftValue, typeName) : leftValue;
-        case '&&':
-        case 'and':
-            return leftValue && rightValue;
-        case '||':
-        case 'or':
-            return leftValue || rightValue;
-        case 'is':
-            return leftValue === rightValue;
-        case 'is not':
-            return leftValue !== rightValue;
-        case 'is a':
-        case 'is an':
-            const checkTypeName = right.type === 'identifier' ? right.name.toLowerCase() : String(rightValue).toLowerCase();
-            switch (checkTypeName) {
-                case 'string':
-                    return typeof leftValue === 'string';
-                case 'number':
-                    return typeof leftValue === 'number';
-                case 'boolean':
-                    return typeof leftValue === 'boolean';
-                case 'object':
-                    return typeof leftValue === 'object' && leftValue !== null;
-                case 'array':
-                    return Array.isArray(leftValue);
-                case 'function':
-                    return typeof leftValue === 'function';
-                case 'null':
-                    return leftValue === null;
-                case 'undefined':
-                    return leftValue === undefined;
-                default:
-                    const typeNameStr = right.type === 'identifier' ? right.name : String(rightValue);
-                    return leftValue != null && leftValue.constructor?.name === typeNameStr;
-            }
-        case 'is not a':
-        case 'is not an':
-            const negCheckTypeName = right.type === 'identifier' ? right.name.toLowerCase() : String(rightValue).toLowerCase();
-            switch (negCheckTypeName) {
-                case 'string':
-                    return typeof leftValue !== 'string';
-                case 'number':
-                    return typeof leftValue !== 'number';
-                case 'boolean':
-                    return typeof leftValue !== 'boolean';
-                case 'object':
-                    return !(typeof leftValue === 'object' && leftValue !== null);
-                case 'array':
-                    return !Array.isArray(leftValue);
-                case 'function':
-                    return typeof leftValue !== 'function';
-                case 'null':
-                    return leftValue !== null;
-                case 'undefined':
-                    return leftValue !== undefined;
-                default:
-                    const negTypeNameStr = right.type === 'identifier' ? right.name : String(rightValue);
-                    return !(leftValue != null && leftValue.constructor?.name === negTypeNameStr);
-            }
-        case '=':
-            if (left.type === 'identifier') {
-                const variableName = left.name;
-                if (variableName === 'result') {
-                    context.result = rightValue;
-                }
-                else if (variableName === 'it') {
-                    context.it = rightValue;
-                }
-                else if (variableName === 'you') {
-                    context.you = rightValue;
-                }
-                else {
-                    context.locals.set(variableName, rightValue);
-                }
-                return rightValue;
-            }
-            else {
-                throw new Error('Left side of assignment must be an identifier');
-            }
-        case 'contains':
-            if (Array.isArray(leftValue)) {
-                return leftValue.includes(rightValue);
-            }
-            if (typeof leftValue === 'string') {
-                return leftValue.includes(String(rightValue));
-            }
-            if (leftValue && typeof leftValue.matches === 'function') {
-                return leftValue.matches(String(rightValue));
-            }
-            return false;
-        case 'include':
-        case 'includes':
-            if (Array.isArray(leftValue)) {
-                return leftValue.includes(rightValue);
-            }
-            if (typeof leftValue === 'string') {
-                return leftValue.includes(String(rightValue));
-            }
-            if (leftValue && typeof leftValue.matches === 'function') {
-                return leftValue.matches(String(rightValue));
-            }
-            return false;
-        case 'match':
-        case 'matches':
-            if (leftValue && typeof leftValue.matches === 'function') {
-                const selectorStr = typeof rightValue === 'string' ? rightValue : String(rightValue);
-                try {
-                    return leftValue.matches(selectorStr);
-                }
-                catch {
-                    return false;
-                }
-            }
-            return false;
-        case 'in':
-            const selectorIn = typeof leftValue === 'string' ? leftValue : String(leftValue);
-            const contextElementIn = rightValue;
-            if (!contextElementIn || typeof contextElementIn.querySelector !== 'function') {
-                if (Array.isArray(contextElementIn)) {
-                    return contextElementIn.includes(leftValue);
-                }
-                if (typeof contextElementIn === 'object' && contextElementIn !== null) {
-                    return selectorIn in contextElementIn;
-                }
-                throw new Error(`'in' operator requires a DOM element, array, or object as the right operand (got: ${typeof contextElementIn})`);
-            }
-            return contextElementIn.querySelector(selectorIn);
-        case ' ':
-            if (typeof leftValue === 'string' && typeof rightValue === 'string') {
-                return { command: leftValue, selector: rightValue };
-            }
-            if (left.type === 'identifier' && right.type === 'selector') {
-                return { command: left.name, selector: right.value };
-            }
-            return rightValue;
-        default:
-            throw new Error(`Unsupported binary operator: "${operator}" (length: ${operator.length})`);
-    }
-}
-
-async function evaluateCallExpression(node, context, evaluate, unwrap, expressionRegistry, evaluateSelector) {
-    const { callee, arguments: args, isConstructor } = node;
-    if (isConstructor) {
-        const constructorName = callee.name;
-        const Constructor = context.globals?.get(constructorName) || window[constructorName];
-        if (typeof Constructor === 'function') {
-            const evaluatedArgs = await Promise.all(args.map((arg) => evaluate(arg, context)));
-            return new Constructor(...evaluatedArgs);
-        }
-        throw new Error(`Unknown constructor: ${constructorName}`);
-    }
-    if (callee.type === 'memberExpression' || callee.type === 'propertyAccess') {
-        return evaluateMethodCall(callee, args, context, evaluate, unwrap);
-    }
-    const functionName = callee.name || callee;
-    const expression = expressionRegistry.get(functionName);
-    if (expression) {
-        const selectorStringFunctions = ['closest', 'previous', 'next'];
-        const collectionFunctions = ['first', 'last', 'random', 'at'];
-        const needsSelectorString = selectorStringFunctions.includes(functionName);
-        const needsCollection = collectionFunctions.includes(functionName);
-        const evaluatedArgs = await Promise.all(args.map((arg) => {
-            if (needsSelectorString &&
-                arg &&
-                arg.type === 'selector' &&
-                typeof arg.value === 'string') {
-                return arg.value;
-            }
-            if (needsSelectorString &&
-                arg &&
-                arg.type === 'identifier' &&
-                typeof arg.name === 'string') {
-                return arg.name;
-            }
-            if (needsCollection && arg && arg.type === 'selector' && typeof arg.value === 'string') {
-                return evaluateSelector(arg, context);
-            }
-            return evaluate(arg, context);
-        }));
-        return expression.evaluate(context, ...evaluatedArgs);
-    }
-    const func = context.globals?.get(functionName) || window[functionName];
-    if (typeof func === 'function') {
-        const evaluatedArgs = await Promise.all(args.map((arg) => evaluate(arg, context)));
-        return func(...evaluatedArgs);
-    }
-    throw new Error(`Unknown function: ${functionName}`);
-}
-async function evaluateMethodCall(callee, args, context, evaluate, unwrap) {
-    try {
-        const object = await evaluate(callee.object, context);
-        const thisContext = unwrap(object);
-        if (thisContext === null || thisContext === undefined) {
-            throw new Error(`Cannot call method on null or undefined`);
-        }
-        const propertyName = extractPropertyName(callee.property);
-        if (!propertyName || typeof propertyName !== 'string') {
-            throw new Error(`Invalid method name: ${propertyName}`);
-        }
-        const func = thisContext[propertyName];
-        if (typeof func !== 'function') {
-            throw new Error(`Property "${propertyName}" is not a function on ${thisContext.constructor?.name || typeof thisContext}`);
-        }
-        const evaluatedArgs = await Promise.all(args.map((arg) => evaluate(arg, context)));
-        const result = func.apply(thisContext, evaluatedArgs);
-        return result;
-    }
-    catch (error) {
-        if (error instanceof Error) {
-            throw error;
-        }
-        throw new Error(`Failed to evaluate method call: ${error}`);
-    }
-}
-
-class BaseExpressionEvaluator {
-    constructor() {
-        this.expressionRegistry = new Map();
-    }
-    registerCategory(expressions) {
-        Object.entries(expressions).forEach(([name, impl]) => {
-            this.expressionRegistry.set(name, impl);
-        });
-    }
-    unwrapSelectorResult(value) {
-        if (value instanceof NodeList && value.length > 0) {
-            return value[0];
-        }
-        if (Array.isArray(value) && value.length > 0) {
-            const firstElement = value[0];
-            const hasRegexProps = 'index' in value && 'input' in value;
-            if (hasRegexProps) {
-                return value;
-            }
-            if (firstElement instanceof Element || firstElement instanceof Node) {
-                return firstElement;
-            }
-            return value;
-        }
-        return value;
-    }
-    async evaluate(node, context) {
-        if (!node) {
-            debug.expressions('EVALUATOR: Received null/undefined node, returning null');
-            return null;
-        }
-        if (!node.type) {
-            console.error('EVALUATOR: Node missing type property:', node);
-            throw new Error(`Node missing type property: ${JSON.stringify(node)}`);
-        }
-        switch (node.type) {
-            case 'identifier':
-                return this.evaluateIdentifier(node, context);
-            case 'literal':
-                return this.evaluateLiteral(node, context);
-            case 'string':
-                return node.value ?? '';
-            case 'memberExpression':
-                return this.evaluateMemberExpression(node, context);
-            case 'binaryExpression':
-                return this.evaluateBinaryExpression(node, context);
-            case 'unaryExpression':
-                return this.evaluateUnaryExpression(node, context);
-            case 'callExpression':
-                return this.evaluateCallExpression(node, context);
-            case 'selector':
-                return this.evaluateSelector(node, context);
-            case 'dollarExpression':
-                return this.evaluateDollarExpression(node, context);
-            case 'possessiveExpression':
-                return this.evaluatePossessiveExpression(node, context);
-            case 'templateLiteral':
-                return this.evaluateTemplateLiteral(node, context);
-            case 'arrayLiteral':
-                return this.evaluateArrayLiteral(node, context);
-            case 'objectLiteral':
-                return this.evaluateObjectLiteral(node, context);
-            case 'conditionalExpression':
-                return this.evaluateConditionalExpression(node, context);
-            case 'cssSelector':
-                return this.evaluateCSSSelector(node, context);
-            case 'propertyAccess':
-                return this.evaluatePropertyAccess(node, context);
-            case 'propertyOfExpression':
-                return this.evaluatePropertyOfExpression(node, context);
-            case 'contextReference':
-                return this.evaluateContextReference(node, context);
-            case 'queryReference':
-                return this.evaluateQueryReference(node, context);
-            case 'idSelector':
-                return this.evaluateIdSelector(node, context);
-            case 'attributeAccess':
-                return this.evaluateAttributeAccess(node, context);
-            case 'asExpression':
-                return this.evaluateAsExpression(node, context);
-            default:
-                throw new Error(`Unsupported AST node type for evaluation: ${node.type}`);
-        }
-    }
-    async evaluateWithResult(node, context) {
-        try {
-            const value = await this.evaluate(node, context);
-            return ok(value);
-        }
-        catch (e) {
-            if (e instanceof Error) {
-                const error = e;
-                if (error.isHalt || error.message === 'HALT_EXECUTION') {
-                    return err({ type: 'halt' });
-                }
-                if (error.isExit || error.message === 'EXIT_COMMAND') {
-                    return err({ type: 'exit', returnValue: error.returnValue });
-                }
-                if (error.isBreak) {
-                    return err({ type: 'break' });
-                }
-                if (error.isContinue) {
-                    return err({ type: 'continue' });
-                }
-                if (error.isReturn) {
-                    return err({ type: 'return', returnValue: error.returnValue });
-                }
-            }
-            throw e;
-        }
-    }
-    async evaluateArrayLiteral(node, context) {
-        const elements = node.elements || [];
-        const evaluatedElements = [];
-        for (const element of elements) {
-            const value = await this.evaluate(element, context);
-            evaluatedElements.push(value);
-        }
-        return evaluatedElements;
-    }
-    async evaluateObjectLiteral(node, context) {
-        const properties = node.properties || [];
-        const result = {};
-        for (const property of properties) {
-            let key;
-            if (property.key.type === 'identifier') {
-                key = property.key.name;
-            }
-            else if (property.key.type === 'literal') {
-                key = String(property.key.value);
-            }
-            else {
-                const evaluatedKey = await this.evaluate(property.key, context);
-                key = String(evaluatedKey);
-            }
-            const value = await this.evaluate(property.value, context);
-            result[key] = value;
-        }
-        return result;
-    }
-    async evaluateConditionalExpression(node, context) {
-        const test = await this.evaluate(node.test, context);
-        if (test) {
-            return this.evaluate(node.consequent, context);
-        }
-        else if (node.alternate) {
-            return this.evaluate(node.alternate, context);
-        }
-        return undefined;
-    }
-    async evaluateTemplateLiteral(node, context) {
-        return evaluateTemplateLiteral(node, context);
-    }
-    async evaluateSimpleExpression(exprCode, context) {
-        return evaluateSimpleExpression(exprCode, context);
-    }
-    async resolveValue(name, context) {
-        return resolveValue(name, context);
-    }
-    async evaluateIdentifier(node, context) {
-        const { name, scope } = node;
-        if (name === 'me' || name === 'my' || name === 'I') {
-            return context.me;
-        }
-        if (name === 'you' || name === 'your') {
-            return context.you;
-        }
-        if (name === 'it' || name === 'its') {
-            return context.it;
-        }
-        if (name === 'result') {
-            return context.result;
-        }
-        if (name === 'event') {
-            return context.event;
-        }
-        const expression = this.expressionRegistry.get(name);
-        if (expression) {
-            return expression.evaluate(context);
-        }
-        if (scope === 'local') {
-            if (context.locals?.has(name)) {
-                return context.locals.get(name);
-            }
-            return undefined;
-        }
-        if (scope === 'global') {
-            if (context.globals?.has(name)) {
-                return context.globals.get(name);
-            }
-            if (typeof window !== 'undefined' && name in window) {
-                return window[name];
-            }
-            return undefined;
-        }
-        if (context.locals?.has(name)) {
-            return context.locals.get(name);
-        }
-        if (context.globals?.has(name)) {
-            return context.globals.get(name);
-        }
-        if (context.variables?.has(name)) {
-            return context.variables.get(name);
-        }
-        if (typeof globalThis !== 'undefined' && name in globalThis) {
-            return globalThis[name];
-        }
-        if (typeof window !== 'undefined' && name in window) {
-            return window[name];
-        }
-        return undefined;
-    }
-    async evaluateLiteral(node, _context) {
-        return node.value;
-    }
-    async evaluateContextReference(node, context) {
-        const { contextType } = node;
-        switch (contextType) {
-            case 'me':
-                return context.me;
-            case 'it':
-                return context.result;
-            case 'you':
-                return context.you;
-            case 'event':
-                return context.event;
-            case 'body':
-                return (context.meta?.ownerDocument?.body || document?.body);
-            case 'detail':
-                return context.event?.detail;
-            case 'target':
-                return context.you || context.event?.target;
-            case 'sender':
-                return context.event?.target;
-            default:
-                if (context.locals && context.locals.has(contextType)) {
-                    return context.locals.get(contextType);
-                }
-                debug.expressions(`Unknown context reference type: ${contextType}`);
-                return undefined;
-        }
-    }
-    async evaluateMemberExpression(node, context) {
-        const { object, property, computed } = node;
-        if (object.type === 'identifier' && ['add', 'remove'].includes(object.name)) {
-            const commandName = object.name;
-            const className = extractPropertyName(property);
-            if (!context.me) {
-                throw new Error('Context element "me" is null');
-            }
-            if (commandName === 'add') {
-                context.me.classList.add(className);
-            }
-            else if (commandName === 'remove') {
-                context.me.classList.remove(className);
-            }
-            return;
-        }
-        let objectValue = await this.evaluate(object, context);
-        if (computed) {
-            const propertyValue = await this.evaluate(property, context);
-            return objectValue[propertyValue];
-        }
-        else {
-            const propertyName = extractPropertyName(property);
-            const isArrayProp = Array.isArray(objectValue) &&
-                typeof propertyName === 'string' &&
-                (propertyName === 'length' || propertyName in Array.prototype);
-            if (!isArrayProp) {
-                objectValue = this.unwrapSelectorResult(objectValue);
-            }
-            if (typeof propertyName === 'string') {
-                if (propertyName.startsWith('computed-')) {
-                    const styleProp = propertyName.substring('computed-'.length);
-                    if (objectValue && typeof window !== 'undefined' && objectValue instanceof Element) {
-                        const computedStyle = window.getComputedStyle(objectValue);
-                        return computedStyle.getPropertyValue(styleProp);
-                    }
-                    return undefined;
-                }
-                if (propertyName.startsWith('@')) {
-                    const attrName = propertyName.substring(1);
-                    if (objectValue && typeof objectValue.getAttribute === 'function') {
-                        return accessAttribute(objectValue, attrName);
-                    }
-                    return undefined;
-                }
-                if (objectValue && objectValue instanceof Element) {
-                    if (propertyName === 'previous' || propertyName === 'prev') {
-                        return objectValue.previousElementSibling;
-                    }
-                    if (propertyName === 'next') {
-                        return objectValue.nextElementSibling;
-                    }
-                }
-            }
-            const value = objectValue?.[propertyName];
-            if (typeof value === 'function') {
-                return value.bind(objectValue);
-            }
-            return value;
-        }
-    }
-    coerceArithmeticOperand(value) {
-        return coerceArithmeticOperand(value);
-    }
-    async evaluateBinaryExpression(node, context) {
-        return evaluateBinaryExpression(node, context, this.evaluate.bind(this), this.unwrapSelectorResult.bind(this), this.expressionRegistry, this.evaluateSelector.bind(this));
-    }
-    async evaluateUnaryExpression(node, context) {
-        const { operator, argument } = node;
-        const operandValue = await this.evaluate(argument, context);
-        switch (operator) {
-            case 'not':
-            case '!':
-                const notExpr = this.expressionRegistry.get('not');
-                return notExpr ? notExpr.evaluate(context, operandValue) : !operandValue;
-            case 'no':
-                const noExpr = this.expressionRegistry.get('no');
-                return noExpr ? noExpr.evaluate(context, operandValue) : false;
-            case 'some':
-                if (operandValue === null || operandValue === undefined)
-                    return false;
-                if (typeof operandValue === 'string')
-                    return operandValue.length > 0;
-                if (Array.isArray(operandValue))
-                    return operandValue.length > 0;
-                if (operandValue instanceof NodeList)
-                    return operandValue.length > 0;
-                if (operandValue instanceof HTMLCollection)
-                    return operandValue.length > 0;
-                if (typeof operandValue === 'object')
-                    return Object.keys(operandValue).length > 0;
-                return true;
-            case 'exists':
-                const existsExpr = this.expressionRegistry.get('exists');
-                return existsExpr ? existsExpr.evaluate(context, operandValue) : operandValue != null;
-            case 'does not exist':
-                const doesNotExistExpr = this.expressionRegistry.get('doesNotExist');
-                return doesNotExistExpr
-                    ? doesNotExistExpr.evaluate(context, operandValue)
-                    : operandValue == null;
-            case '-':
-                return -operandValue;
-            case '+':
-                return +operandValue;
-            default:
-                throw new Error(`Unsupported unary operator: ${operator}`);
-        }
-    }
-    async evaluateCallExpression(node, context) {
-        return evaluateCallExpression(node, context, this.evaluate.bind(this), this.unwrapSelectorResult.bind(this), this.expressionRegistry, this.evaluateSelector.bind(this));
-    }
-    async evaluateMethodCall(callee, args, context) {
-        return evaluateMethodCall(callee, args, context, this.evaluate.bind(this), this.unwrapSelectorResult.bind(this));
-    }
-    async evaluateSelector(node, context) {
-        return evaluateSelector(node, context);
-    }
-    evaluateAttributeAccess(node, context) {
-        if (context.me && typeof context.me.getAttribute === 'function') {
-            return accessAttribute(context.me, node.attributeName);
-        }
-        return `@${node.attributeName}`;
-    }
-    async evaluateAsExpression(node, context) {
-        const value = await this.evaluate(node.expression, context);
-        const asExpr = this.expressionRegistry.get('as');
-        if (asExpr) {
-            return asExpr.evaluate(context, value, node.targetType);
-        }
-        throw new Error(`Conversion type 'as' not registered`);
-    }
-    getAvailableExpressions() {
-        return Array.from(this.expressionRegistry.keys());
-    }
-    async evaluateDollarExpression(node, context) {
-        const value = await this.evaluate(node.expression, context);
-        if (node.expression.type === 'identifier') {
-            const varName = node.expression.name;
-            if (/^\d+$/.test(varName)) {
-                return varName;
-            }
-            if (context.locals?.has(varName)) {
-                return context.locals.get(varName);
-            }
-            if (varName === 'me' && context.me)
-                return context.me;
-            if (varName === 'you' && context.you)
-                return context.you;
-            if (varName === 'it' && context.it)
-                return context.it;
-            if (varName === 'result' && context.result)
-                return context.result;
-            if (typeof window !== 'undefined' && varName === 'window') {
-                return window;
-            }
-            if (context.globals?.has(varName)) {
-                return context.globals.get(varName);
-            }
-            return undefined;
-        }
-        return value;
-    }
-    async evaluatePossessiveExpression(node, context) {
-        const { object, property } = node;
-        const objectValue = this.unwrapSelectorResult(await this.evaluate(object, context));
-        if (!objectValue) {
-            return undefined;
-        }
-        const propertyName = extractPropertyName(property);
-        if (typeof propertyName === 'string') {
-            if (isElement(objectValue)) {
-                return getElementProperty(objectValue, propertyName);
-            }
-            return objectValue[propertyName];
-        }
-        return objectValue[propertyName];
-    }
-    hasExpression(name) {
-        return this.expressionRegistry.has(name);
-    }
-    async evaluateCSSSelector(node, context) {
-        return evaluateCSSSelector(node, context);
-    }
-    async evaluateIdSelector(node, context) {
-        return evaluateIdSelector(node, context);
-    }
-    async evaluateQueryReference(node, context) {
-        return evaluateQueryReference(node, context);
-    }
-    async evaluatePropertyAccess(node, context) {
-        const object = await this.evaluate(node.object, context);
-        const propertyNode = node.property;
-        if (object === null || object === undefined) {
-            throw new Error(`Cannot access property "${propertyNode.name || propertyNode.value}" of ${object}`);
-        }
-        const propertyName = propertyNode.name || propertyNode.value;
-        if (!propertyName) {
-            throw new Error('Property name must be an identifier');
-        }
-        try {
-            let value;
-            if (isElement(object)) {
-                value = getElementProperty(object, propertyName);
-            }
-            else {
-                value = object[propertyName];
-            }
-            if (typeof value === 'function') {
-                return value.bind(object);
-            }
-            return value;
-        }
-        catch (error) {
-            throw new Error(`Error accessing property "${propertyName}": ${error}`);
-        }
-    }
-    async evaluatePropertyOfExpression(node, context) {
-        const propertyNode = node.property;
-        const propertyName = propertyNode.name || propertyNode.value;
-        if (!propertyName) {
-            throw new Error('Property name must be an identifier in "the X of Y" pattern');
-        }
-        const target = this.unwrapSelectorResult(await this.evaluate(node.target, context));
-        if (target === null || target === undefined) {
-            throw new Error(`Cannot access property "${propertyName}" of ${target}`);
-        }
-        try {
-            let value;
-            if (isElement(target)) {
-                value = getElementProperty(target, propertyName);
-            }
-            else {
-                value = target[propertyName];
-            }
-            if (typeof value === 'function') {
-                return value.bind(target);
-            }
-            return value;
-        }
-        catch (error) {
-            throw new Error(`Failed to access property "${propertyName}" on target: ${error}`);
-        }
+            coerceFrom: {
+                String: v => {
+                    try {
+                        const parsed = JSON.parse(v);
+                        if (typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed)) {
+                            return parsed;
+                        }
+                    }
+                    catch {
+                    }
+                    return null;
+                },
+                Array: v => {
+                    const arr = v;
+                    const obj = {};
+                    arr.forEach((item, index) => {
+                        obj[String(index)] = item;
+                    });
+                    return obj;
+                },
+            },
+        });
+        this.register({
+            name: 'Null',
+            hyperscriptType: 'null',
+            tsType: 'null',
+            isType: (v) => v === null,
+            defaultValue: null,
+            description: 'Null value',
+        });
+        this.register({
+            name: 'Undefined',
+            hyperscriptType: 'undefined',
+            tsType: 'undefined',
+            isType: (v) => v === undefined,
+            defaultValue: undefined,
+            description: 'Undefined value',
+        });
+        this.register({
+            name: 'Function',
+            hyperscriptType: 'function',
+            tsType: 'Function',
+            isType: (v) => typeof v === 'function',
+            defaultValue: null,
+            description: 'JavaScript function',
+        });
+        this.register({
+            name: 'Event',
+            hyperscriptType: 'event',
+            tsType: 'Event',
+            isType: (v) => v instanceof Event,
+            defaultValue: null,
+            description: 'DOM Event',
+        });
+        this.register({
+            name: 'NodeList',
+            hyperscriptType: 'element-list',
+            tsType: 'NodeList',
+            isType: (v) => v instanceof NodeList,
+            defaultValue: null,
+            description: 'DOM NodeList (typically from querySelectorAll)',
+            coerceFrom: {
+                Array: v => {
+                    return null;
+                },
+            },
+        });
+        this.register({
+            name: 'Unknown',
+            hyperscriptType: 'unknown',
+            tsType: 'unknown',
+            isType: (_v) => true,
+            defaultValue: null,
+            description: 'Unknown/any value type',
+        });
     }
 }
+const expressionTypeRegistry = new ExpressionTypeRegistry();
 
-class ConfigurableExpressionEvaluator extends BaseExpressionEvaluator {
-    constructor(categories) {
-        super();
-        for (const category of categories) {
-            this.registerCategory(category);
-        }
-    }
+function isString(value) {
+    const stringType = expressionTypeRegistry.get('String');
+    return stringType ? stringType.isType(value) : typeof value === 'string';
+}
+function isNumber(value) {
+    const numberType = expressionTypeRegistry.get('Number');
+    return numberType ? numberType.isType(value) : typeof value === 'number';
+}
+function isBoolean(value) {
+    const boolType = expressionTypeRegistry.get('Boolean');
+    return boolType ? boolType.isType(value) : typeof value === 'boolean';
+}
+function isObject(value) {
+    const objectType = expressionTypeRegistry.get('Object');
+    return objectType ? objectType.isType(value) : typeof value === 'object' && value !== null;
+}
+function isFunction(value) {
+    const funcType = expressionTypeRegistry.get('Function');
+    return funcType ? funcType.isType(value) : typeof value === 'function';
 }
 
 const NUMBER_WORDS = {
@@ -2746,7 +1311,7 @@ const meExpression = {
     category: 'Reference',
     evaluatesTo: 'Element',
     async evaluate(context) {
-        return context.me instanceof HTMLElement ? context.me : null;
+        return context.me ?? null;
     },
     validate: validateNoArgs,
 };
@@ -2755,7 +1320,7 @@ const youExpression = {
     category: 'Reference',
     evaluatesTo: 'Element',
     async evaluate(context) {
-        return context.you instanceof HTMLElement ? context.you : null;
+        return context.you ?? null;
     },
     validate: validateNoArgs,
 };
@@ -3434,6 +1999,39 @@ function toNumberOrNull(value) {
     }
     return null;
 }
+function ensureFinite(num, operation) {
+    if (!Number.isFinite(num)) {
+        if (Number.isNaN(num)) {
+            throw new Error(`${operation} resulted in non-finite value: NaN`);
+        }
+        throw new Error(`${operation} resulted in non-finite value: ${num > 0 ? 'Infinity' : '-Infinity'}`);
+    }
+    return num;
+}
+function canBeNumeric(value) {
+    try {
+        toNumber(value, '_');
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function safeDivide(left, right, allowInfinity = true) {
+    if (right === 0) {
+        if (allowInfinity) {
+            return left === 0 ? NaN : left > 0 ? Infinity : -Infinity;
+        }
+        throw new Error('Division by zero');
+    }
+    return left / right;
+}
+function safeModulo(left, right) {
+    if (right === 0) {
+        throw new Error('Modulo by zero');
+    }
+    return left % right;
+}
 
 function compareValues(left, right, operator) {
     if (operator === '===') {
@@ -3543,6 +2141,44 @@ function coerceToComparable(left, right) {
     return [String(left), String(right)];
 }
 
+function validResult() {
+    return {
+        isValid: true,
+        errors: [],
+        suggestions: [],
+    };
+}
+function invalidResult(errors, suggestions = []) {
+    return {
+        isValid: false,
+        errors,
+        suggestions,
+    };
+}
+function createError(type, message, suggestions = [], severity = 'error') {
+    return { type, message, suggestions, severity };
+}
+function validateBinaryInput(input) {
+    if (input === null || input === undefined) {
+        return invalidResult([createError('missing-argument', 'Input is null or undefined')], ['Provide an object with left and right operands']);
+    }
+    if (typeof input !== 'object') {
+        return invalidResult([createError('type-mismatch', `Expected object, got ${typeof input}`)], ['Provide an object with left and right operands']);
+    }
+    const obj = input;
+    if (!('left' in obj) || !('right' in obj)) {
+        const missing = [];
+        if (!('left' in obj))
+            missing.push('left');
+        if (!('right' in obj))
+            missing.push('right');
+        return invalidResult([
+            createError('missing-argument', `Missing ${missing.join(' and ')} operand${missing.length > 1 ? 's' : ''}`),
+        ], ['Provide { left: value, right: value }']);
+    }
+    return validResult();
+}
+
 function trackEvaluation(expression, context, args, result, startTime, success = true, error) {
     if (context &&
         typeof context === 'object' &&
@@ -4191,10 +2827,6 @@ const noExpression = {
             result = value.length === 0;
         else if (isString(value))
             result = false;
-        else if (value instanceof Node || value instanceof Element)
-            result = false;
-        else if (isObject(value))
-            result = Object.keys(value).length === 0;
         else
             result = false;
         if (tracking)
@@ -4370,6 +3002,33 @@ const endsWithExpression = {
         return validateArgCount(args, 2, 'endsWith', 'str, suffix');
     },
 };
+const betweenExpression = {
+    name: 'between',
+    category: 'Logical',
+    evaluatesTo: 'Boolean',
+    operators: ['is between', 'between'],
+    async evaluate(context, value, min, max) {
+        const tracking = context.evaluationHistory;
+        const startTime = tracking ? Date.now() : 0;
+        let lo = min;
+        let hi = max;
+        if (lo != null && hi != null && lo > hi) {
+            const swap = lo;
+            lo = hi;
+            hi = swap;
+        }
+        const result = lo != null &&
+            hi != null &&
+            value >= lo &&
+            value <= hi;
+        if (tracking)
+            trackEvaluation(this, context, [value, min, max], result, startTime);
+        return result;
+    },
+    validate(args) {
+        return validateArgCount(args, 3, 'between', 'value, min, max');
+    },
+};
 const matchesExpression = {
     name: 'matches',
     category: 'Logical',
@@ -4566,11 +3225,438 @@ const logicalExpressions = {
     doesNotContain: doesNotContainExpression,
     startsWith: startsWithExpression,
     endsWith: endsWithExpression,
+    between: betweenExpression,
     matches: matchesExpression,
     has: hasExpression,
     doesNotHave: doesNotHaveExpression,
 };
 
+function mergeFragments(...fragments) {
+    const merged = new Map();
+    for (const fragment of fragments) {
+        for (const [key, entry] of fragment) {
+            const existing = merged.get(key);
+            if (existing) {
+                merged.set(key, {
+                    prefix: entry.prefix ?? existing.prefix,
+                    infix: entry.infix ?? existing.infix,
+                });
+            }
+            else {
+                merged.set(key, { ...entry });
+            }
+        }
+    }
+    return merged;
+}
+function leftAssoc(bp, handler) {
+    return {
+        infix: {
+            bp: [bp, bp + 1],
+            handler: handler ??
+                ((left, token, ctx) => {
+                    const right = ctx.parseExpr(bp + 1);
+                    return {
+                        type: 'binaryExpression',
+                        operator: token.value,
+                        left,
+                        right,
+                        start: left.start,
+                        end: right.end ?? token.end,
+                        line: left.line ?? token.line,
+                        column: left.column ?? token.column,
+                    };
+                }),
+        },
+    };
+}
+function rightAssoc(bp, handler) {
+    return {
+        infix: {
+            bp: [bp + 1, bp],
+            handler: ((left, token, ctx) => {
+                    const right = ctx.parseExpr(bp);
+                    return {
+                        type: 'binaryExpression',
+                        operator: token.value,
+                        left,
+                        right,
+                        start: left.start,
+                        end: right.end ?? token.end,
+                        line: left.line ?? token.line,
+                        column: left.column ?? token.column,
+                    };
+                }),
+        },
+    };
+}
+function prefix(bp, handler) {
+    return {
+        prefix: {
+            bp,
+            handler: handler ??
+                ((token, ctx) => {
+                    const operand = ctx.parseExpr(bp);
+                    return {
+                        type: 'unaryExpression',
+                        operator: token.value,
+                        operand,
+                        argument: operand,
+                        prefix: true,
+                        start: token.start,
+                        end: operand.end ?? token.end,
+                        line: token.line,
+                        column: token.column,
+                    };
+                }),
+        },
+    };
+}
+const CORE_FRAGMENT = new Map([
+    ['or', leftAssoc(10)],
+    ['||', leftAssoc(10)],
+    ['and', leftAssoc(20)],
+    ['&&', leftAssoc(20)],
+    ['==', leftAssoc(30)],
+    ['!=', leftAssoc(30)],
+    ['<', leftAssoc(30)],
+    ['>', leftAssoc(30)],
+    ['<=', leftAssoc(30)],
+    ['>=', leftAssoc(30)],
+    ['is', leftAssoc(30)],
+    ['matches', leftAssoc(30)],
+    ['contains', leftAssoc(30)],
+    ['starts with', leftAssoc(30)],
+    ['ends with', leftAssoc(30)],
+    ['does not start with', leftAssoc(30)],
+    ['does not end with', leftAssoc(30)],
+    [
+        'is between',
+        leftAssoc(30, (left, _token, ctx) => {
+            const min = ctx.parseExpr(31);
+            const next = ctx.peek();
+            if (!next || next.value.toLowerCase() !== 'and') {
+                throw new Error(`between requires 'and' between min and max operands, got: ${next?.value ?? '<end>'}`);
+            }
+            ctx.advance();
+            const max = ctx.parseExpr(31);
+            return {
+                type: 'betweenExpression',
+                value: left,
+                min,
+                max,
+                negated: false,
+                start: left.start,
+                end: max.end,
+            };
+        }),
+    ],
+    [
+        'is not between',
+        leftAssoc(30, (left, _token, ctx) => {
+            const min = ctx.parseExpr(31);
+            const next = ctx.peek();
+            if (!next || next.value.toLowerCase() !== 'and') {
+                throw new Error(`between requires 'and' between min and max operands, got: ${next?.value ?? '<end>'}`);
+            }
+            ctx.advance();
+            const max = ctx.parseExpr(31);
+            return {
+                type: 'betweenExpression',
+                value: left,
+                min,
+                max,
+                negated: true,
+                start: left.start,
+                end: max.end,
+            };
+        }),
+    ],
+    [
+        'ignoring case',
+        {
+            infix: {
+                bp: [25, 26],
+                handler: (left, _token, _ctx) => {
+                    left.ignoringCase = true;
+                    return left;
+                },
+            },
+        },
+    ],
+    [
+        'where',
+        leftAssoc(28, (left, _token, ctx) => {
+            const predicate = ctx.parseExpr(29);
+            return {
+                type: 'collectionExpression',
+                operator: 'where',
+                collection: left,
+                right: predicate,
+                start: left.start,
+                end: predicate.end,
+            };
+        }),
+    ],
+    [
+        'sorted by',
+        leftAssoc(28, (left, _token, ctx) => {
+            const keyExpr = ctx.parseExpr(29);
+            let order = 'asc';
+            const next = ctx.peek();
+            if (next && typeof next.value === 'string') {
+                const v = next.value.toLowerCase();
+                if (v === 'asc' || v === 'ascending') {
+                    ctx.advance();
+                    order = 'asc';
+                }
+                else if (v === 'desc' || v === 'descending') {
+                    ctx.advance();
+                    order = 'desc';
+                }
+            }
+            return {
+                type: 'collectionExpression',
+                operator: 'sorted by',
+                collection: left,
+                right: keyExpr,
+                order,
+                start: left.start,
+                end: keyExpr.end,
+            };
+        }),
+    ],
+    [
+        'mapped to',
+        leftAssoc(28, (left, _token, ctx) => {
+            const expr = ctx.parseExpr(29);
+            return {
+                type: 'collectionExpression',
+                operator: 'mapped to',
+                collection: left,
+                right: expr,
+                start: left.start,
+                end: expr.end,
+            };
+        }),
+    ],
+    [
+        'split by',
+        leftAssoc(28, (left, _token, ctx) => {
+            const sep = ctx.parseExpr(29);
+            return {
+                type: 'collectionExpression',
+                operator: 'split by',
+                collection: left,
+                right: sep,
+                start: left.start,
+                end: sep.end,
+            };
+        }),
+    ],
+    [
+        'joined by',
+        leftAssoc(28, (left, _token, ctx) => {
+            const sep = ctx.parseExpr(29);
+            return {
+                type: 'collectionExpression',
+                operator: 'joined by',
+                collection: left,
+                right: sep,
+                start: left.start,
+                end: sep.end,
+            };
+        }),
+    ],
+    ['+', { ...leftAssoc(40), ...prefix(80) }],
+    ['-', { ...leftAssoc(40), ...prefix(80) }],
+    ['*', leftAssoc(50)],
+    ['/', leftAssoc(50)],
+    ['%', leftAssoc(50)],
+    ['mod', leftAssoc(50)],
+    ['^', rightAssoc(60)],
+    ['**', rightAssoc(60)],
+    [
+        'as',
+        leftAssoc(70, (left, token, ctx) => {
+            const targetType = ctx.parseExpr(71);
+            const peeked = ctx.peek();
+            if (peeked &&
+                peeked.value === ':' &&
+                targetType &&
+                targetType.type === 'identifier') {
+                ctx.advance();
+                const suffix = ctx.advance();
+                if (suffix && suffix.value !== undefined) {
+                    targetType.name = `${targetType.name}:${suffix.value}`;
+                    targetType.end = suffix.end;
+                }
+            }
+            return {
+                type: 'asExpression',
+                expression: left,
+                targetType,
+                start: left.start,
+                end: targetType.end ?? token.end,
+                line: left.line ?? token.line,
+                column: left.column ?? token.column,
+            };
+        }),
+    ],
+    ['not', prefix(80)],
+    ['!', prefix(80)],
+    ['no', prefix(80)],
+]);
+function makeTypeCheckHandler(negated) {
+    return (left, _token, ctx) => {
+        const typeToken = ctx.advance();
+        if (!typeToken || !typeToken.value) {
+            throw new Error(`Type check requires a type name after 'is ${negated ? 'not ' : ''}a/an', got: <end>`);
+        }
+        let nullOk = true;
+        const peeked = ctx.peek();
+        if (peeked && peeked.value === '!') {
+            ctx.advance();
+            nullOk = false;
+        }
+        return {
+            type: 'typeCheckExpression',
+            value: left,
+            typeName: typeToken.value,
+            nullOk,
+            negated,
+            start: left.start,
+            end: typeToken.end,
+        };
+    };
+}
+const PARSER_COMPARISON_FRAGMENT = new Map([
+    ['===', leftAssoc(30)],
+    ['!==', leftAssoc(30)],
+    ['is not', leftAssoc(30)],
+    ['am', leftAssoc(30)],
+    ['is in', leftAssoc(30)],
+    ['is not in', leftAssoc(30)],
+    ['precedes', leftAssoc(30)],
+    ['does not precede', leftAssoc(30)],
+    ['follows', leftAssoc(30)],
+    ['does not follow', leftAssoc(30)],
+    ['is a', leftAssoc(30, makeTypeCheckHandler(false))],
+    ['is an', leftAssoc(30, makeTypeCheckHandler(false))],
+    ['is not a', leftAssoc(30, makeTypeCheckHandler(true))],
+    ['is not an', leftAssoc(30, makeTypeCheckHandler(true))],
+    ['has', leftAssoc(30)],
+    ['have', leftAssoc(30)],
+    ['match', leftAssoc(30)],
+    ['include', leftAssoc(30)],
+    ['includes', leftAssoc(30)],
+    ['equals', leftAssoc(30)],
+    ['does not contain', leftAssoc(30)],
+    ['does not include', leftAssoc(30)],
+    ['is equal to', leftAssoc(30)],
+    ['is not equal to', leftAssoc(30)],
+    ['is really equal to', leftAssoc(30)],
+    ['is not really equal to', leftAssoc(30)],
+    ['really equals', leftAssoc(30)],
+    ['is greater than', leftAssoc(30)],
+    ['is less than', leftAssoc(30)],
+    ['is greater than or equal to', leftAssoc(30)],
+    ['is less than or equal to', leftAssoc(30)],
+    ['in', leftAssoc(30)],
+    ['of', leftAssoc(30)],
+    ['really', leftAssoc(30)],
+    [
+        'exists',
+        {
+            prefix: {
+                bp: 80,
+                handler: (token, ctx) => ({
+                    type: 'unaryExpression',
+                    operator: token.value,
+                    operand: ctx.parseExpr(80),
+                    start: token.start,
+                }),
+            },
+            infix: {
+                bp: [30, 31],
+                handler: (left, token) => ({
+                    type: 'unaryExpression',
+                    operator: token.value,
+                    operand: left,
+                    prefix: false,
+                    start: left.start,
+                }),
+            },
+        },
+    ],
+    [
+        'does not exist',
+        {
+            infix: {
+                bp: [30, 31],
+                handler: (left, token) => ({
+                    type: 'unaryExpression',
+                    operator: token.value,
+                    operand: left,
+                    prefix: false,
+                    start: left.start,
+                }),
+            },
+        },
+    ],
+    [
+        'is empty',
+        {
+            infix: {
+                bp: [30, 31],
+                handler: (left, token) => ({
+                    type: 'unaryExpression',
+                    operator: token.value,
+                    operand: left,
+                    prefix: false,
+                    start: left.start,
+                }),
+            },
+        },
+    ],
+    [
+        'is not empty',
+        {
+            infix: {
+                bp: [30, 31],
+                handler: (left, token) => ({
+                    type: 'unaryExpression',
+                    operator: token.value,
+                    operand: left,
+                    prefix: false,
+                    start: left.start,
+                }),
+            },
+        },
+    ],
+    ['some', prefix(80)],
+]);
+const ASSIGNMENT_FRAGMENT = new Map([
+    ['=', rightAssoc(5)],
+]);
+mergeFragments(CORE_FRAGMENT, PARSER_COMPARISON_FRAGMENT, ASSIGNMENT_FRAGMENT);
+
+const LOCAL_READ_HOOKS = new Set();
+function notifyLocalRead(name, context) {
+    if (LOCAL_READ_HOOKS.size === 0)
+        return;
+    for (const hook of LOCAL_READ_HOOKS) {
+        try {
+            hook(name, context);
+        }
+        catch (err) {
+            if (typeof console !== 'undefined') {
+                console.error('[hyperfixi] localReadHook threw:', err);
+            }
+        }
+    }
+}
+
 const StringLiteralInputSchema = v
     .object({
     value: v.string().describe('String literal value'),
@@ -4684,6 +3770,7 @@ class StringLiteralExpression extends BaseExpressionImpl {
         if (varName === 'result' && context.result)
             return context.result;
         if (context.locals?.has(varName)) {
+            notifyLocalRead(varName, context);
             return context.locals.get(varName);
         }
         if (context.globals?.has(varName)) {
@@ -4793,7 +3880,7 @@ class BooleanLiteralExpression extends BaseExpressionImpl {
         }
     }
 }
-class AdditionExpression extends BaseExpressionImpl {
+let AdditionExpression$1 = class AdditionExpression extends BaseExpressionImpl {
     constructor() {
         super(...arguments);
         this.name = 'addition';
@@ -4840,7 +3927,7 @@ class AdditionExpression extends BaseExpressionImpl {
             ]);
         }
     }
-}
+};
 class StringConcatenationExpression extends BaseExpressionImpl {
     constructor() {
         super(...arguments);
@@ -4903,7 +3990,7 @@ class StringConcatenationExpression extends BaseExpressionImpl {
         }
     }
 }
-class MultiplicationExpression extends BaseExpressionImpl {
+let MultiplicationExpression$1 = class MultiplicationExpression extends BaseExpressionImpl {
     constructor() {
         super(...arguments);
         this.name = 'multiplication';
@@ -4950,7 +4037,7 @@ class MultiplicationExpression extends BaseExpressionImpl {
             ]);
         }
     }
-}
+};
 function createStringLiteralExpression() {
     return new StringLiteralExpression();
 }
@@ -4960,30 +4047,26 @@ function createNumberLiteralExpression() {
 function createBooleanLiteralExpression() {
     return new BooleanLiteralExpression();
 }
-function createAdditionExpression() {
-    return new AdditionExpression();
+function createAdditionExpression$1() {
+    return new AdditionExpression$1();
 }
 function createStringConcatenationExpression() {
     return new StringConcatenationExpression();
 }
-function createMultiplicationExpression() {
-    return new MultiplicationExpression();
+function createMultiplicationExpression$1() {
+    return new MultiplicationExpression$1();
 }
 const specialExpressions = {
     stringLiteral: createStringLiteralExpression(),
     numberLiteral: createNumberLiteralExpression(),
     booleanLiteral: createBooleanLiteralExpression(),
-    addition: createAdditionExpression(),
+    addition: createAdditionExpression$1(),
     stringConcatenation: createStringConcatenationExpression(),
-    multiplication: createMultiplicationExpression(),
+    multiplication: createMultiplicationExpression$1(),
 };
 
-function createCoreExpressionEvaluator() {
-    return new ConfigurableExpressionEvaluator([
-        referencesExpressions,
-        logicalExpressions,
-        specialExpressions,
-    ]);
+function createCoreRegistry() {
+    return createExpressionRegistry(referencesExpressions, logicalExpressions, specialExpressions);
 }
 
 function converterError(name, code, message, suggestions, type = 'runtime-error') {
@@ -5098,11 +4181,21 @@ const enhancedConverters = {
         }
     },
     JSON: (value, _context) => {
+        if (!isString(value))
+            return success(value, 'object');
+        try {
+            return success(JSON.parse(value), 'object');
+        }
+        catch (error) {
+            return converterError('JSON', 'JSON_PARSE_FAILED', errorMsg('Failed to parse value as JSON', error), ['Check JSON syntax and escaping', 'Use `as JSONString` to stringify a value instead'], 'syntax-error');
+        }
+    },
+    JSONString: (value, _context) => {
         try {
             return success(JSON.stringify(value), 'string');
         }
         catch (error) {
-            return converterError('JSON', 'JSON_STRINGIFY_FAILED', errorMsg('Failed to convert value to JSON', error), [
+            return converterError('JSONString', 'JSON_STRINGIFY_FAILED', errorMsg('Failed to stringify value as JSON', error), [
                 'Check for circular references',
                 'Ensure all properties are serializable',
                 'Remove functions and undefined values',
@@ -5156,6 +4249,35 @@ const enhancedConverters = {
             ]);
         }
     },
+    FormEncoded: (value, context) => {
+        try {
+            let values = value;
+            if (value instanceof HTMLElement) {
+                const extracted = enhancedConverters.Values(value, context);
+                if (!extracted.success)
+                    return extracted;
+                values = extracted.value;
+            }
+            if (!isObject(values))
+                return success('', 'string');
+            const params = new URLSearchParams();
+            for (const [k, v] of Object.entries(values)) {
+                if (v === undefined || v === null)
+                    continue;
+                if (Array.isArray(v)) {
+                    for (const item of v)
+                        params.append(k, String(item));
+                }
+                else {
+                    params.append(k, String(v));
+                }
+            }
+            return success(params.toString(), 'string');
+        }
+        catch (error) {
+            return converterError('FormEncoded', 'FORM_ENCODE_FAILED', errorMsg('Failed to URL-encode values', error), ['Ensure input is a form element or plain object of scalar/array values']);
+        }
+    },
 };
 const AsExpressionInputSchema = v.object({
     value: v.any(),
@@ -5188,10 +4310,15 @@ class AsExpression extends BaseExpressionImpl {
                     expectedOutput: { name: 'John', age: '25' },
                 },
                 {
-                    input: '[1,2,3] as JSON',
-                    description: 'Convert array to JSON string',
+                    input: '[1,2,3] as JSONString',
+                    description: 'Convert array to JSON string (upstream 0.9.90: use JSONString, not JSON)',
                     expectedOutput: '[1,2,3]',
                 },
+                {
+                    input: '\'{"a":1}\' as JSON',
+                    description: 'Parse a JSON string (upstream 0.9.90: as JSON now parses)',
+                    expectedOutput: { a: 1 },
+                },
                 {
                     input: '"2023-12-25" as Date',
                     description: 'Parse date string',
@@ -5256,8 +4383,8 @@ class AsExpression extends BaseExpressionImpl {
                 },
                 {
                     title: 'Array to JSON serialization',
-                    code: 'put items as JSON into storage',
-                    explanation: 'Convert array to JSON string for storage',
+                    code: 'put items as JSONString into storage',
+                    explanation: 'Convert array to JSON string for storage (upstream 0.9.90: use `as JSONString`)',
                     output: '"[1,2,3]"',
                 },
                 {
@@ -5328,6 +4455,8 @@ class AsExpression extends BaseExpressionImpl {
                 obj: 'Object',
                 date: 'Date',
                 json: 'JSON',
+                jsonstring: 'JSONString',
+                formencoded: 'FormEncoded',
             };
             const aliasedType = typeAliases[lowerType];
             if (aliasedType) {
@@ -5674,14 +4803,24 @@ const defaultConversions = {
             const [year, month, day] = value.split('-').map(Number);
             return new Date(year, month - 1, day);
         }
-        const date = new Date(value);
-        return date;
+        const date = new Date(value);
+        return date;
+    },
+    JSON: (value) => {
+        if (!isString(value))
+            return value;
+        try {
+            return JSON.parse(value);
+        }
+        catch {
+            return value;
+        }
     },
-    JSON: (value) => {
+    JSONString: (value) => {
         try {
             return JSON.stringify(value);
         }
-        catch (error) {
+        catch {
             return '{}';
         }
     },
@@ -5741,9 +4880,27 @@ const defaultConversions = {
         }
         return {};
     },
+    FormEncoded: (value, context) => {
+        const values = value instanceof HTMLElement ? defaultConversions.Values(value, context) : value;
+        if (!isObject(values))
+            return '';
+        const params = new URLSearchParams();
+        for (const [k, v] of Object.entries(values)) {
+            if (v === undefined || v === null)
+                continue;
+            if (Array.isArray(v)) {
+                for (const item of v)
+                    params.append(k, String(item));
+            }
+            else {
+                params.append(k, String(v));
+            }
+        }
+        return params.toString();
+    },
     'Values:Form': (value, context) => {
         const values = defaultConversions.Values(value, context);
-        return new URLSearchParams(values).toString();
+        return defaultConversions.FormEncoded(values, context);
     },
     'Values:JSON': (value, context) => {
         const values = defaultConversions.Values(value, context);
@@ -5859,6 +5016,8 @@ const asExpression = {
             obj: 'Object',
             date: 'Date',
             json: 'JSON',
+            jsonstring: 'JSONString',
+            formencoded: 'FormEncoded',
         };
         const aliasedType = typeAliases[lowerType];
         if (aliasedType) {
@@ -6597,14 +5756,127 @@ const positionalExpressions = {
     previousWithin: previousWithinExpression,
 };
 
-function createCommonExpressionEvaluator() {
-    return new ConfigurableExpressionEvaluator([
-        referencesExpressions,
-        logicalExpressions,
-        specialExpressions,
-        conversionExpressions,
-        positionalExpressions,
-    ]);
+function createCommonRegistry() {
+    return createExpressionRegistry(referencesExpressions, logicalExpressions, specialExpressions, conversionExpressions, positionalExpressions);
+}
+
+function isInputElement(el) {
+    return (el !== null && typeof el === 'object' && 'tagName' in el && el.tagName === 'INPUT');
+}
+function isFormElement(el) {
+    if (el === null || typeof el !== 'object' || !('tagName' in el)) {
+        return false;
+    }
+    const tag = el.tagName;
+    return tag === 'INPUT' || tag === 'SELECT' || tag === 'TEXTAREA';
+}
+function isHTMLElement$1(el) {
+    return (el !== null &&
+        typeof el === 'object' &&
+        'nodeType' in el &&
+        el.nodeType === 1 &&
+        'style' in el);
+}
+function isOptionElement(el) {
+    return (el !== null &&
+        typeof el !== 'undefined' &&
+        typeof el === 'object' &&
+        'tagName' in el &&
+        el.tagName === 'OPTION');
+}
+
+function isHTMLElement(value) {
+    return value instanceof HTMLElement;
+}
+const BOOLEAN_ATTRIBUTES = new Set([
+    'disabled',
+    'readonly',
+    'required',
+    'checked',
+    'selected',
+    'hidden',
+    'open',
+    'autofocus',
+    'autoplay',
+    'controls',
+    'loop',
+    'muted',
+    'multiple',
+    'reversed',
+    'defer',
+    'async',
+    'novalidate',
+    'formnovalidate',
+    'ismap',
+]);
+function accessAttribute(element, attrName) {
+    if (BOOLEAN_ATTRIBUTES.has(attrName.toLowerCase())) {
+        return element.hasAttribute(attrName);
+    }
+    return element.getAttribute(attrName);
+}
+function hasAttribute(element, attrName) {
+    return element.hasAttribute(attrName);
+}
+const SPECIAL_DOM_PROPERTIES = {
+    id: el => el.id,
+    classname: el => el.className,
+    class: el => el.className,
+    tagname: el => el.tagName.toLowerCase(),
+    innertext: el => el.textContent?.trim(),
+    innerHTML: el => el.innerHTML,
+    outerhtml: el => el.outerHTML,
+    value: el => (isFormElement(el) ? el.value : undefined),
+    checked: el => (isInputElement(el) ? el.checked : undefined),
+    disabled: el => ('disabled' in el ? el.disabled : undefined),
+    selected: el => (isOptionElement(el) ? el.selected : undefined),
+    tabindex: el => (isHTMLElement$1(el) ? el.tabIndex : undefined),
+    hidden: el => (isHTMLElement$1(el) ? el.hidden : undefined),
+    style: el => getComputedStyle(el),
+    children: el => Array.from(el.children),
+    parent: el => el.parentElement,
+    firstchild: el => el.firstElementChild,
+    lastchild: el => el.lastElementChild,
+    nextsibling: el => el.nextElementSibling,
+    previoussibling: el => el.previousElementSibling,
+    values: el => collectFormValues(el),
+};
+function collectFormValues(el) {
+    if (el instanceof HTMLFormElement)
+        return new FormData(el);
+    const fd = new FormData();
+    el.querySelectorAll('input, select, textarea').forEach((input) => {
+        const name = input.getAttribute('name');
+        if (name && 'value' in input)
+            fd.append(name, input.value);
+    });
+    return fd;
+}
+function getElementProperty(element, property) {
+    if (property.startsWith('computed-')) {
+        const cssProperty = property.slice('computed-'.length);
+        if (isHTMLElement(element)) {
+            const computedStyle = getComputedStyle(element);
+            return computedStyle.getPropertyValue(cssProperty);
+        }
+        return undefined;
+    }
+    if (property.startsWith('@')) {
+        const attrName = property.slice(1);
+        return accessAttribute(element, attrName);
+    }
+    const specialHandler = SPECIAL_DOM_PROPERTIES[property.toLowerCase()];
+    if (specialHandler) {
+        return specialHandler(element);
+    }
+    if (hasAttribute(element, property)) {
+        return accessAttribute(element, property);
+    }
+    const value = element[property];
+    if (isFunction(value)) {
+        return value.bind(element);
+    }
+    return value;
 }
 
 const UNSAFE_PROPS = new Set(['__proto__', 'constructor', 'prototype']);
@@ -6846,24 +6118,279 @@ const propertiesExpressions = {
     idReference: idReferenceExpression,
 };
 
-function createFullExpressionEvaluator() {
-    return new ConfigurableExpressionEvaluator([
-        referencesExpressions,
-        logicalExpressions,
-        specialExpressions,
-        conversionExpressions,
-        positionalExpressions,
-        propertiesExpressions,
-    ]);
+function createFullRegistry() {
+    return createExpressionRegistry(referencesExpressions, logicalExpressions, specialExpressions, conversionExpressions, positionalExpressions, propertiesExpressions);
+}
+
+class AdditionExpression {
+    constructor() {
+        this.name = 'addition';
+        this.category = 'Special';
+        this.syntax = 'left + right';
+        this.outputType = 'number';
+        this.metadata = { category: 'Special', complexity: 'simple' };
+    }
+    async evaluate(_context, input) {
+        const validation = this.validate(input);
+        if (!validation.isValid) {
+            return { success: false, errors: validation.errors, suggestions: validation.suggestions };
+        }
+        try {
+            const { left, right } = input;
+            const leftNum = toNumber(left, 'left operand');
+            const rightNum = toNumber(right, 'right operand');
+            const result = ensureFinite(leftNum + rightNum, 'addition');
+            return { success: true, value: result, type: 'number' };
+        }
+        catch (error) {
+            return {
+                success: false,
+                errors: [
+                    createError('runtime-error', `Addition failed: ${error instanceof Error ? error.message : String(error)}`),
+                ],
+                suggestions: ['Ensure both operands are numeric'],
+            };
+        }
+    }
+    validate(input) {
+        const result = validateBinaryInput(input);
+        if (!result.isValid)
+            return result;
+        const { left, right } = input;
+        if (!canBeNumeric(left)) {
+            return {
+                isValid: false,
+                errors: [
+                    createError('type-mismatch', `Left operand cannot be converted to number: ${String(left)}`),
+                ],
+                suggestions: ['Provide a numeric value for left operand'],
+            };
+        }
+        if (!canBeNumeric(right)) {
+            return {
+                isValid: false,
+                errors: [
+                    createError('type-mismatch', `Right operand cannot be converted to number: ${String(right)}`),
+                ],
+                suggestions: ['Provide a numeric value for right operand'],
+            };
+        }
+        return { isValid: true, errors: [], suggestions: [] };
+    }
+}
+class SubtractionExpression {
+    constructor() {
+        this.name = 'subtraction';
+        this.category = 'Special';
+        this.syntax = 'left - right';
+        this.outputType = 'number';
+        this.metadata = { category: 'Special', complexity: 'simple' };
+    }
+    async evaluate(_context, input) {
+        const validation = this.validate(input);
+        if (!validation.isValid) {
+            return { success: false, errors: validation.errors, suggestions: validation.suggestions };
+        }
+        try {
+            const { left, right } = input;
+            const leftNum = toNumber(left, 'left operand');
+            const rightNum = toNumber(right, 'right operand');
+            const result = ensureFinite(leftNum - rightNum, 'subtraction');
+            return { success: true, value: result, type: 'number' };
+        }
+        catch (error) {
+            return {
+                success: false,
+                errors: [
+                    createError('runtime-error', `Subtraction failed: ${error instanceof Error ? error.message : String(error)}`),
+                ],
+                suggestions: ['Ensure both operands are numeric'],
+            };
+        }
+    }
+    validate(input) {
+        const addExpr = new AdditionExpression();
+        return addExpr.validate(input);
+    }
+}
+class MultiplicationExpression {
+    constructor() {
+        this.name = 'multiplication';
+        this.category = 'Special';
+        this.syntax = 'left * right';
+        this.outputType = 'number';
+        this.metadata = { category: 'Special', complexity: 'simple' };
+    }
+    async evaluate(_context, input) {
+        const validation = this.validate(input);
+        if (!validation.isValid) {
+            return { success: false, errors: validation.errors, suggestions: validation.suggestions };
+        }
+        try {
+            const { left, right } = input;
+            const leftNum = toNumber(left, 'left operand');
+            const rightNum = toNumber(right, 'right operand');
+            const result = ensureFinite(leftNum * rightNum, 'multiplication');
+            return { success: true, value: result, type: 'number' };
+        }
+        catch (error) {
+            return {
+                success: false,
+                errors: [
+                    createError('runtime-error', `Multiplication failed: ${error instanceof Error ? error.message : String(error)}`),
+                ],
+                suggestions: ['Ensure both operands are numeric'],
+            };
+        }
+    }
+    validate(input) {
+        const addExpr = new AdditionExpression();
+        return addExpr.validate(input);
+    }
+}
+class DivisionExpression {
+    constructor() {
+        this.name = 'division';
+        this.category = 'Special';
+        this.syntax = 'left / right';
+        this.outputType = 'number';
+        this.metadata = { category: 'Special', complexity: 'simple' };
+    }
+    async evaluate(_context, input) {
+        const validation = this.validate(input);
+        if (!validation.isValid) {
+            return { success: false, errors: validation.errors, suggestions: validation.suggestions };
+        }
+        try {
+            const { left, right } = input;
+            const leftNum = toNumber(left, 'left operand');
+            const rightNum = toNumber(right, 'right operand');
+            const result = safeDivide(leftNum, rightNum, true);
+            return { success: true, value: result, type: 'number' };
+        }
+        catch (error) {
+            return {
+                success: false,
+                errors: [
+                    createError('runtime-error', `Division failed: ${error instanceof Error ? error.message : String(error)}`),
+                ],
+                suggestions: ['Ensure both operands are numeric'],
+            };
+        }
+    }
+    validate(input) {
+        const addExpr = new AdditionExpression();
+        return addExpr.validate(input);
+    }
+}
+class ModuloExpression {
+    constructor() {
+        this.name = 'modulo';
+        this.category = 'Special';
+        this.syntax = 'left mod right';
+        this.outputType = 'number';
+        this.metadata = { category: 'Special', complexity: 'simple' };
+    }
+    async evaluate(_context, input) {
+        const validation = this.validate(input);
+        if (!validation.isValid) {
+            return { success: false, errors: validation.errors, suggestions: validation.suggestions };
+        }
+        try {
+            const { left, right } = input;
+            const leftNum = toNumber(left, 'left operand');
+            const rightNum = toNumber(right, 'right operand');
+            const result = safeModulo(leftNum, rightNum);
+            return { success: true, value: result, type: 'number' };
+        }
+        catch (error) {
+            return {
+                success: false,
+                errors: [
+                    createError('runtime-error', `Modulo failed: ${error instanceof Error ? error.message : String(error)}`),
+                ],
+                suggestions: ['Ensure both operands are numeric and divisor is not zero'],
+            };
+        }
+    }
+    validate(input) {
+        const addExpr = new AdditionExpression();
+        return addExpr.validate(input);
+    }
+}
+class PowerExpression {
+    constructor() {
+        this.name = 'power';
+        this.category = 'Special';
+        this.syntax = 'left ** right';
+        this.outputType = 'number';
+        this.metadata = { category: 'Special', complexity: 'simple' };
+    }
+    async evaluate(_context, input) {
+        const validation = this.validate(input);
+        if (!validation.isValid) {
+            return { success: false, errors: validation.errors, suggestions: validation.suggestions };
+        }
+        try {
+            const { left, right } = input;
+            const leftNum = toNumber(left, 'left operand');
+            const rightNum = toNumber(right, 'right operand');
+            const result = ensureFinite(Math.pow(leftNum, rightNum), 'power');
+            return { success: true, value: result, type: 'number' };
+        }
+        catch (error) {
+            return {
+                success: false,
+                errors: [
+                    createError('runtime-error', `Power failed: ${error instanceof Error ? error.message : String(error)}`),
+                ],
+                suggestions: ['Ensure both operands are numeric'],
+            };
+        }
+    }
+    validate(input) {
+        const addExpr = new AdditionExpression();
+        return addExpr.validate(input);
+    }
+}
+function createAdditionExpression() {
+    return new AdditionExpression();
+}
+function createSubtractionExpression() {
+    return new SubtractionExpression();
+}
+function createMultiplicationExpression() {
+    return new MultiplicationExpression();
+}
+function createDivisionExpression() {
+    return new DivisionExpression();
+}
+function createModuloExpression() {
+    return new ModuloExpression();
+}
+function createPowerExpression() {
+    return new PowerExpression();
+}
+const mathematicalExpressions = {
+    addition: createAdditionExpression(),
+    subtraction: createSubtractionExpression(),
+    multiplication: createMultiplicationExpression(),
+    division: createDivisionExpression(),
+    modulo: createModuloExpression(),
+    power: createPowerExpression(),
+};
+
+function createFullExpressionRegistry() {
+    return createExpressionRegistry(referencesExpressions, logicalExpressions, conversionExpressions, positionalExpressions, propertiesExpressions, specialExpressions, mathematicalExpressions);
 }
 
-exports.BaseExpressionEvaluator = BaseExpressionEvaluator;
-exports.ConfigurableExpressionEvaluator = ConfigurableExpressionEvaluator;
 exports.conversion = conversionExpressions;
 exports.conversionExpressions = conversionExpressions;
-exports.createCommonExpressionEvaluator = createCommonExpressionEvaluator;
-exports.createCoreExpressionEvaluator = createCoreExpressionEvaluator;
-exports.createFullExpressionEvaluator = createFullExpressionEvaluator;
+exports.createCommonRegistry = createCommonRegistry;
+exports.createCoreRegistry = createCoreRegistry;
+exports.createExpressionRegistry = createExpressionRegistry;
+exports.createFullExpressionRegistry = createFullExpressionRegistry;
+exports.createFullRegistry = createFullRegistry;
 exports.logical = logicalExpressions;
 exports.logicalExpressions = logicalExpressions;
 exports.positional = positionalExpressions;