@higher.archi/boe 1.0.0

package/dist/core/parser/operators/operator-table.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildOperatorTable = buildOperatorTable;
+exports.createDefaultOperatorTable = createDefaultOperatorTable;
+exports.isKnownOperator = isKnownOperator;
+exports.getCanonicalName = getCanonicalName;
+const aliases_1 = require("./aliases");
+const precedence_1 = require("./precedence");
+/**
+ * Builds the operator lookup table.
+ *
+ * The table maps every possible operator form (symbol, short name,
+ * full name) to its OperatorInfo. This allows O(1) lookup when
+ * tokenizing and parsing.
+ *
+ * Sources:
+ *   1. Static definitions in aliases.ts (core operators)
+ *   2. Dynamic operators from the registry (temporal, custom, etc.)
+ *
+ * @param registryOperators - Optional map of additional operators from registry
+ * @returns Complete operator table with all aliases resolved
+ */
+function buildOperatorTable(registryOperators) {
+    const table = new Map();
+    // ─────────────────────────────────────────────────────────────────────
+    // Add static operator definitions
+    // ─────────────────────────────────────────────────────────────────────
+    for (const [canonical, { def, aliases }] of Object.entries(aliases_1.OPERATOR_DEFINITIONS)) {
+        const info = {
+            canonical,
+            ...def
+        };
+        // Add the canonical name itself
+        table.set(canonical, info);
+        // Add all aliases pointing to same info
+        for (const alias of aliases) {
+            table.set(alias, info);
+        }
+    }
+    // ─────────────────────────────────────────────────────────────────────
+    // Add dynamic operators from registry (if provided)
+    // ─────────────────────────────────────────────────────────────────────
+    if (registryOperators) {
+        for (const [name, opDef] of registryOperators) {
+            // Skip if already defined in static definitions
+            if (table.has(name)) {
+                continue;
+            }
+            // Create operator info with sensible defaults
+            // Most registry operators are functions (temporal, etc.)
+            const info = {
+                canonical: name,
+                precedence: precedence_1.PRECEDENCE_PRIMARY, // Functions have highest precedence
+                associativity: 'none',
+                arity: 'binary' // Default assumption, parser handles variadic
+            };
+            table.set(name, info);
+            // Add any aliases
+            if (opDef.aliases) {
+                for (const alias of opDef.aliases) {
+                    if (!table.has(alias)) {
+                        table.set(alias, info);
+                    }
+                }
+            }
+        }
+    }
+    return table;
+}
+/**
+ * Creates a default operator table with just the static definitions.
+ * Use this when you don't have access to the full operator registry.
+ */
+function createDefaultOperatorTable() {
+    return buildOperatorTable();
+}
+/**
+ * Checks if a string is a known operator (in any form).
+ */
+function isKnownOperator(table, name) {
+    return table.has(name);
+}
+/**
+ * Gets the canonical name for an operator, or returns the input
+ * if it's not a known operator (might be a function).
+ */
+function getCanonicalName(table, name) {
+    const info = table.get(name);
+    return info ? info.canonical : name;
+}
+//# sourceMappingURL=operator-table.js.map

