@routier/core 0.2.0 → 0.3.0

package/dist/expressions/index.js

@@ -1,17 +1,16 @@
 var __webpack_modules__ = ({
-"./src/assertions/index.ts"(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-__webpack_require__.r(__webpack_exports__);
+126(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
 __webpack_require__.d(__webpack_exports__, {
-  assertDate: () => (assertDate),
-  assertInstanceOf: () => (assertInstanceOf),
-  assertIsArray: () => (assertIsArray),
-  assertIsNotNull: () => (assertIsNotNull),
-  assertString: () => (assertString)
+  Cv: () => (assertString),
+  S6: () => (isValueExpression),
+  e3: () => (isPropertyExpression),
+  vg: () => (isOperatorExpression),
+  xH: () => (isComparatorExpression)
 });
-/* import */ var _utilities__rspack_import_0 = __webpack_require__("./src/utilities/dates.ts");
+
 
 function assertDate(data) {
-    if ((0,_utilities__rspack_import_0.isDate)(data) === false) {
+    if (isDate(data) === false) {
         throw new TypeError('Value is not a Date');
     }
 }
@@ -41,746 +40,1547 @@ function assertInstanceOf(value, Instance) {
         return;
     }
     if (value != null && typeof value === "object" && "constructor" in value) {
-        throw new TypeError(`Value is not instance of type.  Type: ${value.constructor.name}`);
+        throw new TypeError(`value is not instance of type.  Type: ${value.constructor.name}`);
+    }
+    throw new TypeError(`value is not instance of type`);
+}
+function assertIsNumber(value) {
+    if (typeof value !== "number") {
+        throw new TypeError("value is not of type `number`");
     }
-    throw new TypeError(`Value is not instance of type`);
+}
+function isObjectWithType(value) {
+    return typeof value === "object" && value !== null && "type" in value;
+}
+/**
+ * Type guard: narrows `value` to `Expression` when it is an object with a valid `type` property.
+ */ function isExpression(value) {
+    return isObjectWithType(value) && EXPRESSION_TYPES.includes(value.type);
+}
+/**
+ * Type guard: narrows `value` to `OperatorExpression` when it is an object with `type === "operator"`.
+ */ function isOperatorExpression(value) {
+    return isObjectWithType(value) && value.type === "operator";
+}
+/**
+ * Type guard: narrows `value` to `ComparatorExpression` when it is an object with `type === "comparator"`.
+ */ function isComparatorExpression(value) {
+    return isObjectWithType(value) && value.type === "comparator";
+}
+/**
+ * Type guard: narrows `value` to `PropertyExpression` when it is an object with `type === "property"`.
+ */ function isPropertyExpression(value) {
+    return isObjectWithType(value) && value.type === "property";
+}
+/**
+ * Type guard: narrows `value` to `ValueExpression` when it is an object with `type === "value"`.
+ */ function isValueExpression(value) {
+    return isObjectWithType(value) && value.type === "value";
+}
+/**
+ * Type guard: narrows `value` to `EmptyExpression` when it is an object with `type === "empty"`.
+ */ function isEmptyExpression(value) {
+    return isObjectWithType(value) && value.type === "empty";
+}
+/**
+ * Type guard: narrows `value` to `NotParsableExpression` when it is an object with `type === "not-parsable"`.
+ */ function isNotParsableExpression(value) {
+    return isObjectWithType(value) && value.type === "not-parsable";
 }
 
 
 },
-"./src/expressions/parser.ts"(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-__webpack_require__.r(__webpack_exports__);
+835(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
 __webpack_require__.d(__webpack_exports__, {
-  combineExpressions: () => (combineExpressions),
-  toExpression: () => (toExpression)
+  t: () => (EXPRESSION_TYPES)
 });
-/* import */ var _utilities__rspack_import_2 = __webpack_require__("./src/utilities/logger.ts");
-/* import */ var _assertions__rspack_import_1 = __webpack_require__("./src/assertions/index.ts");
-/* import */ var _types__rspack_import_0 = __webpack_require__("./src/expressions/types.ts");
+const EXPRESSION_TYPES = [
+    "operator",
+    "comparator",
+    "property",
+    "value",
+    "empty",
+    "not-parsable"
+];
 
 
+},
+379(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.d(__webpack_exports__, {
+  Vu: () => (toPredicate),
+  _3: () => (evaluate),
+  wS: () => (toStrictPredicate)
+});
+/* import */ var _assertions__rspack_import_0 = __webpack_require__(126);
 
-// Pre-compiled regex patterns for better performance
-const METHOD_REGEX = /([a-zA-Z0-9_.]+)\.(startsWith|endsWith|includes)\(([^)]+)\)(\s*(===|==|!==|!=)\s*(true|false))?/;
-const TRANSFORM_METHOD_REGEX = /([a-zA-Z0-9_.]+)\.(toLowerCase|toUpperCase|toLocaleLowerCase|toLocaleUpperCase)\(\)\.(startsWith|endsWith|includes)\(((?:[^()]|\([^)]*\))*)\)(\s*(===|==|!==|!=)\s*(true|false))?/;
-const EQUALITY_REGEX = /([^=!<>]+?)\s*(===|==|!==|!=)\s*(.+)/;
-const COMPARISON_REGEX = /([^=!<>]+?)\s*(>=|<=|>|<)\s*(.+)/;
-const PARAM_PATH_REGEX = /^([a-zA-Z0-9_.]+)/;
-// Pre-compiled regex patterns for comment removal
-const SINGLE_LINE_COMMENT_REGEX = /\/\/.*$/gm;
-const MULTI_LINE_COMMENT_REGEX = /\/\*[\s\S]*?\*\//g;
-const WHITESPACE_REGEX = /\s+/g;
-// need to have negated + strict
-const comparators = {
-    startsWith: new _types__rspack_import_0.ComparatorExpression({
-        comparator: "starts-with",
-        negated: false,
-        strict: false
-    }),
-    endsWith: new _types__rspack_import_0.ComparatorExpression({
-        comparator: "ends-with",
-        negated: false,
-        strict: false
-    }),
-    includes: new _types__rspack_import_0.ComparatorExpression({
-        comparator: "includes",
-        negated: false,
-        strict: false
-    }),
-    "==": new _types__rspack_import_0.ComparatorExpression({
+/** Reads a property or literal operand, or `UNRESOLVED` when the node is not one. */ const UNRESOLVED = Symbol("unresolved");
+const applyTransformer = (value, transformer)=>{
+    if (transformer == null) {
+        return value;
+    }
+    // A transformer applied to an absent value has no answer, and inventing one ("" for a missing
+    // string) is how a filter starts matching rows it should not.
+    if (value == null) {
+        return UNRESOLVED;
+    }
+    if (transformer === "to-lower-case") {
+        return typeof value === "string" ? value.toLowerCase() : UNRESOLVED;
+    }
+    if (transformer === "to-upper-case") {
+        return typeof value === "string" ? value.toUpperCase() : UNRESOLVED;
+    }
+    if (transformer === "length") {
+        return typeof value === "string" || Array.isArray(value) ? value.length : UNRESOLVED;
+    }
+    return UNRESOLVED;
+};
+const operand = (expression, row)=>{
+    if (expression == null) {
+        return UNRESOLVED;
+    }
+    if ((0,_assertions__rspack_import_0/* .isValueExpression */.S6)(expression)) {
+        return applyTransformer(expression.value, expression.transformer);
+    }
+    if ((0,_assertions__rspack_import_0/* .isPropertyExpression */.e3)(expression)) {
+        // Through the PropertyInfo, so a nested path and a `from`-renamed segment resolve the same
+        // way every other consumer of the tree resolves them.
+        return applyTransformer(expression.property.getValue(row), expression.transformer);
+    }
+    return UNRESOLVED;
+};
+/**
+ * `a === b` for the comparators, with Dates compared by VALUE.
+ *
+ * A Date compares by reference under `===`, so two Dates holding the same instant would be
+ * unequal — which is not what a filter on a date means, and not what any backend does.
+ */ const equals = (left, right, strict)=>{
+    if (left instanceof Date && right instanceof Date) {
+        return left.getTime() === right.getTime();
+    }
+    // oxlint-disable-next-line eqeqeq
+    return strict ? left === right : left == right;
+};
+/** Ordered comparison, only for shapes that have an order. */ const compare = (left, right, comparator)=>{
+    const asComparable = (value)=>value instanceof Date ? value.getTime() : value;
+    const a = asComparable(left);
+    const b = asComparable(right);
+    const comparable = typeof a === "number" && typeof b === "number" || typeof a === "string" && typeof b === "string";
+    if (comparable === false) {
+        return undefined;
+    }
+    if (comparator === "greater-than") {
+        return a > b;
+    }
+    if (comparator === "greater-than-equals") {
+        return a >= b;
+    }
+    if (comparator === "less-than") {
+        return a < b;
+    }
+    return a <= b;
+};
+const evaluateComparator = (comparator, left, right, strict)=>{
+    if (comparator === "equals") {
+        return equals(left, right, strict);
+    }
+    if (comparator === "includes") {
+        // Two shapes, and the tree does not distinguish them: `array.includes(value)` and
+        // `string.includes(substring)`. Whichever side is the container decides.
+        if (Array.isArray(left)) {
+            return left.some((item)=>equals(item, right, strict));
+        }
+        if (Array.isArray(right)) {
+            return right.some((item)=>equals(item, left, strict));
+        }
+        return typeof left === "string" && typeof right === "string" ? left.includes(right) : undefined;
+    }
+    if (comparator === "starts-with") {
+        return typeof left === "string" && typeof right === "string" ? left.startsWith(right) : undefined;
+    }
+    if (comparator === "ends-with") {
+        return typeof left === "string" && typeof right === "string" ? left.endsWith(right) : undefined;
+    }
+    return compare(left, right, comparator);
+};
+/**
+ * Evaluates `expression` against `row`, or returns `undefined` when it cannot.
+ *
+ * See the note at the top of this file: `undefined` means KEEP the row.
+ */ const evaluate = (expression, row)=>{
+    if ((0,_assertions__rspack_import_0/* .isOperatorExpression */.vg)(expression)) {
+        const left = expression.left == null ? undefined : evaluate(expression.left, row);
+        const right = expression.right == null ? undefined : evaluate(expression.right, row);
+        /**
+         * One unevaluable side does not have to sink the whole tree.
+         *
+         * `a && b` where `a` is definitely false is false whatever `b` is, and `a || b` where `a`
+         * is definitely true is true. That short-circuiting is what lets a mostly-understood
+         * predicate still narrow anything at all — without it, one unfamiliar sub-expression makes
+         * the entire filter a no-op.
+         */ if (expression.operator === "&&") {
+            if (left === false || right === false) {
+                return false;
+            }
+            return left === true && right === true ? true : undefined;
+        }
+        if (left === true || right === true) {
+            return true;
+        }
+        return left === false && right === false ? false : undefined;
+    }
+    if ((0,_assertions__rspack_import_0/* .isComparatorExpression */.xH)(expression)) {
+        const left = operand(expression.left, row);
+        const right = operand(expression.right, row);
+        if (left === UNRESOLVED || right === UNRESOLVED) {
+            return undefined;
+        }
+        const result = evaluateComparator(expression.comparator, left, right, expression.strict);
+        if (result === undefined) {
+            return undefined;
+        }
+        return expression.negated ? result === false : result;
+    }
+    // A tautology excludes nothing, which is exactly `true`. Anything else — a bare property, a
+    // literal, `not-parsable` — is not a predicate this can judge.
+    return expression.type === "empty" ? true : undefined;
+};
+/**
+ * `evaluate`, as a predicate that keeps whatever it cannot judge.
+ *
+ * The form every narrowing caller wants, with the fail-open rule applied once here rather than
+ * remembered at each call site.
+ */ const toPredicate = (expression)=>(row)=>evaluate(expression, row) !== false;
+/**
+ * `evaluate`, as a predicate that THROWS on anything it cannot judge.
+ *
+ * The opposite default to `toPredicate`, and the right one when the predicate is the only thing
+ * standing between a caller and rows they asked to exclude — a filter that arrived over a wire and
+ * is being applied by the receiver. Failing open there does not cost a wasted comparison; it returns
+ * data the requester filtered out, and reports nothing.
+ *
+ * Use `toPredicate` when something authoritative re-checks the result, and this when nothing does.
+ */ const toStrictPredicate = (expression)=>(row)=>{
+        const result = evaluate(expression, row);
+        if (result === undefined) {
+            throw new Error("Cannot apply this filter: its expression cannot be evaluated in memory, and applying it partially would " + "return rows the filter excludes.  This happens when a filter arrives without a runnable predicate — over a " + "wire, or rebuilt from a serialized query — and names something the evaluator does not understand.");
+        }
+        return result;
+    };
+
+
+},
+91(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.d(__webpack_exports__, {
+  MY: () => (toExpression),
+  oH: () => (parseFragment),
+  pg: () => (combineExpressions)
+});
+/* import */ var _utilities__rspack_import_3 = __webpack_require__(581);
+/* import */ var _assertions__rspack_import_0 = __webpack_require__(126);
+/* import */ var _schema__rspack_import_2 = __webpack_require__(537);
+/* import */ var _types__rspack_import_1 = __webpack_require__(27);
+
+
+
+
+// Error message constants
+const ERROR_MESSAGES = {
+    PROPERTY_NOT_FOUND: (path)=>`Error parsing query, could not find PropertyInfo for path: ${path}`,
+    PARAM_PATH_NOT_FOUND: (value, params)=>`Cannot find path in params for .where(). Make sure parameters are not used inline.\r\nPath: ${value}, Params: ${JSON.stringify(params)}`,
+    VARIABLE_VALUE: (value)=>`Cannot derive value from variable, please pass parameters into the expression.
+
+Example: .where(([x, params]) => x.id === params.id, { id: someVar.id })
+Issue At: ${value}`,
+    UNSUPPORTED: (value)=>`Unsupported expression format: ${value}`
+};
+const parseUnknown = (value)=>{
+    (0,_assertions__rspack_import_0/* .assertString */.Cv)(value);
+    return JSON.parse(value);
+};
+/**
+ * A parse failure caused by the params VALUES rather than the filter source.
+ * These must never poison the template cache — the same source can succeed
+ * with different params.
+ */ class ParamDependentParseError extends Error {
+}
+const converters = {
+    Array: (v)=>v,
+    Boolean: (v)=>v == null ? v : Boolean(v),
+    // Stryker disable next-line ArrowFunction: filters on computed properties route to
+    // in-memory execution, so this entry cannot be reached through a parsable filter.
+    Computed: (v)=>v,
+    Date: (v)=>v,
+    // A file is a reference, and a filter can legitimately compare its fields — content type
+    // and size are ordinary columns. The value passes through unconverted like an object.
+    File: (v)=>v,
+    // Stryker disable next-line ArrowFunction: SchemaTypes.Definition is handled as a
+    // generic primitive everywhere (specs/known-defects.md) and never pairs in a filter.
+    Definition: (v)=>v,
+    // Stryker disable next-line ArrowFunction: filters on function properties route to
+    // in-memory execution, so this entry cannot be reached through a parsable filter.
+    Function: (v)=>v,
+    Number: (v)=>v == null ? v : Number(v),
+    Object: (v)=>v,
+    String: (v)=>v == null ? v : String(v),
+    // A vector is a list of numbers and passes through like any other array. Nothing
+    // converts it because nothing compares it: similarity is `.nearest()`, not a filter.
+    Vector: (v)=>v
+};
+// Longest first so multi-character punctuation wins over its prefixes
+const MULTI_CHARACTER_PUNCTUATION = [
+    "===",
+    "!==",
+    "?.",
+    "&&",
+    "||",
+    "==",
+    "!=",
+    ">=",
+    "<=",
+    "=>"
+];
+// Stryker disable next-line all: documented equivalent cluster (see
+// docs/mutation-backlog.md) — dropping an entry only affects source the parser rejects
+// either way, and the rejection message names the character from the source rather than
+// from this set, so no observable boundary distinguishes the mutant. Established
+// experimentally: 30 message-asserting tests killed 1 of 12.
+const SINGLE_CHARACTER_PUNCTUATION = new Set([
+    "(",
+    ")",
+    "[",
+    "]",
+    "{",
+    "}",
+    ".",
+    ",",
+    ";",
+    "!",
+    ">",
+    "<",
+    "-",
+    "+",
+    "*",
+    "/",
+    "%",
+    "=",
+    "?",
+    ":",
+    "&",
+    "|"
+]);
+const STRING_ESCAPES = {
+    "n": "\n",
+    "r": "\r",
+    "t": "\t",
+    "b": "\b",
+    "f": "\f",
+    "v": "\v",
+    "0": "\0"
+};
+const isIdentifierStart = (char)=>/[a-zA-Z_$]/.test(char);
+const isIdentifierPart = (char)=>/[a-zA-Z0-9_$]/.test(char);
+const isDigit = (char)=>char >= "0" && char <= "9";
+const isHexDigit = (char)=>isDigit(char) || char >= "a" && char <= "f" || char >= "A" && char <= "F";
+/**
+ * Decodes a `\uXXXX`, `\u{...}` or `\xXX` escape starting at the backslash.
+ * Returns the decoded character and the index just past the escape.  These
+ * escapes carry a computed character, so mapping them through STRING_ESCAPES
+ * (which would yield the literal "u"/"x") silently corrupts the value.
+ */ const decodeCodeEscape = (source, backslashIndex)=>{
+    const kind = source[backslashIndex + 1];
+    let start = backslashIndex + 2;
+    if (kind === "u" && source[start] === "{") {
+        const end = source.indexOf("}", start + 1);
+        if (end === -1) {
+            throw new Error(ERROR_MESSAGES.UNSUPPORTED("unterminated unicode escape"));
+        }
+        return {
+            value: String.fromCodePoint(parseInt(source.slice(start + 1, end), 16)),
+            nextIndex: end + 1
+        };
+    }
+    const length = kind === "u" ? 4 : 2;
+    const digits = source.slice(start, start + length);
+    if (digits.length < length || [
+        ...digits
+    ].some((d)=>!isHexDigit(d))) {
+        throw new Error(ERROR_MESSAGES.UNSUPPORTED(`'\\${kind}' escape`));
+    }
+    return {
+        value: String.fromCharCode(parseInt(digits, 16)),
+        nextIndex: start + length
+    };
+};
+/**
+ * Converts filter source text into a flat token stream.  Strings and comments are
+ * consumed here so operator characters inside literals can never be mistaken for
+ * real operators.
+ */ const tokenize = (source)=>{
+    const tokens = [];
+    let i = 0;
+    while(i < source.length){
+        const char = source[i];
+        // Whitespace
+        if (char === " " || char === "\t" || char === "\r" || char === "\n") {
+            i++;
+            continue;
+        }
+        // Comments
+        if (char === "/" && source[i + 1] === "/") {
+            while(i < source.length && source[i] !== "\n"){
+                i++;
+            }
+            continue;
+        }
+        if (char === "/" && source[i + 1] === "*") {
+            i += 2;
+            while(i < source.length && !(source[i] === "*" && source[i + 1] === "/")){
+                i++;
+            }
+            i += 2;
+            continue;
+        }
+        // String literals
+        if (char === "'" || char === "\"" || char === "`") {
+            const quote = char;
+            let value = "";
+            i++;
+            while(i < source.length && source[i] !== quote){
+                if (source[i] === "\\") {
+                    const escaped = source[i + 1];
+                    if (escaped === "u" || escaped === "x") {
+                        const decoded = decodeCodeEscape(source, i);
+                        value += decoded.value;
+                        i = decoded.nextIndex;
+                        continue;
+                    }
+                    value += STRING_ESCAPES[escaped] ?? escaped;
+                    i += 2;
+                    continue;
+                }
+                if (quote === "`" && source[i] === "$" && source[i + 1] === "{") {
+                    throw new Error(ERROR_MESSAGES.UNSUPPORTED("template literal interpolation"));
+                }
+                value += source[i];
+                i++;
+            }
+            if (i >= source.length) {
+                throw new Error(ERROR_MESSAGES.UNSUPPORTED("unterminated string literal"));
+            }
+            i++; // consume closing quote
+            tokens.push({
+                kind: "string",
+                value
+            });
+            continue;
+        }
+        // Numbers — covers decimals, exponents (1e6), hex/octal/binary (0xFF),
+        // and numeric separators (1_000_000).  Values are normalized here (the
+        // separator stripped) so the parser can hand them straight to Number()
+        if (isDigit(char)) {
+            let value = "";
+            const nextChar = source[i + 1];
+            const radixPrefix = char === "0" && nextChar != null && "xXoObB".includes(nextChar);
+            if (radixPrefix) {
+                value = source[i] + source[i + 1];
+                i += 2;
+                while(i < source.length && (isHexDigit(source[i]) || source[i] === "_")){
+                    value += source[i];
+                    i++;
+                }
+            } else {
+                while(i < source.length && (isDigit(source[i]) || source[i] === "." || source[i] === "_")){
+                    value += source[i];
+                    i++;
+                }
+                // Exponent part: e/E, optional sign, then digits.  Only consumed when
+                // digits follow, so a stray identifier after a number still errors
+                if (source[i] === "e" || source[i] === "E") {
+                    const signLength = source[i + 1] === "+" || source[i + 1] === "-" ? 1 : 0;
+                    if (isDigit(source[i + 1 + signLength])) {
+                        value += source[i];
+                        i++;
+                        if (signLength === 1) {
+                            value += source[i];
+                            i++;
+                        }
+                        while(i < source.length && isDigit(source[i])){
+                            value += source[i];
+                            i++;
+                        }
+                    }
+                }
+            }
+            tokens.push({
+                kind: "number",
+                value: value.replace(/_/g, "")
+            });
+            continue;
+        }
+        // Identifiers / keywords
+        if (isIdentifierStart(char)) {
+            let value = "";
+            while(i < source.length && isIdentifierPart(source[i])){
+                value += source[i];
+                i++;
+            }
+            tokens.push({
+                kind: "identifier",
+                value
+            });
+            continue;
+        }
+        // Multi-character punctuation (longest match first)
+        const multi = MULTI_CHARACTER_PUNCTUATION.find((w)=>source.startsWith(w, i));
+        if (multi != null) {
+            tokens.push({
+                kind: "punctuation",
+                value: multi
+            });
+            i += multi.length;
+            continue;
+        }
+        if (SINGLE_CHARACTER_PUNCTUATION.has(char)) {
+            tokens.push({
+                kind: "punctuation",
+                value: char
+            });
+            i++;
+            continue;
+        }
+        throw new Error(ERROR_MESSAGES.UNSUPPORTED(`unexpected character '${char}'`));
+    }
+    return tokens;
+};
+/**
+ * Cursor over the token stream with the small set of lookahead operations the
+ * parser needs.
+ */ class TokenStream {
+    tokens;
+    index = 0;
+    constructor(tokens){
+        this.tokens = tokens;
+    }
+    get isAtEnd() {
+        return this.index >= this.tokens.length;
+    }
+    peek(offset = 0) {
+        return this.tokens[this.index + offset] ?? null;
+    }
+    next() {
+        const token = this.tokens[this.index];
+        if (token == null) {
+            throw new Error(ERROR_MESSAGES.UNSUPPORTED("unexpected end of expression"));
+        }
+        this.index++;
+        return token;
+    }
+    isPunctuation(value, offset = 0) {
+        const token = this.peek(offset);
+        return token != null && token.kind === "punctuation" && token.value === value;
+    }
+    matchPunctuation(value) {
+        if (this.isPunctuation(value)) {
+            this.index++;
+            return true;
+        }
+        return false;
+    }
+    expectPunctuation(value) {
+        if (!this.matchPunctuation(value)) {
+            throw new Error(ERROR_MESSAGES.UNSUPPORTED(`expected '${value}'`));
+        }
+    }
+}
+const COMPARATOR_METHODS = {
+    startsWith: "starts-with",
+    endsWith: "ends-with",
+    includes: "includes"
+};
+const TRANSFORM_METHODS = {
+    toLowerCase: {
+        transformer: "to-lower-case",
+        locale: null
+    },
+    toUpperCase: {
+        transformer: "to-upper-case",
+        locale: null
+    },
+    toLocaleLowerCase: {
+        transformer: "to-lower-case",
+        locale: "en-US"
+    },
+    toLocaleUpperCase: {
+        transformer: "to-upper-case",
+        locale: "en-US"
+    }
+};
+const COMPARISON_OPERATORS = {
+    "==": {
         comparator: "equals",
         negated: false,
         strict: false
-    }),
-    "===": new _types__rspack_import_0.ComparatorExpression({
+    },
+    "===": {
         comparator: "equals",
         negated: false,
         strict: true
-    }),
-    "!=": new _types__rspack_import_0.ComparatorExpression({
+    },
+    "!=": {
         comparator: "equals",
         negated: true,
         strict: false
-    }),
-    "!==": new _types__rspack_import_0.ComparatorExpression({
+    },
+    "!==": {
         comparator: "equals",
         negated: true,
         strict: true
-    }),
-    ">=": new _types__rspack_import_0.ComparatorExpression({
-        comparator: "greater-than-equals",
+    },
+    ">": {
+        comparator: "greater-than",
         negated: false,
         strict: false
-    }),
-    ">==": new _types__rspack_import_0.ComparatorExpression({
+    },
+    ">=": {
         comparator: "greater-than-equals",
         negated: false,
-        strict: true
-    }),
-    "<=": new _types__rspack_import_0.ComparatorExpression({
-        comparator: "less-than-equals",
-        negated: false,
         strict: false
-    }),
-    "<==": new _types__rspack_import_0.ComparatorExpression({
-        comparator: "less-than-equals",
-        negated: false,
-        strict: true
-    }),
-    ">": new _types__rspack_import_0.ComparatorExpression({
-        comparator: "greater-than",
+    },
+    "<": {
+        comparator: "less-than",
         negated: false,
         strict: false
-    }),
-    "<": new _types__rspack_import_0.ComparatorExpression({
-        comparator: "less-than",
+    },
+    "<=": {
+        comparator: "less-than-equals",
         negated: false,
         strict: false
-    })
+    }
 };
-// Optimized comparator lookup using Map
-const COMPARATOR_MAP = new Map(Object.entries(comparators));
-// Error message constants
-const ERROR_MESSAGES = {
-    COMPARATOR_NOT_FOUND: (value) => `Cannot find comparator: ${value}`,
-    PROPERTY_NOT_FOUND: (path) => `Error parsing query, could not find PropertyInfo for path: ${path}`,
-    PARAM_PATH_NOT_FOUND: (value, params) => `Cannot find path in params for .where(). Make sure parameters are not used inline.\r\nPath: ${value}, Params: ${JSON.stringify(params)}`
+const SWAPPED_COMPARATORS = {
+    "equals": "equals",
+    "greater-than": "less-than",
+    "greater-than-equals": "less-than-equals",
+    "less-than": "greater-than",
+    "less-than-equals": "greater-than-equals",
+    "starts-with": "starts-with",
+    "ends-with": "ends-with",
+    "includes": "includes"
 };
-const STRINGIFIED_COMPARE_OPERATORS = ["true", "false"];
-const parseUnknown = (value) => {
-    (0,_assertions__rspack_import_1.assertString)(value);
-    return JSON.parse(value);
+// #endregion
+// #region Param references
+/**
+ * Placeholder for a parameter value inside a cached expression template.  Never
+ * escapes this module — binding replaces it with a plain ValueExpression that
+ * holds the resolved value.
+ */ class ParamReferenceExpression extends _types__rspack_import_1/* .ValueExpression */.Ko {
+    /** Path into the params object, excluding the params root name. */ paramPath;
+    /** The property this value is compared against; drives serialization/conversion at bind time. */ pairedProperty;
+    /** Whether the paired property's type converter applies (equality/relational comparisons only). */ applyConverter;
+    constructor(options){
+        super({
+            value: undefined
+        });
+        this.paramPath = options.paramPath;
+        this.pairedProperty = options.pairedProperty;
+        this.applyConverter = options.applyConverter;
+    }
+}
+const resolveParamPath = (paramsName, path, data)=>{
+    let result = data;
+    for(let i = 0; i < path.length; i++){
+        const name = path[i];
+        if (result != null && typeof result === "object" && name in result) {
+            result = result[name];
+            continue;
+        }
+        throw new ParamDependentParseError(ERROR_MESSAGES.PARAM_PATH_NOT_FOUND([
+            paramsName,
+            ...path
+        ].join("."), data));
+    }
+    return result;
 };
-const combineExpressions = (...expressions) => {
-    if (expressions.length === 0) {
-        throw new Error("combineExpressions requires at least 1 expression");
+/**
+ * Applies the paired property's value serializer and (optionally) its schema
+ * type converter, matching how literal values are treated at parse time.
+ */ const resolvePairedValue = (value, pairedProperty, applyConverter)=>{
+    if (pairedProperty == null) {
+        return value;
     }
-    if (expressions.length === 1) {
-        return expressions[0];
+    let result = value;
+    if (pairedProperty.valueSerializer != null) {
+        result = String(pairedProperty.valueSerializer(parseUnknown(result)));
     }
-    // Start with the first expression
-    let result = expressions[0];
-    // Loop through remaining expressions and combine them
-    for (let i = 1; i < expressions.length; i++) {
-        result = new _types__rspack_import_0.OperatorExpression({
-            operator: "&&",
-            left: result,
-            right: expressions[i]
-        });
+    if (applyConverter) {
+        result = converters[pairedProperty.type](result);
     }
     return result;
 };
-const toExpression = (schema, fn, params) => {
-    const stringifiedFunction = fn.toString();
-    try {
-        // Optimized string parsing
-        const arrowIndex = stringifiedFunction.indexOf('=>');
-        if (arrowIndex === -1) {
-            throw new Error("Invalid Function");
+// #endregion
+// #region Parser
+/**
+ * Recursive descent parser over the token stream.  Produces an expression
+ * template: literal values are fully resolved, parameter values are represented
+ * as ParamReferenceExpression placeholders so the template can be cached and
+ * re-bound with different params.
+ */ class ExpressionParser {
+    schema;
+    stream;
+    entityName;
+    paramsName;
+    params;
+    /** Set when a param value shaped the tree itself (e.g. x[p.name]) — such templates cannot be cached. */ structurallyDependsOnParams = false;
+    constructor(schema, stream, entityName, paramsName, params){
+        this.schema = schema;
+        this.stream = stream;
+        this.entityName = entityName;
+        this.paramsName = paramsName;
+        this.params = params;
+    }
+    parse() {
+        const expression = this.parseOr();
+        if (!this.stream.isAtEnd) {
+            throw new Error(ERROR_MESSAGES.UNSUPPORTED(`unexpected token '${this.stream.peek()?.value}'`));
         }
-        const parameterNames = stringifiedFunction.substring(0, arrowIndex).trim();
-        let expression = stringifiedFunction.substring(arrowIndex + 2).trim();
-        // Remove JavaScript comments from the expression
-        expression = expression
-            .replace(SINGLE_LINE_COMMENT_REGEX, '') // Remove single-line comments
-            .replace(MULTI_LINE_COMMENT_REGEX, '') // Remove multi-line comments
-            .replace(WHITESPACE_REGEX, ' ') // Normalize whitespace
-            .trim();
-        let parameterData = undefined;
-        if (params != null) {
-            let name;
-            if (parameterNames.includes("[") && parameterNames.includes("]")) {
-                // Optimized parameter name extraction
-                const commaIndex = parameterNames.indexOf(",");
-                if (commaIndex !== -1) {
-                    const bracketIndex = parameterNames.indexOf("]", commaIndex);
-                    if (bracketIndex !== -1) {
-                        name = parameterNames.substring(commaIndex + 1, bracketIndex).trim();
-                    }
-                }
+        return expression;
+    }
+    // || binds loosest, so it sits at the root of the parse
+    parseOr() {
+        let left = this.parseAnd();
+        while(this.stream.matchPunctuation("||")){
+            const right = this.parseAnd();
+            // A tautology (`true`) absorbs the whole disjunction
+            if (_types__rspack_import_1/* .Expression.isEmpty */.r4.isEmpty(left) || _types__rspack_import_1/* .Expression.isEmpty */.r4.isEmpty(right)) {
+                left = _types__rspack_import_1/* .Expression.EMPTY */.r4.EMPTY;
+                continue;
             }
-            parameterData = {
-                name,
-                data: params
-            };
+            left = new _types__rspack_import_1/* .OperatorExpression */.fw({
+                operator: "||",
+                left,
+                right
+            });
         }
-        return parseExpressionToTree(schema, expression, parameterData);
-    }
-    catch (error) {
-        _utilities__rspack_import_2.logger.warn("Error parsing expression", {
-            error,
-            collectionName: schema.collectionName,
-            params,
-            selector: stringifiedFunction
-        });
-        return _types__rspack_import_0.Expression.NOT_PARSABLE;
+        return left;
     }
-};
-const parseExpressionToTree = (schema, expression, params) => {
-    const parse = (exp) => {
-        // Remove any wrapping parentheses
-        exp = exp.trim();
-        if (exp.startsWith('(') && exp.endsWith(')')) {
-            let depth = 0;
-            let isWrapper = true;
-            for (let i = 0; i < exp.length; i++) {
-                const char = exp[i];
-                if (char === '(') {
-                    depth++;
-                }
-                else if (char === ')') {
-                    depth--;
-                    if (depth < 0)
-                        break; // Early exit for invalid parentheses
-                }
-                // Early exit if we find a closing parenthesis that's not the last character
-                if (depth === 0 && i !== exp.length - 1) {
-                    isWrapper = false;
-                    break; // Early exit
-                }
-                // Early exit if we go negative (invalid parentheses)
-                if (depth < 0) {
-                    isWrapper = false;
-                    break;
-                }
+    parseAnd() {
+        let left = this.parseUnary();
+        while(this.stream.matchPunctuation("&&")){
+            const right = this.parseUnary();
+            // A tautology (`true`) is the identity of a conjunction
+            if (_types__rspack_import_1/* .Expression.isEmpty */.r4.isEmpty(left)) {
+                left = right;
+                continue;
             }
-            if (isWrapper) {
-                exp = exp.slice(1, -1).trim();
+            if (_types__rspack_import_1/* .Expression.isEmpty */.r4.isEmpty(right)) {
+                continue;
             }
+            left = new _types__rspack_import_1/* .OperatorExpression */.fw({
+                operator: "&&",
+                left,
+                right
+            });
         }
-        // Parse based on the operator precedence
-        let operator = null, splitIndex = -1, depth = 0;
-        for (let i = 0; i < exp.length - 1; i++) {
-            const char = exp[i];
-            if (char === '(')
-                depth++;
-            else if (char === ')')
-                depth--;
-            else if (depth === 0) {
-                // Optimized operator detection using character comparison
-                if (char === '&' && exp[i + 1] === '&') {
-                    operator = '&&';
-                    splitIndex = i;
-                    break; // AND takes precedence over OR
-                }
-                else if (operator === null && char === '|' && exp[i + 1] === '|') {
-                    operator = '||';
-                    splitIndex = i;
-                }
-            }
+        return left;
+    }
+    parseUnary() {
+        if (this.stream.matchPunctuation("!")) {
+            return this.negateExpression(this.parseUnary());
         }
-        if (operator) {
-            const left = exp.slice(0, splitIndex).trim();
-            const right = exp.slice(splitIndex + 2).trim();
-            return new _types__rspack_import_0.OperatorExpression({
-                operator,
-                left: parse(left),
-                right: parse(right)
+        return this.parseComparison();
+    }
+    /**
+     * Applies `!` to an already-parsed expression: comparators flip their
+     * negated flag, compound expressions distribute via De Morgan's laws.
+     */ negateExpression(expression) {
+        if (expression instanceof _types__rspack_import_1/* .ComparatorExpression */.bQ) {
+            expression.negated = !expression.negated;
+            return expression;
+        }
+        if (expression instanceof _types__rspack_import_1/* .OperatorExpression */.fw && expression.left != null && expression.right != null) {
+            return new _types__rspack_import_1/* .OperatorExpression */.fw({
+                operator: expression.operator === "&&" ? "||" : "&&",
+                left: this.negateExpression(expression.left),
+                right: this.negateExpression(expression.right)
             });
         }
-        // If no operator, try to parse as a condition
-        return parseCondition(schema, exp, params);
-    };
-    return parse(expression);
-};
-const convertAndAssignValue = (valueExpression, propertyPathExpression) => {
-    assertIsPropertyPathExpression(propertyPathExpression);
-    assertIsValueExpression(valueExpression);
-    const propertyType = propertyPathExpression.property.type;
-    valueExpression.value = converters[propertyType](valueExpression.value);
-};
-const converters = {
-    Array: v => v,
-    Boolean: v => v == null ? v : Boolean(v),
-    Computed: v => v,
-    Date: v => v,
-    Definition: v => v,
-    Function: v => v,
-    Number: v => v == null ? v : Number(v),
-    Object: v => v,
-    String: v => v == null ? v : String(v)
-};
-const isExpression = (value) => {
-    return typeof value === "object" && value !== null && "type" in value;
-};
-function assertIsExpression(value) {
-    if (isExpression(value) === false) {
-        throw new Error("Assertion Failed: Value is not a Expression");
+        throw new Error(ERROR_MESSAGES.UNSUPPORTED("'!' on this expression"));
     }
-}
-function assertIsPropertyPathExpression(value) {
-    assertIsExpression(value);
-    if (!("property" in value)) {
-        throw new Error("Assertion Failed: Value is not a PropertyPathExpression");
+    parseComparison() {
+        // Parenthesized group
+        if (this.stream.matchPunctuation("(")) {
+            const expression = this.parseOr();
+            this.stream.expectPunctuation(")");
+            const trailing = this.stream.peek();
+            if (trailing != null && trailing.kind === "punctuation" && COMPARISON_OPERATORS[trailing.value] != null) {
+                throw new Error(ERROR_MESSAGES.UNSUPPORTED("comparison against a parenthesized expression"));
+            }
+            return expression;
+        }
+        const left = this.parseOperand();
+        const operatorToken = this.stream.peek();
+        if (operatorToken != null && operatorToken.kind === "punctuation" && COMPARISON_OPERATORS[operatorToken.value] != null) {
+            this.stream.next();
+            const right = this.parseOperand();
+            return this.buildComparison(left, COMPARISON_OPERATORS[operatorToken.value], right);
+        }
+        return this.buildStandalone(left);
     }
-}
-function assertIsValueExpression(value) {
-    assertIsExpression(value);
-    if (!("value" in value)) {
-        throw new Error("Assertion Failed: Value is not a ValueExpression");
+    parseOperand() {
+        const token = this.stream.peek();
+        if (token == null) {
+            throw new Error(ERROR_MESSAGES.UNSUPPORTED("unexpected end of expression"));
+        }
+        if (token.kind === "string") {
+            this.stream.next();
+            return this.withValueTransformer({
+                kind: "value",
+                value: token.value,
+                transformer: null,
+                locale: null
+            });
+        }
+        if (token.kind === "number") {
+            this.stream.next();
+            return {
+                kind: "value",
+                value: Number(token.value),
+                transformer: null,
+                locale: null
+            };
+        }
+        if (token.kind === "punctuation" && token.value === "-") {
+            this.stream.next();
+            const numberToken = this.stream.next();
+            if (numberToken.kind !== "number") {
+                throw new Error(ERROR_MESSAGES.UNSUPPORTED("unary '-' on a non-number"));
+            }
+            return {
+                kind: "value",
+                value: -Number(numberToken.value),
+                transformer: null,
+                locale: null
+            };
+        }
+        if (token.kind === "punctuation" && token.value === "[") {
+            return this.parseArrayLiteralOperand();
+        }
+        if (token.kind === "identifier") {
+            return this.parseIdentifierOperand();
+        }
+        throw new Error(ERROR_MESSAGES.UNSUPPORTED(String(token.value)));
     }
-}
-// Helper function to detect if a string is a property path
-const isPropertyPath = (value, params) => {
-    // Check for dot notation (e.g., entity.name)
-    if (value.includes('.') && value.match(/^[a-zA-Z0-9_.]+$/) !== null) {
-        return true;
+    /**
+     * Parses an inline array of literals, e.g. `["active", "pending"]`, and the
+     * membership test that follows it: `[...].includes(entity.property)`.
+     */ parseArrayLiteralOperand() {
+        this.stream.expectPunctuation("[");
+        const elements = [];
+        while(!this.stream.isPunctuation("]")){
+            const element = this.parseOperand();
+            if (element.kind !== "value" || element.transformer != null) {
+                throw new Error(ERROR_MESSAGES.UNSUPPORTED("a non-literal element in an array literal"));
+            }
+            elements.push(element.value);
+            if (!this.stream.matchPunctuation(",")) {
+                break;
+            }
+        }
+        this.stream.expectPunctuation("]");
+        const array = {
+            kind: "value",
+            value: elements,
+            transformer: null,
+            locale: null
+        };
+        // The only supported use is a membership test on a schema property
+        if (this.stream.isPunctuation(".") || this.stream.isPunctuation("?.")) {
+            this.stream.next();
+            const method = this.stream.next();
+            if (method.kind !== "identifier" || method.value !== "includes") {
+                throw new Error(ERROR_MESSAGES.UNSUPPORTED(`'.${method.value}' on an array literal`));
+            }
+            this.stream.expectPunctuation("(");
+            const argument = this.parseOperand();
+            this.stream.expectPunctuation(")");
+            if (argument.kind === "method-call") {
+                throw new Error(ERROR_MESSAGES.UNSUPPORTED("nested method call inside .includes()"));
+            }
+            return {
+                kind: "method-call",
+                target: array,
+                method: "includes",
+                argument
+            };
+        }
+        return array;
     }
-    // Check for bracket notation with literal strings (e.g., entity["name"], entity['name'], or entity[\"name\"] with escaped quotes)
-    const literalBracketPattern = /^[a-zA-Z_$][a-zA-Z0-9_$]*(\[\\?["'][^"']+\\?["']\])+$/;
-    if (literalBracketPattern.test(value)) {
-        return true;
+    parseIdentifierOperand() {
+        const root = this.stream.next().value;
+        // Keyword literals
+        if (root === "true" || root === "false") {
+            return {
+                kind: "value",
+                value: root === "true",
+                transformer: null,
+                locale: null
+            };
+        }
+        if (root === "null") {
+            return {
+                kind: "value",
+                value: null,
+                transformer: null,
+                locale: null
+            };
+        }
+        if (root === "undefined") {
+            return {
+                kind: "value",
+                value: undefined,
+                transformer: null,
+                locale: null
+            };
+        }
+        if (root === "void") {
+            this.stream.next(); // the '0'
+            return {
+                kind: "value",
+                value: undefined,
+                transformer: null,
+                locale: null
+            };
+        }
+        if (root === this.entityName) {
+            return this.parseChain({
+                kind: "property",
+                root
+            });
+        }
+        if (this.paramsName != null && root === this.paramsName) {
+            return this.parseChain({
+                kind: "param",
+                root
+            });
+        }
+        // A bare variable from the outer scope — its value cannot be derived from source text
+        throw new Error(ERROR_MESSAGES.VARIABLE_VALUE(root));
     }
-    // Check for bracket notation with parameter paths (e.g., entity[p.name], entity[params.property])
-    if (params && value.includes('[') && value.includes(']')) {
-        const bracketMatch = value.match(/\[([^\]]+)\]/);
-        if (bracketMatch) {
-            const bracketContent = bracketMatch[1].trim();
-            // Check if it's a parameter path - should start with params.name followed by dot, or be just params.name
-            const isParamPath = bracketContent.startsWith(params.name + '.') || bracketContent === params.name;
-            if (isParamPath || (bracketContent.includes('.') && bracketContent.match(PARAM_PATH_REGEX))) {
-                return true;
+    /**
+     * Parses the segments after an entity/params root: dot access, bracket
+     * access, transform methods and comparator methods.
+     */ parseChain(options) {
+        const path = [];
+        let transformer = null;
+        let locale = null;
+        while(true){
+            if (this.stream.matchPunctuation(".") || this.stream.matchPunctuation("?.")) {
+                const segment = this.stream.next();
+                if (segment.kind !== "identifier") {
+                    throw new Error(ERROR_MESSAGES.UNSUPPORTED(`'.${segment.value}'`));
+                }
+                // Method call
+                if (this.stream.isPunctuation("(")) {
+                    const method = segment.value;
+                    if (TRANSFORM_METHODS[method] != null) {
+                        this.stream.expectPunctuation("(");
+                        this.stream.expectPunctuation(")");
+                        transformer = TRANSFORM_METHODS[method].transformer;
+                        locale = TRANSFORM_METHODS[method].locale;
+                        continue;
+                    }
+                    if (COMPARATOR_METHODS[method] != null) {
+                        this.stream.expectPunctuation("(");
+                        const argument = this.parseOperand();
+                        this.stream.expectPunctuation(")");
+                        if (argument.kind === "method-call") {
+                            throw new Error(ERROR_MESSAGES.UNSUPPORTED(`nested method call inside .${method}()`));
+                        }
+                        return {
+                            kind: "method-call",
+                            target: this.resolveChain(options.kind, path, transformer, locale),
+                            method: method,
+                            argument
+                        };
+                    }
+                    throw new Error(ERROR_MESSAGES.UNSUPPORTED(`method '.${method}()'`));
+                }
+                if (transformer != null) {
+                    throw new Error(ERROR_MESSAGES.UNSUPPORTED("property access after a transform method"));
+                }
+                path.push(segment.value);
+                continue;
+            }
+            if (this.stream.matchPunctuation("[")) {
+                path.push(this.parseBracketSegment(options.kind));
+                this.stream.expectPunctuation("]");
+                continue;
             }
+            break;
         }
+        return this.resolveChain(options.kind, path, transformer, locale);
     }
-    return false;
-};
-// Helper function to determine if we need to swap the operator for reversed comparisons
-const getSwappedOperator = (operator) => {
-    const swapMap = {
-        '>': '<',
-        '<': '>',
-        '>=': '<=',
-        '<=': '>='
-    };
-    return swapMap[operator] || operator;
-};
-const parseCondition = (schema, expression, params) => {
-    // Optimized string operations - single trim operation
-    const trimmed = expression.trim();
-    const isNegation = trimmed.startsWith('!');
-    const finalExpression = isNegation ? trimmed.slice(1).trim() : trimmed;
-    // Enhanced pattern matching for complex expressions
-    const methodMatch = finalExpression.match(METHOD_REGEX);
-    const transformMethodMatch = finalExpression.match(TRANSFORM_METHOD_REGEX);
-    const equalityMatch = finalExpression.match(EQUALITY_REGEX);
-    const comparisonMatch = finalExpression.match(COMPARISON_REGEX);
-    if (methodMatch) {
-        // Handle .startsWith or .endsWith
-        const comparator = getComparator(methodMatch[2]);
-        if (isNegation) {
-            comparator.negated = isNegation;
-        }
-        // Check if the left side is a parameter path
-        const leftSide = methodMatch[1];
-        const rightSide = methodMatch[3];
-        if (params && leftSide.startsWith(params.name)) {
-            // This is a parameter path on the left side (e.g., params.distinctPlayers.includes(entity.playerId))
-            // For includes method, we need to swap left and right sides
-            if (methodMatch[2] === 'includes') {
-                const property = getProperty(schema, rightSide, params);
-                const value = getValue(leftSide, params); // retrieve the original value
-                const serializer = property.property.valueSerializer;
-                comparator.left = serializer ? getValue(String(property.property.valueSerializer(parseUnknown(value.value)))) : value;
-                comparator.right = property;
+    parseBracketSegment(kind) {
+        const token = this.stream.next();
+        // Literal segment: entity["name"]
+        if (token.kind === "string") {
+            return token.value;
+        }
+        // Param-driven segment: entity[p.name] — the property depends on the
+        // param VALUE, so the resulting template is tied to these params.
+        // Stryker disable next-line all: documented equivalent cluster (see
+        // docs/mutation-backlog.md) — every mutation of this four-conjunct guard reroutes
+        // bracket access between two paths that both collapse to NOT_PARSABLE; the
+        // experiment recorded there aimed 30 tests at this line and killed none.
+        if (kind === "property" && token.kind === "identifier" && this.paramsName != null && token.value === this.paramsName) {
+            const paramPath = [];
+            while(this.stream.matchPunctuation(".") || this.stream.matchPunctuation("?.")){
+                paramPath.push(this.stream.next().value);
             }
-            else {
-                // For other methods, return NOT_PARSABLE for now
-                return _types__rspack_import_0.Expression.NOT_PARSABLE;
+            const resolved = resolveParamPath(this.paramsName, paramPath, this.params);
+            if (typeof resolved !== "string") {
+                throw new ParamDependentParseError(ERROR_MESSAGES.PROPERTY_NOT_FOUND(paramPath.join(".")));
             }
+            this.structurallyDependsOnParams = true;
+            return resolved;
         }
-        else {
-            // Normal case: property on left, value on right
-            const property = getProperty(schema, leftSide, params);
-            const serializer = property.property.valueSerializer;
-            const value = getValue(rightSide, params); // retrieve the original value
-            comparator.left = property;
-            comparator.right = serializer ? getValue(String(property.property.valueSerializer(parseUnknown(value.value)))) : value;
-        }
-        // If the comparison is explicitly to false, mark it as negated
-        if (methodMatch[6] === "false") {
-            comparator.negated = true;
-        }
-        return comparator;
-    }
-    // Check for transformations on the value side (right side of comparison) - check this FIRST
-    const valueTransformMatch = finalExpression.match(/([^=!<>]+?)\s*(===|==|!==|!=)\s*([^)]+)\.(toLowerCase|toUpperCase|toLocaleLowerCase|toLocaleUpperCase)\(\)/);
-    if (valueTransformMatch) {
-        const comparator = getComparator(valueTransformMatch[2]);
-        if (isNegation) {
-            comparator.negated = isNegation;
-        }
-        const property = getProperty(schema, valueTransformMatch[1].trim(), params);
-        const serializer = property.property.valueSerializer;
-        const value = getValue(valueTransformMatch[3], params); // retrieve the original value
-        // Create the property expression for the left side (no transformer)
-        const propertyExpression = property;
-        // Create a ValueExpression for the right side with transformer
-        const valueExpression = serializer ? getValue(String(property.property.valueSerializer(parseUnknown(value.value)))) : value;
-        // Set transformer and locale based on the method
-        const method = valueTransformMatch[4];
-        if (method === 'toLowerCase' || method === 'toLocaleLowerCase') {
-            valueExpression.transformer = 'to-lower-case';
-            if (method === 'toLocaleLowerCase') {
-                valueExpression.locale = 'en-US';
+        throw new Error(ERROR_MESSAGES.UNSUPPORTED(`bracket access '[${token.value}]'`));
+    }
+    resolveChain(kind, path, transformer, locale) {
+        if (kind === "param") {
+            if (path.length === 0) {
+                // `params` alone is a variable, not a value we can resolve
+                throw new Error(ERROR_MESSAGES.PARAM_PATH_NOT_FOUND(this.paramsName ?? "params", this.params));
             }
+            return {
+                kind: "param",
+                path,
+                transformer,
+                locale
+            };
         }
-        else {
-            valueExpression.transformer = 'to-upper-case';
-            if (method === 'toLocaleUpperCase') {
-                valueExpression.locale = 'en-US';
+        const pathString = path.join(".");
+        const property = this.schema.properties.find((w)=>w.getAssignmentPath() == pathString);
+        if (property == null) {
+            // `.length` on a string/array property — a real schema property named
+            // `length` wins (checked above); otherwise treat it as a transformer
+            if (path.length > 1 && path[path.length - 1] === "length" && transformer == null) {
+                const parentPath = path.slice(0, -1).join(".");
+                const parent = this.schema.properties.find((w)=>w.getAssignmentPath() == parentPath);
+                // Vector is deliberately absent. Its length is the dimension count declared
+                // in the schema — a constant, not data — so a filter on it answers a question
+                // nobody asks, and pushing it down would need `json_array_length` on a
+                // backend storing JSON and something else entirely on one with a native
+                // vector column. Not parsing it leaves a clear error instead of a dialect gap.
+                if (parent != null && (parent.type === _schema__rspack_import_2/* .SchemaTypes.String */.L.String || parent.type === _schema__rspack_import_2/* .SchemaTypes.Array */.L.Array)) {
+                    return {
+                        kind: "property",
+                        property: parent,
+                        transformer: "length",
+                        locale: null
+                    };
+                }
             }
+            throw new Error(ERROR_MESSAGES.PROPERTY_NOT_FOUND(pathString));
         }
-        comparator.left = propertyExpression;
-        comparator.right = valueExpression;
-        return comparator;
-    }
-    if (transformMethodMatch) {
-        // Handle .toLowerCase or .toUpperCase on the property side
-        const comparator = getComparator(transformMethodMatch[3]); // e.g., startsWith, endsWith, includes
-        if (isNegation) {
-            comparator.negated = isNegation;
-        }
-        // Create the property expression for the left side with transformer
-        const property = getProperty(schema, transformMethodMatch[1], params);
-        // Set transformer and locale based on the method
-        const method = transformMethodMatch[2];
-        if (method === 'toLowerCase' || method === 'toLocaleLowerCase') {
-            property.transformer = 'to-lower-case';
-            if (method === 'toLocaleLowerCase') {
-                property.locale = 'en-US'; // Default locale, could be extracted from method call
+        return {
+            kind: "property",
+            property,
+            transformer,
+            locale
+        };
+    }
+    withValueTransformer(operand) {
+        if (this.stream.isPunctuation(".")) {
+            const method = this.stream.peek(1);
+            // Stryker disable next-line all: documented equivalent cluster (see
+            // docs/mutation-backlog.md) — the guard's conjuncts each route to a rejection that
+            // collapses to NOT_PARSABLE with an indistinguishable message; 18 targeted tests
+            // killed none of these.
+            if (method != null && method.kind === "identifier" && TRANSFORM_METHODS[method.value] != null) {
+                this.stream.next(); // .
+                this.stream.next(); // method name
+                this.stream.expectPunctuation("(");
+                this.stream.expectPunctuation(")");
+                operand.transformer = TRANSFORM_METHODS[method.value].transformer;
+                operand.locale = TRANSFORM_METHODS[method.value].locale;
             }
         }
-        else {
-            property.transformer = 'to-upper-case';
-            if (method === 'toLocaleUpperCase') {
-                property.locale = 'en-US'; // Default locale, could be extracted from method call
+        return operand;
+    }
+    // #region Condition building
+    buildComparison(left, operator, right) {
+        // methodCall == true/false — fold the boolean into negation
+        if (left.kind === "method-call") {
+            if (operator.comparator === "equals" && right.kind === "value" && typeof right.value === "boolean") {
+                const comparator = this.buildMethodComparator(left);
+                const comparedToFalse = right.value === false;
+                comparator.negated = comparator.negated !== (operator.negated !== comparedToFalse);
+                return comparator;
             }
+            throw new Error(ERROR_MESSAGES.UNSUPPORTED("comparing a method call to a non-boolean"));
         }
-        // Create a ValueExpression for the right side
-        let value = getValue(transformMethodMatch[4], params);
-        // Check if the value also has a transformation (but only if it's not already handled by value-side check)
-        const valueTransformMatch = transformMethodMatch[4].match(/^([^)]+)\.(toLowerCase|toUpperCase|toLocaleLowerCase|toLocaleUpperCase)\(\)$/);
-        if (valueTransformMatch) {
-            // Create a new ValueExpression with the base value and transformer
-            value = new _types__rspack_import_0.ValueExpression({
-                value: valueTransformMatch[1].replace(/^["']|["']$/g, '') // Remove quotes
+        if (right.kind === "method-call") {
+            throw new Error(ERROR_MESSAGES.UNSUPPORTED("method call on the right side of a comparison"));
+        }
+        if (left.kind === "property" && right.kind === "property") {
+            // Casing transformers are only valid with string-matching comparators,
+            // which cannot produce a property-to-property comparison
+            if (left.transformer === "to-lower-case" || left.transformer === "to-upper-case" || right.transformer === "to-lower-case" || right.transformer === "to-upper-case") {
+                throw new Error(ERROR_MESSAGES.UNSUPPORTED("transform method outside of startsWith/endsWith/includes"));
+            }
+            return new _types__rspack_import_1/* .ComparatorExpression */.bQ({
+                comparator: operator.comparator,
+                negated: operator.negated,
+                strict: operator.strict,
+                left: this.createPropertyExpression(left),
+                right: this.createPropertyExpression(right)
             });
-            // Set transformer and locale based on the method
-            const valueMethod = valueTransformMatch[2];
-            if (valueMethod === 'toLowerCase' || valueMethod === 'toLocaleLowerCase') {
-                value.transformer = 'to-lower-case';
-                if (valueMethod === 'toLocaleLowerCase') {
-                    value.locale = 'en-US'; // Default locale
-                }
+        }
+        if (left.kind === "property" && right.kind !== "property") {
+            return this.buildPropertyComparator(left, operator, right, /* applyConverter */ true);
+        }
+        if (right.kind === "property" && left.kind !== "property") {
+            const swapped = {
+                ...operator,
+                comparator: SWAPPED_COMPARATORS[operator.comparator]
+            };
+            return this.buildPropertyComparator(right, swapped, left, /* applyConverter */ true);
+        }
+        throw new Error(ERROR_MESSAGES.UNSUPPORTED("comparison requires a schema property on at least one side"));
+    }
+    buildStandalone(operand) {
+        if (operand.kind === "method-call") {
+            return this.buildMethodComparator(operand);
+        }
+        if (operand.kind === "property") {
+            // Truthy shorthand on `.length`: a length is truthy exactly when > 0
+            if (operand.transformer === "length") {
+                return this.buildPropertyComparator(operand, COMPARISON_OPERATORS[">"], {
+                    kind: "value",
+                    value: 0,
+                    transformer: null,
+                    locale: null
+                }, /* applyConverter */ true);
             }
-            else {
-                value.transformer = 'to-upper-case';
-                if (valueMethod === 'toLocaleUpperCase') {
-                    value.locale = 'en-US'; // Default locale
-                }
+            // Truthy shorthand: `w.isActive` → isActive === true
+            return this.buildPropertyComparator(operand, COMPARISON_OPERATORS["==="], {
+                kind: "value",
+                value: true,
+                transformer: null,
+                locale: null
+            }, /* applyConverter */ true);
+        }
+        // Constant `true` — a tautology, which parseAnd/parseOr simplify away
+        if (operand.kind === "value" && operand.value === true && operand.transformer == null) {
+            return _types__rspack_import_1/* .Expression.EMPTY */.r4.EMPTY;
+        }
+        throw new Error(ERROR_MESSAGES.UNSUPPORTED("a filter condition must reference a schema property"));
+    }
+    buildMethodComparator(operand) {
+        const { target, method, argument } = operand;
+        if (target.kind === "property") {
+            if (argument.kind === "property") {
+                throw new Error(ERROR_MESSAGES.UNSUPPORTED(`.${method}() comparing two schema properties`));
             }
+            // Method arguments skip type conversion — only the value serializer applies
+            return this.buildPropertyComparator(target, {
+                comparator: COMPARATOR_METHODS[method],
+                negated: false,
+                strict: false
+            }, argument, /* applyConverter */ false);
         }
-        const serializer = property.property.valueSerializer;
-        comparator.left = property;
-        comparator.right = serializer ? getValue(String(property.property.valueSerializer(parseUnknown(value.value)))) : value;
-        // If the comparison is explicitly to false, mark it as negated
-        if (transformMethodMatch[7] === "false") {
-            comparator.negated = true;
-        }
-        return comparator;
-    }
-    if (equalityMatch) {
-        const left = equalityMatch[1].trim();
-        const operator = equalityMatch[2];
-        const right = equalityMatch[3].trim();
-        const leftIsProperty = isPropertyPath(left, params);
-        const rightIsProperty = isPropertyPath(right, params);
-        // Determine which side is the property and which is the value
-        let propertySide, valueSide, finalOperator;
-        if (leftIsProperty && !rightIsProperty) {
-            // Normal case: property === value
-            propertySide = left;
-            valueSide = right;
-            finalOperator = operator;
-        }
-        else if (!leftIsProperty && rightIsProperty) {
-            // Reversed case: value === property
-            propertySide = right;
-            valueSide = left;
-            finalOperator = operator;
-        }
-        else {
-            // Both sides look like properties or neither does - assume left is property
-            propertySide = left;
-            valueSide = right;
-            finalOperator = operator;
-        }
-        const comparator = getComparator(finalOperator);
-        if (isNegation) {
-            comparator.negated = isNegation;
-        }
-        const property = getProperty(schema, propertySide, params);
-        const value = getValue(valueSide, params);
-        const serializer = property.property.valueSerializer;
-        comparator.left = property;
-        comparator.right = serializer ? getValue(String(property.property.valueSerializer(parseUnknown(value.value)))) : value;
-        convertAndAssignValue(comparator.right, comparator.left);
-        return comparator;
-    }
-    if (comparisonMatch) {
-        const left = comparisonMatch[1].trim();
-        const operator = comparisonMatch[2];
-        const right = comparisonMatch[3].trim();
-        const leftIsProperty = isPropertyPath(left, params);
-        const rightIsProperty = isPropertyPath(right, params);
-        // Determine which side is the property and which is the value
-        let propertySide, valueSide, finalOperator;
-        if (leftIsProperty && !rightIsProperty) {
-            // Normal case: property > value
-            propertySide = left;
-            valueSide = right;
-            finalOperator = operator;
-        }
-        else if (!leftIsProperty && rightIsProperty) {
-            // Reversed case: value > property -> property < value
-            propertySide = right;
-            valueSide = left;
-            finalOperator = getSwappedOperator(operator);
-        }
-        else {
-            // Both sides look like properties or neither does - assume left is property
-            propertySide = left;
-            valueSide = right;
-            finalOperator = operator;
-        }
-        const comparator = getComparator(finalOperator);
-        if (isNegation) {
-            comparator.negated = isNegation;
-        }
-        const property = getProperty(schema, propertySide, params);
-        const value = getValue(valueSide, params);
-        const serializer = property.property.valueSerializer;
-        comparator.left = property;
-        comparator.right = serializer ? getValue(String(property.property.valueSerializer(parseUnknown(value.value)))) : value;
-        convertAndAssignValue(comparator.right, comparator.left);
-        return comparator;
-    }
-    // Check for standalone property reference (truthy comparison)
-    // Pattern: property name only (e.g., "w.inStock" -> w.inStock === true)
-    const standalonePropertyMatch = finalExpression.match(/^[a-zA-Z_$][a-zA-Z0-9_$]*(\.[a-zA-Z_$][a-zA-Z0-9_$]*)*$/);
-    if (standalonePropertyMatch && isPropertyPath(finalExpression, params)) {
-        const comparator = getComparator('===');
-        if (isNegation) {
-            comparator.negated = isNegation;
-        }
-        const property = getProperty(schema, finalExpression, params);
-        const value = getValue('true', params);
-        const serializer = property.property.valueSerializer;
-        comparator.left = property;
-        // need to parse the value so it matches what the serializer expects
-        comparator.right = serializer ? getValue(String(property.property.valueSerializer(parseUnknown(value.value)))) : value;
-        return comparator;
-    }
-    // If we get here, the expression is too complex for the current parser
-    // This is expected for complex real-world expressions
-    throw new Error(`Unsupported expression format: ${finalExpression}`);
-};
-const getComparator = (value) => {
-    const comparator = COMPARATOR_MAP.get(value);
-    if (comparator == null) {
-        throw new Error(ERROR_MESSAGES.COMPARATOR_NOT_FOUND(value));
-    }
-    // Return a new instance to avoid modifying the cached one
-    return new _types__rspack_import_0.ComparatorExpression({
-        comparator: comparator.comparator,
-        negated: comparator.negated,
-        strict: comparator.strict
-    });
-};
-const getValue = (value, params) => {
-    // Early return for string literals
-    if (value.startsWith("\'") || value.startsWith("\"")) {
-        return new _types__rspack_import_0.ValueExpression({
-            value: value.replace(/\"|\'/g, "")
+        // ["a", "b"].includes(x.prop) / params.list.includes(x.prop) —
+        // membership test with the collection on the left
+        if (method === "includes" && argument.kind === "property") {
+            if (target.transformer != null) {
+                throw new Error(ERROR_MESSAGES.UNSUPPORTED("transform method on a collection used with .includes()"));
+            }
+            return new _types__rspack_import_1/* .ComparatorExpression */.bQ({
+                comparator: "includes",
+                negated: false,
+                strict: false,
+                left: this.createValueExpression(target, argument.property, /* applyConverter */ false),
+                right: this.createPropertyExpression(argument)
+            });
+        }
+        throw new Error(ERROR_MESSAGES.UNSUPPORTED(`.${method}() on a non-property target`));
+    }
+    buildPropertyComparator(property, operator, value, applyConverter) {
+        const isStringMatch = operator.comparator === "starts-with" || operator.comparator === "ends-with" || operator.comparator === "includes";
+        // `.length` compares a NUMBER, so the paired property's serializer and
+        // type converter must not touch the value; and a length has no meaning
+        // inside a string-matching comparator
+        if (property.transformer === "length") {
+            if (isStringMatch) {
+                throw new Error(ERROR_MESSAGES.UNSUPPORTED("'.length' with startsWith/endsWith/includes"));
+            }
+            return new _types__rspack_import_1/* .ComparatorExpression */.bQ({
+                comparator: operator.comparator,
+                negated: operator.negated,
+                strict: operator.strict,
+                left: this.createPropertyExpression(property),
+                right: this.createValueExpression(value, null, /* applyConverter */ false)
+            });
+        }
+        // Casing transformers on a property are only meaningful with string-matching
+        // comparators; on relational comparators the plugins would silently
+        // ignore them and return wrong data
+        if (property.transformer != null && !isStringMatch) {
+            throw new Error(ERROR_MESSAGES.UNSUPPORTED("transform method outside of startsWith/endsWith/includes"));
+        }
+        return new _types__rspack_import_1/* .ComparatorExpression */.bQ({
+            comparator: operator.comparator,
+            negated: operator.negated,
+            strict: operator.strict,
+            left: this.createPropertyExpression(property),
+            right: this.createValueExpression(value, property.property, applyConverter)
+        });
+    }
+    createPropertyExpression(operand) {
+        const expression = new _types__rspack_import_1/* .PropertyExpression */.ep({
+            property: operand.property
+        });
+        expression.transformer = operand.transformer;
+        expression.locale = operand.locale;
+        return expression;
+    }
+    createValueExpression(operand, pairedProperty, applyConverter) {
+        if (operand.kind === "param") {
+            const expression = new ParamReferenceExpression({
+                paramPath: operand.path,
+                pairedProperty,
+                applyConverter
+            });
+            expression.transformer = operand.transformer;
+            expression.locale = operand.locale;
+            return expression;
+        }
+        const expression = new _types__rspack_import_1/* .ValueExpression */.Ko({
+            value: resolvePairedValue(operand.value, pairedProperty, applyConverter)
+        });
+        expression.transformer = operand.transformer;
+        expression.locale = operand.locale;
+        return expression;
+    }
+}
+// #endregion
+// #region Template binding
+/**
+ * Deep-clones a template into a consumer-facing tree, resolving parameter
+ * placeholders against the supplied params.  Always clones so cached templates
+ * can never be mutated by consumers.
+ */ const bindExpression = (expression, paramsName, params)=>{
+    if (expression instanceof ParamReferenceExpression) {
+        const raw = resolveParamPath(paramsName ?? "params", expression.paramPath, params);
+        const bound = new _types__rspack_import_1/* .ValueExpression */.Ko({
+            value: resolvePairedValue(raw, expression.pairedProperty, expression.applyConverter)
         });
+        bound.transformer = expression.transformer;
+        bound.locale = expression.locale;
+        return bound;
     }
-    // Early return for null/undefined
-    if (value === "null") {
-        return new _types__rspack_import_0.ValueExpression({ value: null });
+    if (expression instanceof _types__rspack_import_1/* .ValueExpression */.Ko) {
+        const clone = new _types__rspack_import_1/* .ValueExpression */.Ko({
+            value: expression.value
+        });
+        clone.transformer = expression.transformer;
+        clone.locale = expression.locale;
+        return clone;
     }
-    if (value === "undefined" || value === "void 0") {
-        return new _types__rspack_import_0.ValueExpression({ value: undefined });
+    if (expression instanceof _types__rspack_import_1/* .PropertyExpression */.ep) {
+        const clone = new _types__rspack_import_1/* .PropertyExpression */.ep({
+            property: expression.property
+        });
+        clone.transformer = expression.transformer;
+        clone.locale = expression.locale;
+        return clone;
     }
-    // Optimized number parsing with early return
-    const numValue = +value;
-    if (!isNaN(numValue) && isFinite(numValue)) {
-        return new _types__rspack_import_0.ValueExpression({ value: numValue });
+    if (expression instanceof _types__rspack_import_1/* .ComparatorExpression */.bQ) {
+        return new _types__rspack_import_1/* .ComparatorExpression */.bQ({
+            comparator: expression.comparator,
+            negated: expression.negated,
+            strict: expression.strict,
+            left: expression.left ? bindExpression(expression.left, paramsName, params) : undefined,
+            right: expression.right ? bindExpression(expression.right, paramsName, params) : undefined
+        });
     }
-    // Handle parameter paths if params are provided
-    if (params != null) {
-        // Check if this is a parameter path (starts with params.name)
-        if (value.startsWith(params.name)) {
-            return new _types__rspack_import_0.ValueExpression({
-                value: getValueFromParams(value, params)
-            });
+    if (expression instanceof _types__rspack_import_1/* .OperatorExpression */.fw) {
+        return new _types__rspack_import_1/* .OperatorExpression */.fw({
+            operator: expression.operator,
+            left: expression.left ? bindExpression(expression.left, paramsName, params) : undefined,
+            right: expression.right ? bindExpression(expression.right, paramsName, params) : undefined
+        });
+    }
+    return expression;
+};
+/**
+ * Splits stringified filter source into parameter names and the expression
+ * body, unwrapping single-return block bodies.
+ */ const resolveFunctionShape = (stringifiedFunction, hasParams)=>{
+    const source = stringifiedFunction.trim();
+    let parameterNames;
+    let body;
+    // `function (x) { ... }` / `function name(x) { ... }` — what ES5-targeting
+    // transpilers rewrite every arrow filter into
+    const functionHead = /^function\b[^(]*\(/.exec(source);
+    if (functionHead != null) {
+        const parametersEnd = source.indexOf(")", functionHead[0].length);
+        if (parametersEnd === -1) {
+            throw new Error("Invalid Function");
         }
-        // Check if this is a parameter path without the params prefix
-        if (value.includes('.')) {
-            // Try to extract the parameter path
-            const paramMatch = value.match(PARAM_PATH_REGEX);
-            if (paramMatch) {
-                const potentialParamPath = paramMatch[1];
-                try {
-                    const paramValue = getValueFromParams(`${params.name}.${potentialParamPath}`, params);
-                    return new _types__rspack_import_0.ValueExpression({ value: paramValue });
-                }
-                catch (e) {
-                    // Not a parameter path, continue with normal parsing
-                }
-            }
+        parameterNames = source.slice(functionHead[0].length, parametersEnd).trim();
+        body = source.slice(parametersEnd + 1).trim();
+    } else {
+        const arrowIndex = source.indexOf("=>");
+        if (arrowIndex === -1) {
+            throw new Error("Invalid Function");
+        }
+        parameterNames = source.substring(0, arrowIndex).trim();
+        body = source.substring(arrowIndex + 2).trim();
+        // Strip wrapping parens: (entity) or ([x, p])
+        if (parameterNames.startsWith("(") && parameterNames.endsWith(")")) {
+            parameterNames = parameterNames.slice(1, -1).trim();
         }
     }
-    if (STRINGIFIED_COMPARE_OPERATORS.includes(value)) {
-        return new _types__rspack_import_0.ValueExpression({ value });
+    let entityName;
+    let paramsName = null;
+    if (parameterNames.startsWith("[") && parameterNames.endsWith("]")) {
+        const destructured = parameterNames.slice(1, -1).split(",").map((w)=>w.trim());
+        entityName = destructured[0];
+        if (hasParams) {
+            paramsName = destructured[1] ?? null;
+        }
+    } else {
+        entityName = parameterNames;
     }
-    if (isNaN(numValue)) {
-        // value is a variable passed in by the dev, we cannot evaluate it's value
-        // need to fallback to select all by throwing an error
-        throw new Error(`Cannot derive value from variable, please pass parameters into the expression.
-
-Example: .where(([x, params]) => x.id === params.id, { id: someVar.id })
-Issue At: ${value}`);
+    if (entityName == null || entityName.length === 0) {
+        throw new Error("Invalid Function");
     }
-    // Default case: return as-is
-    return new _types__rspack_import_0.ValueExpression({ value });
-};
-const getValueFromParams = (value, params) => {
-    const split = value.split('.');
-    // Early exit for invalid paths
-    if (split.length === 1) {
-        throw new Error(ERROR_MESSAGES.PARAM_PATH_NOT_FOUND(value, params.data));
-    }
-    let result = params.data;
-    // For nested params - start from index 1 to skip the params prefix
-    for (let i = 1; i < split.length; i++) {
-        const name = split[i];
-        if (name in result) {
-            result = result[name];
-            continue;
+    // Unwrap a single-return block body: { return <expression>; }
+    if (body.startsWith("{")) {
+        const inner = body.slice(1, body.lastIndexOf("}")).trim();
+        if (!inner.startsWith("return")) {
+            throw new Error(ERROR_MESSAGES.UNSUPPORTED("block body without a single return statement"));
         }
-        throw new Error(ERROR_MESSAGES.PARAM_PATH_NOT_FOUND(value, params.data));
+        body = inner.slice("return".length).trim();
+        if (body.endsWith(";")) {
+            body = body.slice(0, -1).trim();
+        }
+    }
+    return {
+        entityName,
+        paramsName,
+        body
+    };
+};
+// Keyed by schema instance so identical filter source on different schemas can
+// never collide; entries live only as long as the schema does
+const templateCache = new WeakMap();
+const MAX_CACHED_TEMPLATES_PER_SCHEMA = 1024;
+const getCachedTemplate = (schema, source)=>{
+    return templateCache.get(schema)?.get(source) ?? null;
+};
+const setCachedTemplate = (schema, source, entry)=>{
+    let bySource = templateCache.get(schema);
+    if (bySource == null) {
+        bySource = new Map();
+        templateCache.set(schema, bySource);
+    }
+    // Filter source strings come from static code, so this cap should never be
+    // hit in practice — it only guards against unbounded dynamic generation.
+    // Stryker disable next-line all: the cap is a pure resource bound — every mutation of
+    // it (never clear, always clear, off-by-one) parses identically and differs only in
+    // memory growth, which no observable boundary can assert.
+    if (bySource.size >= MAX_CACHED_TEMPLATES_PER_SCHEMA) {
+        bySource.clear();
+    }
+    bySource.set(source, entry);
+};
+// #endregion
+const combineExpressions = (...expressions)=>{
+    if (expressions.length === 0) {
+        throw new Error("combineExpressions requires at least 1 expression");
+    }
+    if (expressions.length === 1) {
+        return expressions[0];
+    }
+    // Start with the first expression
+    let result = expressions[0];
+    // Loop through remaining expressions and combine them
+    for(let i = 1; i < expressions.length; i++){
+        result = new _types__rspack_import_1/* .OperatorExpression */.fw({
+            operator: "&&",
+            left: result,
+            right: expressions[i]
+        });
     }
     return result;
 };
-const getProperty = (schema, value, params) => {
-    let pathString;
-    // Handle bracket notation (e.g., entity["name"], entity['name'], entity[p.name], or entity[\"name\"] with escaped quotes)
-    if (value.includes('[') && value.includes(']')) {
-        // First try to match literal string brackets: ["name"], ['name'], [\"name\"], [\'name\']
-        const literalBracketMatches = value.matchAll(/\[\\?["']([^"']+)\\?["']\]/g);
-        const pathParts = [];
-        let foundLiteral = false;
-        for (const match of literalBracketMatches) {
-            // match[1] is the property name inside the brackets
-            const propName = match[1];
-            if (propName) {
-                pathParts.push(propName);
-                foundLiteral = true;
-            }
-        }
-        // If no literal matches found, try parameter path in brackets (e.g., [p.name])
-        if (!foundLiteral && params) {
-            // Match brackets containing parameter paths: [p.name], [params.property], etc.
-            const bracketParamMatch = value.match(/\[([^\]]+)\]/);
-            if (bracketParamMatch) {
-                const bracketContent = bracketParamMatch[1].trim();
-                // Check if this is a parameter path
-                // It should start with params.name (e.g., "p") followed by a dot, or be just params.name
-                const isParamPath = bracketContent.startsWith(params.name + '.') || bracketContent === params.name;
-                if (isParamPath || (bracketContent.includes('.') && bracketContent.match(PARAM_PATH_REGEX))) {
-                    try {
-                        // Try to resolve as a parameter path
-                        let paramPath;
-                        if (bracketContent.startsWith(params.name + '.') || bracketContent === params.name) {
-                            // Already has params.name prefix
-                            paramPath = bracketContent;
-                        }
-                        else {
-                            // Add params.name prefix
-                            const paramMatch = bracketContent.match(PARAM_PATH_REGEX);
-                            paramPath = paramMatch
-                                ? `${params.name}.${paramMatch[1]}`
-                                : `${params.name}.${bracketContent}`;
-                        }
-                        const resolvedValue = getValueFromParams(paramPath, params);
-                        // The resolved value should be the property name
-                        if (typeof resolvedValue === 'string') {
-                            pathParts.push(resolvedValue);
-                        }
-                        else {
-                            throw new Error(ERROR_MESSAGES.PROPERTY_NOT_FOUND(value));
-                        }
-                    }
-                    catch (e) {
-                        // Not a valid parameter path, continue to error
-                        throw new Error(ERROR_MESSAGES.PROPERTY_NOT_FOUND(value));
-                    }
-                }
-                else {
-                    throw new Error(ERROR_MESSAGES.PROPERTY_NOT_FOUND(value));
-                }
-            }
-            else {
-                throw new Error(ERROR_MESSAGES.PROPERTY_NOT_FOUND(value));
-            }
+/**
+ * Parses an expression SOURCE FRAGMENT against one schema and one root name.
+ *
+ * `toExpression` starts from a function and works out its own roots. This starts from text, which
+ * is what a caller has when it has split a larger predicate apart — `p.rank > 10` lifted out of
+ * `([p, m]) => p.rank > 10 && m.won === true`.
+ *
+ * **A fragment naming anything other than `rootName` returns `NOT_PARSABLE`, and that is the
+ * point.** It is how a caller discovers which side of a join a conjunct belongs to: parse it
+ * against each side in turn, and exactly one succeeds for a single-side condition. A condition
+ * spanning both fails against both, which is the correct answer — it cannot be pushed to either.
+ *
+ * No params: a fragment carrying a params reference has no bag to resolve it against here, so it
+ * fails rather than binding to nothing.
+ *
+ * Deliberately NOT cached. The cache is keyed by function source, and a fragment is not a function
+ * — two different lambdas can contain the same fragment text against different schemas.
+ */ const parseFragment = (schema, body, rootName)=>{
+    try {
+        const stream = new TokenStream(tokenize(body));
+        const parser = new ExpressionParser(schema, stream, rootName, null, undefined);
+        return parser.parse();
+    } catch  {
+        // The failure is expected and informative — see above — so it is not logged. A caller that
+        // parses one conjunct against two schemas would otherwise warn on every successful split.
+        return _types__rspack_import_1/* .Expression.NOT_PARSABLE */.r4.NOT_PARSABLE;
+    }
+};
+const toExpression = (schema, fn, params)=>{
+    const stringifiedFunction = fn.toString();
+    const warn = (error)=>_utilities__rspack_import_3/* .logger.warn */.vF.warn("Error parsing expression", {
+            error,
+            collectionName: schema.collectionName,
+            params,
+            selector: stringifiedFunction
+        });
+    const cached = getCachedTemplate(schema, stringifiedFunction);
+    if (cached != null) {
+        // A cached failure — the warning was already logged when it was discovered
+        if (_types__rspack_import_1/* .Expression.isNotParsable */.r4.isNotParsable(cached.template)) {
+            return _types__rspack_import_1/* .Expression.NOT_PARSABLE */.r4.NOT_PARSABLE;
         }
-        if (pathParts.length === 0) {
-            throw new Error(ERROR_MESSAGES.PROPERTY_NOT_FOUND(value));
+        try {
+            return bindExpression(cached.template, cached.paramsName, params);
+        } catch (error) {
+            // Binding failures are param-dependent by nature — never cached
+            warn(error);
+            return _types__rspack_import_1/* .Expression.NOT_PARSABLE */.r4.NOT_PARSABLE;
         }
-        pathString = pathParts.join(".");
     }
-    else if (value.includes('.')) {
-        // Handle dot notation (e.g., entity.name)
-        const pathSplit = value.split(/[?!.]/g).slice(1);
-        pathString = pathSplit.join(".");
-    }
-    else {
-        throw new Error(ERROR_MESSAGES.PROPERTY_NOT_FOUND(value));
+    let paramsName = null;
+    let template;
+    let structurallyDependsOnParams;
+    try {
+        const shape = resolveFunctionShape(stringifiedFunction, params != null);
+        const stream = new TokenStream(tokenize(shape.body));
+        const parser = new ExpressionParser(schema, stream, shape.entityName, shape.paramsName, params);
+        paramsName = shape.paramsName;
+        template = parser.parse();
+        structurallyDependsOnParams = parser.structurallyDependsOnParams;
+    } catch (error) {
+        // Cache the failure so a hot query on an unsupported filter doesn't
+        // re-parse and re-warn on every execution.  Param-dependent failures are
+        // exempt: the same source can succeed with different params.
+        if (!(error instanceof ParamDependentParseError)) {
+            setCachedTemplate(schema, stringifiedFunction, {
+                template: _types__rspack_import_1/* .Expression.NOT_PARSABLE */.r4.NOT_PARSABLE,
+                paramsName: null
+            });
+        }
+        warn(error);
+        return _types__rspack_import_1/* .Expression.NOT_PARSABLE */.r4.NOT_PARSABLE;
     }
-    // Early exit if no path found
-    if (!pathString) {
-        throw new Error(ERROR_MESSAGES.PROPERTY_NOT_FOUND(value));
+    // Templates whose structure was resolved from param values are only
+    // valid for this exact params object — parse those fresh every time
+    if (!structurallyDependsOnParams) {
+        setCachedTemplate(schema, stringifiedFunction, {
+            template,
+            paramsName
+        });
     }
-    const found = schema.properties.find(w => w.getAssignmentPath() == pathString);
-    if (found == null) {
-        throw new Error(ERROR_MESSAGES.PROPERTY_NOT_FOUND(value));
+    try {
+        return bindExpression(template, paramsName, params);
+    } catch (error) {
+        warn(error);
+        return _types__rspack_import_1/* .Expression.NOT_PARSABLE */.r4.NOT_PARSABLE;
     }
-    return new _types__rspack_import_0.PropertyExpression({ property: found });
 };
 
 
 },
-"./src/expressions/types.ts"(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-__webpack_require__.r(__webpack_exports__);
+27(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
 __webpack_require__.d(__webpack_exports__, {
-  ComparatorExpression: () => (ComparatorExpression),
-  EmptyExpression: () => (EmptyExpression),
-  Expression: () => (Expression),
-  NotParsableExpression: () => (NotParsableExpression),
-  OperatorExpression: () => (OperatorExpression),
-  PropertyExpression: () => (PropertyExpression),
-  ValueExpression: () => (ValueExpression)
+  Ko: () => (ValueExpression),
+  SC: () => (NotParsableExpression),
+  Sm: () => (EmptyExpression),
+  bQ: () => (ComparatorExpression),
+  ep: () => (PropertyExpression),
+  fw: () => (OperatorExpression),
+  r4: () => (Expression)
 });
+const valueToJson = (value)=>{
+    if (value === undefined) {
+        return {
+            k: "undefined"
+        };
+    }
+    if (value === null) {
+        return {
+            k: "raw",
+            v: null
+        };
+    }
+    if (value instanceof Date) {
+        // ISO rather than epoch millis: it survives a human reading the payload, and an invalid
+        // Date has no ISO form — so it is caught here rather than becoming a silent `null`.
+        return {
+            k: "date",
+            v: value.toISOString()
+        };
+    }
+    if (Array.isArray(value)) {
+        return {
+            k: "array",
+            v: value.map(valueToJson)
+        };
+    }
+    if (typeof value === "number" && Number.isFinite(value) === false) {
+        // `JSON.stringify` turns all three of these into `null`, which would compare as a different
+        // value entirely rather than failing.
+        return {
+            k: "number",
+            v: Number.isNaN(value) ? "NaN" : value > 0 ? "Infinity" : "-Infinity"
+        };
+    }
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+        return {
+            k: "raw",
+            v: value
+        };
+    }
+    throw new Error(`Cannot serialize this filter value: only strings, numbers, booleans, null, undefined, Dates and arrays of those can cross a wire.  ` + `Received: ${Object.prototype.toString.call(value)}`);
+};
+const valueFromJson = (value)=>{
+    if (value.k === "undefined") {
+        return undefined;
+    }
+    if (value.k === "date") {
+        return new Date(value.v);
+    }
+    if (value.k === "array") {
+        return value.v.map(valueFromJson);
+    }
+    if (value.k === "number") {
+        return value.v === "NaN" ? Number.NaN : value.v === "Infinity" ? Number.POSITIVE_INFINITY : Number.NEGATIVE_INFINITY;
+    }
+    return value.v;
+};
 /**
  * The base class for all expression types.
- */
-class Expression {
-    /** The left-hand side of the expression (if applicable). */
-    left;
-    /** The right-hand side of the expression (if applicable). */
-    right;
-    constructor(left, right) {
+ */ class Expression {
+    /** The left-hand side of the expression (if applicable). */ left;
+    /** The right-hand side of the expression (if applicable). */ right;
+    constructor(left, right){
         this.left = left;
         this.right = right;
     }
@@ -796,6 +1596,132 @@ class Expression {
     static isNotParsable(expression) {
         return expression.type === "not-parsable" || expression instanceof NotParsableExpression;
     }
+    /**
+     * Turns a tree into plain JSON, so a whole query can cross a wire.
+     *
+     * On the class rather than beside it, because this is the type's own REPRESENTATION — there is one
+     * right answer and it belongs with the thing being represented, next to `EMPTY` and `isEmpty`.
+     * Rendering a tree into some other language (`toSql`, `toMql`, `evaluate`) is a different kind of
+     * thing: there are many, each belongs to its consumer, and none of them is canonical.
+     *
+     * ## Why it is this small
+     *
+     * Of the six node types a bound tree can contain, exactly one holds anything JSON cannot carry:
+     * `PropertyExpression`, whose live `PropertyInfo` has functions, a parent chain and caches. It
+     * reduces to a property PATH — `PropertyInfo.id` IS the dotted path, and `getProperty` is keyed by
+     * exactly that — so rebinding is one lookup.
+     *
+     * `ParamReferenceExpression` never appears: it is a parse-time placeholder that binding replaces
+     * with a plain `ValueExpression` holding the resolved value. A serialized tree is always already
+     * bound, so there is no params object to send alongside it.
+     *
+     * Switches on `type` rather than using the `isXExpression` guards, which live in `../assertions`
+     * and import this module — the guards test the same discriminant, so nothing is lost.
+     */ static toJson(expression) {
+        if (expression.type === "operator") {
+            const operator = expression;
+            return {
+                t: "operator",
+                operator: operator.operator,
+                ...operator.left != null && {
+                    left: Expression.toJson(operator.left)
+                },
+                ...operator.right != null && {
+                    right: Expression.toJson(operator.right)
+                }
+            };
+        }
+        if (expression.type === "comparator") {
+            const comparator = expression;
+            return {
+                t: "comparator",
+                comparator: comparator.comparator,
+                negated: comparator.negated,
+                strict: comparator.strict,
+                ...comparator.left != null && {
+                    left: Expression.toJson(comparator.left)
+                },
+                ...comparator.right != null && {
+                    right: Expression.toJson(comparator.right)
+                }
+            };
+        }
+        if (expression.type === "property") {
+            const property = expression;
+            return {
+                t: "property",
+                // The dotted path, which is exactly the key `getProperty` is looking up
+                path: property.property.id,
+                transformer: property.transformer,
+                locale: property.locale
+            };
+        }
+        if (expression.type === "value") {
+            const value = expression;
+            return {
+                t: "value",
+                value: valueToJson(value.value),
+                transformer: value.transformer,
+                locale: value.locale
+            };
+        }
+        return expression.type === "empty" ? {
+            t: "empty"
+        } : {
+            t: "not-parsable"
+        };
+    }
+    /**
+     * Rebuilds a tree from JSON, rebinding every property against `schema`.
+     *
+     * The schema is SUPPLIED rather than read out of the payload. A filter always belongs to a known
+     * collection, and the RECEIVER's schema is the authority on what its properties are — taking an
+     * id from the payload would mean rebinding against a schema the sender chose, which is backwards
+     * for anything crossing a trust boundary.
+     *
+     * @throws when a property path is not declared by `schema`. Not `NOT_PARSABLE`: on a receiver, a
+     * filter that silently stops filtering returns rows the requester excluded, which is the one
+     * failure here worse than an error.
+     */ static fromJson(json, schema) {
+        const child = (node)=>node == null ? undefined : Expression.fromJson(node, schema);
+        if (json.t === "operator") {
+            return new OperatorExpression({
+                operator: json.operator,
+                left: child(json.left),
+                right: child(json.right)
+            });
+        }
+        if (json.t === "comparator") {
+            return new ComparatorExpression({
+                comparator: json.comparator,
+                negated: json.negated,
+                strict: json.strict,
+                left: child(json.left),
+                right: child(json.right)
+            });
+        }
+        if (json.t === "property") {
+            const property = schema.getProperty(json.path);
+            if (property == null) {
+                throw new Error(`Cannot deserialize a filter: this schema does not declare the property it names.  ` + `Property: ${json.path}, Collection: ${schema.collectionName}.  ` + `The two sides disagree about the shape of the data, so the filter cannot be applied.`);
+            }
+            const rebuilt = new PropertyExpression({
+                property
+            });
+            rebuilt.transformer = json.transformer;
+            rebuilt.locale = json.locale;
+            return rebuilt;
+        }
+        if (json.t === "value") {
+            const rebuilt = new ValueExpression({
+                value: valueFromJson(json.value)
+            });
+            rebuilt.transformer = json.transformer;
+            rebuilt.locale = json.locale;
+            return rebuilt;
+        }
+        return json.t === "empty" ? Expression.EMPTY : Expression.NOT_PARSABLE;
+    }
 }
 class EmptyExpression extends Expression {
     type = "empty";
@@ -805,17 +1731,12 @@ class NotParsableExpression extends Expression {
 }
 /**
  * A class representing a comparison operation (e.g., equals, greater-than).
- */
-class ComparatorExpression extends Expression {
-    /** The type of the expression (always 'comparator'). */
-    type = "comparator";
-    /** The comparator operation (e.g., equals, greater-than). */
-    comparator;
-    /** Whether the comparison is negated (e.g., not equals). */
-    negated;
-    /** Whether the comparison is strict (type-sensitive). */
-    strict;
-    constructor(options) {
+ */ class ComparatorExpression extends Expression {
+    /** The type of the expression (always 'comparator'). */ type = "comparator";
+    /** The comparator operation (e.g., equals, greater-than). */ comparator;
+    /** Whether the comparison is negated (e.g., not equals). */ negated;
+    /** Whether the comparison is strict (type-sensitive). */ strict;
+    constructor(options){
         super(options.left, options.right);
         this.comparator = options.comparator;
         this.negated = options.negated;
@@ -824,43 +1745,34 @@ class ComparatorExpression extends Expression {
 }
 /**
  * A class representing a logical operator (e.g., &&, ||).
- */
-class OperatorExpression extends Expression {
-    /** The type of the expression (always 'operator'). */
-    type = "operator";
-    /** The logical operator. */
-    operator;
-    constructor(options) {
+ */ class OperatorExpression extends Expression {
+    /** The type of the expression (always 'operator'). */ type = "operator";
+    /** The logical operator. */ operator;
+    constructor(options){
         super(options.left, options.right);
         this.operator = options.operator;
     }
 }
 /**
  * A class representing a property path.
- */
-class PropertyExpression extends Expression {
-    /** The type of the expression (always 'property'). */
-    type = "property";
-    /** The property info for the path. */
-    property;
+ */ class PropertyExpression extends Expression {
+    /** The type of the expression (always 'property'). */ type = "property";
+    /** The property info for the path. */ property;
     transformer = null;
     locale = null;
-    constructor(options) {
+    constructor(options){
         super();
         this.property = options.property;
     }
 }
 /**
  * A class representing a literal value.
- */
-class ValueExpression extends Expression {
-    /** The type of the expression (always 'value'). */
-    type = "value";
-    /** The literal value. */
-    value;
+ */ class ValueExpression extends Expression {
+    /** The type of the expression (always 'value'). */ type = "value";
+    /** The literal value. */ value;
     transformer = null;
     locale = null;
-    constructor(options) {
+    constructor(options){
         super();
         this.value = options.value;
     }
@@ -868,19 +1780,16 @@ class ValueExpression extends Expression {
 
 
 },
-"./src/expressions/utils.ts"(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-__webpack_require__.r(__webpack_exports__);
+63(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
 __webpack_require__.d(__webpack_exports__, {
-  forEach: () => (forEach),
-  getProperties: () => (getProperties),
-  isPropertyExpression: () => (isPropertyExpression)
+  j: () => (forEach),
+  o: () => (getProperties)
 });
 /**
  * Extracts all properties referenced in an expression
  * @param expression The expression to analyze
  * @returns Array of PropertyInfo objects referenced in the expression
- */
-function getProperties(expression) {
+ */ function getProperties(expression) {
     const properties = [];
     function traverse(expr) {
         // If this is a property expression, add it to our collection
@@ -898,9 +1807,6 @@ function getProperties(expression) {
     traverse(expression);
     return properties;
 }
-function isPropertyExpression(expression) {
-    return expression.type === "property";
-}
 function forEach(expression, callback) {
     function traverse(expr) {
         // Call the callback for this expression
@@ -926,60 +1832,165 @@ function forEach(expression, callback) {
 
 
 },
-"./src/utilities/dates.ts"(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-__webpack_require__.r(__webpack_exports__);
+537(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
 __webpack_require__.d(__webpack_exports__, {
-  isDate: () => (isDate)
+  L: () => (SchemaTypes)
 });
-const isDate = (data) => {
-    if (data == null) {
-        return false;
-    }
-    if (typeof data !== "object") {
-        return false;
-    }
-    return data instanceof Date;
-};
+var SchemaTypes = /*#__PURE__*/ function(SchemaTypes) {
+    SchemaTypes["Array"] = "Array";
+    SchemaTypes["Boolean"] = "Boolean";
+    SchemaTypes["Date"] = "Date";
+    SchemaTypes["Number"] = "Number";
+    SchemaTypes["Object"] = "Object";
+    SchemaTypes["String"] = "String";
+    SchemaTypes["Definition"] = "Definition";
+    SchemaTypes["Function"] = "Function";
+    SchemaTypes["Computed"] = "Computed";
+    /**
+     * Content in, reference out. The only type whose write shape differs from its stored
+     * shape, and a leaf on purpose — see `SchemaFile`.
+     */ SchemaTypes["File"] = "File";
+    /**
+     * A fixed-length list of numbers, carrying its dimension count — see `SchemaVector`.
+     *
+     * Value-shaped exactly like `s.array(s.number())`, which is why every array codegen
+     * handler accepts it. It is a distinct type only so a backend can recognise it and store
+     * it natively; nothing else needs to tell the two apart.
+     */ SchemaTypes["Vector"] = "Vector";
+    return SchemaTypes;
+}({});
+var HashType = /*#__PURE__*/ (/* unused pure expression or super */ null && (function(HashType) {
+    HashType["Ids"] = "Ids";
+    HashType["Object"] = "Object";
+    return HashType;
+}({})));
 
 
 },
-"./src/utilities/logger.ts"(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-__webpack_require__.r(__webpack_exports__);
+581(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
 __webpack_require__.d(__webpack_exports__, {
-  logger: () => (logger)
+  vF: () => (logger)
 });
-const isDevelopment = () => {
-    if (typeof process === 'undefined' || process.env == null) {
-        return false;
+/**
+ * Levelled logging, resolved once.
+ *
+ * Three things about the previous implementation drove this shape:
+ *
+ *  - **There was no way to turn logging off.** `globalThis.__ROUTIER_DEBUG__` was only ever
+ *    compared against `true`, so setting it to `false` did nothing — while
+ *    `docs/how-to/debug-logging.md` documented exactly that as the way to force logging off.
+ *    A documented switch that silently does nothing is worse than no switch.
+ *  - **`NODE_ENV === 'test'` enabled it.** Every Jest run therefore logged, because Jest always
+ *    sets `NODE_ENV=test`. Measured on the S7 stress scenario, which drives ~2,000 saves through
+ *    a plugin that logs three lines per query: 12.4s with logging, ~6s without. Test runners also
+ *    capture console output by snapshotting a stack trace per call, so the cost is far above what
+ *    writing to a terminal would suggest — and the output buries whatever the failure was.
+ *  - **It was all-or-nothing, and re-resolved per call.** An error could not be kept while debug
+ *    was dropped, and every one of the ~97 call sites re-read `globalThis` and `process.env`.
+ *
+ * Levels are compared numerically against a value cached at module load. Measured against a
+ * no-op console at 200k calls: an enabled call costs ~70ns, a call rejected by the gate ~3ns.
+ * Building the arguments the call site passes in accounts for ~0.2ns of that 3ns, which is why
+ * this keeps the ordinary `logger.debug(msg, payload)` signature instead of taking a thunk —
+ * a lazy API would recover 0.3% of an enabled call's cost and would have to change every call
+ * site to do it.
+ */ /** Ordered from most severe to most verbose. `silent` discards everything. */ const LOG_LEVELS = [
+    'silent',
+    'error',
+    'warn',
+    'info',
+    'debug'
+];
+/** Numeric rank, so a gate is one integer comparison. */ const RANK = {
+    silent: 0,
+    error: 1,
+    warn: 2,
+    info: 3,
+    debug: 4
+};
+const isLogLevel = (value)=>typeof value === 'string' && LOG_LEVELS.includes(value);
+/**
+ * Resolves the configured level, in precedence order.
+ *
+ * Ordered most specific first: an explicit level beats a boolean flag, a boolean flag beats an
+ * environment variable, and an environment variable beats an inference from `NODE_ENV`. Anything
+ * unrecognised is ignored rather than treated as an error — a typo'd level should not take down
+ * an application, and `silent` is the safe direction to fall back to.
+ */ const resolveLevel = ()=>{
+    if (typeof globalThis !== 'undefined') {
+        const g = globalThis;
+        if (isLogLevel(g.__ROUTIER_LOG_LEVEL__)) {
+            return g.__ROUTIER_LOG_LEVEL__;
+        }
+        // Both directions honoured. `=== false` used to fall through to the NODE_ENV checks
+        // below and re-enable the logging it was asked to suppress.
+        if (g.__ROUTIER_DEBUG__ === true) return 'debug';
+        if (g.__ROUTIER_DEBUG__ === false) return 'silent';
+    }
+    // There is deliberately no `import.meta.env` branch, although the documentation used to
+    // promise one. It could never work: this package is bundled with rspack, which replaces
+    // `import.meta` with `undefined`, so the check would read the *library's* build-time
+    // environment rather than the application's — and referencing `import.meta` at all is a parse
+    // error under a CommonJS build target, which is how the test suite loads this file. Vite and
+    // similar apps set `__ROUTIER_LOG_LEVEL__` or `__ROUTIER_DEBUG__` from their own
+    // `import.meta.env`, which is what the docs now describe.
+    if (typeof process !== 'undefined' && process.env != null) {
+        if (isLogLevel(process.env.ROUTIER_LOG_LEVEL)) {
+            return process.env.ROUTIER_LOG_LEVEL;
+        }
+        const debug = process.env.DEBUG;
+        if (debug === 'routier' || debug === '*') return 'debug';
+        const env = "production"?.toLowerCase();
+        // `test` is deliberately absent. It used to be here, which meant no test suite anywhere
+        // could run Routier quietly. Opt in with DEBUG=routier or ROUTIER_LOG_LEVEL when a test
+        // needs the output.
+        if (env === 'dev' || env === 'development') return 'debug';
+    }
+    return 'silent';
+};
+let level = resolveLevel();
+let rank = RANK[level];
+/**
+ * Overrides the level for the rest of the process.
+ *
+ * The configuration above is read once, at import, which is what makes the gate cheap — but it
+ * also means an application that decides its verbosity after startup, or a test that wants to
+ * assert on output, has no way in. This is that way in.
+ */ const setLogLevel = (next)=>{
+    if (isLogLevel(next) === false) {
+        throw new Error(`Unknown log level "${next}". Expected one of: ${LOG_LEVELS.join(', ')}`);
     }
-    const env = "development"?.toLowerCase();
-    return env === 'dev' || env === 'development' || env === 'test';
+    level = next;
+    rank = RANK[next];
 };
-const shouldLog = isDevelopment();
-const tryLog = (type, ...args) => {
-    if (shouldLog) {
-        console[type](...args);
+const getLogLevel = ()=>level;
+/** Re-reads the environment. For tests that change it after this module was imported. */ const resetLogLevel = ()=>{
+    level = resolveLevel();
+    rank = RANK[level];
+};
+/**
+ * Whether a message at this level would be emitted.
+ *
+ * For the rare call site whose *arguments* are expensive to build — a serialization, a deep
+ * clone, a join over a large collection. An ordinary payload object is not worth guarding; see
+ * the measurement in the header.
+ */ const isLogLevelEnabled = (at)=>rank >= RANK[at];
+const emit = (at, method, args)=>{
+    if (rank < RANK[at]) {
+        return;
     }
+    // Resolved at call time rather than captured once: test harnesses and browser devtools both
+    // replace console methods after modules have loaded, and a captured reference would keep
+    // writing past the replacement.
+    console[method](...args);
 };
 const logger = {
-    log: (...args) => {
-        tryLog("log", ...args);
-    },
-    info: (...args) => {
-        tryLog("info", ...args);
-    },
-    warn: (...args) => {
-        tryLog("warn", ...args);
-    },
-    error: (...args) => {
-        tryLog("error", ...args);
-    },
-    debug: (...args) => {
-        tryLog("debug", ...args);
-    },
-    table: (...args) => {
-        tryLog("table", ...args);
-    },
+    /** General-purpose output. Carried at `info`, since `log` names a console method, not a level. */ log: (...args)=>emit('info', 'log', args),
+    info: (...args)=>emit('info', 'info', args),
+    warn: (...args)=>emit('warn', 'warn', args),
+    error: (...args)=>emit('error', 'error', args),
+    debug: (...args)=>emit('debug', 'debug', args),
+    /** Diagnostic tabular output; verbose by nature, so it sits at `debug`. */ table: (...args)=>emit('debug', 'table', args)
 };
 
 
@@ -1023,55 +2034,56 @@ __webpack_require__.d = (exports, definition) => {
 (() => {
 __webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
 })();
-// webpack/runtime/make_namespace_object
-(() => {
-// define __esModule on exports
-__webpack_require__.r = (exports) => {
-	if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
-		Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-	}
-	Object.defineProperty(exports, '__esModule', { value: true });
-};
-})();
 var __webpack_exports__ = {};
 // This entry needs to be wrapped in an IIFE because it needs to be isolated against other modules in the chunk.
 (() => {
-__webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-  ComparatorExpression: () => (/* reexport safe */ _types__rspack_import_1.ComparatorExpression),
-  EmptyExpression: () => (/* reexport safe */ _types__rspack_import_1.EmptyExpression),
-  Expression: () => (/* reexport safe */ _types__rspack_import_1.Expression),
-  NotParsableExpression: () => (/* reexport safe */ _types__rspack_import_1.NotParsableExpression),
-  OperatorExpression: () => (/* reexport safe */ _types__rspack_import_1.OperatorExpression),
-  PropertyExpression: () => (/* reexport safe */ _types__rspack_import_1.PropertyExpression),
-  ValueExpression: () => (/* reexport safe */ _types__rspack_import_1.ValueExpression),
-  combineExpressions: () => (/* reexport safe */ _parser__rspack_import_0.combineExpressions),
-  forEach: () => (/* reexport safe */ _utils__rspack_import_2.forEach),
-  getProperties: () => (/* reexport safe */ _utils__rspack_import_2.getProperties),
-  isPropertyExpression: () => (/* reexport safe */ _utils__rspack_import_2.isPropertyExpression),
-  toExpression: () => (/* reexport safe */ _parser__rspack_import_0.toExpression)
+  Ko: () => (/* reexport safe */ _types__rspack_import_2.Ko),
+  MY: () => (/* reexport safe */ _parser__rspack_import_1.MY),
+  SC: () => (/* reexport safe */ _types__rspack_import_2.SC),
+  Sm: () => (/* reexport safe */ _types__rspack_import_2.Sm),
+  Vu: () => (/* reexport safe */ _evaluate__rspack_import_0.Vu),
+  _3: () => (/* reexport safe */ _evaluate__rspack_import_0._3),
+  bQ: () => (/* reexport safe */ _types__rspack_import_2.bQ),
+  ep: () => (/* reexport safe */ _types__rspack_import_2.ep),
+  fw: () => (/* reexport safe */ _types__rspack_import_2.fw),
+  jJ: () => (/* reexport safe */ _utils__rspack_import_3.j),
+  oH: () => (/* reexport safe */ _parser__rspack_import_1.oH),
+  oY: () => (/* reexport safe */ _utils__rspack_import_3.o),
+  pg: () => (/* reexport safe */ _parser__rspack_import_1.pg),
+  r4: () => (/* reexport safe */ _types__rspack_import_2.r4),
+  tA: () => (/* reexport safe */ _constants__rspack_import_4.t),
+  wS: () => (/* reexport safe */ _evaluate__rspack_import_0.wS)
 });
-/* import */ var _parser__rspack_import_0 = __webpack_require__("./src/expressions/parser.ts");
-/* import */ var _types__rspack_import_1 = __webpack_require__("./src/expressions/types.ts");
-/* import */ var _utils__rspack_import_2 = __webpack_require__("./src/expressions/utils.ts");
+/* import */ var _evaluate__rspack_import_0 = __webpack_require__(379);
+/* import */ var _parser__rspack_import_1 = __webpack_require__(91);
+/* import */ var _types__rspack_import_2 = __webpack_require__(27);
+/* import */ var _utils__rspack_import_3 = __webpack_require__(63);
+/* import */ var _constants__rspack_import_4 = __webpack_require__(835);
+
+
 
 
 
 
 })();
 
-var __webpack_exports__ComparatorExpression = __webpack_exports__.ComparatorExpression;
-var __webpack_exports__EmptyExpression = __webpack_exports__.EmptyExpression;
-var __webpack_exports__Expression = __webpack_exports__.Expression;
-var __webpack_exports__NotParsableExpression = __webpack_exports__.NotParsableExpression;
-var __webpack_exports__OperatorExpression = __webpack_exports__.OperatorExpression;
-var __webpack_exports__PropertyExpression = __webpack_exports__.PropertyExpression;
-var __webpack_exports__ValueExpression = __webpack_exports__.ValueExpression;
-var __webpack_exports__combineExpressions = __webpack_exports__.combineExpressions;
-var __webpack_exports__forEach = __webpack_exports__.forEach;
-var __webpack_exports__getProperties = __webpack_exports__.getProperties;
-var __webpack_exports__isPropertyExpression = __webpack_exports__.isPropertyExpression;
-var __webpack_exports__toExpression = __webpack_exports__.toExpression;
-export { __webpack_exports__ComparatorExpression as ComparatorExpression, __webpack_exports__EmptyExpression as EmptyExpression, __webpack_exports__Expression as Expression, __webpack_exports__NotParsableExpression as NotParsableExpression, __webpack_exports__OperatorExpression as OperatorExpression, __webpack_exports__PropertyExpression as PropertyExpression, __webpack_exports__ValueExpression as ValueExpression, __webpack_exports__combineExpressions as combineExpressions, __webpack_exports__forEach as forEach, __webpack_exports__getProperties as getProperties, __webpack_exports__isPropertyExpression as isPropertyExpression, __webpack_exports__toExpression as toExpression };
+var __webpack_exports__ComparatorExpression = __webpack_exports__.bQ;
+var __webpack_exports__EXPRESSION_TYPES = __webpack_exports__.tA;
+var __webpack_exports__EmptyExpression = __webpack_exports__.Sm;
+var __webpack_exports__Expression = __webpack_exports__.r4;
+var __webpack_exports__NotParsableExpression = __webpack_exports__.SC;
+var __webpack_exports__OperatorExpression = __webpack_exports__.fw;
+var __webpack_exports__PropertyExpression = __webpack_exports__.ep;
+var __webpack_exports__ValueExpression = __webpack_exports__.Ko;
+var __webpack_exports__combineExpressions = __webpack_exports__.pg;
+var __webpack_exports__evaluate = __webpack_exports__._3;
+var __webpack_exports__forEach = __webpack_exports__.jJ;
+var __webpack_exports__getProperties = __webpack_exports__.oY;
+var __webpack_exports__parseFragment = __webpack_exports__.oH;
+var __webpack_exports__toExpression = __webpack_exports__.MY;
+var __webpack_exports__toPredicate = __webpack_exports__.Vu;
+var __webpack_exports__toStrictPredicate = __webpack_exports__.wS;
+export { __webpack_exports__ComparatorExpression as ComparatorExpression, __webpack_exports__EXPRESSION_TYPES as EXPRESSION_TYPES, __webpack_exports__EmptyExpression as EmptyExpression, __webpack_exports__Expression as Expression, __webpack_exports__NotParsableExpression as NotParsableExpression, __webpack_exports__OperatorExpression as OperatorExpression, __webpack_exports__PropertyExpression as PropertyExpression, __webpack_exports__ValueExpression as ValueExpression, __webpack_exports__combineExpressions as combineExpressions, __webpack_exports__evaluate as evaluate, __webpack_exports__forEach as forEach, __webpack_exports__getProperties as getProperties, __webpack_exports__parseFragment as parseFragment, __webpack_exports__toExpression as toExpression, __webpack_exports__toPredicate as toPredicate, __webpack_exports__toStrictPredicate as toStrictPredicate };
 
 //# sourceMappingURL=index.js.map