package/dist/core/parser/operators/operator-table.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"operator-table.js","sourceRoot":"","sources":["../../../../src/core/parser/operators/operator-table.ts"],"names":[],"mappings":";;AAkBA,gDA0DC;AAMD,gEAEC;AAKD,0CAKC;AAMD,4CAMC;AAzGD,uCAAiD;AACjD,6CAAkD;AAElD;;;;;;;;;;;;;GAaG;AACH,SAAgB,kBAAkB,CAChC,iBAAuD;IAEvD,MAAM,KAAK,GAAkB,IAAI,GAAG,EAAE,CAAC;IAEvC,wEAAwE;IACxE,kCAAkC;IAClC,wEAAwE;IACxE,KAAK,MAAM,CAAC,SAAS,EAAE,EAAE,GAAG,EAAE,OAAO,EAAE,CAAC,IAAI,MAAM,CAAC,OAAO,CACxD,8BAAoB,CACrB,EAAE,CAAC;QACF,MAAM,IAAI,GAAiB;YACzB,SAAS;YACT,GAAG,GAAG;SACP,CAAC;QAEF,gCAAgC;QAChC,KAAK,CAAC,GAAG,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC;QAE3B,wCAAwC;QACxC,KAAK,MAAM,KAAK,IAAI,OAAO,EAAE,CAAC;YAC5B,KAAK,CAAC,GAAG,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;QACzB,CAAC;IACH,CAAC;IAED,wEAAwE;IACxE,oDAAoD;IACpD,wEAAwE;IACxE,IAAI,iBAAiB,EAAE,CAAC;QACtB,KAAK,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,iBAAiB,EAAE,CAAC;YAC9C,gDAAgD;YAChD,IAAI,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;gBACpB,SAAS;YACX,CAAC;YAED,8CAA8C;YAC9C,yDAAyD;YACzD,MAAM,IAAI,GAAiB;gBACzB,SAAS,EAAE,IAAI;gBACf,UAAU,EAAE,+BAAkB,EAAE,oCAAoC;gBACpE,aAAa,EAAE,MAAM;gBACrB,KAAK,EAAE,QAAQ,CAAC,8CAA8C;aAC/D,CAAC;YAEF,KAAK,CAAC,GAAG,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;YAEtB,kBAAkB;YAClB,IAAI,KAAK,CAAC,OAAO,EAAE,CAAC;gBAClB,KAAK,MAAM,KAAK,IAAI,KAAK,CAAC,OAAO,EAAE,CAAC;oBAClC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC;wBACtB,KAAK,CAAC,GAAG,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;oBACzB,CAAC;gBACH,CAAC;YACH,CAAC;QACH,CAAC;IACH,CAAC;IAED,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;GAGG;AACH,SAAgB,0BAA0B;IACxC,OAAO,kBAAkB,EAAE,CAAC;AAC9B,CAAC;AAED;;GAEG;AACH,SAAgB,eAAe,CAC7B,KAAoB,EACpB,IAAY;IAEZ,OAAO,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;AACzB,CAAC;AAED;;;GAGG;AACH,SAAgB,gBAAgB,CAC9B,KAAoB,EACpB,IAAY;IAEZ,MAAM,IAAI,GAAG,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IAC7B,OAAO,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC;AACtC,CAAC"}

package/dist/core/parser/operators/precedence.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Operator Precedence Levels
+ *
+ * These constants define the binding power of operators.
+ * Higher numbers bind more tightly than lower numbers.
+ *
+ * For example, in "$a + $b * $c":
+ *   - * has higher precedence than +
+ *   - So it parses as $a + ($b * $c), not ($a + $b) * $c
+ *
+ * Precedence Scale (1-8):
+ *   1 - Logical OR (lowest, evaluated last)
+ *   2 - Logical AND
+ *   3 - Logical NOT (unary prefix)
+ *   4 - Comparison operators
+ *   5 - Addition and subtraction
+ *   6 - Multiplication and division
+ *   7 - Unary minus (negation)
+ *   8 - Function calls, literals, parentheses (highest)
+ *
+ * Note: Parentheses override precedence - they're always evaluated first.
+ */
+/** Logical OR: or, || */
+export declare const PRECEDENCE_OR = 1;
+/** Logical AND: and, && */
+export declare const PRECEDENCE_AND = 2;
+/** Logical NOT (unary): not, ! */
+export declare const PRECEDENCE_NOT = 3;
+/**
+ * Comparison operators:
+ *   - Relational: >, >=, <, <=, gt, gte, lt, lte
+ *   - Equality: ==, !=, equals, notEquals
+ *   - String: contains, startsWith, endsWith, matches
+ *   - Membership: in, notIn
+ *   - Temporal: isBefore, isAfter, isBetween
+ */
+export declare const PRECEDENCE_COMPARISON = 4;
+/** Addition and subtraction: +, - (binary) */
+export declare const PRECEDENCE_ADDITIVE = 5;
+/** Multiplication, division, modulo: *, /, % */
+export declare const PRECEDENCE_MULTIPLICATIVE = 6;
+/** Unary minus (negation): -$x */
+export declare const PRECEDENCE_UNARY = 7;
+/**
+ * Highest precedence:
+ *   - Function calls: daysAgo(7), now()
+ *   - Literals: 42, "hello", true
+ *   - Property refs: $age, $user.name
+ *   - Parenthesized expressions: ($a + $b)
+ */
+export declare const PRECEDENCE_PRIMARY = 8;
+/**
+ * Maps operator categories to their precedence level.
+ * Used by the operator table builder to assign precedence.
+ */
+export type OperatorCategory = 'logical-or' | 'logical-and' | 'logical-not' | 'comparison' | 'additive' | 'multiplicative' | 'unary' | 'primary';
+export declare function getPrecedenceForCategory(category: OperatorCategory): number;
+//# sourceMappingURL=precedence.d.ts.map

package/dist/core/parser/operators/precedence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"precedence.d.ts","sourceRoot":"","sources":["../../../../src/core/parser/operators/precedence.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,yBAAyB;AACzB,eAAO,MAAM,aAAa,IAAI,CAAC;AAE/B,2BAA2B;AAC3B,eAAO,MAAM,cAAc,IAAI,CAAC;AAEhC,kCAAkC;AAClC,eAAO,MAAM,cAAc,IAAI,CAAC;AAEhC;;;;;;;GAOG;AACH,eAAO,MAAM,qBAAqB,IAAI,CAAC;AAEvC,8CAA8C;AAC9C,eAAO,MAAM,mBAAmB,IAAI,CAAC;AAErC,gDAAgD;AAChD,eAAO,MAAM,yBAAyB,IAAI,CAAC;AAE3C,kCAAkC;AAClC,eAAO,MAAM,gBAAgB,IAAI,CAAC;AAElC;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,IAAI,CAAC;AAEpC;;;GAGG;AACH,MAAM,MAAM,gBAAgB,GACxB,YAAY,GACZ,aAAa,GACb,aAAa,GACb,YAAY,GACZ,UAAU,GACV,gBAAgB,GAChB,OAAO,GACP,SAAS,CAAC;AAEd,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,gBAAgB,GAAG,MAAM,CAmB3E"}

package/dist/core/parser/operators/precedence.js

@@ -0,0 +1,76 @@
+"use strict";
+/**
+ * Operator Precedence Levels
+ *
+ * These constants define the binding power of operators.
+ * Higher numbers bind more tightly than lower numbers.
+ *
+ * For example, in "$a + $b * $c":
+ *   - * has higher precedence than +
+ *   - So it parses as $a + ($b * $c), not ($a + $b) * $c
+ *
+ * Precedence Scale (1-8):
+ *   1 - Logical OR (lowest, evaluated last)
+ *   2 - Logical AND
+ *   3 - Logical NOT (unary prefix)
+ *   4 - Comparison operators
+ *   5 - Addition and subtraction
+ *   6 - Multiplication and division
+ *   7 - Unary minus (negation)
+ *   8 - Function calls, literals, parentheses (highest)
+ *
+ * Note: Parentheses override precedence - they're always evaluated first.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PRECEDENCE_PRIMARY = exports.PRECEDENCE_UNARY = exports.PRECEDENCE_MULTIPLICATIVE = exports.PRECEDENCE_ADDITIVE = exports.PRECEDENCE_COMPARISON = exports.PRECEDENCE_NOT = exports.PRECEDENCE_AND = exports.PRECEDENCE_OR = void 0;
+exports.getPrecedenceForCategory = getPrecedenceForCategory;
+/** Logical OR: or, || */
+exports.PRECEDENCE_OR = 1;
+/** Logical AND: and, && */
+exports.PRECEDENCE_AND = 2;
+/** Logical NOT (unary): not, ! */
+exports.PRECEDENCE_NOT = 3;
+/**
+ * Comparison operators:
+ *   - Relational: >, >=, <, <=, gt, gte, lt, lte
+ *   - Equality: ==, !=, equals, notEquals
+ *   - String: contains, startsWith, endsWith, matches
+ *   - Membership: in, notIn
+ *   - Temporal: isBefore, isAfter, isBetween
+ */
+exports.PRECEDENCE_COMPARISON = 4;
+/** Addition and subtraction: +, - (binary) */
+exports.PRECEDENCE_ADDITIVE = 5;
+/** Multiplication, division, modulo: *, /, % */
+exports.PRECEDENCE_MULTIPLICATIVE = 6;
+/** Unary minus (negation): -$x */
+exports.PRECEDENCE_UNARY = 7;
+/**
+ * Highest precedence:
+ *   - Function calls: daysAgo(7), now()
+ *   - Literals: 42, "hello", true
+ *   - Property refs: $age, $user.name
+ *   - Parenthesized expressions: ($a + $b)
+ */
+exports.PRECEDENCE_PRIMARY = 8;
+function getPrecedenceForCategory(category) {
+    switch (category) {
+        case 'logical-or':
+            return exports.PRECEDENCE_OR;
+        case 'logical-and':
+            return exports.PRECEDENCE_AND;
+        case 'logical-not':
+            return exports.PRECEDENCE_NOT;
+        case 'comparison':
+            return exports.PRECEDENCE_COMPARISON;
+        case 'additive':
+            return exports.PRECEDENCE_ADDITIVE;
+        case 'multiplicative':
+            return exports.PRECEDENCE_MULTIPLICATIVE;
+        case 'unary':
+            return exports.PRECEDENCE_UNARY;
+        case 'primary':
+            return exports.PRECEDENCE_PRIMARY;
+    }
+}
+//# sourceMappingURL=precedence.js.map

package/dist/core/parser/operators/precedence.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"precedence.js","sourceRoot":"","sources":["../../../../src/core/parser/operators/precedence.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;;;AAqDH,4DAmBC;AAtED,yBAAyB;AACZ,QAAA,aAAa,GAAG,CAAC,CAAC;AAE/B,2BAA2B;AACd,QAAA,cAAc,GAAG,CAAC,CAAC;AAEhC,kCAAkC;AACrB,QAAA,cAAc,GAAG,CAAC,CAAC;AAEhC;;;;;;;GAOG;AACU,QAAA,qBAAqB,GAAG,CAAC,CAAC;AAEvC,8CAA8C;AACjC,QAAA,mBAAmB,GAAG,CAAC,CAAC;AAErC,gDAAgD;AACnC,QAAA,yBAAyB,GAAG,CAAC,CAAC;AAE3C,kCAAkC;AACrB,QAAA,gBAAgB,GAAG,CAAC,CAAC;AAElC;;;;;;GAMG;AACU,QAAA,kBAAkB,GAAG,CAAC,CAAC;AAgBpC,SAAgB,wBAAwB,CAAC,QAA0B;IACjE,QAAQ,QAAQ,EAAE,CAAC;QACjB,KAAK,YAAY;YACf,OAAO,qBAAa,CAAC;QACvB,KAAK,aAAa;YAChB,OAAO,sBAAc,CAAC;QACxB,KAAK,aAAa;YAChB,OAAO,sBAAc,CAAC;QACxB,KAAK,YAAY;YACf,OAAO,6BAAqB,CAAC;QAC/B,KAAK,UAAU;YACb,OAAO,2BAAmB,CAAC;QAC7B,KAAK,gBAAgB;YACnB,OAAO,iCAAyB,CAAC;QACnC,KAAK,OAAO;YACV,OAAO,wBAAgB,CAAC;QAC1B,KAAK,SAAS;YACZ,OAAO,0BAAkB,CAAC;IAC9B,CAAC;AACH,CAAC"}

package/dist/core/parser/parser/expression.parser.d.ts

@@ -0,0 +1,34 @@
+import type { Token, OperatorTable } from '../types';
+/**
+ * Pratt Parser for Expressions
+ *
+ * This parser uses Vaughan Pratt's "top-down operator precedence" algorithm.
+ * It's elegant and handles operator precedence and associativity naturally.
+ *
+ * Key Insight:
+ * ────────────
+ * Each operator has a "binding power" (precedence). We parse the left side,
+ * then loop: if the next operator binds tighter than our current minimum,
+ * we consume it and recursively parse the right side.
+ *
+ * This creates the correct parse tree without complex grammar rules.
+ *
+ * Example: "$a + $b * $c"
+ *   1. Parse $a (primary)
+ *   2. See '+' (precedence 5), consume it
+ *   3. Parse right side with minPrecedence=6 (to get tighter ops)
+ *   4. That parses "$b * $c" as ['multiply', '$b', '$c']
+ *   5. Result: ['add', '$a', ['multiply', '$b', '$c']]
+ *
+ * Multi-Value Shorthand:
+ * ─────────────────────
+ * Special handling for patterns like: $status == 'a' or 'b' or 'c'
+ * This becomes: ['in', '$status', ['a', 'b', 'c']]
+ *
+ * Detection: When we see '==' or '!=' followed by 'or' with bare literals.
+ */
+/**
+ * Main parsing function - entry point for the Pratt parser.
+ */
+export declare function parseExpressionFromTokens(tokens: Token[], operatorTable: OperatorTable, input: string): any;
+//# sourceMappingURL=expression.parser.d.ts.map

package/dist/core/parser/parser/expression.parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expression.parser.d.ts","sourceRoot":"","sources":["../../../../src/core/parser/parser/expression.parser.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAKrD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH;;GAEG;AACH,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,KAAK,EAAE,EACf,aAAa,EAAE,aAAa,EAC5B,KAAK,EAAE,MAAM,GACZ,GAAG,CAqBL"}

package/dist/core/parser/parser/expression.parser.js

@@ -0,0 +1,250 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseExpressionFromTokens = parseExpressionFromTokens;
+const errors_1 = require("../errors");
+const primary_parser_1 = require("./primary.parser");
+/**
+ * Pratt Parser for Expressions
+ *
+ * This parser uses Vaughan Pratt's "top-down operator precedence" algorithm.
+ * It's elegant and handles operator precedence and associativity naturally.
+ *
+ * Key Insight:
+ * ────────────
+ * Each operator has a "binding power" (precedence). We parse the left side,
+ * then loop: if the next operator binds tighter than our current minimum,
+ * we consume it and recursively parse the right side.
+ *
+ * This creates the correct parse tree without complex grammar rules.
+ *
+ * Example: "$a + $b * $c"
+ *   1. Parse $a (primary)
+ *   2. See '+' (precedence 5), consume it
+ *   3. Parse right side with minPrecedence=6 (to get tighter ops)
+ *   4. That parses "$b * $c" as ['multiply', '$b', '$c']
+ *   5. Result: ['add', '$a', ['multiply', '$b', '$c']]
+ *
+ * Multi-Value Shorthand:
+ * ─────────────────────
+ * Special handling for patterns like: $status == 'a' or 'b' or 'c'
+ * This becomes: ['in', '$status', ['a', 'b', 'c']]
+ *
+ * Detection: When we see '==' or '!=' followed by 'or' with bare literals.
+ */
+/**
+ * Main parsing function - entry point for the Pratt parser.
+ */
+function parseExpressionFromTokens(tokens, operatorTable, input) {
+    const state = {
+        tokens,
+        position: 0,
+        operatorTable,
+        input
+    };
+    const result = parseExpr(state, 0);
+    // Ensure we consumed all tokens (except EOF)
+    const remaining = peek(state);
+    if (remaining.type !== 'EOF') {
+        throw new errors_1.SyntaxError(`Unexpected token after expression: ${remaining.type}`, remaining.position, input);
+    }
+    return result;
+}
+/**
+ * Recursive expression parser with precedence climbing.
+ *
+ * @param state - Parser state
+ * @param minPrecedence - Minimum precedence to parse (higher = tighter binding)
+ */
+function parseExpr(state, minPrecedence) {
+    // Parse the left-hand side (primary expression)
+    let left = (0, primary_parser_1.parsePrimary)(state, parseExpr);
+    // Loop while we see operators that bind at least as tight as minPrecedence
+    while (true) {
+        const token = peek(state);
+        // Stop if not an operator
+        if (token.type !== 'OPERATOR') {
+            break;
+        }
+        const opInfo = state.operatorTable.get(token.value);
+        if (!opInfo) {
+            // Unknown operator - stop here and let caller handle
+            break;
+        }
+        // Stop if operator doesn't bind tight enough
+        if (opInfo.precedence < minPrecedence) {
+            break;
+        }
+        // ─────────────────────────────────────────────────────────────────
+        // Multi-Value Shorthand Detection
+        // ─────────────────────────────────────────────────────────────────
+        // Check for: $x == 'a' or 'b' or 'c' pattern
+        // This should become: ['in', '$x', ['a', 'b', 'c']]
+        if (isComparisonOp(opInfo.canonical)) {
+            advance(state); // consume comparison operator
+            const firstValue = (0, primary_parser_1.parsePrimary)(state, parseExpr);
+            // Check for multi-value pattern: literal followed by 'or' and more literals
+            const multiValues = tryParseMultiValueShorthand(state, firstValue);
+            if (multiValues) {
+                // Transform to 'in' or 'notIn'
+                const inOp = opInfo.canonical === 'notEquals' ? 'notIn' : 'in';
+                left = [inOp, left, multiValues];
+                continue;
+            }
+            // Not a multi-value pattern - normal binary operation
+            left = [opInfo.canonical, left, firstValue];
+            continue;
+        }
+        // ─────────────────────────────────────────────────────────────────
+        // Variadic Flattening (and, or)
+        // ─────────────────────────────────────────────────────────────────
+        // Multiple 'and'/'or' at same level should flatten:
+        // $a and $b and $c → ['and', '$a', '$b', '$c'] (not nested)
+        if (opInfo.arity === 'variadic') {
+            advance(state); // consume operator
+            // Parse the right side with same precedence (left associative)
+            const right = parseExpr(state, opInfo.precedence + 1);
+            // Collect all operands at same level
+            const operands = [];
+            // Flatten left if it's the same operator
+            if (Array.isArray(left) && left[0] === opInfo.canonical) {
+                operands.push(...left.slice(1));
+            }
+            else {
+                operands.push(left);
+            }
+            // Flatten right if it's the same operator
+            if (Array.isArray(right) && right[0] === opInfo.canonical) {
+                operands.push(...right.slice(1));
+            }
+            else {
+                operands.push(right);
+            }
+            left = [opInfo.canonical, ...operands];
+            continue;
+        }
+        // ─────────────────────────────────────────────────────────────────
+        // Normal Binary Operators
+        // ─────────────────────────────────────────────────────────────────
+        advance(state); // consume operator
+        // Calculate next precedence based on associativity
+        // Left-associative: next must be higher to steal operand
+        // Right-associative: next can be same or higher
+        const nextMinPrecedence = opInfo.associativity === 'right'
+            ? opInfo.precedence
+            : opInfo.precedence + 1;
+        const right = parseExpr(state, nextMinPrecedence);
+        left = [opInfo.canonical, left, right];
+    }
+    return left;
+}
+// ═══════════════════════════════════════════════════════════════════════
+// Multi-Value Shorthand Handling
+// ═══════════════════════════════════════════════════════════════════════
+/**
+ * Checks if an operator is a comparison operator that can use multi-value shorthand.
+ * Only 'equals' and 'notEquals' support this pattern.
+ */
+function isComparisonOp(canonical) {
+    return canonical === 'equals' || canonical === 'notEquals';
+}
+/**
+ * Checks if a value is a "bare literal" (not a property ref or expression).
+ * Used to detect multi-value shorthand patterns.
+ */
+function isBareLiteral(value) {
+    if (value === null || typeof value === 'boolean' || typeof value === 'number') {
+        return true;
+    }
+    if (typeof value === 'string') {
+        // Property refs start with $
+        return !value.startsWith('$');
+    }
+    return false;
+}
+/**
+ * Tries to parse multi-value shorthand after an equals comparison.
+ *
+ * Pattern: == literal or literal or literal ...
+ *
+ * Returns array of values if pattern matches, null otherwise.
+ *
+ * Example: $status == 'a' or 'b' or 'c'
+ *   - firstValue: 'a'
+ *   - Sees 'or' followed by bare literal 'b'
+ *   - Collects: ['a', 'b', 'c']
+ *   - Returns: ['a', 'b', 'c']
+ *
+ * NOT a match: $a == 5 or $b == 6
+ *   - firstValue: 5
+ *   - Sees 'or' followed by property ref $b (not bare literal)
+ *   - Returns: null (normal OR handling takes over)
+ */
+function tryParseMultiValueShorthand(state, firstValue) {
+    // First value must be a bare literal
+    if (!isBareLiteral(firstValue)) {
+        return null;
+    }
+    // Check if followed by 'or'
+    const token = peek(state);
+    if (token.type !== 'OPERATOR') {
+        return null;
+    }
+    const opInfo = state.operatorTable.get(token.value);
+    if (!opInfo || opInfo.canonical !== 'or') {
+        return null;
+    }
+    // Peek ahead to see if the next primary is a bare literal
+    // We need to be careful here - don't consume tokens yet
+    // Save position for potential backtrack
+    const savedPosition = state.position;
+    // Consume 'or' and check next primary
+    advance(state);
+    const nextValue = (0, primary_parser_1.parsePrimary)(state, parseExpr);
+    if (!isBareLiteral(nextValue)) {
+        // Not a multi-value pattern - restore position
+        state.position = savedPosition;
+        return null;
+    }
+    // It's a multi-value pattern! Collect all values
+    const values = [firstValue, nextValue];
+    // Continue collecting while we see 'or' followed by bare literals
+    while (true) {
+        const orToken = peek(state);
+        if (orToken.type !== 'OPERATOR') {
+            break;
+        }
+        const orInfo = state.operatorTable.get(orToken.value);
+        if (!orInfo || orInfo.canonical !== 'or') {
+            break;
+        }
+        // Peek at what comes after 'or'
+        const posBeforeOr = state.position;
+        advance(state); // consume 'or'
+        const value = (0, primary_parser_1.parsePrimary)(state, parseExpr);
+        if (!isBareLiteral(value)) {
+            // Not a bare literal - backtrack and stop
+            state.position = posBeforeOr;
+            break;
+        }
+        values.push(value);
+    }
+    return values;
+}
+// ═══════════════════════════════════════════════════════════════════════
+// Helper Functions
+// ═══════════════════════════════════════════════════════════════════════
+/**
+ * Returns the current token without advancing.
+ */
+function peek(state) {
+    return state.tokens[state.position];
+}
+/**
+ * Advances to the next token.
+ */
+function advance(state) {
+    if (state.position < state.tokens.length - 1) {
+        state.position++;
+    }
+}
+//# sourceMappingURL=expression.parser.js.map

package/dist/core/parser/parser/expression.parser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"expression.parser.js","sourceRoot":"","sources":["../../../../src/core/parser/parser/expression.parser.ts"],"names":[],"mappings":"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"}

package/dist/core/parser/parser/function.parser.d.ts

@@ -0,0 +1,26 @@
+import type { ParserState, ParsedOperand } from './types';
+/**
+ * Parses function call syntax: functionName(arg1, arg2, ...)
+ *
+ * Function calls are used for both:
+ *   1. Operator functions: gt($a, 5), contains($str, "test")
+ *   2. Utility functions: daysAgo(7), now()
+ *
+ * Special handling for nullary functions (no arguments):
+ * ────────────────────────────────────────────────────────
+ * Some functions like now(), today(), yesterday() take no arguments.
+ * But our operator system expects at least one operand.
+ * So we output: now() → ['now', 0]
+ *
+ * The 0 is a dummy argument that the operator ignores.
+ * This maintains consistency with the S-expression format.
+ *
+ * Examples:
+ *   gt($a, 5)           → ['greaterThan', '$a', 5]
+ *   contains($x, "y")   → ['contains', '$x', 'y']
+ *   daysAgo(7)          → ['daysAgo', 7]
+ *   now()               → ['now', 0]
+ *   add($a, $b, $c)     → ['add', '$a', '$b', '$c']
+ */
+export declare function parseFunctionCall(state: ParserState, parseExpression: (state: ParserState, minPrecedence: number) => ParsedOperand): any[];
+//# sourceMappingURL=function.parser.d.ts.map

package/dist/core/parser/parser/function.parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"function.parser.d.ts","sourceRoot":"","sources":["../../../../src/core/parser/parser/function.parser.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAG1D;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,WAAW,EAClB,eAAe,EAAE,CAAC,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,KAAK,aAAa,GAC5E,GAAG,EAAE,CA8DP"}

package/dist/core/parser/parser/function.parser.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseFunctionCall = parseFunctionCall;
+const errors_1 = require("../errors");
+/**
+ * Parses function call syntax: functionName(arg1, arg2, ...)
+ *
+ * Function calls are used for both:
+ *   1. Operator functions: gt($a, 5), contains($str, "test")
+ *   2. Utility functions: daysAgo(7), now()
+ *
+ * Special handling for nullary functions (no arguments):
+ * ────────────────────────────────────────────────────────
+ * Some functions like now(), today(), yesterday() take no arguments.
+ * But our operator system expects at least one operand.
+ * So we output: now() → ['now', 0]
+ *
+ * The 0 is a dummy argument that the operator ignores.
+ * This maintains consistency with the S-expression format.
+ *
+ * Examples:
+ *   gt($a, 5)           → ['greaterThan', '$a', 5]
+ *   contains($x, "y")   → ['contains', '$x', 'y']
+ *   daysAgo(7)          → ['daysAgo', 7]
+ *   now()               → ['now', 0]
+ *   add($a, $b, $c)     → ['add', '$a', '$b', '$c']
+ */
+function parseFunctionCall(state, parseExpression) {
+    const funcToken = peek(state);
+    if (funcToken.type !== 'FUNCTION') {
+        throw new errors_1.SyntaxError(`Expected function name but found ${funcToken.type}`, funcToken.position, state.input);
+    }
+    const funcName = funcToken.value;
+    advance(state); // consume function name
+    // Get canonical name - prefer from token (set by tokenizer) or look up in table
+    // The tokenizer sets funcToken.canonical for known operators used as functions
+    const canonicalName = funcToken.canonical || funcName;
+    // Expect opening parenthesis
+    const openParen = peek(state);
+    if (openParen.type !== 'LPAREN') {
+        throw new errors_1.SyntaxError(`Expected '(' after function name '${funcName}'`, openParen.position, state.input);
+    }
+    advance(state); // consume '('
+    // Parse arguments
+    const args = [];
+    // Check for empty argument list: func()
+    if (peek(state).type !== 'RPAREN') {
+        // Parse first argument
+        args.push(parseExpression(state, 0));
+        // Parse remaining arguments (comma-separated)
+        while (peek(state).type === 'COMMA') {
+            advance(state); // consume ','
+            args.push(parseExpression(state, 0));
+        }
+    }
+    // Expect closing parenthesis
+    const closeParen = peek(state);
+    if (closeParen.type !== 'RPAREN') {
+        throw new errors_1.SyntaxError(`Expected ')' after function arguments`, closeParen.position, state.input);
+    }
+    advance(state); // consume ')'
+    // Handle nullary functions - add dummy argument
+    // This ensures consistent S-expression format: ['now', 0] not ['now']
+    if (args.length === 0) {
+        return [canonicalName, 0];
+    }
+    return [canonicalName, ...args];
+}
+// ═══════════════════════════════════════════════════════════════════════
+// Helper Functions
+// ═══════════════════════════════════════════════════════════════════════
+/**
+ * Returns the current token without advancing.
+ */
+function peek(state) {
+    return state.tokens[state.position];
+}
+/**
+ * Advances to the next token.
+ */
+function advance(state) {
+    if (state.position < state.tokens.length - 1) {
+        state.position++;
+    }
+}
+//# sourceMappingURL=function.parser.js.map