@routier/core 0.5.0 → 0.7.0

package/dist/expressions/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"expressions/index.cjs","sources":["webpack://@routier/core/./src/assertions/index.ts","webpack://@routier/core/./src/expressions/constants.ts","webpack://@routier/core/./src/expressions/evaluate.ts","webpack://@routier/core/./src/expressions/parser.ts","webpack://@routier/core/./src/expressions/types.ts","webpack://@routier/core/./src/expressions/utils.ts","webpack://@routier/core/./src/schema/types.ts","webpack://@routier/core/./src/utilities/logger.ts","webpack://@routier/core/webpack/runtime/define_property_getters","webpack://@routier/core/webpack/runtime/has_own_property","webpack://@routier/core/webpack/runtime/make_namespace_object","webpack://@routier/core/./src/expressions/index.ts"],"sourcesContent":["import { EXPRESSION_TYPES } from \"../expressions/constants\";\nimport { ComparatorExpression, EmptyExpression, Expression, ExpressionType, NotParsableExpression, OperatorExpression, PropertyExpression, ValueExpression } from \"../expressions/types\";\nimport { isDate } from \"../utilities\";\n\nexport function assertDate(data: unknown): asserts data is Date {\n    if (isDate(data) === false) {\n        throw new TypeError('Value is not a Date');\n    }\n}\n\nexport function assertIsNotNull<T>(data: T | null | undefined, message?: string | (() => string)): asserts data is NonNullable<T> {\n    if (data == null) {\n        if (message == null) {\n            throw new TypeError('Assertion failed, data is null');\n        }\n\n        if (typeof message === \"string\") {\n            throw new TypeError(message);\n        }\n\n        throw new TypeError(message());\n    }\n}\n\nexport function assertIsArray<T>(data: unknown, message?: string): asserts data is T[] {\n    if (!Array.isArray(data)) {\n        throw new TypeError(message ?? 'Assertion failed, data is not of type Array');\n    }\n}\n\nexport function assertString(data: unknown, message?: string): asserts data is string {\n    if (typeof data !== \"string\") {\n        throw new TypeError(message ?? 'Assertion failed, data is not of type String');\n    }\n}\n\nexport function assertInstanceOf<T extends new (...args: any[]) => any>(value: unknown, Instance: T): asserts value is T {\n    if (value instanceof Instance) {\n        return;\n    }\n\n    if (value != null && typeof value === \"object\" && \"constructor\" in value) {\n        throw new TypeError(`value is not instance of type.  Type: ${value.constructor.name}`);\n    }\n\n    throw new TypeError(`value is not instance of type`);\n}\n\nexport function assertIsNumber(value: unknown): asserts value is number {\n    if (typeof value !== \"number\") {\n        throw new TypeError(\"value is not of type `number`\");\n    }\n}\n\n\nfunction isObjectWithType(value: unknown): value is Record<\"type\", unknown> {\n    return typeof value === \"object\" && value !== null && \"type\" in value;\n}\n\n/**\n * Type guard: narrows `value` to `Expression` when it is an object with a valid `type` property.\n */\nexport function isExpression(value: unknown): value is Expression {\n    return isObjectWithType(value) && EXPRESSION_TYPES.includes(value.type as ExpressionType);\n}\n\n/**\n * Type guard: narrows `value` to `OperatorExpression` when it is an object with `type === \"operator\"`.\n */\nexport function isOperatorExpression(value: unknown): value is OperatorExpression {\n    return isObjectWithType(value) && value.type === \"operator\";\n}\n\n/**\n * Type guard: narrows `value` to `ComparatorExpression` when it is an object with `type === \"comparator\"`.\n */\nexport function isComparatorExpression(value: unknown): value is ComparatorExpression {\n    return isObjectWithType(value) && value.type === \"comparator\";\n}\n\n/**\n * Type guard: narrows `value` to `PropertyExpression` when it is an object with `type === \"property\"`.\n */\nexport function isPropertyExpression(value: unknown): value is PropertyExpression {\n    return isObjectWithType(value) && value.type === \"property\";\n}\n\n/**\n * Type guard: narrows `value` to `ValueExpression` when it is an object with `type === \"value\"`.\n */\nexport function isValueExpression(value: unknown): value is ValueExpression {\n    return isObjectWithType(value) && value.type === \"value\";\n}\n\n/**\n * Type guard: narrows `value` to `EmptyExpression` when it is an object with `type === \"empty\"`.\n */\nexport function isEmptyExpression(value: unknown): value is EmptyExpression {\n    return isObjectWithType(value) && value.type === \"empty\";\n}\n\n/**\n * Type guard: narrows `value` to `NotParsableExpression` when it is an object with `type === \"not-parsable\"`.\n */\nexport function isNotParsableExpression(value: unknown): value is NotParsableExpression {\n    return isObjectWithType(value) && value.type === \"not-parsable\";\n}","import { ExpressionType } from \"./types\";\n\nexport const EXPRESSION_TYPES: ExpressionType[] = [\n    \"operator\",\n    \"comparator\",\n    \"property\",\n    \"value\",\n    \"empty\",\n    \"not-parsable\",\n];\n","import { isComparatorExpression, isOperatorExpression, isPropertyExpression, isValueExpression } from \"../assertions\";\nimport { UnknownRecord } from \"../utilities\";\nimport { Comparator, Expression, Transformer } from \"./types\";\n\n/**\n * Runs a parsed expression against a row.\n *\n * The counterpart to `toSql` and `toMql`: those turn a tree into a backend's language, and this\n * turns it into an answer. Needed wherever a tree exists but the closure that produced it does\n * not — a filter split out of a larger predicate, an option rebuilt from a serialized query.\n *\n * ## It fails OPEN, and that is the whole safety argument\n *\n * `undefined` means \"this tree cannot be evaluated here\" — an unknown node, a transformer with no\n * implementation, a comparison between shapes that do not compare. Callers must read that as KEEP\n * THE ROW, never as exclude it.\n *\n * The reason is asymmetric cost. Every caller today uses this to NARROW something that a\n * subsequent, authoritative predicate will check again: a semi-join prefilter, a split conjunct.\n * Keeping a row this cannot judge costs one wasted comparison downstream. Dropping one loses data\n * from a query result and nothing anywhere reports it. So every uncertain path returns `undefined`,\n * and no path guesses `false`.\n *\n * ## Why not just reuse the caller's closure\n *\n * Because there often isn't one. A conjunct pulled out of `([p, m]) => p.a === 1 && m.b === 2` is\n * source TEXT; turning it back into a callable needs `new Function`, which a\n * Content-Security-Policy blocks — the same constraint that makes `softDeleteScope` build its tree\n * by hand. The tree is the only representation that survives.\n */\nexport type EvaluationResult = boolean | undefined;\n\n/** Reads a property or literal operand, or `UNRESOLVED` when the node is not one. */\nconst UNRESOLVED = Symbol(\"unresolved\");\n\nconst applyTransformer = (value: unknown, transformer: Transformer | null): unknown | typeof UNRESOLVED => {\n    if (transformer == null) {\n        return value;\n    }\n\n    // A transformer applied to an absent value has no answer, and inventing one (\"\" for a missing\n    // string) is how a filter starts matching rows it should not.\n    if (value == null) {\n        return UNRESOLVED;\n    }\n\n    if (transformer === \"to-lower-case\") {\n        return typeof value === \"string\" ? value.toLowerCase() : UNRESOLVED;\n    }\n\n    if (transformer === \"to-upper-case\") {\n        return typeof value === \"string\" ? value.toUpperCase() : UNRESOLVED;\n    }\n\n    if (transformer === \"length\") {\n        return typeof value === \"string\" || Array.isArray(value) ? value.length : UNRESOLVED;\n    }\n\n    return UNRESOLVED;\n};\n\nconst operand = (expression: Expression | undefined, row: UnknownRecord): unknown | typeof UNRESOLVED => {\n    if (expression == null) {\n        return UNRESOLVED;\n    }\n\n    if (isValueExpression(expression)) {\n        return applyTransformer(expression.value, expression.transformer);\n    }\n\n    if (isPropertyExpression(expression)) {\n        // Through the PropertyInfo, so a nested path and a `from`-renamed segment resolve the same\n        // way every other consumer of the tree resolves them.\n        return applyTransformer(expression.property.getValue(row), expression.transformer);\n    }\n\n    return UNRESOLVED;\n};\n\n/**\n * `a === b` for the comparators, with Dates compared by VALUE.\n *\n * A Date compares by reference under `===`, so two Dates holding the same instant would be\n * unequal — which is not what a filter on a date means, and not what any backend does.\n */\nconst equals = (left: unknown, right: unknown, strict: boolean): boolean => {\n    if (left instanceof Date && right instanceof Date) {\n        return left.getTime() === right.getTime();\n    }\n\n    // oxlint-disable-next-line eqeqeq\n    return strict ? left === right : left == right;\n};\n\n/** Ordered comparison, only for shapes that have an order. */\nconst compare = (left: unknown, right: unknown, comparator: Comparator): EvaluationResult => {\n    const asComparable = (value: unknown) => value instanceof Date ? value.getTime() : value;\n\n    const a = asComparable(left);\n    const b = asComparable(right);\n\n    const comparable = (typeof a === \"number\" && typeof b === \"number\")\n        || (typeof a === \"string\" && typeof b === \"string\");\n\n    if (comparable === false) {\n        return undefined;\n    }\n\n    if (comparator === \"greater-than\") {\n        return a > b;\n    }\n\n    if (comparator === \"greater-than-equals\") {\n        return a >= b;\n    }\n\n    if (comparator === \"less-than\") {\n        return a < b;\n    }\n\n    return a <= b;\n};\n\nconst evaluateComparator = (comparator: Comparator, left: unknown, right: unknown, strict: boolean): EvaluationResult => {\n\n    if (comparator === \"equals\") {\n        return equals(left, right, strict);\n    }\n\n    if (comparator === \"includes\") {\n        // Two shapes, and the tree does not distinguish them: `array.includes(value)` and\n        // `string.includes(substring)`. Whichever side is the container decides.\n        if (Array.isArray(left)) {\n            return left.some(item => equals(item, right, strict));\n        }\n\n        if (Array.isArray(right)) {\n            return right.some(item => equals(item, left, strict));\n        }\n\n        return typeof left === \"string\" && typeof right === \"string\" ? left.includes(right) : undefined;\n    }\n\n    if (comparator === \"starts-with\") {\n        return typeof left === \"string\" && typeof right === \"string\" ? left.startsWith(right) : undefined;\n    }\n\n    if (comparator === \"ends-with\") {\n        return typeof left === \"string\" && typeof right === \"string\" ? left.endsWith(right) : undefined;\n    }\n\n    return compare(left, right, comparator);\n};\n\n/**\n * Evaluates `expression` against `row`, or returns `undefined` when it cannot.\n *\n * See the note at the top of this file: `undefined` means KEEP the row.\n */\nexport const evaluate = (expression: Expression, row: UnknownRecord): EvaluationResult => {\n\n    if (isOperatorExpression(expression)) {\n        const left = expression.left == null ? undefined : evaluate(expression.left, row);\n        const right = expression.right == null ? undefined : evaluate(expression.right, row);\n\n        /**\n         * One unevaluable side does not have to sink the whole tree.\n         *\n         * `a && b` where `a` is definitely false is false whatever `b` is, and `a || b` where `a`\n         * is definitely true is true. That short-circuiting is what lets a mostly-understood\n         * predicate still narrow anything at all — without it, one unfamiliar sub-expression makes\n         * the entire filter a no-op.\n         */\n        if (expression.operator === \"&&\") {\n            if (left === false || right === false) {\n                return false;\n            }\n\n            return left === true && right === true ? true : undefined;\n        }\n\n        if (left === true || right === true) {\n            return true;\n        }\n\n        return left === false && right === false ? false : undefined;\n    }\n\n    if (isComparatorExpression(expression)) {\n        const left = operand(expression.left, row);\n        const right = operand(expression.right, row);\n\n        if (left === UNRESOLVED || right === UNRESOLVED) {\n            return undefined;\n        }\n\n        const result = evaluateComparator(expression.comparator, left, right, expression.strict);\n\n        if (result === undefined) {\n            return undefined;\n        }\n\n        return expression.negated ? result === false : result;\n    }\n\n    // A tautology excludes nothing, which is exactly `true`. Anything else — a bare property, a\n    // literal, `not-parsable` — is not a predicate this can judge.\n    return expression.type === \"empty\" ? true : undefined;\n};\n\n/**\n * `evaluate`, as a predicate that keeps whatever it cannot judge.\n *\n * The form every narrowing caller wants, with the fail-open rule applied once here rather than\n * remembered at each call site.\n */\nexport const toPredicate = (expression: Expression) => (row: UnknownRecord): boolean =>\n    evaluate(expression, row) !== false;\n\n/**\n * `evaluate`, as a predicate that THROWS on anything it cannot judge.\n *\n * The opposite default to `toPredicate`, and the right one when the predicate is the only thing\n * standing between a caller and rows they asked to exclude — a filter that arrived over a wire and\n * is being applied by the receiver. Failing open there does not cost a wasted comparison; it returns\n * data the requester filtered out, and reports nothing.\n *\n * Use `toPredicate` when something authoritative re-checks the result, and this when nothing does.\n */\nexport const toStrictPredicate = (expression: Expression) => (row: UnknownRecord): boolean => {\n    const result = evaluate(expression, row);\n\n    if (result === undefined) {\n        throw new Error(\n            \"Cannot apply this filter: its expression cannot be evaluated in memory, and applying it partially would \" +\n            \"return rows the filter excludes.  This happens when a filter arrives without a runnable predicate — over a \" +\n            \"wire, or rebuilt from a serialized query — and names something the evaluator does not understand.\"\n        );\n    }\n\n    return result;\n};\n","import { logger } from \"../utilities\";\nimport { assertString } from \"../assertions\";\nimport { CompiledSchema, PropertyInfo, SchemaTypes } from \"../schema\";\nimport { Expression, OperatorExpression, ComparatorExpression, ValueExpression, PropertyExpression, Filter, ParamsFilter, Comparator, Transformer } from \"./types\";\n\n// Error message constants\nconst ERROR_MESSAGES = {\n    PROPERTY_NOT_FOUND: (path: string) => `Error parsing query, could not find PropertyInfo for path: ${path}`,\n    PARAM_PATH_NOT_FOUND: (value: string, params: unknown) => `Cannot find path in params for .where(). Make sure parameters are not used inline.\\r\\nPath: ${value}, Params: ${JSON.stringify(params)}`,\n    VARIABLE_VALUE: (value: string) => `Cannot derive value from variable, please pass parameters into the expression.\n\nExample: .where(([x, params]) => x.id === params.id, { id: someVar.id })\nIssue At: ${value}`,\n    UNSUPPORTED: (value: string) => `Unsupported expression format: ${value}`\n};\n\nconst parseUnknown = (value: unknown) => {\n    assertString(value);\n    return JSON.parse(value);\n}\n\n/**\n * A parse failure caused by the params VALUES rather than the filter source.\n * These must never poison the template cache — the same source can succeed\n * with different params.\n */\nclass ParamDependentParseError extends Error { }\n\nconst converters: Record<SchemaTypes, (value: unknown) => unknown> = {\n    Array: v => v,\n    Boolean: v => v == null ? v : Boolean(v),\n    // Stryker disable next-line ArrowFunction: filters on computed properties route to\n    // in-memory execution, so this entry cannot be reached through a parsable filter.\n    Computed: v => v,\n    Date: v => v,\n    // A file is a reference, and a filter can legitimately compare its fields — content type\n    // and size are ordinary columns. The value passes through unconverted like an object.\n    File: v => v,\n    // Stryker disable next-line ArrowFunction: SchemaTypes.Definition is handled as a\n    // generic primitive everywhere (specs/known-defects.md) and never pairs in a filter.\n    Definition: v => v,\n    // Stryker disable next-line ArrowFunction: filters on function properties route to\n    // in-memory execution, so this entry cannot be reached through a parsable filter.\n    Function: v => v,\n    Number: v => v == null ? v : Number(v),\n    Object: v => v,\n    String: v => v == null ? v : String(v),\n    // A vector is a list of numbers and passes through like any other array. Nothing\n    // converts it because nothing compares it: similarity is `.nearest()`, not a filter.\n    Vector: v => v\n};\n\n// #region Tokenizer\n\ntype TokenKind = \"identifier\" | \"string\" | \"number\" | \"punctuation\";\n\ntype Token = {\n    kind: TokenKind;\n    value: string;\n}\n\n// Longest first so multi-character punctuation wins over its prefixes\nconst MULTI_CHARACTER_PUNCTUATION = [\"===\", \"!==\", \"?.\", \"&&\", \"||\", \"==\", \"!=\", \">=\", \"<=\", \"=>\"] as const;\n// Stryker disable next-line all: documented equivalent cluster (see\n// docs/mutation-backlog.md) — dropping an entry only affects source the parser rejects\n// either way, and the rejection message names the character from the source rather than\n// from this set, so no observable boundary distinguishes the mutant. Established\n// experimentally: 30 message-asserting tests killed 1 of 12.\nconst SINGLE_CHARACTER_PUNCTUATION = new Set([\"(\", \")\", \"[\", \"]\", \"{\", \"}\", \".\", \",\", \";\", \"!\", \">\", \"<\", \"-\", \"+\", \"*\", \"/\", \"%\", \"=\", \"?\", \":\", \"&\", \"|\"]);\n\nconst STRING_ESCAPES: Record<string, string> = {\n    \"n\": \"\\n\",\n    \"r\": \"\\r\",\n    \"t\": \"\\t\",\n    \"b\": \"\\b\",\n    \"f\": \"\\f\",\n    \"v\": \"\\v\",\n    \"0\": \"\\0\"\n};\n\nconst isIdentifierStart = (char: string) => /[a-zA-Z_$]/.test(char);\nconst isIdentifierPart = (char: string) => /[a-zA-Z0-9_$]/.test(char);\nconst isDigit = (char: string) => char >= \"0\" && char <= \"9\";\nconst isHexDigit = (char: string) => isDigit(char) || (char >= \"a\" && char <= \"f\") || (char >= \"A\" && char <= \"F\");\n\n/**\n * Decodes a `\\uXXXX`, `\\u{...}` or `\\xXX` escape starting at the backslash.\n * Returns the decoded character and the index just past the escape.  These\n * escapes carry a computed character, so mapping them through STRING_ESCAPES\n * (which would yield the literal \"u\"/\"x\") silently corrupts the value.\n */\nconst decodeCodeEscape = (source: string, backslashIndex: number): { value: string, nextIndex: number } => {\n    const kind = source[backslashIndex + 1];\n    let start = backslashIndex + 2;\n\n    if (kind === \"u\" && source[start] === \"{\") {\n        const end = source.indexOf(\"}\", start + 1);\n\n        if (end === -1) {\n            throw new Error(ERROR_MESSAGES.UNSUPPORTED(\"unterminated unicode escape\"));\n        }\n\n        return { value: String.fromCodePoint(parseInt(source.slice(start + 1, end), 16)), nextIndex: end + 1 };\n    }\n\n    const length = kind === \"u\" ? 4 : 2;\n    const digits = source.slice(start, start + length);\n\n    if (digits.length < length || [...digits].some(d => !isHexDigit(d))) {\n        throw new Error(ERROR_MESSAGES.UNSUPPORTED(`'\\\\${kind}' escape`));\n    }\n\n    return { value: String.fromCharCode(parseInt(digits, 16)), nextIndex: start + length };\n}\n\n/**\n * Converts filter source text into a flat token stream.  Strings and comments are\n * consumed here so operator characters inside literals can never be mistaken for\n * real operators.\n */\nconst tokenize = (source: string): Token[] => {\n\n    const tokens: Token[] = [];\n    let i = 0;\n\n    while (i < source.length) {\n        const char = source[i];\n\n        // Whitespace\n        if (char === \" \" || char === \"\\t\" || char === \"\\r\" || char === \"\\n\") {\n            i++;\n            continue;\n        }\n\n        // Comments\n        if (char === \"/\" && source[i + 1] === \"/\") {\n            while (i < source.length && source[i] !== \"\\n\") {\n                i++;\n            }\n            continue;\n        }\n\n        if (char === \"/\" && source[i + 1] === \"*\") {\n            i += 2;\n            while (i < source.length && !(source[i] === \"*\" && source[i + 1] === \"/\")) {\n                i++;\n            }\n            i += 2;\n            continue;\n        }\n\n        // String literals\n        if (char === \"'\" || char === \"\\\"\" || char === \"`\") {\n            const quote = char;\n            let value = \"\";\n            i++;\n\n            while (i < source.length && source[i] !== quote) {\n                if (source[i] === \"\\\\\") {\n                    const escaped = source[i + 1];\n\n                    if (escaped === \"u\" || escaped === \"x\") {\n                        const decoded = decodeCodeEscape(source, i);\n                        value += decoded.value;\n                        i = decoded.nextIndex;\n                        continue;\n                    }\n\n                    value += STRING_ESCAPES[escaped] ?? escaped;\n                    i += 2;\n                    continue;\n                }\n\n                if (quote === \"`\" && source[i] === \"$\" && source[i + 1] === \"{\") {\n                    throw new Error(ERROR_MESSAGES.UNSUPPORTED(\"template literal interpolation\"));\n                }\n\n                value += source[i];\n                i++;\n            }\n\n            if (i >= source.length) {\n                throw new Error(ERROR_MESSAGES.UNSUPPORTED(\"unterminated string literal\"));\n            }\n\n            i++; // consume closing quote\n            tokens.push({ kind: \"string\", value });\n            continue;\n        }\n\n        // Numbers — covers decimals, exponents (1e6), hex/octal/binary (0xFF),\n        // and numeric separators (1_000_000).  Values are normalized here (the\n        // separator stripped) so the parser can hand them straight to Number()\n        if (isDigit(char)) {\n            let value = \"\";\n\n            const nextChar = source[i + 1];\n            const radixPrefix = char === \"0\" && nextChar != null && \"xXoObB\".includes(nextChar);\n\n            if (radixPrefix) {\n                value = source[i] + source[i + 1];\n                i += 2;\n\n                while (i < source.length && (isHexDigit(source[i]) || source[i] === \"_\")) {\n                    value += source[i];\n                    i++;\n                }\n            } else {\n                while (i < source.length && (isDigit(source[i]) || source[i] === \".\" || source[i] === \"_\")) {\n                    value += source[i];\n                    i++;\n                }\n\n                // Exponent part: e/E, optional sign, then digits.  Only consumed when\n                // digits follow, so a stray identifier after a number still errors\n                if ((source[i] === \"e\" || source[i] === \"E\")) {\n                    const signLength = source[i + 1] === \"+\" || source[i + 1] === \"-\" ? 1 : 0;\n\n                    if (isDigit(source[i + 1 + signLength])) {\n                        value += source[i];\n                        i++;\n\n                        if (signLength === 1) {\n                            value += source[i];\n                            i++;\n                        }\n\n                        while (i < source.length && isDigit(source[i])) {\n                            value += source[i];\n                            i++;\n                        }\n                    }\n                }\n            }\n\n            tokens.push({ kind: \"number\", value: value.replace(/_/g, \"\") });\n            continue;\n        }\n\n        // Identifiers / keywords\n        if (isIdentifierStart(char)) {\n            let value = \"\";\n\n            while (i < source.length && isIdentifierPart(source[i])) {\n                value += source[i];\n                i++;\n            }\n\n            tokens.push({ kind: \"identifier\", value });\n            continue;\n        }\n\n        // Multi-character punctuation (longest match first)\n        const multi = MULTI_CHARACTER_PUNCTUATION.find(w => source.startsWith(w, i));\n\n        if (multi != null) {\n            tokens.push({ kind: \"punctuation\", value: multi });\n            i += multi.length;\n            continue;\n        }\n\n        if (SINGLE_CHARACTER_PUNCTUATION.has(char)) {\n            tokens.push({ kind: \"punctuation\", value: char });\n            i++;\n            continue;\n        }\n\n        throw new Error(ERROR_MESSAGES.UNSUPPORTED(`unexpected character '${char}'`));\n    }\n\n    return tokens;\n}\n\n/**\n * Cursor over the token stream with the small set of lookahead operations the\n * parser needs.\n */\nclass TokenStream {\n\n    private readonly tokens: Token[];\n    private index: number = 0;\n\n    constructor(tokens: Token[]) {\n        this.tokens = tokens;\n    }\n\n    get isAtEnd() {\n        return this.index >= this.tokens.length;\n    }\n\n    peek(offset: number = 0): Token | null {\n        return this.tokens[this.index + offset] ?? null;\n    }\n\n    next(): Token {\n        const token = this.tokens[this.index];\n\n        if (token == null) {\n            throw new Error(ERROR_MESSAGES.UNSUPPORTED(\"unexpected end of expression\"));\n        }\n\n        this.index++;\n        return token;\n    }\n\n    isPunctuation(value: string, offset: number = 0): boolean {\n        const token = this.peek(offset);\n        return token != null && token.kind === \"punctuation\" && token.value === value;\n    }\n\n    matchPunctuation(value: string): boolean {\n        if (this.isPunctuation(value)) {\n            this.index++;\n            return true;\n        }\n\n        return false;\n    }\n\n    expectPunctuation(value: string) {\n        if (!this.matchPunctuation(value)) {\n            throw new Error(ERROR_MESSAGES.UNSUPPORTED(`expected '${value}'`));\n        }\n    }\n}\n\n// #endregion\n\n// #region Operands\n\n// Discriminated union so a condition builder can only ever see the operand\n// shapes the grammar allows\ntype PropertyOperand = {\n    kind: \"property\";\n    property: PropertyInfo<any>;\n    transformer: Transformer | null;\n    locale: string | null;\n}\n\ntype ValueOperand = {\n    kind: \"value\";\n    value: unknown;\n    transformer: Transformer | null;\n    locale: string | null;\n}\n\ntype ParamOperand = {\n    kind: \"param\";\n    path: string[];\n    transformer: Transformer | null;\n    locale: string | null;\n}\n\ntype MethodCallOperand = {\n    kind: \"method-call\";\n    target: PropertyOperand | ParamOperand | ValueOperand;\n    method: \"startsWith\" | \"endsWith\" | \"includes\";\n    argument: PropertyOperand | ValueOperand | ParamOperand;\n}\n\ntype Operand = PropertyOperand | ValueOperand | ParamOperand | MethodCallOperand;\n\nconst COMPARATOR_METHODS: Record<string, Comparator> = {\n    startsWith: \"starts-with\",\n    endsWith: \"ends-with\",\n    includes: \"includes\"\n};\n\nconst TRANSFORM_METHODS: Record<string, { transformer: Transformer, locale: string | null }> = {\n    toLowerCase: { transformer: \"to-lower-case\", locale: null },\n    toUpperCase: { transformer: \"to-upper-case\", locale: null },\n    toLocaleLowerCase: { transformer: \"to-lower-case\", locale: \"en-US\" },\n    toLocaleUpperCase: { transformer: \"to-upper-case\", locale: \"en-US\" }\n};\n\nconst COMPARISON_OPERATORS: Record<string, { comparator: Comparator, negated: boolean, strict: boolean }> = {\n    \"==\": { comparator: \"equals\", negated: false, strict: false },\n    \"===\": { comparator: \"equals\", negated: false, strict: true },\n    \"!=\": { comparator: \"equals\", negated: true, strict: false },\n    \"!==\": { comparator: \"equals\", negated: true, strict: true },\n    \">\": { comparator: \"greater-than\", negated: false, strict: false },\n    \">=\": { comparator: \"greater-than-equals\", negated: false, strict: false },\n    \"<\": { comparator: \"less-than\", negated: false, strict: false },\n    \"<=\": { comparator: \"less-than-equals\", negated: false, strict: false }\n};\n\nconst SWAPPED_COMPARATORS: Record<Comparator, Comparator> = {\n    \"equals\": \"equals\",\n    \"greater-than\": \"less-than\",\n    \"greater-than-equals\": \"less-than-equals\",\n    \"less-than\": \"greater-than\",\n    \"less-than-equals\": \"greater-than-equals\",\n    \"starts-with\": \"starts-with\",\n    \"ends-with\": \"ends-with\",\n    \"includes\": \"includes\"\n};\n\n// #endregion\n\n// #region Param references\n\n/**\n * Placeholder for a parameter value inside a cached expression template.  Never\n * escapes this module — binding replaces it with a plain ValueExpression that\n * holds the resolved value.\n */\nclass ParamReferenceExpression extends ValueExpression {\n\n    /** Path into the params object, excluding the params root name. */\n    readonly paramPath: string[];\n    /** The property this value is compared against; drives serialization/conversion at bind time. */\n    readonly pairedProperty: PropertyInfo<any> | null;\n    /** Whether the paired property's type converter applies (equality/relational comparisons only). */\n    readonly applyConverter: boolean;\n\n    constructor(options: {\n        paramPath: string[],\n        pairedProperty: PropertyInfo<any> | null,\n        applyConverter: boolean\n    }) {\n        super({ value: undefined });\n        this.paramPath = options.paramPath;\n        this.pairedProperty = options.pairedProperty;\n        this.applyConverter = options.applyConverter;\n    }\n}\n\nconst resolveParamPath = (paramsName: string, path: string[], data: unknown) => {\n\n    let result = data as Record<string, unknown>;\n\n    for (let i = 0; i < path.length; i++) {\n        const name = path[i];\n\n        if (result != null && typeof result === \"object\" && name in result) {\n            result = result[name] as Record<string, unknown>;\n            continue;\n        }\n\n        throw new ParamDependentParseError(ERROR_MESSAGES.PARAM_PATH_NOT_FOUND([paramsName, ...path].join(\".\"), data));\n    }\n\n    return result as unknown;\n}\n\n/**\n * Applies the paired property's value serializer and (optionally) its schema\n * type converter, matching how literal values are treated at parse time.\n */\nconst resolvePairedValue = (value: unknown, pairedProperty: PropertyInfo<any> | null, applyConverter: boolean) => {\n\n    if (pairedProperty == null) {\n        return value;\n    }\n\n    let result = value;\n\n    if (pairedProperty.valueSerializer != null) {\n        result = String(pairedProperty.valueSerializer(parseUnknown(result)));\n    }\n\n    if (applyConverter) {\n        result = converters[pairedProperty.type](result);\n    }\n\n    return result;\n}\n\n// #endregion\n\n// #region Parser\n\n/**\n * Recursive descent parser over the token stream.  Produces an expression\n * template: literal values are fully resolved, parameter values are represented\n * as ParamReferenceExpression placeholders so the template can be cached and\n * re-bound with different params.\n */\nclass ExpressionParser {\n\n    private readonly schema: CompiledSchema<any>;\n    private readonly stream: TokenStream;\n    private readonly entityName: string;\n    private readonly paramsName: string | null;\n    private readonly params: unknown;\n\n    /** Set when a param value shaped the tree itself (e.g. x[p.name]) — such templates cannot be cached. */\n    structurallyDependsOnParams: boolean = false;\n\n    constructor(schema: CompiledSchema<any>, stream: TokenStream, entityName: string, paramsName: string | null, params: unknown) {\n        this.schema = schema;\n        this.stream = stream;\n        this.entityName = entityName;\n        this.paramsName = paramsName;\n        this.params = params;\n    }\n\n    parse(): Expression {\n        const expression = this.parseOr();\n\n        if (!this.stream.isAtEnd) {\n            throw new Error(ERROR_MESSAGES.UNSUPPORTED(`unexpected token '${this.stream.peek()?.value}'`));\n        }\n\n        return expression;\n    }\n\n    // || binds loosest, so it sits at the root of the parse\n    private parseOr(): Expression {\n        let left = this.parseAnd();\n\n        while (this.stream.matchPunctuation(\"||\")) {\n            const right = this.parseAnd();\n\n            // A tautology (`true`) absorbs the whole disjunction\n            if (Expression.isEmpty(left) || Expression.isEmpty(right)) {\n                left = Expression.EMPTY;\n                continue;\n            }\n\n            left = new OperatorExpression({ operator: \"||\", left, right });\n        }\n\n        return left;\n    }\n\n    private parseAnd(): Expression {\n        let left = this.parseUnary();\n\n        while (this.stream.matchPunctuation(\"&&\")) {\n            const right = this.parseUnary();\n\n            // A tautology (`true`) is the identity of a conjunction\n            if (Expression.isEmpty(left)) {\n                left = right;\n                continue;\n            }\n\n            if (Expression.isEmpty(right)) {\n                continue;\n            }\n\n            left = new OperatorExpression({ operator: \"&&\", left, right });\n        }\n\n        return left;\n    }\n\n    private parseUnary(): Expression {\n        if (this.stream.matchPunctuation(\"!\")) {\n            return this.negateExpression(this.parseUnary());\n        }\n\n        return this.parseComparison();\n    }\n\n    /**\n     * Applies `!` to an already-parsed expression: comparators flip their\n     * negated flag, compound expressions distribute via De Morgan's laws.\n     */\n    private negateExpression(expression: Expression): Expression {\n        if (expression instanceof ComparatorExpression) {\n            expression.negated = !expression.negated;\n            return expression;\n        }\n\n        if (expression instanceof OperatorExpression && expression.left != null && expression.right != null) {\n            return new OperatorExpression({\n                operator: expression.operator === \"&&\" ? \"||\" : \"&&\",\n                left: this.negateExpression(expression.left),\n                right: this.negateExpression(expression.right)\n            });\n        }\n\n        throw new Error(ERROR_MESSAGES.UNSUPPORTED(\"'!' on this expression\"));\n    }\n\n    private parseComparison(): Expression {\n\n        // Parenthesized group\n        if (this.stream.matchPunctuation(\"(\")) {\n            const expression = this.parseOr();\n            this.stream.expectPunctuation(\")\");\n\n            const trailing = this.stream.peek();\n            if (trailing != null && trailing.kind === \"punctuation\" && COMPARISON_OPERATORS[trailing.value] != null) {\n                throw new Error(ERROR_MESSAGES.UNSUPPORTED(\"comparison against a parenthesized expression\"));\n            }\n\n            return expression;\n        }\n\n        const left = this.parseOperand();\n        const operatorToken = this.stream.peek();\n\n        if (operatorToken != null && operatorToken.kind === \"punctuation\" && COMPARISON_OPERATORS[operatorToken.value] != null) {\n            this.stream.next();\n            const right = this.parseOperand();\n            return this.buildComparison(left, COMPARISON_OPERATORS[operatorToken.value], right);\n        }\n\n        return this.buildStandalone(left);\n    }\n\n    private parseOperand(): Operand {\n        const token = this.stream.peek();\n\n        if (token == null) {\n            throw new Error(ERROR_MESSAGES.UNSUPPORTED(\"unexpected end of expression\"));\n        }\n\n        if (token.kind === \"string\") {\n            this.stream.next();\n            return this.withValueTransformer({ kind: \"value\", value: token.value, transformer: null, locale: null });\n        }\n\n        if (token.kind === \"number\") {\n            this.stream.next();\n            return { kind: \"value\", value: Number(token.value), transformer: null, locale: null };\n        }\n\n        if (token.kind === \"punctuation\" && token.value === \"-\") {\n            this.stream.next();\n            const numberToken = this.stream.next();\n\n            if (numberToken.kind !== \"number\") {\n                throw new Error(ERROR_MESSAGES.UNSUPPORTED(\"unary '-' on a non-number\"));\n            }\n\n            return { kind: \"value\", value: -Number(numberToken.value), transformer: null, locale: null };\n        }\n\n        if (token.kind === \"punctuation\" && token.value === \"[\") {\n            return this.parseArrayLiteralOperand();\n        }\n\n        if (token.kind === \"identifier\") {\n            return this.parseIdentifierOperand();\n        }\n\n        throw new Error(ERROR_MESSAGES.UNSUPPORTED(String(token.value)));\n    }\n\n    /**\n     * Parses an inline array of literals, e.g. `[\"active\", \"pending\"]`, and the\n     * membership test that follows it: `[...].includes(entity.property)`.\n     */\n    private parseArrayLiteralOperand(): Operand {\n        this.stream.expectPunctuation(\"[\");\n        const elements: unknown[] = [];\n\n        while (!this.stream.isPunctuation(\"]\")) {\n            const element = this.parseOperand();\n\n            if (element.kind !== \"value\" || element.transformer != null) {\n                throw new Error(ERROR_MESSAGES.UNSUPPORTED(\"a non-literal element in an array literal\"));\n            }\n\n            elements.push(element.value);\n\n            if (!this.stream.matchPunctuation(\",\")) {\n                break;\n            }\n        }\n\n        this.stream.expectPunctuation(\"]\");\n\n        const array: ValueOperand = { kind: \"value\", value: elements, transformer: null, locale: null };\n\n        // The only supported use is a membership test on a schema property\n        if (this.stream.isPunctuation(\".\") || this.stream.isPunctuation(\"?.\")) {\n            this.stream.next();\n            const method = this.stream.next();\n\n            if (method.kind !== \"identifier\" || method.value !== \"includes\") {\n                throw new Error(ERROR_MESSAGES.UNSUPPORTED(`'.${method.value}' on an array literal`));\n            }\n\n            this.stream.expectPunctuation(\"(\");\n            const argument = this.parseOperand();\n            this.stream.expectPunctuation(\")\");\n\n            if (argument.kind === \"method-call\") {\n                throw new Error(ERROR_MESSAGES.UNSUPPORTED(\"nested method call inside .includes()\"));\n            }\n\n            return { kind: \"method-call\", target: array, method: \"includes\", argument };\n        }\n\n        return array;\n    }\n\n    private parseIdentifierOperand(): Operand {\n        const root = this.stream.next().value;\n\n        // Keyword literals\n        if (root === \"true\" || root === \"false\") {\n            return { kind: \"value\", value: root === \"true\", transformer: null, locale: null };\n        }\n\n        if (root === \"null\") {\n            return { kind: \"value\", value: null, transformer: null, locale: null };\n        }\n\n        if (root === \"undefined\") {\n            return { kind: \"value\", value: undefined, transformer: null, locale: null };\n        }\n\n        if (root === \"void\") {\n            this.stream.next(); // the '0'\n            return { kind: \"value\", value: undefined, transformer: null, locale: null };\n        }\n\n        if (root === this.entityName) {\n            return this.parseChain({ kind: \"property\", root });\n        }\n\n        if (this.paramsName != null && root === this.paramsName) {\n            return this.parseChain({ kind: \"param\", root });\n        }\n\n        // A bare variable from the outer scope — its value cannot be derived from source text\n        throw new Error(ERROR_MESSAGES.VARIABLE_VALUE(root));\n    }\n\n    /**\n     * Parses the segments after an entity/params root: dot access, bracket\n     * access, transform methods and comparator methods.\n     */\n    private parseChain(options: { kind: \"property\" | \"param\", root: string }): Operand {\n        const path: string[] = [];\n        let transformer: Transformer | null = null;\n        let locale: string | null = null;\n\n        while (true) {\n            if (this.stream.matchPunctuation(\".\") || this.stream.matchPunctuation(\"?.\")) {\n                const segment = this.stream.next();\n\n                if (segment.kind !== \"identifier\") {\n                    throw new Error(ERROR_MESSAGES.UNSUPPORTED(`'.${segment.value}'`));\n                }\n\n                // Method call\n                if (this.stream.isPunctuation(\"(\")) {\n                    const method = segment.value;\n\n                    if (TRANSFORM_METHODS[method] != null) {\n                        this.stream.expectPunctuation(\"(\");\n                        this.stream.expectPunctuation(\")\");\n                        transformer = TRANSFORM_METHODS[method].transformer;\n                        locale = TRANSFORM_METHODS[method].locale;\n                        continue;\n                    }\n\n                    if (COMPARATOR_METHODS[method] != null) {\n                        this.stream.expectPunctuation(\"(\");\n                        const argument = this.parseOperand();\n                        this.stream.expectPunctuation(\")\");\n\n                        if (argument.kind === \"method-call\") {\n                            throw new Error(ERROR_MESSAGES.UNSUPPORTED(`nested method call inside .${method}()`));\n                        }\n\n                        return {\n                            kind: \"method-call\",\n                            target: this.resolveChain(options.kind, path, transformer, locale),\n                            method: method as MethodCallOperand[\"method\"],\n                            argument\n                        };\n                    }\n\n                    throw new Error(ERROR_MESSAGES.UNSUPPORTED(`method '.${method}()'`));\n                }\n\n                if (transformer != null) {\n                    throw new Error(ERROR_MESSAGES.UNSUPPORTED(\"property access after a transform method\"));\n                }\n\n                path.push(segment.value);\n                continue;\n            }\n\n            if (this.stream.matchPunctuation(\"[\")) {\n                path.push(this.parseBracketSegment(options.kind));\n                this.stream.expectPunctuation(\"]\");\n                continue;\n            }\n\n            break;\n        }\n\n        return this.resolveChain(options.kind, path, transformer, locale);\n    }\n\n    private parseBracketSegment(kind: \"property\" | \"param\"): string {\n        const token = this.stream.next();\n\n        // Literal segment: entity[\"name\"]\n        if (token.kind === \"string\") {\n            return token.value;\n        }\n\n        // Param-driven segment: entity[p.name] — the property depends on the\n        // param VALUE, so the resulting template is tied to these params.\n        // Stryker disable next-line all: documented equivalent cluster (see\n        // docs/mutation-backlog.md) — every mutation of this four-conjunct guard reroutes\n        // bracket access between two paths that both collapse to NOT_PARSABLE; the\n        // experiment recorded there aimed 30 tests at this line and killed none.\n        if (kind === \"property\" && token.kind === \"identifier\" && this.paramsName != null && token.value === this.paramsName) {\n            const paramPath: string[] = [];\n\n            while (this.stream.matchPunctuation(\".\") || this.stream.matchPunctuation(\"?.\")) {\n                paramPath.push(this.stream.next().value);\n            }\n\n            const resolved = resolveParamPath(this.paramsName, paramPath, this.params);\n\n            if (typeof resolved !== \"string\") {\n                throw new ParamDependentParseError(ERROR_MESSAGES.PROPERTY_NOT_FOUND(paramPath.join(\".\")));\n            }\n\n            this.structurallyDependsOnParams = true;\n            return resolved;\n        }\n\n        throw new Error(ERROR_MESSAGES.UNSUPPORTED(`bracket access '[${token.value}]'`));\n    }\n\n    private resolveChain(kind: \"property\" | \"param\", path: string[], transformer: Transformer | null, locale: string | null): PropertyOperand | ParamOperand {\n\n        if (kind === \"param\") {\n            if (path.length === 0) {\n                // `params` alone is a variable, not a value we can resolve\n                throw new Error(ERROR_MESSAGES.PARAM_PATH_NOT_FOUND(this.paramsName ?? \"params\", this.params));\n            }\n\n            return { kind: \"param\", path, transformer, locale };\n        }\n\n        const pathString = path.join(\".\");\n        const property = this.schema.properties.find(w => w.getAssignmentPath() == pathString);\n\n        if (property == null) {\n            // `.length` on a string/array property — a real schema property named\n            // `length` wins (checked above); otherwise treat it as a transformer\n            if (path.length > 1 && path[path.length - 1] === \"length\" && transformer == null) {\n                const parentPath = path.slice(0, -1).join(\".\");\n                const parent = this.schema.properties.find(w => w.getAssignmentPath() == parentPath);\n\n                // Vector is deliberately absent. Its length is the dimension count declared\n                // in the schema — a constant, not data — so a filter on it answers a question\n                // nobody asks, and pushing it down would need `json_array_length` on a\n                // backend storing JSON and something else entirely on one with a native\n                // vector column. Not parsing it leaves a clear error instead of a dialect gap.\n                if (parent != null && (parent.type === SchemaTypes.String || parent.type === SchemaTypes.Array)) {\n                    return { kind: \"property\", property: parent, transformer: \"length\", locale: null };\n                }\n            }\n\n            throw new Error(ERROR_MESSAGES.PROPERTY_NOT_FOUND(pathString));\n        }\n\n        return { kind: \"property\", property, transformer, locale };\n    }\n\n    private withValueTransformer(operand: ValueOperand): ValueOperand {\n        if (this.stream.isPunctuation(\".\")) {\n            const method = this.stream.peek(1);\n\n            // Stryker disable next-line all: documented equivalent cluster (see\n        // docs/mutation-backlog.md) — the guard's conjuncts each route to a rejection that\n        // collapses to NOT_PARSABLE with an indistinguishable message; 18 targeted tests\n        // killed none of these.\n        if (method != null && method.kind === \"identifier\" && TRANSFORM_METHODS[method.value] != null) {\n                this.stream.next(); // .\n                this.stream.next(); // method name\n                this.stream.expectPunctuation(\"(\");\n                this.stream.expectPunctuation(\")\");\n\n                operand.transformer = TRANSFORM_METHODS[method.value].transformer;\n                operand.locale = TRANSFORM_METHODS[method.value].locale;\n            }\n        }\n\n        return operand;\n    }\n\n    // #region Condition building\n\n    private buildComparison(left: Operand, operator: { comparator: Comparator, negated: boolean, strict: boolean }, right: Operand): Expression {\n\n        // methodCall == true/false — fold the boolean into negation\n        if (left.kind === \"method-call\") {\n            if (operator.comparator === \"equals\" && right.kind === \"value\" && typeof right.value === \"boolean\") {\n                const comparator = this.buildMethodComparator(left);\n                const comparedToFalse = right.value === false;\n                comparator.negated = comparator.negated !== (operator.negated !== comparedToFalse);\n                return comparator;\n            }\n\n            throw new Error(ERROR_MESSAGES.UNSUPPORTED(\"comparing a method call to a non-boolean\"));\n        }\n\n        if (right.kind === \"method-call\") {\n            throw new Error(ERROR_MESSAGES.UNSUPPORTED(\"method call on the right side of a comparison\"));\n        }\n\n        if (left.kind === \"property\" && right.kind === \"property\") {\n            // Casing transformers are only valid with string-matching comparators,\n            // which cannot produce a property-to-property comparison\n            if (left.transformer === \"to-lower-case\" || left.transformer === \"to-upper-case\" ||\n                right.transformer === \"to-lower-case\" || right.transformer === \"to-upper-case\") {\n                throw new Error(ERROR_MESSAGES.UNSUPPORTED(\"transform method outside of startsWith/endsWith/includes\"));\n            }\n\n            return new ComparatorExpression({\n                comparator: operator.comparator,\n                negated: operator.negated,\n                strict: operator.strict,\n                left: this.createPropertyExpression(left),\n                right: this.createPropertyExpression(right)\n            });\n        }\n\n        if (left.kind === \"property\" && right.kind !== \"property\") {\n            return this.buildPropertyComparator(left, operator, right, /* applyConverter */ true);\n        }\n\n        if (right.kind === \"property\" && left.kind !== \"property\") {\n            const swapped = { ...operator, comparator: SWAPPED_COMPARATORS[operator.comparator] };\n            return this.buildPropertyComparator(right, swapped, left, /* applyConverter */ true);\n        }\n\n        throw new Error(ERROR_MESSAGES.UNSUPPORTED(\"comparison requires a schema property on at least one side\"));\n    }\n\n    private buildStandalone(operand: Operand): Expression {\n\n        if (operand.kind === \"method-call\") {\n            return this.buildMethodComparator(operand);\n        }\n\n        if (operand.kind === \"property\") {\n            // Truthy shorthand on `.length`: a length is truthy exactly when > 0\n            if (operand.transformer === \"length\") {\n                return this.buildPropertyComparator(operand, COMPARISON_OPERATORS[\">\"], { kind: \"value\", value: 0, transformer: null, locale: null }, /* applyConverter */ true);\n            }\n\n            // Truthy shorthand: `w.isActive` → isActive === true\n            return this.buildPropertyComparator(operand, COMPARISON_OPERATORS[\"===\"], { kind: \"value\", value: true, transformer: null, locale: null }, /* applyConverter */ true);\n        }\n\n        // Constant `true` — a tautology, which parseAnd/parseOr simplify away\n        if (operand.kind === \"value\" && operand.value === true && operand.transformer == null) {\n            return Expression.EMPTY;\n        }\n\n        throw new Error(ERROR_MESSAGES.UNSUPPORTED(\"a filter condition must reference a schema property\"));\n    }\n\n    private buildMethodComparator(operand: MethodCallOperand): ComparatorExpression {\n        const { target, method, argument } = operand;\n\n        if (target.kind === \"property\") {\n            if (argument.kind === \"property\") {\n                throw new Error(ERROR_MESSAGES.UNSUPPORTED(`.${method}() comparing two schema properties`));\n            }\n\n            // Method arguments skip type conversion — only the value serializer applies\n            return this.buildPropertyComparator(target, { comparator: COMPARATOR_METHODS[method], negated: false, strict: false }, argument, /* applyConverter */ false);\n        }\n\n        // [\"a\", \"b\"].includes(x.prop) / params.list.includes(x.prop) —\n        // membership test with the collection on the left\n        if (method === \"includes\" && argument.kind === \"property\") {\n            if (target.transformer != null) {\n                throw new Error(ERROR_MESSAGES.UNSUPPORTED(\"transform method on a collection used with .includes()\"));\n            }\n\n            return new ComparatorExpression({\n                comparator: \"includes\",\n                negated: false,\n                strict: false,\n                left: this.createValueExpression(target, argument.property, /* applyConverter */ false),\n                right: this.createPropertyExpression(argument)\n            });\n        }\n\n        throw new Error(ERROR_MESSAGES.UNSUPPORTED(`.${method}() on a non-property target`));\n    }\n\n    private buildPropertyComparator(property: PropertyOperand, operator: { comparator: Comparator, negated: boolean, strict: boolean }, value: ValueOperand | ParamOperand, applyConverter: boolean): ComparatorExpression {\n\n        const isStringMatch = operator.comparator === \"starts-with\" || operator.comparator === \"ends-with\" || operator.comparator === \"includes\";\n\n        // `.length` compares a NUMBER, so the paired property's serializer and\n        // type converter must not touch the value; and a length has no meaning\n        // inside a string-matching comparator\n        if (property.transformer === \"length\") {\n            if (isStringMatch) {\n                throw new Error(ERROR_MESSAGES.UNSUPPORTED(\"'.length' with startsWith/endsWith/includes\"));\n            }\n\n            return new ComparatorExpression({\n                comparator: operator.comparator,\n                negated: operator.negated,\n                strict: operator.strict,\n                left: this.createPropertyExpression(property),\n                right: this.createValueExpression(value, null, /* applyConverter */ false)\n            });\n        }\n\n        // Casing transformers on a property are only meaningful with string-matching\n        // comparators; on relational comparators the plugins would silently\n        // ignore them and return wrong data\n        if (property.transformer != null && !isStringMatch) {\n            throw new Error(ERROR_MESSAGES.UNSUPPORTED(\"transform method outside of startsWith/endsWith/includes\"));\n        }\n\n        return new ComparatorExpression({\n            comparator: operator.comparator,\n            negated: operator.negated,\n            strict: operator.strict,\n            left: this.createPropertyExpression(property),\n            right: this.createValueExpression(value, property.property, applyConverter)\n        });\n    }\n\n    private createPropertyExpression(operand: PropertyOperand): PropertyExpression {\n        const expression = new PropertyExpression({ property: operand.property });\n        expression.transformer = operand.transformer;\n        expression.locale = operand.locale;\n        return expression;\n    }\n\n    private createValueExpression(operand: ValueOperand | ParamOperand, pairedProperty: PropertyInfo<any> | null, applyConverter: boolean): ValueExpression {\n\n        if (operand.kind === \"param\") {\n            const expression = new ParamReferenceExpression({ paramPath: operand.path, pairedProperty, applyConverter });\n            expression.transformer = operand.transformer;\n            expression.locale = operand.locale;\n            return expression;\n        }\n\n        const expression = new ValueExpression({ value: resolvePairedValue(operand.value, pairedProperty, applyConverter) });\n        expression.transformer = operand.transformer;\n        expression.locale = operand.locale;\n        return expression;\n    }\n\n    // #endregion\n}\n\n// #endregion\n\n// #region Template binding\n\n/**\n * Deep-clones a template into a consumer-facing tree, resolving parameter\n * placeholders against the supplied params.  Always clones so cached templates\n * can never be mutated by consumers.\n */\nconst bindExpression = (expression: Expression, paramsName: string | null, params: unknown): Expression => {\n\n    if (expression instanceof ParamReferenceExpression) {\n        const raw = resolveParamPath(paramsName ?? \"params\", expression.paramPath, params);\n        const bound = new ValueExpression({ value: resolvePairedValue(raw, expression.pairedProperty, expression.applyConverter) });\n        bound.transformer = expression.transformer;\n        bound.locale = expression.locale;\n        return bound;\n    }\n\n    if (expression instanceof ValueExpression) {\n        const clone = new ValueExpression({ value: expression.value });\n        clone.transformer = expression.transformer;\n        clone.locale = expression.locale;\n        return clone;\n    }\n\n    if (expression instanceof PropertyExpression) {\n        const clone = new PropertyExpression({ property: expression.property });\n        clone.transformer = expression.transformer;\n        clone.locale = expression.locale;\n        return clone;\n    }\n\n    if (expression instanceof ComparatorExpression) {\n        return new ComparatorExpression({\n            comparator: expression.comparator,\n            negated: expression.negated,\n            strict: expression.strict,\n            left: expression.left ? bindExpression(expression.left, paramsName, params) : undefined,\n            right: expression.right ? bindExpression(expression.right, paramsName, params) : undefined\n        });\n    }\n\n    if (expression instanceof OperatorExpression) {\n        return new OperatorExpression({\n            operator: expression.operator,\n            left: expression.left ? bindExpression(expression.left, paramsName, params) : undefined,\n            right: expression.right ? bindExpression(expression.right, paramsName, params) : undefined\n        });\n    }\n\n    return expression;\n}\n\n// #endregion\n\n// #region Function source handling\n\ntype FunctionShape = {\n    entityName: string;\n    paramsName: string | null;\n    body: string;\n}\n\n/**\n * Splits stringified filter source into parameter names and the expression\n * body, unwrapping single-return block bodies.\n */\nconst resolveFunctionShape = (stringifiedFunction: string, hasParams: boolean): FunctionShape => {\n\n    const source = stringifiedFunction.trim();\n\n    let parameterNames: string;\n    let body: string;\n\n    // `function (x) { ... }` / `function name(x) { ... }` — what ES5-targeting\n    // transpilers rewrite every arrow filter into\n    const functionHead = /^function\\b[^(]*\\(/.exec(source);\n\n    if (functionHead != null) {\n        const parametersEnd = source.indexOf(\")\", functionHead[0].length);\n\n        if (parametersEnd === -1) {\n            throw new Error(\"Invalid Function\");\n        }\n\n        parameterNames = source.slice(functionHead[0].length, parametersEnd).trim();\n        body = source.slice(parametersEnd + 1).trim();\n    } else {\n        const arrowIndex = source.indexOf(\"=>\");\n\n        if (arrowIndex === -1) {\n            throw new Error(\"Invalid Function\");\n        }\n\n        parameterNames = source.substring(0, arrowIndex).trim();\n        body = source.substring(arrowIndex + 2).trim();\n\n        // Strip wrapping parens: (entity) or ([x, p])\n        if (parameterNames.startsWith(\"(\") && parameterNames.endsWith(\")\")) {\n            parameterNames = parameterNames.slice(1, -1).trim();\n        }\n    }\n\n    let entityName: string;\n    let paramsName: string | null = null;\n\n    if (parameterNames.startsWith(\"[\") && parameterNames.endsWith(\"]\")) {\n        const destructured = parameterNames.slice(1, -1).split(\",\").map(w => w.trim());\n        entityName = destructured[0];\n\n        if (hasParams) {\n            paramsName = destructured[1] ?? null;\n        }\n    } else {\n        entityName = parameterNames;\n    }\n\n    if (entityName == null || entityName.length === 0) {\n        throw new Error(\"Invalid Function\");\n    }\n\n    // Unwrap a single-return block body: { return <expression>; }\n    if (body.startsWith(\"{\")) {\n        const inner = body.slice(1, body.lastIndexOf(\"}\")).trim();\n\n        if (!inner.startsWith(\"return\")) {\n            throw new Error(ERROR_MESSAGES.UNSUPPORTED(\"block body without a single return statement\"));\n        }\n\n        body = inner.slice(\"return\".length).trim();\n\n        if (body.endsWith(\";\")) {\n            body = body.slice(0, -1).trim();\n        }\n    }\n\n    return { entityName, paramsName, body };\n}\n\n// #endregion\n\n// #region Cache\n\ntype ParsedTemplate = {\n    template: Expression;\n    paramsName: string | null;\n}\n\n// Keyed by schema instance so identical filter source on different schemas can\n// never collide; entries live only as long as the schema does\nconst templateCache = new WeakMap<CompiledSchema<any>, Map<string, ParsedTemplate>>();\nconst MAX_CACHED_TEMPLATES_PER_SCHEMA = 1024;\n\nconst getCachedTemplate = (schema: CompiledSchema<any>, source: string): ParsedTemplate | null => {\n    return templateCache.get(schema)?.get(source) ?? null;\n}\n\nconst setCachedTemplate = (schema: CompiledSchema<any>, source: string, entry: ParsedTemplate) => {\n    let bySource = templateCache.get(schema);\n\n    if (bySource == null) {\n        bySource = new Map<string, ParsedTemplate>();\n        templateCache.set(schema, bySource);\n    }\n\n    // Filter source strings come from static code, so this cap should never be\n    // hit in practice — it only guards against unbounded dynamic generation.\n    // Stryker disable next-line all: the cap is a pure resource bound — every mutation of\n    // it (never clear, always clear, off-by-one) parses identically and differs only in\n    // memory growth, which no observable boundary can assert.\n    if (bySource.size >= MAX_CACHED_TEMPLATES_PER_SCHEMA) {\n        bySource.clear();\n    }\n\n    bySource.set(source, entry);\n}\n\n// #endregion\n\nexport const combineExpressions = (...expressions: Expression[]): Expression => {\n\n    if (expressions.length === 0) {\n        throw new Error(\"combineExpressions requires at least 1 expression\");\n    }\n\n\n    if (expressions.length === 1) {\n        return expressions[0];\n    }\n\n    // Start with the first expression\n    let result = expressions[0];\n\n    // Loop through remaining expressions and combine them\n    for (let i = 1; i < expressions.length; i++) {\n        result = new OperatorExpression({\n            operator: \"&&\",\n            left: result,\n            right: expressions[i]\n        });\n    }\n\n    return result;\n};\n\n/**\n * Parses an expression SOURCE FRAGMENT against one schema and one root name.\n *\n * `toExpression` starts from a function and works out its own roots. This starts from text, which\n * is what a caller has when it has split a larger predicate apart — `p.rank > 10` lifted out of\n * `([p, m]) => p.rank > 10 && m.won === true`.\n *\n * **A fragment naming anything other than `rootName` returns `NOT_PARSABLE`, and that is the\n * point.** It is how a caller discovers which side of a join a conjunct belongs to: parse it\n * against each side in turn, and exactly one succeeds for a single-side condition. A condition\n * spanning both fails against both, which is the correct answer — it cannot be pushed to either.\n *\n * No params: a fragment carrying a params reference has no bag to resolve it against here, so it\n * fails rather than binding to nothing.\n *\n * Deliberately NOT cached. The cache is keyed by function source, and a fragment is not a function\n * — two different lambdas can contain the same fragment text against different schemas.\n */\nexport const parseFragment = (schema: CompiledSchema<any>, body: string, rootName: string): Expression => {\n    try {\n        const stream = new TokenStream(tokenize(body));\n        const parser = new ExpressionParser(schema, stream, rootName, null, undefined);\n\n        return parser.parse();\n    } catch {\n        // The failure is expected and informative — see above — so it is not logged. A caller that\n        // parses one conjunct against two schemas would otherwise warn on every successful split.\n        return Expression.NOT_PARSABLE;\n    }\n};\n\nexport const toExpression = <T extends any, P extends any>(schema: CompiledSchema<any>, fn: Filter<T> | ParamsFilter<T, P>, params?: P) => {\n    const stringifiedFunction = fn.toString();\n\n    const warn = (error: unknown) => logger.warn(\"Error parsing expression\", {\n        error,\n        collectionName: schema.collectionName,\n        params,\n        selector: stringifiedFunction\n    });\n\n    const cached = getCachedTemplate(schema, stringifiedFunction);\n\n    if (cached != null) {\n        // A cached failure — the warning was already logged when it was discovered\n        if (Expression.isNotParsable(cached.template)) {\n            return Expression.NOT_PARSABLE;\n        }\n\n        try {\n            return bindExpression(cached.template, cached.paramsName, params);\n        } catch (error) {\n            // Binding failures are param-dependent by nature — never cached\n            warn(error);\n            return Expression.NOT_PARSABLE;\n        }\n    }\n\n    let paramsName: string | null = null;\n    let template: Expression;\n    let structurallyDependsOnParams: boolean;\n\n    try {\n        const shape = resolveFunctionShape(stringifiedFunction, params != null);\n        const stream = new TokenStream(tokenize(shape.body));\n        const parser = new ExpressionParser(schema, stream, shape.entityName, shape.paramsName, params);\n        paramsName = shape.paramsName;\n        template = parser.parse();\n        structurallyDependsOnParams = parser.structurallyDependsOnParams;\n    } catch (error) {\n        // Cache the failure so a hot query on an unsupported filter doesn't\n        // re-parse and re-warn on every execution.  Param-dependent failures are\n        // exempt: the same source can succeed with different params.\n        if (!(error instanceof ParamDependentParseError)) {\n            setCachedTemplate(schema, stringifiedFunction, { template: Expression.NOT_PARSABLE, paramsName: null });\n        }\n\n        warn(error);\n        return Expression.NOT_PARSABLE;\n    }\n\n    // Templates whose structure was resolved from param values are only\n    // valid for this exact params object — parse those fresh every time\n    if (!structurallyDependsOnParams) {\n        setCachedTemplate(schema, stringifiedFunction, { template, paramsName });\n    }\n\n    try {\n        return bindExpression(template, paramsName, params);\n    } catch (error) {\n        warn(error);\n        return Expression.NOT_PARSABLE;\n    }\n}\n","import { QueryOptionExecutionTarget } from \"../plugins\";\nimport { CompiledSchemaCore, PropertyInfo } from \"../schema\";\n\n/**\n * JSON-safe form of a literal. Tagged only where JSON cannot carry the value as it is.\n *\n * See `Expression.toJson`.\n */\nexport type SerializedValue =\n    | { k: \"raw\"; v: string | number | boolean | null }\n    | { k: \"date\"; v: string }\n    | { k: \"undefined\" }\n    | { k: \"number\"; v: \"NaN\" | \"Infinity\" | \"-Infinity\" }\n    | { k: \"array\"; v: SerializedValue[] };\n\n/** JSON-safe form of an expression tree. See `Expression.toJson`. */\nexport type SerializedExpression =\n    | { t: \"empty\" }\n    | { t: \"not-parsable\" }\n    | { t: \"operator\"; operator: Operator; left?: SerializedExpression; right?: SerializedExpression }\n    | {\n        t: \"comparator\";\n        comparator: Comparator;\n        negated: boolean;\n        strict: boolean;\n        left?: SerializedExpression;\n        right?: SerializedExpression;\n    }\n    | { t: \"property\"; path: string; transformer: Transformer | null; locale: string | null }\n    | { t: \"value\"; value: SerializedValue; transformer: Transformer | null; locale: string | null };\n\nconst valueToJson = (value: unknown): SerializedValue => {\n    if (value === undefined) {\n        return { k: \"undefined\" };\n    }\n\n    if (value === null) {\n        return { k: \"raw\", v: null };\n    }\n\n    if (value instanceof Date) {\n        // ISO rather than epoch millis: it survives a human reading the payload, and an invalid\n        // Date has no ISO form — so it is caught here rather than becoming a silent `null`.\n        return { k: \"date\", v: value.toISOString() };\n    }\n\n    if (Array.isArray(value)) {\n        return { k: \"array\", v: value.map(valueToJson) };\n    }\n\n    if (typeof value === \"number\" && Number.isFinite(value) === false) {\n        // `JSON.stringify` turns all three of these into `null`, which would compare as a different\n        // value entirely rather than failing.\n        return { k: \"number\", v: Number.isNaN(value) ? \"NaN\" : value > 0 ? \"Infinity\" : \"-Infinity\" };\n    }\n\n    if (typeof value === \"string\" || typeof value === \"number\" || typeof value === \"boolean\") {\n        return { k: \"raw\", v: value };\n    }\n\n    throw new Error(\n        `Cannot serialize this filter value: only strings, numbers, booleans, null, undefined, Dates and arrays of those can cross a wire.  ` +\n        `Received: ${Object.prototype.toString.call(value)}`\n    );\n};\n\nconst valueFromJson = (value: SerializedValue): unknown => {\n    if (value.k === \"undefined\") {\n        return undefined;\n    }\n\n    if (value.k === \"date\") {\n        return new Date(value.v);\n    }\n\n    if (value.k === \"array\") {\n        return value.v.map(valueFromJson);\n    }\n\n    if (value.k === \"number\") {\n        return value.v === \"NaN\" ? Number.NaN : value.v === \"Infinity\" ? Number.POSITIVE_INFINITY : Number.NEGATIVE_INFINITY;\n    }\n\n    return value.v;\n};\n\nexport type ParsedExpression = {\n    expression: Expression;\n    // Will be memory when trying to query on an untracked computed property or on a function\n    executionTarget: QueryOptionExecutionTarget;\n}\n\n/**\n * The base class for all expression types.\n */\nexport abstract class Expression {\n    /** The type of the expression. */\n    abstract readonly type: ExpressionType;\n    /** The left-hand side of the expression (if applicable). */\n    left?: Expression;\n    /** The right-hand side of the expression (if applicable). */\n    right?: Expression;\n\n    constructor(left?: Expression, right?: Expression) {\n        this.left = left;\n        this.right = right;\n    }\n\n    static get EMPTY() {\n        return new EmptyExpression();\n    }\n\n    static get NOT_PARSABLE() {\n        return new NotParsableExpression();\n    }\n\n    static isEmpty(expression: Expression) {\n        return expression.type === \"empty\" || expression instanceof EmptyExpression;\n    }\n\n    static isNotParsable(expression: Expression) {\n        return expression.type === \"not-parsable\" || expression instanceof NotParsableExpression;\n    }\n\n    /**\n     * Turns a tree into plain JSON, so a whole query can cross a wire.\n     *\n     * On the class rather than beside it, because this is the type's own REPRESENTATION — there is one\n     * right answer and it belongs with the thing being represented, next to `EMPTY` and `isEmpty`.\n     * Rendering a tree into some other language (`toSql`, `toMql`, `evaluate`) is a different kind of\n     * thing: there are many, each belongs to its consumer, and none of them is canonical.\n     *\n     * ## Why it is this small\n     *\n     * Of the six node types a bound tree can contain, exactly one holds anything JSON cannot carry:\n     * `PropertyExpression`, whose live `PropertyInfo` has functions, a parent chain and caches. It\n     * reduces to a property PATH — `PropertyInfo.id` IS the dotted path, and `getProperty` is keyed by\n     * exactly that — so rebinding is one lookup.\n     *\n     * `ParamReferenceExpression` never appears: it is a parse-time placeholder that binding replaces\n     * with a plain `ValueExpression` holding the resolved value. A serialized tree is always already\n     * bound, so there is no params object to send alongside it.\n     *\n     * Switches on `type` rather than using the `isXExpression` guards, which live in `../assertions`\n     * and import this module — the guards test the same discriminant, so nothing is lost.\n     */\n    static toJson(expression: Expression): SerializedExpression {\n\n        if (expression.type === \"operator\") {\n            const operator = expression as OperatorExpression;\n\n            return {\n                t: \"operator\",\n                operator: operator.operator,\n                ...(operator.left != null && { left: Expression.toJson(operator.left) }),\n                ...(operator.right != null && { right: Expression.toJson(operator.right) }),\n            };\n        }\n\n        if (expression.type === \"comparator\") {\n            const comparator = expression as ComparatorExpression;\n\n            return {\n                t: \"comparator\",\n                comparator: comparator.comparator,\n                negated: comparator.negated,\n                strict: comparator.strict,\n                ...(comparator.left != null && { left: Expression.toJson(comparator.left) }),\n                ...(comparator.right != null && { right: Expression.toJson(comparator.right) }),\n            };\n        }\n\n        if (expression.type === \"property\") {\n            const property = expression as PropertyExpression;\n\n            return {\n                t: \"property\",\n                // The dotted path, which is exactly the key `getProperty` is looking up\n                path: property.property.id,\n                transformer: property.transformer,\n                locale: property.locale,\n            };\n        }\n\n        if (expression.type === \"value\") {\n            const value = expression as ValueExpression;\n\n            return {\n                t: \"value\",\n                value: valueToJson(value.value),\n                transformer: value.transformer,\n                locale: value.locale,\n            };\n        }\n\n        return expression.type === \"empty\" ? { t: \"empty\" } : { t: \"not-parsable\" };\n    }\n\n    /**\n     * Rebuilds a tree from JSON, rebinding every property against `schema`.\n     *\n     * The schema is SUPPLIED rather than read out of the payload. A filter always belongs to a known\n     * collection, and the RECEIVER's schema is the authority on what its properties are — taking an\n     * id from the payload would mean rebinding against a schema the sender chose, which is backwards\n     * for anything crossing a trust boundary.\n     *\n     * @throws when a property path is not declared by `schema`. Not `NOT_PARSABLE`: on a receiver, a\n     * filter that silently stops filtering returns rows the requester excluded, which is the one\n     * failure here worse than an error.\n     */\n    static fromJson(json: SerializedExpression, schema: CompiledSchemaCore<any>): Expression {\n\n        const child = (node: SerializedExpression | undefined) => node == null ? undefined : Expression.fromJson(node, schema);\n\n        if (json.t === \"operator\") {\n            return new OperatorExpression({ operator: json.operator, left: child(json.left), right: child(json.right) });\n        }\n\n        if (json.t === \"comparator\") {\n            return new ComparatorExpression({\n                comparator: json.comparator,\n                negated: json.negated,\n                strict: json.strict,\n                left: child(json.left),\n                right: child(json.right),\n            });\n        }\n\n        if (json.t === \"property\") {\n            const property = schema.getProperty(json.path);\n\n            if (property == null) {\n                throw new Error(\n                    `Cannot deserialize a filter: this schema does not declare the property it names.  ` +\n                    `Property: ${json.path}, Collection: ${schema.collectionName}.  ` +\n                    `The two sides disagree about the shape of the data, so the filter cannot be applied.`\n                );\n            }\n\n            const rebuilt = new PropertyExpression({ property });\n            rebuilt.transformer = json.transformer;\n            rebuilt.locale = json.locale;\n\n            return rebuilt;\n        }\n\n        if (json.t === \"value\") {\n            const rebuilt = new ValueExpression({ value: valueFromJson(json.value) });\n            rebuilt.transformer = json.transformer;\n            rebuilt.locale = json.locale;\n\n            return rebuilt;\n        }\n\n        return json.t === \"empty\" ? Expression.EMPTY : Expression.NOT_PARSABLE;\n    }\n}\n\nexport class EmptyExpression extends Expression {\n    readonly type = \"empty\" as const;\n}\n\nexport class NotParsableExpression extends Expression {\n    readonly type = \"not-parsable\" as const;\n}\n\n/**\n * A class representing a comparison operation (e.g., equals, greater-than).\n */\nexport class ComparatorExpression extends Expression {\n    /** The type of the expression (always 'comparator'). */\n    readonly type = \"comparator\" as const;\n    /** The comparator operation (e.g., equals, greater-than). */\n    comparator: Comparator;\n    /** Whether the comparison is negated (e.g., not equals). */\n    negated: boolean;\n    /** Whether the comparison is strict (type-sensitive). */\n    strict: boolean;\n\n    constructor(\n        options: {\n            comparator: Comparator,\n            negated: boolean,\n            strict: boolean,\n            left?: Expression,\n            right?: Expression\n        }\n    ) {\n        super(options.left, options.right);\n        this.comparator = options.comparator;\n        this.negated = options.negated;\n        this.strict = options.strict;\n    }\n}\n\n/**\n * A class representing a logical operator (e.g., &&, ||).\n */\nexport class OperatorExpression extends Expression {\n    /** The type of the expression (always 'operator'). */\n    readonly type = \"operator\" as const;\n    /** The logical operator. */\n    operator: Operator;\n\n    constructor(options: { operator: Operator, left?: Expression, right?: Expression }) {\n        super(options.left, options.right);\n        this.operator = options.operator;\n    }\n}\n\n/**\n * A class representing a property path.\n */\nexport class PropertyExpression extends Expression {\n    /** The type of the expression (always 'property'). */\n    readonly type = \"property\" as const;\n    /** The property info for the path. */\n    property: PropertyInfo<any>;\n    transformer: Transformer | null = null;\n    locale: string | null = null;\n\n    constructor(options: { property: PropertyInfo<any> }) {\n        super();\n        this.property = options.property;\n    }\n}\n\n/**\n * A class representing a literal value.\n */\nexport class ValueExpression extends Expression {\n    /** The type of the expression (always 'value'). */\n    readonly type = \"value\" as const;\n    /** The literal value. */\n    value: unknown;\n\n    transformer: Transformer | null = null;\n    locale: string | null = null;\n\n    constructor(options: {\n        value: unknown\n    }) {\n        super();\n        this.value = options.value;\n    }\n}\n\n\n/**\n * The set of possible expression types.\n */\nexport type ExpressionType = \"operator\" | \"comparator\" | \"property\" | \"value\" | \"empty\" | \"not-parsable\";\n\n/**\n * Supported value transformations that can be applied to values.\n * `length` reads the length of a string or array property.\n */\nexport type Transformer = \"to-lower-case\" | \"to-upper-case\" | \"length\";\n\n/**\n * Supported comparator operations for expressions.\n */\nexport type Comparator =\n    | \"equals\"\n    | \"starts-with\"\n    | \"includes\"\n    | \"ends-with\"\n    | \"greater-than\"\n    | \"greater-than-equals\"\n    | \"less-than\"\n    | \"less-than-equals\";\n\n/**\n * Supported logical operators for expressions.\n */\nexport type Operator = \"&&\" | \"||\";\n\n/**\n * A function that filters a value of type T and returns a boolean.\n */\nexport type Filter<T extends any> = (value: T) => boolean;\n\n/**\n * A function that filters a value of type T with additional parameters P.\n */\nexport type ParamsFilter<T extends any, P> = (payload: [T, P]) => boolean;\n\n/**\n * A filter that can be either a simple filter or a parameterized filter.\n */\nexport type CompositeFilter<T extends any, P = never> = Filter<T> | ParamsFilter<T, P>;\n\n/**\n * An object that can be filtered using a composite filter and optional parameters.\n */\nexport type Filterable<T extends any, P = any> = {\n    /** The filter function. */\n    filter: CompositeFilter<T, P>;\n    /** Optional parameters for the filter. */\n    params?: P;\n};","import { PropertyInfo } from \"../schema\";\nimport { Expression, PropertyExpression } from \"./types\";\n\n/**\n * Extracts all properties referenced in an expression\n * @param expression The expression to analyze\n * @returns Array of PropertyInfo objects referenced in the expression\n */\nexport function getProperties(expression: Expression): PropertyInfo<any>[] {\n    const properties: PropertyInfo<any>[] = [];\n\n    function traverse(expr: Expression) {\n        // If this is a property expression, add it to our collection\n        if (expr.type === \"property\") {\n            properties.push((expr as PropertyExpression).property);\n        }\n\n        // Traverse left and right expressions if they exist\n        if (expr.left) {\n            traverse(expr.left);\n        }\n        if (expr.right) {\n            traverse(expr.right);\n        }\n    }\n\n    traverse(expression);\n    return properties;\n}\n\nexport function forEach(expression: Expression, callback: (expression: Expression) => boolean) {\n    function traverse(expr: Expression): boolean {\n        // Call the callback for this expression\n        // If callback returns false, stop traversing\n        if (!callback(expr)) {\n            return false;\n        }\n\n        // Traverse left and right expressions if they exist\n        if (expr.left) {\n            if (!traverse(expr.left)) {\n                return false;\n            }\n        }\n        if (expr.right) {\n            if (!traverse(expr.right)) {\n                return false;\n            }\n        }\n\n        return true;\n    }\n\n    traverse(expression);\n}","import type { SchemaDefinition } from \"./SchemaDefinition\";\nimport type { SchemaBase } from \"./property/base/SchemaBase\";\nimport type { SchemaArray } from \"./property/types/SchemaArray\";\nimport type { SchemaVector } from \"./property/types/SchemaVector\";\nimport type { SchemaObject } from \"./property/types/SchemaObject\";\nimport type { PropertyInfo } from \"./PropertyInfo\";\nimport type { DeepPartial } from \"../types\";\nimport type { SchemaFunction } from \"./table\";\nimport type { SchemaOptional, SchemaTag } from \"./property/modifiers\";\nimport type { Branded } from \"../utilities/types\";\nimport type { SchemaSubscriptionOptions } from \"./communication/broadcast\";\n\nexport type DefaultValue<T, I = never> = T | ((injected: I) => T);\nexport type FunctionBody<TEntity, TResult> = (entity: TEntity, collectionName: CollectionName) => TResult;\nexport type IdType = string | number;\nexport type ForeignKey<T extends {}> = { \n    schema: CompiledSchema<T>, \n    property: PropertyInfo<T> \n};\n\nexport enum SchemaTypes {\n    Array = \"Array\",\n    Boolean = \"Boolean\",\n    Date = \"Date\",\n    Number = \"Number\",\n    Object = \"Object\",\n    String = \"String\",\n    Definition = \"Definition\",\n    Function = \"Function\",\n    Computed = \"Computed\",\n    /**\n     * Content in, reference out. The only type whose write shape differs from its stored\n     * shape, and a leaf on purpose — see `SchemaFile`.\n     */\n    File = \"File\",\n    /**\n     * A fixed-length list of numbers, carrying its dimension count — see `SchemaVector`.\n     *\n     * Value-shaped exactly like `s.array(s.number())`, which is why every array codegen\n     * handler accepts it. It is a distinct type only so a backend can recognise it and store\n     * it natively; nothing else needs to tell the two apart.\n     */\n    Vector = \"Vector\"\n}\n\nexport type ArrayShape = string | number | Date | {};\n\n\n/**\n * What a file property gives back: where the bytes are and what they are.\n *\n * Declared in core so `InferType` can name it. Core never reads or writes the bytes — it only\n * carries this shape — and `@routier/blob-plugin` is what puts one here.\n */\nexport type FileReferenceValue = {\n    /** Where the bytes live, content-addressed by the blob plugin. */\n    key: string;\n    /** Byte length. */\n    size: number;\n    /** Media type as supplied at upload. */\n    contentType: string;\n    /** SHA-256 of the bytes, lowercase hex. */\n    checksum: string;\n    /** The name to show a user. Not part of the key. */\n    fileName: string;\n};\n\n/**\n * What a file property ACCEPTS: content, or a reference you already have.\n *\n * `Blob` covers `File`, which is what an `<input type=\"file\">` yields. A reference is accepted\n * too, so re-saving an entity that was read from the database does not have to re-upload it.\n */\nexport type FileContentValue =\n    | FileReferenceValue\n    | Uint8Array\n    | ArrayBuffer\n    | Blob\n    | string;\n\n/**\n * What a vector property holds, in and out: a plain list of numbers.\n *\n * Named rather than written inline because the inference rules have to recognise it after a\n * modifier has erased which class produced it — the same problem `FileReferenceValue` solves\n * above, and for the same reason.\n */\nexport type VectorValue = number[];\n\n/**\n * What `s.string({ ... })` accepts.\n *\n * Declarations only. Core stores them and never acts on them; a backend that can use one does.\n */\nexport type StringOptions = {\n    /**\n     * The longest value the property is declared to hold.\n     *\n     * MySQL uses it for `VARCHAR(maxLength)`; without it every string column is\n     * `VARCHAR(255)`, which silently truncates longer values. Other backends ignore it. Core\n     * never validates a value against it — see `SchemaBase.maxLength`.\n     */\n    maxLength?: number;\n};\n\nexport type ExpandedProperty = ExpandedChildProperty & {\n    assignmentPath: string;\n    selectorPath: string;\n    properties: Map<string, ExpandedChildProperty>;\n    childDegree: number;\n};\n\nexport type ExpandedChildProperty = {\n    propertyName: string;\n    type: SchemaTypes;\n    isNullableOrOptional: boolean;\n    isReadonly: boolean;\n    isIdentity: boolean;\n    isUnmapped: boolean;\n}\n\nexport enum HashType {\n    Ids = \"Ids\",\n    Object = \"Object\"\n}\n\nexport type HashFunction<TEntity extends {}> = {\n    (entity: InferCreateType<TEntity>, type: HashType.Object): string;\n    (entity: InferType<TEntity>, type: HashType.Ids): string;\n}\n\nexport type GetHashTypeFunction<TEntity extends {}> = {\n    (entity: InferCreateType<TEntity>): HashType.Object;\n    (entity: InferType<TEntity>): HashType.Ids;\n}\n\nexport type ChangeTrackingType = \"proxy\" | \"diff\" | \"immutable\";\n\nexport type IndexType = \"single\" | \"compound\" | \"unique\" | \"primary-key\"\nexport type Index = {\n    properties: PropertyInfo<any>[],\n    type: IndexType;\n    name: string;\n}\n\n/**\n * Represents changes to subscriptions, categorizing them by modifications to\n * entities (additions, updates, removals) or query-driven removals.\n * @template T - The type of the entities in the subscription.\n */\nexport type SubscriptionChanges<T extends {}> = {\n    /**\n     * Entities that have been added to the subscription.\n     */\n    adds: InferType<T>[];\n    /**\n     * Entities that have been updated within the subscription.\n     */\n    updates: InferType<T>[];\n    /**\n     * Entities that have been removed from the subscription.\n     */\n    removals: InferType<T>[];\n    /**\n     * Entities that have been added/updated/removed from the subscription and it is unknown \n     * if the entities have been added/updated/removed.\n     */\n    unknown: InferType<T>[];\n}\n\nexport interface ISchemaSubscription<T extends {}> extends Disposable {\n    send(changes: SubscriptionChanges<T>): void;\n    onMessage(callback: (changes: SubscriptionChanges<T>) => void): void;\n}\n\nexport type Enrich<TEntity extends {}> = {\n    (entity: InferType<TEntity>, changeTrackingType: ChangeTrackingType): InferType<TEntity>;\n    (entity: InferCreateType<TEntity>, changeTrackingType: ChangeTrackingType): InferCreateType<TEntity>;\n}\nexport type Prepare<TEntity extends {}> = {\n    (entity: InferCreateType<TEntity>): InferCreateType<TEntity>;\n    (entity: InferType<TEntity>): InferType<TEntity>;\n}\nexport type Preprocess<TEntity extends {}> = {\n    (entity: InferCreateType<TEntity>): InferType<TEntity>;\n    (entity: InferType<TEntity>): InferType<TEntity>;\n}\n\nexport type SetProperties<TEntity extends {}> = (destination: DeepPartial<InferType<TEntity> | InferCreateType<TEntity>>, source: DeepPartial<InferType<TEntity> | InferCreateType<TEntity>>) => void;\n\nexport type CompiledSchemaCore<TEntity extends {}> = Omit<CompiledSchema<TEntity>, \"createSubscription\">;\n\nexport type CompiledSchemaWithMetadata<TEntity extends {}, TMetadata> = {\n    readonly metadata: TMetadata;\n} & CompiledSchema<TEntity>;\n\n/**\n * Represents a fully compiled schema with all utilities and metadata for an entity type.\n */\nexport type CompiledSchema<TEntity extends {}> = {\n\n    deserializePartial: (item: Record<string, unknown>, properties: PropertyInfo<TEntity>[]) => DeepPartial<InferType<TEntity>>;\n\n    createSubscription: (abortSignal?: AbortSignal, scope?: string, options?: SchemaSubscriptionOptions) => ISchemaSubscription<TEntity>;\n    /** Returns the property info for a given id (full path) */\n    getProperty: (id: string) => PropertyInfo<TEntity>;\n    /** Returns the ID of the given entity. */\n    getId: (entity: InferType<TEntity>) => IdType;\n    /** Returns a deep clone of the given entity. */\n    clone: (entity: InferType<TEntity>) => InferType<TEntity>;\n    /**\n     * Returns a deep clone of a record that is still in the STORAGE shape — renamed properties\n     * under their `from` names rather than their in-memory names.\n     *\n     * `clone` reads in-memory names, so it returns `undefined` for every renamed property of a\n     * stored record. Use this when copying rows a store holds before they have been deserialized.\n     * Generated on first call; schemas that are never cloned in storage shape never build it.\n     */\n    cloneStorage: (entity: InferType<TEntity>) => InferType<TEntity>;\n    /** Removes unmapped or extraneous properties from the entity. */\n    strip: (entity: InferType<TEntity>) => InferType<TEntity>;\n    /** Prepares a new entity for creation, applying defaults and transformations. */\n    prepare: Prepare<TEntity>;\n    /** Merges the source entity into the destination entity. */\n    merge: (destination: InferType<TEntity> | InferCreateType<TEntity>, source: InferType<TEntity>) => InferType<TEntity>;\n    /** Indicates if the schema has identity properties. */\n    hasIdentities: boolean;\n    /** List of properties that are identity keys. */\n    idProperties: PropertyInfo<TEntity>[];\n    /** All property metadata for the schema. */\n    properties: PropertyInfo<TEntity>[],\n    /** The hash type used for this schema. */\n    hashType: HashType;\n    /** Computes a hash for the given entity. */\n    hash: HashFunction<TEntity>;\n    /** Returns the hash type for the given entity. */\n    getHashType: GetHashTypeFunction<TEntity>;\n    /** Compares two entities for equality. */\n    compare: (a: InferType<TEntity>, fromDb: InferType<TEntity>) => boolean;\n    /** Deserializes an entity from storage format. */\n    deserialize: (entity: InferType<TEntity>) => InferType<TEntity>;\n    /** Sets 1 or many properties from the source object onto the destination object with change tracking. */\n    set: SetProperties<TEntity>;\n    /** Combines serializing and preparing an entity for saving. */\n    preprocess: Preprocess<TEntity>;\n    /** Combines deserializing and enriching an entity for selection. */\n    postprocess: Enrich<TEntity>;\n\n    /** Serializes an entity to storage format. */\n    serialize: (entity: InferType<TEntity>) => InferType<TEntity>;\n    /** Unique id for the schema. */\n    id: SchemaId,\n    /** The name of the collection for this schema. */\n    collectionName: CollectionName;\n    /** Returns all IDs for the given entity (usually a single-element tuple). */\n    getIds: (entity: InferType<TEntity>) => [IdType];\n    /** Enriches the entity with change tracking or other metadata. */\n    enrich: Enrich<TEntity>;\n    /** Indicates if the schema has identity keys. */\n    hasIdentityKeys: boolean;\n    /** Returns a deeply frozen (immutable) version of the entity. */\n    freeze: (entity: InferType<TEntity>) => InferType<TEntity>;\n    /** Enables change tracking on the entity. */\n    enableChangeTracking: (entity: InferType<TEntity>) => InferType<TEntity>;\n    /** The schema definition object. */\n    definition: SchemaDefinition<TEntity>;\n    /** Returns all indexes defined for this schema. */\n    getIndexes: () => Index[];\n    /** Compares two entities for Id equality. */\n    compareIds: (a: InferType<TEntity>, b: InferType<TEntity>) => boolean;\n}\n\nexport type PropertySerializer<T extends any> = (value: T) => string | number;\nexport type PropertyDeserializer<T extends any> = (value: string | number) => T;\n\n/**\n * A two-way transform between the application value and the stored value.\n *\n * Both directions may be async. Held as a live reference rather than stringified, so a\n * closure works and `injected` is a convenience rather than the only way in.\n */\nexport type PropertyTransform<T extends any> = {\n    /**\n     * Application value to stored value. Runs before the plugin sees it. May be async.\n     *\n     * `entity` is there for the one-way case: a transform with no `from` derives a value\n     * rather than converting one, which is what `computed` does.\n     */\n    to: (value: T, entity: Record<string, unknown>) => unknown | Promise<unknown>;\n\n    /**\n     * Stored value back to application value. Runs after the plugin returns it.\n     *\n     * Optional. Leave it out and the transform is one-way: the stored value is the value.\n     */\n    from?: (value: unknown) => T | Promise<T>;\n\n    /**\n     * What the column becomes, when the stored form is not the property's own type.\n     *\n     * Defaults to the property's own type, so nothing changes unless you say it does. A\n     * library that always produces text — a cipher, a compressor — sets this once, and the\n     * caller who uses that library never writes it.\n     */\n    stores?: SchemaTypes;\n\n    /**\n     * Whether a filter on this property can still run in the database.\n     *\n     * Defaults to `none`, which rejects the filter rather than returning wrong rows. Set\n     * `equality` only when `to` is deterministic.\n     */\n    comparable?: 'equality' | 'none';\n};\n\nexport type SchemaId = Branded<number, \"SchemaId\">;\nexport type CollectionName = Branded<string, \"CollectionName\">;\n\nexport type SchemaModifiers = \"default\" | \"deserialize\" |\n    \"identity\" | \"key\" |\n    \"nullable\" | \"optional\" |\n    \"readonly\" | \"serialize\" |\n    \"unmapped\" | \"computed\" |\n    \"distinct\" | \"searchable\";\n\n/**\n * What a tagged property infers to.\n *\n * `tag()` is metadata and must not change a type, but `SchemaTag<T>` carries the same `T` as\n * whatever it wrapped without carrying which class that was. For a string `T` is already\n * `string`; for an object `T` is the map of child schemas, which only the `SchemaObject`\n * branch below knows how to unwrap. Falling through to the generic `SchemaBase` branch\n * therefore handed the raw map back, so `s.object({ key: s.string() }).tag('x')` typed\n * `key` as `SchemaString` instead of `string` — everything ran, and only the types lied.\n *\n * An array is distinguishable because `SchemaArray`'s parameter is the ELEMENT schema, so a\n * tagged array arrives here as a `SchemaBase` rather than a plain map.\n */\ntype InferTagged<C> = ResolveWrapped<C>;\n\n/**\n * What a wrapping modifier's inner type resolves to.\n *\n * `SchemaOptional`, `SchemaNullable` and `SchemaTag` all carry the same `C` as whatever they\n * wrapped, without carrying which class that was, so each has to work out what it is holding.\n * Three shapes are possible:\n *\n * - an already-resolved value (`string` from `s.string()`, a file reference from `s.file()`)\n * - an ELEMENT schema, which is what `SchemaArray` parameterises on\n * - a map of child schemas, which is what `SchemaObject` parameterises on\n *\n * Getting this wrong is silent. The map branch applied to an already-resolved object walks\n * its keys and infers `never` for each, so `s.file().optional()` typed as\n * `{ key: never, size: never, ... }` — which no value can satisfy and no test would catch at\n * runtime.\n */\ntype ResolveWrapped<C> =\n    C extends string | number | boolean | Date | FileReferenceValue ? C :\n    C extends VectorValue ? C :\n    C extends SchemaBase<any, any> ? InferPrimitive<C>[] :\n    { [K in keyof C]: InferPrimitive<C[K]> };\n\ntype InferPrimitive<T> =\n    T extends SchemaOptional<infer C, infer __> ? ResolveWrapped<C> :\n    T extends SchemaTag<infer C, infer __> ? InferTagged<C> :\n    // Before the generic `SchemaBase` branch below, which would see `X = number[]` and map\n    // the element through `InferPrimitive<number>` — no branch matches a bare `number`, so a\n    // vector would type as `never[]`: assignable from nothing, and invisible at runtime.\n    T extends SchemaVector<infer __, infer ___> ? VectorValue :\n    T extends SchemaArray<infer Y, infer __> ? InferPrimitive<Y>[]\n    : T extends SchemaObject<infer Obj, infer _> ?\n    { [K in keyof Obj]: InferPrimitive<Obj[K]> } : // Process nested objects\n    T extends SchemaFunction<infer F, infer __> ? F : T extends SchemaBase<infer X, infer _> ?\n    X extends Array<infer A> ? InferPrimitive<A>[] : X : // Extract the primitive type\n    never;\n\nexport type InferType<T> = T extends CompiledSchema<infer R> ? InferCompiledSchema<R> : T extends {} ? InferCompiledSchema<T> : T;\nexport type InferCreateType<T> = T extends CompiledSchema<infer R> ? InferCompiledCreateSchema<R> : T extends {} ? InferCompiledCreateSchema<T> : unknown;\nexport type InferMappedType<T> = T extends SchemaBase<infer K, infer __> ? InferType<K> : InferCompiledSchema<T>;\nexport type InferRoot<T> = T extends CompiledSchema<infer R> ? R : never;\n\ntype HasModifier<T, K extends keyof T, M extends SchemaModifiers> =\n    T[K] extends SchemaBase<any, infer Mods> ?\n    M extends Mods ? true : false :\n    false;\n\ntype IsPlainProperty<T, K extends keyof T> =\n    [\n        HasModifier<T, K, \"readonly\">,\n        HasModifier<T, K, \"optional\">,\n        HasModifier<T, K, \"nullable\">\n    ] extends [\n        false,\n        false,\n        false\n    ] ? true : false;\n\ntype IsCreateExcluded<T, K extends keyof T> =\n    [\n        HasModifier<T, K, \"identity\">,\n        HasModifier<T, K, \"computed\">,\n        HasModifier<T, K, \"unmapped\">\n    ] extends [\n        false,\n        false,\n        false\n    ] ? false : true;\n\ntype IsCreateOptional<T, K extends keyof T> =\n    [\n        HasModifier<T, K, \"optional\">,\n        HasModifier<T, K, \"default\">\n    ] extends [\n        false,\n        false\n    ] ? false : true;\n\ntype IsCreateNullable<T, K extends keyof T> =\n    HasModifier<T, K, \"nullable\"> extends true ? true : false;\n\n/**\n * What a property ACCEPTS on the way in, which is not always what it gives back.\n *\n * Only a file differs today: you assign content and read a reference. Matching on the read\n * type rather than on `SchemaFile` itself is deliberate — it keeps working through every\n * modifier. `s.file().optional()` is a `SchemaOptional`, `s.file().tag('x')` is a\n * `SchemaTag`, and neither carries the original class, so a check against the class alone\n * would silently stop accepting content the moment anyone added a modifier.\n *\n * Assignability is required in BOTH directions, and the tuple wrappers are load-bearing.\n * One-way `extends` matches `never` — which is assignable to everything — so a generic\n * property over `Record<string, unknown>` resolved to file content and broke the Dexie\n * plugin's types. It also matched any object that merely happens to have these five fields\n * plus more. Mutual assignability admits the reference shape and nothing else, and the\n * tuples stop the conditional distributing over a union.\n */\ntype InferWritePrimitive<T> =\n    [InferPrimitive<T>] extends [FileReferenceValue]\n    ? [FileReferenceValue] extends [InferPrimitive<T>] ? FileContentValue : InferPrimitive<T>\n    : InferPrimitive<T>;\n\ntype InferCreateProperty<T, K extends keyof T> =\n    IsCreateNullable<T, K> extends true ? null | InferWritePrimitive<T[K]> : InferWritePrimitive<T[K]>;\n\ntype InferCompiledSchema<T> = CoalesceEmpty<{\n    [K in keyof T as IsPlainProperty<T, K> extends true ? K : never]: InferPrimitive<T[K]>\n}, {\n        readonly [K in keyof T as HasModifier<T, K, \"readonly\"> extends true ? K : never]: InferPrimitive<T[K]>\n    }, {\n        [K in keyof T as HasModifier<T, K, \"optional\"> extends true ? K : never]?: InferPrimitive<T[K]>\n    }, {\n        [K in keyof T as HasModifier<T, K, \"nullable\"> extends true ? K : never]: null | InferPrimitive<T[K]>\n}>;\n\ntype InferCompiledCreateSchema<T> = {\n    [K in keyof T as IsCreateExcluded<T, K> extends true ? never\n        : IsCreateOptional<T, K> extends true ? K : never]?: InferCreateProperty<T, K>\n} & {\n    [K in keyof T as IsCreateExcluded<T, K> extends true ? never\n        : IsCreateOptional<T, K> extends true ? never : K]: InferCreateProperty<T, K>\n};\n\ntype IsEmptyObject<T> = keyof T extends never ? true : false;\ntype CoalesceEmpty<T1 extends {}, T2 extends {}, T3 extends {}, T4 extends {}> = (IsEmptyObject<T1> extends true ? {} : T1) & (IsEmptyObject<T2> extends true ? {} : T2) & (IsEmptyObject<T3> extends true ? {} : T3) & (IsEmptyObject<T4> extends true ? {} : T4);\n","/**\n * Levelled logging, resolved once.\n *\n * Three things about the previous implementation drove this shape:\n *\n *  - **There was no way to turn logging off.** `globalThis.__ROUTIER_DEBUG__` was only ever\n *    compared against `true`, so setting it to `false` did nothing — while\n *    `docs/how-to/debug-logging.md` documented exactly that as the way to force logging off.\n *    A documented switch that silently does nothing is worse than no switch.\n *  - **`NODE_ENV === 'test'` enabled it.** Every Jest run therefore logged, because Jest always\n *    sets `NODE_ENV=test`. Measured on the S7 stress scenario, which drives ~2,000 saves through\n *    a plugin that logs three lines per query: 12.4s with logging, ~6s without. Test runners also\n *    capture console output by snapshotting a stack trace per call, so the cost is far above what\n *    writing to a terminal would suggest — and the output buries whatever the failure was.\n *  - **It was all-or-nothing, and re-resolved per call.** An error could not be kept while debug\n *    was dropped, and every one of the ~97 call sites re-read `globalThis` and `process.env`.\n *\n * Levels are compared numerically against a value cached at module load. Measured against a\n * no-op console at 200k calls: an enabled call costs ~70ns, a call rejected by the gate ~3ns.\n * Building the arguments the call site passes in accounts for ~0.2ns of that 3ns, which is why\n * this keeps the ordinary `logger.debug(msg, payload)` signature instead of taking a thunk —\n * a lazy API would recover 0.3% of an enabled call's cost and would have to change every call\n * site to do it.\n */\n\n/** Ordered from most severe to most verbose. `silent` discards everything. */\nexport const LOG_LEVELS = ['silent', 'error', 'warn', 'info', 'debug'] as const;\n\nexport type LogLevel = (typeof LOG_LEVELS)[number];\n\n/** Numeric rank, so a gate is one integer comparison. */\nconst RANK: Record<LogLevel, number> = {\n    silent: 0,\n    error: 1,\n    warn: 2,\n    info: 3,\n    debug: 4,\n};\n\nconst isLogLevel = (value: unknown): value is LogLevel =>\n    typeof value === 'string' && (LOG_LEVELS as readonly string[]).includes(value);\n\n/**\n * Resolves the configured level, in precedence order.\n *\n * Ordered most specific first: an explicit level beats a boolean flag, a boolean flag beats an\n * environment variable, and an environment variable beats an inference from `NODE_ENV`. Anything\n * unrecognised is ignored rather than treated as an error — a typo'd level should not take down\n * an application, and `silent` is the safe direction to fall back to.\n */\nconst resolveLevel = (): LogLevel => {\n    if (typeof globalThis !== 'undefined') {\n        const g = globalThis as { __ROUTIER_LOG_LEVEL__?: unknown; __ROUTIER_DEBUG__?: unknown };\n\n        if (isLogLevel(g.__ROUTIER_LOG_LEVEL__)) {\n            return g.__ROUTIER_LOG_LEVEL__;\n        }\n\n        // Both directions honoured. `=== false` used to fall through to the NODE_ENV checks\n        // below and re-enable the logging it was asked to suppress.\n        if (g.__ROUTIER_DEBUG__ === true) return 'debug';\n        if (g.__ROUTIER_DEBUG__ === false) return 'silent';\n    }\n\n    // There is deliberately no `import.meta.env` branch, although the documentation used to\n    // promise one. It could never work: this package is bundled with rspack, which replaces\n    // `import.meta` with `undefined`, so the check would read the *library's* build-time\n    // environment rather than the application's — and referencing `import.meta` at all is a parse\n    // error under a CommonJS build target, which is how the test suite loads this file. Vite and\n    // similar apps set `__ROUTIER_LOG_LEVEL__` or `__ROUTIER_DEBUG__` from their own\n    // `import.meta.env`, which is what the docs now describe.\n    if (typeof process !== 'undefined' && process.env != null) {\n        if (isLogLevel(process.env.ROUTIER_LOG_LEVEL)) {\n            return process.env.ROUTIER_LOG_LEVEL as LogLevel;\n        }\n\n        const debug = process.env.DEBUG;\n        if (debug === 'routier' || debug === '*') return 'debug';\n\n        const env = process.env.NODE_ENV?.toLowerCase();\n\n        // `test` is deliberately absent. It used to be here, which meant no test suite anywhere\n        // could run Routier quietly. Opt in with DEBUG=routier or ROUTIER_LOG_LEVEL when a test\n        // needs the output.\n        if (env === 'dev' || env === 'development') return 'debug';\n    }\n\n    return 'silent';\n};\n\nlet level: LogLevel = resolveLevel();\nlet rank = RANK[level];\n\n/**\n * Overrides the level for the rest of the process.\n *\n * The configuration above is read once, at import, which is what makes the gate cheap — but it\n * also means an application that decides its verbosity after startup, or a test that wants to\n * assert on output, has no way in. This is that way in.\n */\nexport const setLogLevel = (next: LogLevel): void => {\n    if (isLogLevel(next) === false) {\n        throw new Error(`Unknown log level \"${next}\". Expected one of: ${LOG_LEVELS.join(', ')}`);\n    }\n\n    level = next;\n    rank = RANK[next];\n};\n\nexport const getLogLevel = (): LogLevel => level;\n\n/** Re-reads the environment. For tests that change it after this module was imported. */\nexport const resetLogLevel = (): void => {\n    level = resolveLevel();\n    rank = RANK[level];\n};\n\n/**\n * Whether a message at this level would be emitted.\n *\n * For the rare call site whose *arguments* are expensive to build — a serialization, a deep\n * clone, a join over a large collection. An ordinary payload object is not worth guarding; see\n * the measurement in the header.\n */\nexport const isLogLevelEnabled = (at: LogLevel): boolean => rank >= RANK[at];\n\ntype ConsoleMethod = 'log' | 'info' | 'warn' | 'error' | 'debug' | 'table';\n\nconst emit = (at: LogLevel, method: ConsoleMethod, args: unknown[]) => {\n    if (rank < RANK[at]) {\n        return;\n    }\n\n    // Resolved at call time rather than captured once: test harnesses and browser devtools both\n    // replace console methods after modules have loaded, and a captured reference would keep\n    // writing past the replacement.\n    (console[method] as (...a: unknown[]) => void)(...args);\n};\n\nexport const logger = {\n    /** General-purpose output. Carried at `info`, since `log` names a console method, not a level. */\n    log: (...args: unknown[]): void => emit('info', 'log', args),\n    info: (...args: unknown[]): void => emit('info', 'info', args),\n    warn: (...args: unknown[]): void => emit('warn', 'warn', args),\n    error: (...args: unknown[]): void => emit('error', 'error', args),\n    debug: (...args: unknown[]): void => emit('debug', 'debug', args),\n    /** Diagnostic tabular output; verbose by nature, so it sits at `debug`. */\n    table: (...args: unknown[]): void => emit('debug', 'table', args),\n};\n","__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n        if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n            Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n        }\n    }\n};","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","// define __esModule on exports\n__webpack_require__.r = (exports) => {\n\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n\t}\n\tObject.defineProperty(exports, '__esModule', { value: true });\n};","export * from './evaluate';\nexport * from './parser';\nexport * from './types';\nexport * from './utils';\nexport * from './constants';"],"names":["EXPRESSION_TYPES","isDate","assertDate","data","TypeError","assertIsNotNull","message","assertIsArray","Array","assertString","assertInstanceOf","value","Instance","assertIsNumber","isObjectWithType","isExpression","isOperatorExpression","isComparatorExpression","isPropertyExpression","isValueExpression","isEmptyExpression","isNotParsableExpression","UNRESOLVED","Symbol","applyTransformer","transformer","operand","expression","row","equals","left","right","strict","Date","compare","comparator","asComparable","a","b","comparable","undefined","evaluateComparator","item","evaluate","result","toPredicate","toStrictPredicate","Error","logger","SchemaTypes","Expression","OperatorExpression","ComparatorExpression","ValueExpression","PropertyExpression","ERROR_MESSAGES","path","params","JSON","parseUnknown","ParamDependentParseError","converters","v","Boolean","Number","String","MULTI_CHARACTER_PUNCTUATION","SINGLE_CHARACTER_PUNCTUATION","Set","STRING_ESCAPES","isIdentifierStart","char","isIdentifierPart","isDigit","isHexDigit","decodeCodeEscape","source","backslashIndex","kind","start","end","parseInt","length","digits","d","tokenize","tokens","i","quote","escaped","decoded","nextChar","radixPrefix","signLength","multi","w","TokenStream","offset","token","COMPARATOR_METHODS","TRANSFORM_METHODS","COMPARISON_OPERATORS","SWAPPED_COMPARATORS","ParamReferenceExpression","options","resolveParamPath","paramsName","name","resolvePairedValue","pairedProperty","applyConverter","ExpressionParser","schema","stream","entityName","trailing","operatorToken","numberToken","elements","element","array","method","argument","root","locale","segment","paramPath","resolved","pathString","property","parentPath","parent","operator","comparedToFalse","swapped","target","isStringMatch","bindExpression","raw","bound","clone","resolveFunctionShape","stringifiedFunction","hasParams","parameterNames","body","functionHead","parametersEnd","arrowIndex","destructured","inner","templateCache","WeakMap","MAX_CACHED_TEMPLATES_PER_SCHEMA","getCachedTemplate","setCachedTemplate","entry","bySource","Map","combineExpressions","expressions","parseFragment","rootName","parser","toExpression","fn","warn","error","cached","template","structurallyDependsOnParams","shape","valueToJson","Object","valueFromJson","EmptyExpression","NotParsableExpression","json","child","node","rebuilt","getProperties","properties","traverse","expr","forEach","callback","HashType","LOG_LEVELS","RANK","isLogLevel","resolveLevel","globalThis","g","process","debug","env","level","rank","setLogLevel","next","getLogLevel","resetLogLevel","isLogLevelEnabled","at","emit","args","console"],"mappings":"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"}
+{"version":3,"file":"expressions/index.cjs","sources":["webpack://@routier/core/./src/assertions/index.ts","webpack://@routier/core/./src/expressions/callSource.ts","webpack://@routier/core/./src/expressions/constants.ts","webpack://@routier/core/./src/expressions/evaluate.ts","webpack://@routier/core/./src/expressions/fold.ts","webpack://@routier/core/./src/expressions/parser.ts","webpack://@routier/core/./src/expressions/types.ts","webpack://@routier/core/./src/expressions/utils.ts","webpack://@routier/core/./src/schema/types.ts","webpack://@routier/core/./src/utilities/logger.ts","webpack://@routier/core/webpack/runtime/define_property_getters","webpack://@routier/core/webpack/runtime/has_own_property","webpack://@routier/core/webpack/runtime/make_namespace_object","webpack://@routier/core/./src/expressions/index.ts"],"sourcesContent":["import { EXPRESSION_TYPES } from \"../expressions/constants\";\nimport { CallExpression, ComparatorExpression, EmptyExpression, Expression, ExpressionType, NotParsableExpression, OperatorExpression, PropertyExpression, ValueExpression } from \"../expressions/types\";\nimport { isDate } from \"../utilities\";\n\nexport function assertDate(data: unknown): asserts data is Date {\n    if (isDate(data) === false) {\n        throw new TypeError('Value is not a Date');\n    }\n}\n\nexport function assertIsNotNull<T>(data: T | null | undefined, message?: string | (() => string)): asserts data is NonNullable<T> {\n    if (data == null) {\n        if (message == null) {\n            throw new TypeError('Assertion failed, data is null');\n        }\n\n        if (typeof message === \"string\") {\n            throw new TypeError(message);\n        }\n\n        throw new TypeError(message());\n    }\n}\n\nexport function assertIsArray<T>(data: unknown, message?: string): asserts data is T[] {\n    if (!Array.isArray(data)) {\n        throw new TypeError(message ?? 'Assertion failed, data is not of type Array');\n    }\n}\n\nexport function assertString(data: unknown, message?: string): asserts data is string {\n    if (typeof data !== \"string\") {\n        throw new TypeError(message ?? 'Assertion failed, data is not of type String');\n    }\n}\n\nexport function assertInstanceOf<T extends new (...args: any[]) => any>(value: unknown, Instance: T): asserts value is T {\n    if (value instanceof Instance) {\n        return;\n    }\n\n    if (value != null && typeof value === \"object\" && \"constructor\" in value) {\n        throw new TypeError(`value is not instance of type.  Type: ${value.constructor.name}`);\n    }\n\n    throw new TypeError(`value is not instance of type`);\n}\n\nexport function assertIsNumber(value: unknown): asserts value is number {\n    if (typeof value !== \"number\") {\n        throw new TypeError(\"value is not of type `number`\");\n    }\n}\n\n\nfunction isObjectWithType(value: unknown): value is Record<\"type\", unknown> {\n    return typeof value === \"object\" && value !== null && \"type\" in value;\n}\n\n/**\n * Type guard: narrows `value` to `Expression` when it is an object with a valid `type` property.\n */\nexport function isExpression(value: unknown): value is Expression {\n    return isObjectWithType(value) && EXPRESSION_TYPES.includes(value.type as ExpressionType);\n}\n\n/**\n * Type guard: narrows `value` to `OperatorExpression` when it is an object with `type === \"operator\"`.\n */\nexport function isOperatorExpression(value: unknown): value is OperatorExpression {\n    return isObjectWithType(value) && value.type === \"operator\";\n}\n\n/**\n * Type guard: narrows `value` to `ComparatorExpression` when it is an object with `type === \"comparator\"`.\n */\nexport function isComparatorExpression(value: unknown): value is ComparatorExpression {\n    return isObjectWithType(value) && value.type === \"comparator\";\n}\n\n/**\n * Type guard: narrows `value` to `PropertyExpression` when it is an object with `type === \"property\"`.\n */\nexport function isPropertyExpression(value: unknown): value is PropertyExpression {\n    return isObjectWithType(value) && value.type === \"property\";\n}\n\n/**\n * Type guard: narrows `value` to `ValueExpression` when it is an object with `type === \"value\"`.\n */\nexport function isValueExpression(value: unknown): value is ValueExpression {\n    return isObjectWithType(value) && value.type === \"value\";\n}\n\n/**\n * Type guard: narrows `value` to `CallExpression` when it is an object with `type === \"call\"`.\n */\nexport function isCallExpression(value: unknown): value is CallExpression {\n    return isObjectWithType(value) && value.type === \"call\";\n}\n\n/**\n * Type guard: narrows `value` to `EmptyExpression` when it is an object with `type === \"empty\"`.\n */\nexport function isEmptyExpression(value: unknown): value is EmptyExpression {\n    return isObjectWithType(value) && value.type === \"empty\";\n}\n\n/**\n * Type guard: narrows `value` to `NotParsableExpression` when it is an object with `type === \"not-parsable\"`.\n */\nexport function isNotParsableExpression(value: unknown): value is NotParsableExpression {\n    return isObjectWithType(value) && value.type === \"not-parsable\";\n}","import { Call } from \"./types\";\n\n/**\n * How a {@link Call} is spelled in JavaScript, and where its operand goes.\n *\n * `length` is a property, `Math.abs` is a function, `+` is an operator and `typeof` is a prefix — so\n * a name alone is not enough to render one.\n */\nexport type CallSource =\n    | { form: \"method\", name: string }\n    | { form: \"property\", name: string }\n    | { form: \"function\", name: string }\n    | { form: \"operator\", symbol: string }\n    | { form: \"prefix\", keyword: string }\n    | { form: \"conditional\" }\n    /** The argument is the receiver in source: `/^a/.test(x.name)`, not `x.name.test(/^a/)`. */\n    | { form: \"regex-test\" };\n\nexport const CALL_SOURCE: Record<Call, CallSource> = {\n    \"to-lower-case\": { form: \"method\", name: \"toLowerCase\" },\n    \"to-upper-case\": { form: \"method\", name: \"toUpperCase\" },\n    \"length\": { form: \"property\", name: \"length\" },\n    \"trim\": { form: \"method\", name: \"trim\" },\n    \"trim-start\": { form: \"method\", name: \"trimStart\" },\n    \"trim-end\": { form: \"method\", name: \"trimEnd\" },\n    \"index-of\": { form: \"method\", name: \"indexOf\" },\n    \"substring\": { form: \"method\", name: \"substring\" },\n    \"concat\": { form: \"method\", name: \"concat\" },\n    \"replace\": { form: \"method\", name: \"replace\" },\n    \"replace-all\": { form: \"method\", name: \"replaceAll\" },\n\n    \"absolute\": { form: \"function\", name: \"Math.abs\" },\n    \"floor\": { form: \"function\", name: \"Math.floor\" },\n    \"ceiling\": { form: \"function\", name: \"Math.ceil\" },\n    \"round\": { form: \"function\", name: \"Math.round\" },\n    \"sign\": { form: \"function\", name: \"Math.sign\" },\n    \"square-root\": { form: \"function\", name: \"Math.sqrt\" },\n\n    \"add\": { form: \"operator\", symbol: \"+\" },\n    \"subtract\": { form: \"operator\", symbol: \"-\" },\n    \"multiply\": { form: \"operator\", symbol: \"*\" },\n    \"divide\": { form: \"operator\", symbol: \"/\" },\n    \"modulo\": { form: \"operator\", symbol: \"%\" },\n\n    \"utc-year\": { form: \"method\", name: \"getUTCFullYear\" },\n    \"utc-month\": { form: \"method\", name: \"getUTCMonth\" },\n    \"utc-day-of-month\": { form: \"method\", name: \"getUTCDate\" },\n    \"utc-day-of-week\": { form: \"method\", name: \"getUTCDay\" },\n    \"utc-hour\": { form: \"method\", name: \"getUTCHours\" },\n    \"utc-minute\": { form: \"method\", name: \"getUTCMinutes\" },\n    \"utc-second\": { form: \"method\", name: \"getUTCSeconds\" },\n    \"utc-millisecond\": { form: \"method\", name: \"getUTCMilliseconds\" },\n    \"epoch-ms\": { form: \"method\", name: \"getTime\" },\n\n    \"to-string\": { form: \"function\", name: \"String\" },\n    \"to-number\": { form: \"function\", name: \"Number\" },\n    \"to-boolean\": { form: \"function\", name: \"Boolean\" },\n    \"type-of\": { form: \"prefix\", keyword: \"typeof\" },\n\n    \"some\": { form: \"method\", name: \"some\" },\n    \"every\": { form: \"method\", name: \"every\" },\n\n    // `Math.pow(a, b)` parses to the same call; `**` is the shorter of the two spellings\n    \"power\": { form: \"operator\", symbol: \"**\" },\n    \"bit-and\": { form: \"operator\", symbol: \"&\" },\n    \"bit-or\": { form: \"operator\", symbol: \"|\" },\n    \"bit-xor\": { form: \"operator\", symbol: \"^\" },\n    \"shift-left\": { form: \"operator\", symbol: \"<<\" },\n    \"shift-right\": { form: \"operator\", symbol: \">>\" },\n    \"shift-right-unsigned\": { form: \"operator\", symbol: \">>>\" },\n    \"bit-not\": { form: \"prefix\", keyword: \"~\" },\n    \"coalesce\": { form: \"operator\", symbol: \"??\" },\n    \"conditional\": { form: \"conditional\" },\n    \"matches\": { form: \"regex-test\" },\n};\n\n/**\n * A call rendered as the JavaScript that produced it, from operand and argument text already\n * rendered by the caller.\n *\n * Takes strings so one implementation serves a live tree and a serialized one.\n */\n/**\n * Thunked because rendering a side can record a parameter, and `regex-test` emits its argument\n * before its operand — so the two orders have to agree.\n */\nexport const renderCallAsJs = (call: Call, renderOperand: () => string, renderArgs: () => string[]): string => {\n    const source = CALL_SOURCE[call];\n\n    if (source == null) {\n        const operand = renderOperand();\n\n        return `${operand}.${call}(${renderArgs().join(\", \")})`;\n    }\n\n    if (source.form === \"property\") {\n        return `${renderOperand()}.${source.name}`;\n    }\n\n    if (source.form === \"regex-test\") {\n        const pattern = renderArgs()[0] ?? \"?\";\n\n        return `${pattern}.test(${renderOperand()})`;\n    }\n\n    if (source.form === \"method\") {\n        const operand = renderOperand();\n\n        return `${operand}.${source.name}(${renderArgs().join(\", \")})`;\n    }\n\n    if (source.form === \"function\") {\n        const operand = renderOperand();\n\n        return `${source.name}(${[operand, ...renderArgs()].join(\", \")})`;\n    }\n\n    if (source.form === \"prefix\") {\n        // `~x`, not `~ x` — a bitwise complement is written tight, unlike `typeof`\n        const operand = renderOperand();\n\n        return source.keyword === \"~\" ? `${source.keyword}${operand}` : `${source.keyword} ${operand}`;\n    }\n\n    if (source.form === \"conditional\") {\n        const operand = renderOperand();\n        const args = renderArgs();\n\n        return `${operand} ? ${args[0] ?? \"?\"} : ${args[1] ?? \"?\"}`;\n    }\n\n    const operand = renderOperand();\n\n    return `${[operand, ...renderArgs()].join(` ${source.symbol} `)}`;\n};\n","import { ExpressionType } from \"./types\";\n\n/**\n * A `Record` rather than a list, so adding to `ExpressionType` without adding it here is a compile\n * error. As a list it was not exhaustive, and `call` was silently missing from `isExpression`.\n */\nconst EXPRESSION_TYPE_SET: Record<ExpressionType, true> = {\n    \"operator\": true,\n    \"comparator\": true,\n    \"property\": true,\n    \"value\": true,\n    \"call\": true,\n    \"empty\": true,\n    \"not-parsable\": true,\n};\n\nexport const EXPRESSION_TYPES = Object.keys(EXPRESSION_TYPE_SET) as ExpressionType[];\n","import { isCallExpression, isComparatorExpression, isOperatorExpression, isPropertyExpression, isValueExpression } from \"../assertions\";\nimport { UnknownRecord } from \"../utilities\";\nimport { Call, Comparator, Expression } from \"./types\";\n\n/**\n * Runs a parsed expression against a row.\n *\n * The counterpart to `toSql` and `toMql`: those turn a tree into a backend's language, and this\n * turns it into an answer. Needed wherever a tree exists but the closure that produced it does\n * not — a filter split out of a larger predicate, an option rebuilt from a serialized query.\n *\n * ## It fails OPEN, and that is the whole safety argument\n *\n * `undefined` means \"this tree cannot be evaluated here\" — an unknown node, a transformer with no\n * implementation, a comparison between shapes that do not compare. Callers must read that as KEEP\n * THE ROW, never as exclude it.\n *\n * The reason is asymmetric cost. Every caller today uses this to NARROW something that a\n * subsequent, authoritative predicate will check again: a semi-join prefilter, a split conjunct.\n * Keeping a row this cannot judge costs one wasted comparison downstream. Dropping one loses data\n * from a query result and nothing anywhere reports it. So every uncertain path returns `undefined`,\n * and no path guesses `false`.\n *\n * ## Why not just reuse the caller's closure\n *\n * Because there often isn't one. A conjunct pulled out of `([p, m]) => p.a === 1 && m.b === 2` is\n * source TEXT; turning it back into a callable needs `new Function`, which a\n * Content-Security-Policy blocks — the same constraint that makes `softDeleteScope` build its tree\n * by hand. The tree is the only representation that survives.\n */\nexport type EvaluationResult = boolean | undefined;\n\n/** Reads a property or literal operand, or `UNRESOLVED` when the node is not one. */\nexport const UNRESOLVED = Symbol(\"unresolved\");\n\nconst ARITHMETIC: Partial<Record<Call, (left: number, right: number) => number>> = {\n    \"add\": (left, right) => left + right,\n    \"subtract\": (left, right) => left - right,\n    \"multiply\": (left, right) => left * right,\n    \"divide\": (left, right) => left / right,\n    \"modulo\": (left, right) => left % right,\n    \"power\": (left, right) => left ** right,\n    \"bit-and\": (left, right) => left & right,\n    \"bit-or\": (left, right) => left | right,\n    \"bit-xor\": (left, right) => left ^ right,\n    \"shift-left\": (left, right) => left << right,\n    \"shift-right\": (left, right) => left >> right,\n    \"shift-right-unsigned\": (left, right) => left >>> right,\n};\n\nconst applyCall = (call: Call, value: unknown, args: unknown[]): unknown | typeof UNRESOLVED => {\n    // Above the guard: a template renders null as \"null\" in JavaScript, so these two are total.\n    if (call === \"to-string\") {\n        return String(value);\n    }\n\n    if (call === \"concat\") {\n        return [value, ...args].map(String).join(\"\");\n    }\n\n    // A call applied to an absent value has no answer, and inventing one (\"\" for a missing string)\n    // is how a filter starts matching rows it should not.\n    if (value == null) {\n        return UNRESOLVED;\n    }\n\n    if (call === \"to-lower-case\" || call === \"to-upper-case\") {\n        if (typeof value !== \"string\") {\n            return UNRESOLVED;\n        }\n\n        const lower = call === \"to-lower-case\";\n\n        if (args.length === 0 || args[0] == null) {\n            return lower ? value.toLowerCase() : value.toUpperCase();\n        }\n\n        if (typeof args[0] !== \"string\") {\n            return UNRESOLVED;\n        }\n\n        try {\n            // An explicit locale is deterministic; dropping it answers a different question in Turkish.\n            return lower ? value.toLocaleLowerCase(args[0]) : value.toLocaleUpperCase(args[0]);\n        } catch {\n            // An invalid language tag throws RangeError; no answer beats the host's default.\n            return UNRESOLVED;\n        }\n    }\n\n    if (call === \"length\") {\n        return typeof value === \"string\" || Array.isArray(value) ? value.length : UNRESOLVED;\n    }\n\n    if (call === \"bit-not\") {\n        return typeof value === \"number\" ? ~value : UNRESOLVED;\n    }\n\n    if (call === \"matches\") {\n        if (typeof value !== \"string\" || !(args[0] instanceof RegExp)) {\n            return UNRESOLVED;\n        }\n\n        // `test` advances `lastIndex` on a global or sticky pattern, and the pattern is shared with\n        // the cached template, where a source evaluates fresh in JavaScript.\n        return args[0].global || args[0].sticky\n            ? new RegExp(args[0].source, args[0].flags).test(value)\n            : args[0].test(value);\n    }\n\n    const arithmetic = ARITHMETIC[call];\n\n    if (arithmetic != null) {\n        return typeof value === \"number\" && typeof args[0] === \"number\"\n            ? arithmetic(value, args[0])\n            : UNRESOLVED;\n    }\n\n    return UNRESOLVED;\n};\n\nexport const operandValue = (expression: Expression | undefined, row: UnknownRecord): unknown | typeof UNRESOLVED => {\n    if (expression == null) {\n        return UNRESOLVED;\n    }\n\n    if (isValueExpression(expression)) {\n        return expression.value;\n    }\n\n    if (isPropertyExpression(expression)) {\n        // Through the PropertyInfo, so a nested path and a `from`-renamed segment resolve the same\n        // way every other consumer of the tree resolves them.\n        return expression.property.getValue(row);\n    }\n\n    if (isCallExpression(expression)) {\n\n        /**\n         * `??` and `? :` are the two calls whose whole job is to answer when something is absent, so\n         * they run before the guard that refuses an absent operand.\n         */\n        if (expression.call === \"coalesce\") {\n            const left = operandValue(expression.expression, row);\n\n            return left === UNRESOLVED || left == null ? operandValue(expression.arguments[0], row) : left;\n        }\n\n        if (expression.call === \"conditional\") {\n            const condition = evaluate(expression.expression, row);\n\n            if (condition === undefined) {\n                return UNRESOLVED;\n            }\n\n            return operandValue(expression.arguments[condition === true ? 0 : 1], row);\n        }\n\n        const inner = operandValue(expression.expression, row);\n\n        if (inner === UNRESOLVED) {\n            return UNRESOLVED;\n        }\n\n        const args: unknown[] = [];\n\n        for (const argument of expression.arguments) {\n            const resolved = operandValue(argument, row);\n\n            if (resolved === UNRESOLVED) {\n                return UNRESOLVED;\n            }\n\n            args.push(resolved);\n        }\n\n        return applyCall(expression.call, inner, args);\n    }\n\n    return UNRESOLVED;\n};\n\n/**\n * `a === b` for the comparators, with Dates compared by VALUE.\n *\n * A Date compares by reference under `===`, so two Dates holding the same instant would be\n * unequal — which is not what a filter on a date means, and not what any backend does.\n */\nconst equals = (left: unknown, right: unknown, strict: boolean): boolean => {\n    if (left instanceof Date && right instanceof Date) {\n        return left.getTime() === right.getTime();\n    }\n\n    // oxlint-disable-next-line eqeqeq\n    return strict ? left === right : left == right;\n};\n\n/** Ordered comparison, only for shapes that have an order. */\nconst compare = (left: unknown, right: unknown, comparator: Comparator): EvaluationResult => {\n    const asComparable = (value: unknown) => value instanceof Date ? value.getTime() : value;\n\n    const a = asComparable(left);\n    const b = asComparable(right);\n\n    const comparable = (typeof a === \"number\" && typeof b === \"number\")\n        || (typeof a === \"string\" && typeof b === \"string\");\n\n    if (comparable === false) {\n        return undefined;\n    }\n\n    if (comparator === \"greater-than\") {\n        return a > b;\n    }\n\n    if (comparator === \"greater-than-equals\") {\n        return a >= b;\n    }\n\n    if (comparator === \"less-than\") {\n        return a < b;\n    }\n\n    return a <= b;\n};\n\nconst evaluateComparator = (comparator: Comparator, left: unknown, right: unknown, strict: boolean): EvaluationResult => {\n\n    if (comparator === \"equals\") {\n        return equals(left, right, strict);\n    }\n\n    if (comparator === \"includes\") {\n        // Two shapes, and the tree does not distinguish them: `array.includes(value)` and\n        // `string.includes(substring)`. Whichever side is the container decides.\n        if (Array.isArray(left)) {\n            return left.some(item => equals(item, right, strict));\n        }\n\n        if (Array.isArray(right)) {\n            return right.some(item => equals(item, left, strict));\n        }\n\n        return typeof left === \"string\" && typeof right === \"string\" ? left.includes(right) : undefined;\n    }\n\n    if (comparator === \"starts-with\") {\n        return typeof left === \"string\" && typeof right === \"string\" ? left.startsWith(right) : undefined;\n    }\n\n    if (comparator === \"ends-with\") {\n        return typeof left === \"string\" && typeof right === \"string\" ? left.endsWith(right) : undefined;\n    }\n\n    return compare(left, right, comparator);\n};\n\n/**\n * Evaluates `expression` against `row`, or returns `undefined` when it cannot.\n *\n * See the note at the top of this file: `undefined` means KEEP the row.\n */\nexport const evaluate = (expression: Expression, row: UnknownRecord): EvaluationResult => {\n\n    if (isOperatorExpression(expression)) {\n        const left = expression.left == null ? undefined : evaluate(expression.left, row);\n        const right = expression.right == null ? undefined : evaluate(expression.right, row);\n\n        /**\n         * One unevaluable side does not have to sink the whole tree.\n         *\n         * `a && b` where `a` is definitely false is false whatever `b` is, and `a || b` where `a`\n         * is definitely true is true. That short-circuiting is what lets a mostly-understood\n         * predicate still narrow anything at all — without it, one unfamiliar sub-expression makes\n         * the entire filter a no-op.\n         */\n        if (expression.operator === \"&&\") {\n            if (left === false || right === false) {\n                return false;\n            }\n\n            return left === true && right === true ? true : undefined;\n        }\n\n        if (left === true || right === true) {\n            return true;\n        }\n\n        return left === false && right === false ? false : undefined;\n    }\n\n    if (isComparatorExpression(expression)) {\n        const left = operandValue(expression.left, row);\n        const right = operandValue(expression.right, row);\n\n        if (left === UNRESOLVED || right === UNRESOLVED) {\n            return undefined;\n        }\n\n        const result = evaluateComparator(expression.comparator, left, right, expression.strict);\n\n        if (result === undefined) {\n            return undefined;\n        }\n\n        return expression.negated ? result === false : result;\n    }\n\n    // A tautology excludes nothing, which is exactly `true`. Anything else — a bare property, a\n    // literal, `not-parsable` — is not a predicate this can judge.\n    return expression.type === \"empty\" ? true : undefined;\n};\n\n/**\n * `evaluate`, as a predicate that keeps whatever it cannot judge.\n *\n * The form every narrowing caller wants, with the fail-open rule applied once here rather than\n * remembered at each call site.\n */\nexport const toPredicate = (expression: Expression) => (row: UnknownRecord): boolean =>\n    evaluate(expression, row) !== false;\n\n/**\n * `evaluate`, as a predicate that THROWS on anything it cannot judge.\n *\n * The opposite default to `toPredicate`, and the right one when the predicate is the only thing\n * standing between a caller and rows they asked to exclude — a filter that arrived over a wire and\n * is being applied by the receiver. Failing open there does not cost a wasted comparison; it returns\n * data the requester filtered out, and reports nothing.\n *\n * Use `toPredicate` when something authoritative re-checks the result, and this when nothing does.\n */\nexport const toStrictPredicate = (expression: Expression) => (row: UnknownRecord): boolean => {\n    const result = evaluate(expression, row);\n\n    if (result === undefined) {\n        throw new Error(\n            \"Cannot apply this filter: its expression cannot be evaluated in memory, and applying it partially would \" +\n            \"return rows the filter excludes.  This happens when a filter arrives without a runnable predicate — over a \" +\n            \"wire, or rebuilt from a serialized query — and names something the evaluator does not understand.\"\n        );\n    }\n\n    return result;\n};\n","import { isCallExpression, isComparatorExpression, isOperatorExpression, isPropertyExpression, isValueExpression } from \"../assertions\";\nimport { operandValue, UNRESOLVED } from \"./evaluate\";\nimport { Call, CallExpression, ComparatorExpression, Expression, OperatorExpression, ValueExpression } from \"./types\";\nimport { childrenOf } from \"./utils\";\n\n/** Calls fold may compute. Absent means a plugin declines it, so a new call is opt-in. */\nexport const FOLDABLE: ReadonlySet<Call> = new Set([\n    \"to-lower-case\", \"to-upper-case\", \"length\", \"bit-not\", \"matches\", \"to-string\", \"concat\",\n    \"add\", \"subtract\", \"multiply\", \"divide\", \"modulo\", \"power\",\n    \"bit-and\", \"bit-or\", \"bit-xor\", \"shift-left\", \"shift-right\", \"shift-right-unsigned\",\n    \"coalesce\", \"conditional\",\n]);\n\n/** `String(value)` on an object is the host's rendering — a Date carries its timezone. */\nconst COERCES_TO_TEXT: ReadonlySet<Call> = new Set([\"to-string\", \"concat\"]);\n\nconst isFrozenPrimitive = (value: unknown): boolean => value == null || typeof value !== \"object\";\n\nconst readsAProperty = (expression: Expression): boolean => {\n    if (isPropertyExpression(expression)) {\n        return true;\n    }\n\n    return childrenOf(expression).some(readsAProperty);\n};\n\n/** A `conditional` holds a condition where every other call holds a value. */\nconst isConstant = (call: CallExpression): boolean => {\n    if (!FOLDABLE.has(call.call) || !call.arguments.every(isValueExpression)) {\n        return false;\n    }\n\n    if (COERCES_TO_TEXT.has(call.call)\n        && [call.expression, ...call.arguments].some(operand =>\n            isValueExpression(operand) && !isFrozenPrimitive(operand.value))) {\n        return false;\n    }\n\n    return call.call === \"conditional\"\n        ? !readsAProperty(call.expression)\n        : isValueExpression(call.expression);\n};\n\n/** Computes every call whose operand and arguments are all literals. Runs after `bindExpression`. */\nexport const foldConstantCalls = (expression: Expression): Expression => {\n\n    if (isCallExpression(expression)) {\n        const folded = new CallExpression({\n            call: expression.call,\n            expression: foldConstantCalls(expression.expression),\n            arguments: expression.arguments.map(foldConstantCalls)\n        });\n\n        if (!isConstant(folded)) {\n            return folded;\n        }\n\n        const value = operandValue(folded, {});\n\n        return value === UNRESOLVED ? folded : new ValueExpression({ value });\n    }\n\n    if (isComparatorExpression(expression)) {\n        return new ComparatorExpression({\n            comparator: expression.comparator,\n            negated: expression.negated,\n            strict: expression.strict,\n            left: expression.left == null ? undefined : foldConstantCalls(expression.left),\n            right: expression.right == null ? undefined : foldConstantCalls(expression.right)\n        });\n    }\n\n    if (isOperatorExpression(expression)) {\n        return new OperatorExpression({\n            operator: expression.operator,\n            left: expression.left == null ? undefined : foldConstantCalls(expression.left),\n            right: expression.right == null ? undefined : foldConstantCalls(expression.right)\n        });\n    }\n\n    return expression;\n};\n\n/** The value a literal operand binds as once the calls on it are computed. Throws if it cannot. */\nexport const foldedOperandValue = (operand: ValueExpression, calls: CallExpression[]): unknown => {\n    if (calls.length === 0) {\n        return operand.value;\n    }\n\n    // `peelCalls` returns calls innermost first, so the last one evaluates the whole chain.\n    const outermost = calls[calls.length - 1];\n    const value = readsAProperty(outermost) ? UNRESOLVED : operandValue(outermost, {});\n\n    if (value === UNRESOLVED) {\n        throw new Error(\n            `'${calls.map(call => call.call).join(\"', '\")}' cannot be computed on the literal ` +\n            `'${String(operand.value)}'.`\n        );\n    }\n\n    return value;\n};\n","import { logger } from \"../utilities\";\nimport { assertString } from \"../assertions\";\nimport { CompiledSchema, PropertyInfo, SchemaTypes } from \"../schema\";\nimport { evaluate } from \"./evaluate\";\nimport { foldConstantCalls } from \"./fold\";\nimport { Expression, OperatorExpression, ComparatorExpression, ValueExpression, PropertyExpression, CallExpression, Filter, ParamsFilter, Call, Comparator, Transformer } from \"./types\";\n\n// Error message constants\nconst ERROR_MESSAGES = {\n    PROPERTY_NOT_FOUND: (path: string) => `Error parsing query, could not find PropertyInfo for path: ${path}`,\n    PARAM_PATH_NOT_FOUND: (value: string, params: unknown) => `Cannot find path in params for .where(). Make sure parameters are not used inline.\\r\\nPath: ${value}, Params: ${JSON.stringify(params)}`,\n    VARIABLE_VALUE: (value: string) => `Cannot derive value from variable, please pass parameters into the expression.\n\nExample: .where(([x, params]) => x.id === params.id, { id: someVar.id })\nIssue At: ${value}`,\n    UNSUPPORTED: (value: string) => `Unsupported expression format: ${value}`\n};\n\nconst parseUnknown = (value: unknown) => {\n    assertString(value);\n    return JSON.parse(value);\n}\n\n/**\n * A parse failure caused by the params VALUES rather than the filter source.\n * These must never poison the template cache — the same source can succeed\n * with different params.\n */\nclass ParamDependentParseError extends Error { }\n\nconst converters: Record<SchemaTypes, (value: unknown) => unknown> = {\n    Array: v => v,\n    Boolean: v => v == null ? v : Boolean(v),\n    // Stryker disable next-line ArrowFunction: filters on computed properties route to\n    // in-memory execution, so this entry cannot be reached through a parsable filter.\n    Computed: v => v,\n    Date: v => v,\n    // A file is a reference, and a filter can legitimately compare its fields — content type\n    // and size are ordinary columns. The value passes through unconverted like an object.\n    File: v => v,\n    // Stryker disable next-line ArrowFunction: SchemaTypes.Definition is handled as a\n    // generic primitive everywhere (specs/known-defects.md) and never pairs in a filter.\n    Definition: v => v,\n    // Stryker disable next-line ArrowFunction: filters on function properties route to\n    // in-memory execution, so this entry cannot be reached through a parsable filter.\n    Function: v => v,\n    Number: v => v == null ? v : Number(v),\n    Object: v => v,\n    String: v => v == null ? v : String(v),\n    // A vector is a list of numbers and passes through like any other array. Nothing\n    // converts it because nothing compares it: similarity is `.nearest()`, not a filter.\n    Vector: v => v\n};\n\n// #region Tokenizer\n\ntype TokenKind = \"identifier\" | \"string\" | \"number\" | \"bigint\" | \"regex\" | \"template\" | \"punctuation\";\n\ntype Token = {\n    kind: TokenKind;\n    value: string;\n}\n\n// Longest first so multi-character punctuation wins over its prefixes\nconst MULTI_CHARACTER_PUNCTUATION = [\">>>\", \"===\", \"!==\", \"**\", \"<<\", \">>\", \"??\", \"?.\", \"&&\", \"||\", \"==\", \"!=\", \">=\", \"<=\", \"=>\"] as const;\n// Stryker disable next-line all: documented equivalent cluster (see\n// docs/mutation-backlog.md) — dropping an entry only affects source the parser rejects\n// either way, and the rejection message names the character from the source rather than\n// from this set, so no observable boundary distinguishes the mutant. Established\n// experimentally: 30 message-asserting tests killed 1 of 12.\nconst SINGLE_CHARACTER_PUNCTUATION = new Set([\"(\", \")\", \"[\", \"]\", \"{\", \"}\", \".\", \",\", \";\", \"!\", \">\", \"<\", \"-\", \"+\", \"*\", \"/\", \"%\", \"=\", \"?\", \":\", \"&\", \"|\", \"^\", \"~\"]);\n\n/**\n * A lookup table keyed by source text.\n *\n * Null-prototype: `TRANSFORM_METHODS[\"toString\"]` otherwise returns `Object.prototype.toString`,\n * which is truthy, and the parser reads a method it does not support as one it does.\n */\nconst sourceKeyed = <T>(entries: Record<string, T>): Record<string, T> =>\n    Object.assign(Object.create(null) as Record<string, T>, entries);\n\nconst STRING_ESCAPES: Record<string, string> = sourceKeyed({\n    \"n\": \"\\n\",\n    \"r\": \"\\r\",\n    \"t\": \"\\t\",\n    \"b\": \"\\b\",\n    \"f\": \"\\f\",\n    \"v\": \"\\v\",\n    \"0\": \"\\0\"\n});\n\n/**\n * Whether a `/` here opens a regex rather than dividing.\n *\n * A regex cannot follow a value. Everything else — the start of the source, an operator, an opening\n * bracket, a comma — is a position where only a regex makes sense.\n */\nconst regexCanStartHere = (tokens: Token[]): boolean => {\n    const previous = tokens[tokens.length - 1];\n\n    if (previous == null) {\n        return true;\n    }\n\n    if (previous.kind === \"number\" || previous.kind === \"string\" || previous.kind === \"bigint\" || previous.kind === \"regex\") {\n        return false;\n    }\n\n    if (previous.kind === \"identifier\") {\n        return false;\n    }\n\n    return previous.value !== \")\" && previous.value !== \"]\";\n};\n\nconst isIdentifierStart = (char: string) => /[a-zA-Z_$]/.test(char);\nconst isIdentifierPart = (char: string) => /[a-zA-Z0-9_$]/.test(char);\nconst isDigit = (char: string) => char >= \"0\" && char <= \"9\";\nconst isHexDigit = (char: string) => isDigit(char) || (char >= \"a\" && char <= \"f\") || (char >= \"A\" && char <= \"F\");\n\n/**\n * Decodes a `\\uXXXX`, `\\u{...}` or `\\xXX` escape starting at the backslash.\n * Returns the decoded character and the index just past the escape.  These\n * escapes carry a computed character, so mapping them through STRING_ESCAPES\n * (which would yield the literal \"u\"/\"x\") silently corrupts the value.\n */\nconst decodeCodeEscape = (source: string, backslashIndex: number): { value: string, nextIndex: number } => {\n    const kind = source[backslashIndex + 1];\n    let start = backslashIndex + 2;\n\n    if (kind === \"u\" && source[start] === \"{\") {\n        const end = source.indexOf(\"}\", start + 1);\n\n        if (end === -1) {\n            throw new Error(ERROR_MESSAGES.UNSUPPORTED(\"unterminated unicode escape\"));\n        }\n\n        return { value: String.fromCodePoint(parseInt(source.slice(start + 1, end), 16)), nextIndex: end + 1 };\n    }\n\n    const length = kind === \"u\" ? 4 : 2;\n    const digits = source.slice(start, start + length);\n\n    if (digits.length < length || [...digits].some(d => !isHexDigit(d))) {\n        throw new Error(ERROR_MESSAGES.UNSUPPORTED(`'\\\\${kind}' escape`));\n    }\n\n    return { value: String.fromCharCode(parseInt(digits, 16)), nextIndex: start + length };\n}\n\n/**\n * Converts filter source text into a flat token stream.  Strings and comments are\n * consumed here so operator characters inside literals can never be mistaken for\n * real operators.\n */\nconst tokenize = (source: string): Token[] => {\n\n    const tokens: Token[] = [];\n    let i = 0;\n\n    while (i < source.length) {\n        const char = source[i];\n\n        // Whitespace\n        if (char === \" \" || char === \"\\t\" || char === \"\\r\" || char === \"\\n\") {\n            i++;\n            continue;\n        }\n\n        /**\n         * A regex literal, told from division by what came before it.\n         *\n         * `/` after a value — a number, string, identifier, `)` or `]` — is division. Anywhere else\n         * it opens a regex. That is the same rule a JavaScript lexer uses, and it is why `x.a / 2`\n         * and `/^a/.test(x.a)` can share a character.\n         */\n        if (char === \"/\" && source[i + 1] !== \"/\" && source[i + 1] !== \"*\" && regexCanStartHere(tokens)) {\n            let value = \"\";\n            let inClass = false;\n            let j = i + 1;\n\n            while (j < source.length) {\n                const current = source[j];\n\n                if (current === \"\\\\\") {\n                    value += current + (source[j + 1] ?? \"\");\n                    j += 2;\n                    continue;\n                }\n\n                if (current === \"[\") {\n                    inClass = true;\n                } else if (current === \"]\") {\n                    inClass = false;\n                } else if (current === \"/\" && inClass === false) {\n                    break;\n                } else if (current === \"\\n\") {\n                    throw new Error(ERROR_MESSAGES.UNSUPPORTED(\"unterminated regular expression\"));\n                }\n\n                value += current;\n                j++;\n            }\n\n            if (j >= source.length) {\n                throw new Error(ERROR_MESSAGES.UNSUPPORTED(\"unterminated regular expression\"));\n            }\n\n            j++;\n            let flags = \"\";\n\n            while (j < source.length && isIdentifierPart(source[j])) {\n                flags += source[j];\n                j++;\n            }\n\n            i = j;\n            tokens.push({ kind: \"regex\", value: `${value}\\u0000${flags}` });\n            continue;\n        }\n\n        // Comments\n        if (char === \"/\" && source[i + 1] === \"/\") {\n            while (i < source.length && source[i] !== \"\\n\") {\n                i++;\n            }\n            continue;\n        }\n\n        if (char === \"/\" && source[i + 1] === \"*\") {\n            i += 2;\n            while (i < source.length && !(source[i] === \"*\" && source[i + 1] === \"/\")) {\n                i++;\n            }\n            i += 2;\n            continue;\n        }\n\n        // String literals\n        if (char === \"'\" || char === \"\\\"\" || char === \"`\") {\n            const quote = char;\n            let value = \"\";\n            const chunks: string[] = [];\n            const expressions: string[] = [];\n            i++;\n\n            while (i < source.length && source[i] !== quote) {\n                if (source[i] === \"\\\\\") {\n                    const escaped = source[i + 1];\n\n                    if (escaped === \"u\" || escaped === \"x\") {\n                        const decoded = decodeCodeEscape(source, i);\n                        value += decoded.value;\n                        i = decoded.nextIndex;\n                        continue;\n                    }\n\n                    value += STRING_ESCAPES[escaped] ?? escaped;\n                    i += 2;\n                    continue;\n                }\n\n                /**\n                 * An interpolation. The literal so far becomes a chunk and the expression source is\n                 * kept whole, to be parsed by its own stream — nesting means the inner source can\n                 * hold anything, including another template.\n                 */\n                if (quote === \"`\" && source[i] === \"$\" && source[i + 1] === \"{\") {\n                    let depth = 1;\n                    let expression = \"\";\n                    let at = i + 2;\n\n                    while (at < source.length && depth > 0) {\n                        const current = source[at];\n\n                        if (current === \"{\") {\n                            depth++;\n                        } else if (current === \"}\") {\n                            depth--;\n\n                            if (depth === 0) {\n                                break;\n                            }\n                        } else if (current === \"'\" || current === '\"' || current === \"`\") {\n                            const closing = current;\n                            expression += current;\n                            at++;\n\n                            while (at < source.length && source[at] !== closing) {\n                                expression += source[at] === \"\\\\\" ? source[at] + (source[at + 1] ?? \"\") : source[at];\n                                at += source[at] === \"\\\\\" ? 2 : 1;\n                            }\n                        }\n\n                        expression += source[at];\n                        at++;\n                    }\n\n                    if (depth > 0) {\n                        throw new Error(ERROR_MESSAGES.UNSUPPORTED(\"unterminated template interpolation\"));\n                    }\n\n                    chunks.push(value);\n                    expressions.push(expression);\n                    value = \"\";\n                    i = at + 1;\n                    continue;\n                }\n\n                value += source[i];\n                i++;\n            }\n\n            if (i >= source.length) {\n                throw new Error(ERROR_MESSAGES.UNSUPPORTED(\"unterminated string literal\"));\n            }\n\n            i++; // consume closing quote\n\n            if (expressions.length > 0) {\n                chunks.push(value);\n                tokens.push({ kind: \"template\", value: JSON.stringify({ chunks, expressions }) });\n                continue;\n            }\n\n            tokens.push({ kind: \"string\", value });\n            continue;\n        }\n\n        // Numbers — covers decimals, exponents (1e6), hex/octal/binary (0xFF),\n        // and numeric separators (1_000_000).  Values are normalized here (the\n        // separator stripped) so the parser can hand them straight to Number()\n        if (isDigit(char)) {\n            let value = \"\";\n\n            const nextChar = source[i + 1];\n            const radixPrefix = char === \"0\" && nextChar != null && \"xXoObB\".includes(nextChar);\n\n            if (radixPrefix) {\n                value = source[i] + source[i + 1];\n                i += 2;\n\n                while (i < source.length && (isHexDigit(source[i]) || source[i] === \"_\")) {\n                    value += source[i];\n                    i++;\n                }\n            } else {\n                while (i < source.length && (isDigit(source[i]) || source[i] === \".\" || source[i] === \"_\")) {\n                    value += source[i];\n                    i++;\n                }\n\n                // Exponent part: e/E, optional sign, then digits.  Only consumed when\n                // digits follow, so a stray identifier after a number still errors\n                if ((source[i] === \"e\" || source[i] === \"E\")) {\n                    const signLength = source[i + 1] === \"+\" || source[i + 1] === \"-\" ? 1 : 0;\n\n                    if (isDigit(source[i + 1 + signLength])) {\n                        value += source[i];\n                        i++;\n\n                        if (signLength === 1) {\n                            value += source[i];\n                            i++;\n                        }\n\n                        while (i < source.length && isDigit(source[i])) {\n                            value += source[i];\n                            i++;\n                        }\n                    }\n                }\n            }\n\n            if (source[i] === \"n\") {\n                i++;\n                tokens.push({ kind: \"bigint\", value: value.replace(/_/g, \"\") });\n                continue;\n            }\n\n            tokens.push({ kind: \"number\", value: value.replace(/_/g, \"\") });\n            continue;\n        }\n\n        // Identifiers / keywords\n        if (isIdentifierStart(char)) {\n            let value = \"\";\n\n            while (i < source.length && isIdentifierPart(source[i])) {\n                value += source[i];\n                i++;\n            }\n\n            tokens.push({ kind: \"identifier\", value });\n            continue;\n        }\n\n        // Multi-character punctuation (longest match first)\n        const multi = MULTI_CHARACTER_PUNCTUATION.find(w => source.startsWith(w, i));\n\n        if (multi != null) {\n            tokens.push({ kind: \"punctuation\", value: multi });\n            i += multi.length;\n            continue;\n        }\n\n        if (SINGLE_CHARACTER_PUNCTUATION.has(char)) {\n            tokens.push({ kind: \"punctuation\", value: char });\n            i++;\n            continue;\n        }\n\n        throw new Error(ERROR_MESSAGES.UNSUPPORTED(`unexpected character '${char}'`));\n    }\n\n    return tokens;\n}\n\n/**\n * Cursor over the token stream with the small set of lookahead operations the\n * parser needs.\n */\nclass TokenStream {\n\n    private tokens: Token[];\n    private index: number = 0;\n\n    constructor(tokens: Token[]) {\n        this.tokens = tokens;\n    }\n\n    /** Inserts tokens at the cursor, bracketed so they keep their own precedence. */\n    splice(tokens: Token[]) {\n        const bracketed: Token[] = [\n            { kind: \"punctuation\", value: \"(\" },\n            ...tokens,\n            { kind: \"punctuation\", value: \")\" }\n        ];\n\n        this.tokens = [...this.tokens.slice(0, this.index), ...bracketed, ...this.tokens.slice(this.index)];\n    }\n\n    get isAtEnd() {\n        return this.index >= this.tokens.length;\n    }\n\n    peek(offset: number = 0): Token | null {\n        return this.tokens[this.index + offset] ?? null;\n    }\n\n    next(): Token {\n        const token = this.tokens[this.index];\n\n        if (token == null) {\n            throw new Error(ERROR_MESSAGES.UNSUPPORTED(\"unexpected end of expression\"));\n        }\n\n        this.index++;\n        return token;\n    }\n\n    /** The tokens of one statement's value, through the `;` or block end that closes it. */\n    takeStatementTokens(): Token[] {\n        const tokens: Token[] = [];\n        let depth = 0;\n\n        while (!this.isAtEnd) {\n            const token = this.peek()!;\n\n            if (token.kind === \"punctuation\") {\n                if (token.value === \"(\" || token.value === \"[\" || token.value === \"{\") {\n                    depth++;\n                } else if (token.value === \")\" || token.value === \"]\" || token.value === \"}\") {\n                    if (depth === 0) {\n                        break;\n                    }\n\n                    depth--;\n                } else if (token.value === \";\" && depth === 0) {\n                    this.next();\n                    break;\n                }\n            }\n\n            tokens.push(this.next());\n        }\n\n        if (tokens.length === 0) {\n            throw new Error(ERROR_MESSAGES.UNSUPPORTED(\"a declaration with no value\"));\n        }\n\n        return tokens;\n    }\n\n    isPunctuation(value: string, offset: number = 0): boolean {\n        const token = this.peek(offset);\n        return token != null && token.kind === \"punctuation\" && token.value === value;\n    }\n\n    /**\n     * Whether the group starting here holds a value rather than a condition.\n     *\n     * `(a && b)` is a boolean sub-expression; `(x.name ?? '') === 'ada'` and `(x.name).length` are\n     * values. Only the token after the matching bracket tells them apart, so the decision is made by\n     * looking ahead rather than by parsing one way and catching the failure — a rewind on exception\n     * would swallow a genuine syntax error inside the group and report it as something else.\n     */\n    groupIsValue(): boolean {\n        let depth = 0;\n        let at = this.index;\n\n        for (; at < this.tokens.length; at++) {\n            const token = this.tokens[at];\n\n            if (token.kind !== \"punctuation\") {\n                continue;\n            }\n\n            if (token.value === \"(\") {\n                depth++;\n                continue;\n            }\n\n            if (token.value === \")\") {\n                depth--;\n\n                if (depth === 0) {\n                    break;\n                }\n            }\n        }\n\n        const after = this.tokens[at + 1];\n\n        if (after == null || after.kind !== \"punctuation\") {\n            return false;\n        }\n\n        return COMPARISON_OPERATORS[after.value] != null || after.value === \".\" || after.value === \"?.\";\n    }\n\n    /** Whether a `?` sits at the top level of what is left, so this is a conditional. */\n    holdsConditional(): boolean {\n        let depth = 0;\n\n        for (let at = this.index; at < this.tokens.length; at++) {\n            const token = this.tokens[at];\n\n            if (token.kind !== \"punctuation\") {\n                continue;\n            }\n\n            if (token.value === \"(\" || token.value === \"[\") {\n                depth++;\n            } else if (token.value === \")\" || token.value === \"]\") {\n                depth--;\n            } else if (token.value === \"?\" && depth === 0) {\n                return true;\n            }\n        }\n\n        return false;\n    }\n\n    /** Whether the group starting here is `( … ? … : … )` rather than a plain value. */\n    groupHoldsConditional(): boolean {\n        let depth = 0;\n\n        for (let at = this.index; at < this.tokens.length; at++) {\n            const token = this.tokens[at];\n\n            if (token.kind !== \"punctuation\") {\n                continue;\n            }\n\n            if (token.value === \"(\") {\n                depth++;\n                continue;\n            }\n\n            if (token.value === \")\") {\n                depth--;\n\n                if (depth === 0) {\n                    return false;\n                }\n\n                continue;\n            }\n\n            if (token.value === \"?\" && depth === 1) {\n                return true;\n            }\n        }\n\n        return false;\n    }\n\n    matchPunctuation(value: string): boolean {\n        if (this.isPunctuation(value)) {\n            this.index++;\n            return true;\n        }\n\n        return false;\n    }\n\n    expectPunctuation(value: string) {\n        if (!this.matchPunctuation(value)) {\n            throw new Error(ERROR_MESSAGES.UNSUPPORTED(`expected '${value}'`));\n        }\n    }\n}\n\n// #endregion\n\n// #region Operands\n\n// Discriminated union so a condition builder can only ever see the operand\n// shapes the grammar allows\ntype PropertyOperand = {\n    kind: \"property\";\n    property: PropertyInfo<any>;\n    transformer: Transformer | null;\n    locale: string | null;\n}\n\ntype ValueOperand = {\n    kind: \"value\";\n    value: unknown;\n    transformer: Transformer | null;\n    locale: string | null;\n}\n\ntype ParamOperand = {\n    kind: \"param\";\n    path: string[];\n    transformer: Transformer | null;\n    locale: string | null;\n}\n\ntype MethodCallOperand = {\n    kind: \"method-call\";\n    target: PropertyOperand | ParamOperand | ValueOperand;\n    method: \"startsWith\" | \"endsWith\" | \"includes\";\n    argument: PropertyOperand | ValueOperand | ParamOperand;\n}\n\n/**\n * Arithmetic, which the tree carries as a binary `CallExpression`.\n *\n * A parse-time shape rather than an expression because the comparator builders orient on operand\n * KIND, and they have to be able to see that the property is in here.\n */\ntype ArithmeticOperand = {\n    kind: \"arithmetic\";\n    call: Call;\n    left: Operand;\n    right: Operand;\n    /** The third operand, which only `conditional` has. */\n    extra?: Operand;\n    /** Set when brackets around it settled the precedence. See {@link LOOSER_THAN_COMPARISON}. */\n    grouped?: true;\n}\n\n/**\n * Calls JavaScript binds LOOSER than a comparison.\n *\n * This grammar reads a comparison's operands as values, which puts these tighter than they belong:\n * `x.flags & 6 === 2` is `x.flags & (6 === 2)` in JavaScript and would be read here as\n * `(x.flags & 6) === 2`. The two answer differently, so an ungrouped one is refused rather than\n * reinterpreted — the filter then runs in memory against the caller's own function, which is right by\n * construction. Brackets say which was meant, and JavaScript itself makes an unbracketed `??` mix a\n * syntax error for the same reason.\n */\nconst LOOSER_THAN_COMPARISON: readonly Call[] = [\"bit-and\", \"bit-or\", \"bit-xor\", \"coalesce\"];\n\nconst needsBrackets = (operand: Operand): boolean =>\n    operand.kind === \"arithmetic\" && operand.grouped !== true && LOOSER_THAN_COMPARISON.includes(operand.call);\n\n/**\n * `a ? b : c`, where the condition is a BOOLEAN and the branches are values.\n *\n * Its own kind rather than an arithmetic operand with three slots, because the condition is an\n * Expression already — a comparison — while the branches are operands still being built.\n */\ntype ConditionalOperand = {\n    kind: \"conditional\";\n    condition: Expression;\n    whenTrue: Operand;\n    whenFalse: Operand;\n}\n\ntype Operand = PropertyOperand | ValueOperand | ParamOperand | MethodCallOperand | ArithmeticOperand | ConditionalOperand;\n\n/** JavaScript precedence: `*`, `/`, `%` bind tighter than `+` and `-`. */\nconst MULTIPLICATIVE_OPERATORS: Record<string, Call> = sourceKeyed({\n    \"*\": \"multiply\",\n    \"/\": \"divide\",\n    \"%\": \"modulo\",\n});\n\nconst ADDITIVE_OPERATORS: Record<string, Call> = sourceKeyed({\n    \"+\": \"add\",\n    \"-\": \"subtract\",\n});\n\nconst SHIFT_OPERATORS: Record<string, Call> = sourceKeyed({\n    \"<<\": \"shift-left\",\n    \">>\": \"shift-right\",\n    \">>>\": \"shift-right-unsigned\",\n});\n\nconst BITWISE_AND_OPERATORS: Record<string, Call> = sourceKeyed({ \"&\": \"bit-and\" });\nconst BITWISE_XOR_OPERATORS: Record<string, Call> = sourceKeyed({ \"^\": \"bit-xor\" });\nconst BITWISE_OR_OPERATORS: Record<string, Call> = sourceKeyed({ \"|\": \"bit-or\" });\nconst COALESCE_OPERATORS: Record<string, Call> = sourceKeyed({ \"??\": \"coalesce\" });\n\n/** Whether a schema property is reachable in here, which decides which side of a comparison it is. */\nconst containsProperty = (operand: Operand): boolean => {\n    if (operand.kind === \"property\") {\n        return true;\n    }\n\n    if (operand.kind === \"conditional\") {\n        // A comparison always names a schema property, so the condition alone settles it\n        return true;\n    }\n\n    return operand.kind === \"arithmetic\"\n        && (containsProperty(operand.left) || containsProperty(operand.right) || (operand.extra != null && containsProperty(operand.extra)));\n};\n\nconst DECLARATION_KEYWORDS = new Set([\"const\", \"let\", \"var\"]);\n\n/** An operand whose value only a row can supply. */\nconst UNKNOWN_UNTIL_ROW = Symbol(\"unknown until row\");\n\n/** The empty argument slot of a unary call. Compared by identity, so a real `undefined` still counts. */\nconst NO_ARGUMENT: ValueOperand = Object.freeze({ kind: \"value\", value: undefined, transformer: null, locale: null }) as ValueOperand;\n\nconst noArgument = (): ValueOperand => NO_ARGUMENT;\n\n/** A predicate no row satisfies. Never reaches a tree: no expression node means \"match nothing\". */\nconst NEVER = \"never\";\n\ntype Answer = Expression | typeof NEVER;\n\nconst and = (left: Expression, right: Expression): Expression => {\n    if (Expression.isEmpty(left)) {\n        return right;\n    }\n\n    if (Expression.isEmpty(right)) {\n        return left;\n    }\n\n    return new OperatorExpression({ operator: \"&&\", left, right });\n}\n\nconst or = (left: Expression, right: Expression): Expression => {\n    if (Expression.isEmpty(left) || Expression.isEmpty(right)) {\n        return Expression.EMPTY;\n    }\n\n    return new OperatorExpression({ operator: \"||\", left, right });\n}\n\nconst COMPARATOR_METHODS: Record<string, Comparator> = sourceKeyed({\n    startsWith: \"starts-with\",\n    endsWith: \"ends-with\",\n    includes: \"includes\"\n});\n\nconst TRANSFORM_METHODS: Record<string, { transformer: Transformer, locale: string | null }> = sourceKeyed({\n    toLowerCase: { transformer: \"to-lower-case\", locale: null },\n    toUpperCase: { transformer: \"to-upper-case\", locale: null },\n    toLocaleLowerCase: { transformer: \"to-lower-case\", locale: \"en-US\" },\n    toLocaleUpperCase: { transformer: \"to-upper-case\", locale: \"en-US\" }\n});\n\nconst COMPARISON_OPERATORS: Record<string, { comparator: Comparator, negated: boolean, strict: boolean }> = sourceKeyed({\n    \"==\": { comparator: \"equals\", negated: false, strict: false },\n    \"===\": { comparator: \"equals\", negated: false, strict: true },\n    \"!=\": { comparator: \"equals\", negated: true, strict: false },\n    \"!==\": { comparator: \"equals\", negated: true, strict: true },\n    \">\": { comparator: \"greater-than\", negated: false, strict: false },\n    \">=\": { comparator: \"greater-than-equals\", negated: false, strict: false },\n    \"<\": { comparator: \"less-than\", negated: false, strict: false },\n    \"<=\": { comparator: \"less-than-equals\", negated: false, strict: false }\n});\n\nconst SWAPPED_COMPARATORS: Record<Comparator, Comparator> = {\n    \"equals\": \"equals\",\n    \"greater-than\": \"less-than\",\n    \"greater-than-equals\": \"less-than-equals\",\n    \"less-than\": \"greater-than\",\n    \"less-than-equals\": \"greater-than-equals\",\n    \"starts-with\": \"starts-with\",\n    \"ends-with\": \"ends-with\",\n    \"includes\": \"includes\"\n};\n\n// #endregion\n\n// #region Param references\n\n/**\n * Placeholder for a parameter value inside a cached expression template.  Never\n * escapes this module — binding replaces it with a plain ValueExpression that\n * holds the resolved value.\n */\nclass ParamReferenceExpression extends ValueExpression {\n\n    /** Path into the params object, excluding the params root name. */\n    readonly paramPath: string[];\n    /** The property this value is compared against; drives serialization/conversion at bind time. */\n    readonly pairedProperty: PropertyInfo<any> | null;\n    /** Whether the paired property's type converter applies (equality/relational comparisons only). */\n    readonly applyConverter: boolean;\n\n    constructor(options: {\n        paramPath: string[],\n        pairedProperty: PropertyInfo<any> | null,\n        applyConverter: boolean\n    }) {\n        super({ value: undefined });\n        this.paramPath = options.paramPath;\n        this.pairedProperty = options.pairedProperty;\n        this.applyConverter = options.applyConverter;\n    }\n}\n\nconst resolveParamPath = (paramsName: string, path: string[], data: unknown) => {\n\n    let result = data as Record<string, unknown>;\n\n    for (let i = 0; i < path.length; i++) {\n        const name = path[i];\n\n        if (result != null && typeof result === \"object\" && name in result) {\n            result = result[name] as Record<string, unknown>;\n            continue;\n        }\n\n        throw new ParamDependentParseError(ERROR_MESSAGES.PARAM_PATH_NOT_FOUND([paramsName, ...path].join(\".\"), data));\n    }\n\n    return result as unknown;\n}\n\n/**\n * Applies the paired property's value serializer and (optionally) its schema\n * type converter, matching how literal values are treated at parse time.\n */\nconst resolvePairedValue = (value: unknown, pairedProperty: PropertyInfo<any> | null, applyConverter: boolean) => {\n\n    if (pairedProperty == null) {\n        return value;\n    }\n\n    let result = value;\n\n    if (pairedProperty.valueSerializer != null) {\n        result = String(pairedProperty.valueSerializer(parseUnknown(result)));\n    }\n\n    if (applyConverter) {\n        result = converters[pairedProperty.type](result);\n    }\n\n    return result;\n}\n\n// #endregion\n\n// #region Parser\n\n/**\n * Recursive descent parser over the token stream.  Produces an expression\n * template: literal values are fully resolved, parameter values are represented\n * as ParamReferenceExpression placeholders so the template can be cached and\n * re-bound with different params.\n */\nclass ExpressionParser {\n\n    private readonly schema: CompiledSchema<any>;\n    private readonly stream: TokenStream;\n    private readonly scope: Scope;\n    private readonly paramsName: string | null;\n    private readonly params: unknown;\n\n    /** Set when a param value shaped the tree itself (e.g. x[p.name]) — such templates cannot be cached. */\n    structurallyDependsOnParams: boolean = false;\n\n    constructor(schema: CompiledSchema<any>, stream: TokenStream, scope: Scope, paramsName: string | null, params: unknown) {\n        this.schema = schema;\n        this.stream = stream;\n        this.scope = scope;\n        this.paramsName = paramsName;\n        this.params = params;\n    }\n\n    parse(): Expression {\n        const expression = this.parseOr();\n\n        if (!this.stream.isAtEnd) {\n            throw new Error(ERROR_MESSAGES.UNSUPPORTED(`unexpected token '${this.stream.peek()?.value}'`));\n        }\n\n        return expression;\n    }\n\n    parseBody(): Expression {\n\n        if (!this.stream.isPunctuation(\"{\")) {\n            return this.parse();\n        }\n\n        const answer = this.parseBlock();\n\n        if (!this.stream.isAtEnd) {\n            throw new Error(ERROR_MESSAGES.UNSUPPORTED(`unexpected token '${this.stream.peek()?.value}'`));\n        }\n\n        if (answer === NEVER) {\n            throw new Error(ERROR_MESSAGES.UNSUPPORTED(\"a predicate no row can satisfy\"));\n        }\n\n        return answer;\n    }\n\n    /** The expression a `{ … }` block answers with. */\n    private parseBlock(): Answer {\n        this.stream.expectPunctuation(\"{\");\n        const answer = this.parseStatements();\n        this.stream.expectPunctuation(\"}\");\n\n        return answer;\n    }\n\n    /** Statements up to the one that returns. What follows a `return` is never read, as in JavaScript. */\n    private parseStatements(): Answer {\n        if (this.stream.isPunctuation(\"}\") || this.stream.isAtEnd) {\n            throw new Error(ERROR_MESSAGES.UNSUPPORTED(\"a block body that returns nothing\"));\n        }\n\n        const keyword = this.stream.peek();\n\n        if (keyword == null || keyword.kind !== \"identifier\") {\n            throw new Error(ERROR_MESSAGES.UNSUPPORTED(`a statement starting '${keyword?.value}'`));\n        }\n\n        if (DECLARATION_KEYWORDS.has(keyword.value)) {\n            this.declare();\n            return this.parseStatements();\n        }\n\n        if (keyword.value === \"return\") {\n            this.stream.next();\n            const answer = this.parseReturnedCondition();\n            this.stream.matchPunctuation(\";\");\n\n            return answer;\n        }\n\n        if (keyword.value === \"if\") {\n            return this.parseIfStatement();\n        }\n\n        if (keyword.value === \"switch\") {\n            return this.parseSwitchStatement();\n        }\n\n        throw new Error(ERROR_MESSAGES.UNSUPPORTED(`the statement '${keyword.value}'`));\n    }\n\n    /**\n     * Binds a `const`/`let`/`var` name to the tokens of its initializer — tokens rather than a parsed\n     * expression, so the name works as an operand, an argument, or a call receiver alike.\n     */\n    private declare() {\n        this.stream.next();\n\n        const name = this.stream.next();\n\n        if (name.kind !== \"identifier\") {\n            throw new Error(ERROR_MESSAGES.UNSUPPORTED(`the declaration '${name.value}'`));\n        }\n\n        this.stream.expectPunctuation(\"=\");\n\n        this.scope.set(name.value, { kind: \"inlined\", tokens: this.stream.takeStatementTokens() });\n    }\n\n    /** `return false` on its own, which no row satisfies, and every other returned condition. */\n    private parseReturnedCondition(): Answer {\n        const next = this.stream.peek();\n        const after = this.stream.peek(1);\n        const endsHere = after == null || (after.kind === \"punctuation\" && (after.value === \";\" || after.value === \"}\"));\n\n        if (next != null && next.kind === \"identifier\" && next.value === \"false\" && endsHere) {\n            this.stream.next();\n            return NEVER;\n        }\n\n        return this.parseOr();\n    }\n\n    private parseIfStatement(): Answer {\n        this.stream.next();\n\n        this.stream.expectPunctuation(\"(\");\n        const condition = this.parseOr();\n        this.stream.expectPunctuation(\")\");\n\n        const whenTrue = this.parseBranch();\n\n        if (this.stream.peek()?.value === \"else\") {\n            this.stream.next();\n            return this.either(condition, whenTrue, this.parseBranch());\n        }\n\n        // Without an `else`, the statements after the `if` are the other branch\n        return this.either(condition, whenTrue, this.parseStatements());\n    }\n\n    /** One arm of an `if`: a block, or a single statement. */\n    private parseBranch(): Answer {\n        return this.stream.isPunctuation(\"{\") ? this.parseBlock() : this.parseStatements();\n    }\n\n    /** A `switch` over one subject, as the disjunction of its cases. */\n    private parseSwitchStatement(): Answer {\n        this.stream.next();\n\n        this.stream.expectPunctuation(\"(\");\n        const subject = this.parseValue();\n        this.stream.expectPunctuation(\")\");\n        this.stream.expectPunctuation(\"{\");\n\n        let matching: Expression | null = null;\n        let pending: Expression[] = [];\n        let everyLabel: Expression[] = [];\n        let byDefault: Expression | null = null;\n        let anyCaseBroke = false;\n\n        while (!this.stream.matchPunctuation(\"}\")) {\n            const label = this.stream.next();\n\n            if (label.kind !== \"identifier\" || (label.value !== \"case\" && label.value !== \"default\")) {\n                throw new Error(ERROR_MESSAGES.UNSUPPORTED(`'${label.value}' inside a switch`));\n            }\n\n            if (label.value === \"case\") {\n                const test = this.buildComparison(subject, COMPARISON_OPERATORS[\"===\"], this.parseValue());\n                pending.push(test);\n                everyLabel.push(test);\n            }\n\n            this.stream.expectPunctuation(\":\");\n\n            // `case 'a':` with no body of its own runs the next case's body\n            if (this.stream.peek()?.value === \"case\" || this.stream.peek()?.value === \"default\") {\n                continue;\n            }\n\n            if (this.stream.peek()?.value === \"break\") {\n                this.stream.next();\n                this.stream.matchPunctuation(\";\");\n                anyCaseBroke = true;\n                pending = [];\n                continue;\n            }\n\n            const body = this.parseCaseBody();\n\n            if (label.value === \"default\") {\n                byDefault = body === NEVER ? null : body;\n                continue;\n            }\n\n            if (body !== NEVER && pending.length > 0) {\n                const reached = pending.reduce((left, right) => or(left, right));\n                const term = Expression.isEmpty(body) ? reached : and(reached, body);\n\n                matching = matching == null ? term : or(matching, term);\n            }\n\n            pending = [];\n        }\n\n        // Falling out of the switch continues after it, so the statements there are the default too\n        const afterSwitch = byDefault == null && !this.stream.isPunctuation(\"}\") && !this.stream.isAtEnd\n            ? this.parseStatements()\n            : NEVER;\n\n        if (afterSwitch !== NEVER) {\n            // A `break` also continues after the switch, so its case would take that answer rather\n            // than none — a distinction this rewrite cannot carry\n            if (anyCaseBroke) {\n                throw new Error(ERROR_MESSAGES.UNSUPPORTED(\"a switch that breaks and then falls into more statements\"));\n            }\n\n            byDefault = afterSwitch;\n        }\n\n        // A `default` runs only when every case failed, wherever it was written\n        if (byDefault != null) {\n            const noCaseMatched = everyLabel.length === 0\n                ? byDefault\n                : and(this.negateExpression(everyLabel.reduce((left, right) => or(left, right))), byDefault);\n\n            matching = matching == null ? noCaseMatched : or(matching, noCaseMatched);\n        }\n\n        return matching ?? NEVER;\n    }\n\n    /** One case body, and the `break` that may follow its `return`. */\n    private parseCaseBody(): Answer {\n        const answer = this.parseStatements();\n\n        if (this.stream.peek()?.value === \"break\") {\n            this.stream.next();\n            this.stream.matchPunctuation(\";\");\n        }\n\n        return answer;\n    }\n\n    /**\n     * The predicate an `if`/`else` answers: `(condition && whenTrue) || (!condition && whenFalse)`,\n     * with each case below that form after a constant branch cancels out.\n     */\n    private either(condition: Expression, whenTrue: Answer, whenFalse: Answer): Answer {\n\n        if (whenTrue === NEVER) {\n            return whenFalse === NEVER ? NEVER : and(this.negateExpression(condition), whenFalse);\n        }\n\n        if (whenFalse === NEVER) {\n            return and(condition, whenTrue);\n        }\n\n        if (Expression.isEmpty(whenTrue)) {\n            return or(condition, whenFalse);\n        }\n\n        if (Expression.isEmpty(whenFalse)) {\n            return or(this.negateExpression(condition), whenTrue);\n        }\n\n        return or(and(condition, whenTrue), and(this.negateExpression(condition), whenFalse));\n    }\n\n    // || binds loosest, so it sits at the root of the parse\n    private parseOr(): Expression {\n        let left = this.parseAnd();\n\n        while (this.stream.matchPunctuation(\"||\")) {\n            const right = this.parseAnd();\n\n            // A tautology (`true`) absorbs the whole disjunction\n            if (Expression.isEmpty(left) || Expression.isEmpty(right)) {\n                left = Expression.EMPTY;\n                continue;\n            }\n\n            left = new OperatorExpression({ operator: \"||\", left, right });\n        }\n\n        return left;\n    }\n\n    private parseAnd(): Expression {\n        let left = this.parseUnary();\n\n        while (this.stream.matchPunctuation(\"&&\")) {\n            const right = this.parseUnary();\n\n            // A tautology (`true`) is the identity of a conjunction\n            if (Expression.isEmpty(left)) {\n                left = right;\n                continue;\n            }\n\n            if (Expression.isEmpty(right)) {\n                continue;\n            }\n\n            left = new OperatorExpression({ operator: \"&&\", left, right });\n        }\n\n        return left;\n    }\n\n    private parseUnary(): Expression {\n        if (this.stream.matchPunctuation(\"!\")) {\n            return this.negateExpression(this.parseUnary());\n        }\n\n        return this.parseComparison();\n    }\n\n    /**\n     * Applies `!` to an already-parsed expression: comparators flip their\n     * negated flag, compound expressions distribute via De Morgan's laws.\n     *\n     * Builds a new tree rather than flipping the flag in place, because an `if` uses its condition\n     * twice — once negated — and a shared node would carry the flip into both branches.\n     */\n    private negateExpression(expression: Expression): Expression {\n        if (expression instanceof ComparatorExpression) {\n            return new ComparatorExpression({\n                comparator: expression.comparator,\n                negated: !expression.negated,\n                strict: expression.strict,\n                left: expression.left,\n                right: expression.right\n            });\n        }\n\n        if (expression instanceof OperatorExpression && expression.left != null && expression.right != null) {\n            return new OperatorExpression({\n                operator: expression.operator === \"&&\" ? \"||\" : \"&&\",\n                left: this.negateExpression(expression.left),\n                right: this.negateExpression(expression.right)\n            });\n        }\n\n        throw new Error(ERROR_MESSAGES.UNSUPPORTED(\"'!' on this expression\"));\n    }\n\n    private parseComparison(): Expression {\n\n        /**\n         * A parenthesised group is either a boolean sub-expression or a VALUE — `(a && b)` against\n         * `(x.name ?? '') === 'ada'` — and which one it is is only known at the closing bracket, by\n         * what follows. So the boolean reading is tried first and rewound if a comparator turns up.\n         */\n        if (this.stream.isPunctuation(\"(\") && this.stream.groupIsValue() === false) {\n            this.stream.next();\n\n            const expression = this.parseOr();\n            this.stream.expectPunctuation(\")\");\n\n            return expression;\n        }\n\n        const left = this.parseValue();\n        const operatorToken = this.stream.peek();\n\n        if (operatorToken != null && operatorToken.kind === \"punctuation\" && COMPARISON_OPERATORS[operatorToken.value] != null) {\n            this.stream.next();\n            const right = this.parseValue();\n            return this.buildComparison(left, COMPARISON_OPERATORS[operatorToken.value], right);\n        }\n\n        return this.buildStandalone(left);\n    }\n\n    /**\n     * A value, at JavaScript's precedence.\n     *\n     * Lowest first: the conditional operator, then nullish coalescing, then the bitwise levels, then\n     * the shifts, then the arithmetic. Comparison sits between the shifts and the bitwise levels in\n     * JavaScript, but a comparison is a boolean and is handled by `parseComparison` above, so this\n     * chain skips it — a bitwise operand here is always a value.\n     */\n    /**\n     * An operand from its own source, sharing this parser's schema and parameter names.\n     *\n     * A structural dependence found inside propagates outward: the template it belongs to cannot be\n     * cached either.\n     */\n    private parseNested(source: string): Operand {\n        const nested = new ExpressionParser(this.schema, new TokenStream(tokenize(source)), this.scope, this.paramsName, this.params);\n        const operand = nested.parseInterpolation();\n\n        // Leftover tokens mean the interpolation held something this reads only part of. Silently\n        // keeping the part it understood is the worst outcome available: `${x.age > 5 ? \"a\" : \"b\"}`\n        // would become `x.age`, and the filter would answer a question nobody asked.\n        if (nested.stream.isAtEnd === false) {\n            throw new Error(ERROR_MESSAGES.UNSUPPORTED(\"an interpolation this parser reads only part of\"));\n        }\n\n        if (nested.structurallyDependsOnParams === true) {\n            this.structurallyDependsOnParams = true;\n        }\n\n        return operand;\n    }\n\n    /**\n     * The whole of one `${…}`.\n     *\n     * A conditional is read here rather than in `parseValue`, because an interpolation is the one\n     * place a conditional appears without brackets around it.\n     */\n    parseInterpolation(): Operand {\n\n        if (this.stream.holdsConditional()) {\n            const condition = this.parseOr();\n\n            this.stream.expectPunctuation(\"?\");\n            const whenTrue = this.parseValue();\n            this.stream.expectPunctuation(\":\");\n            const whenFalse = this.parseValue();\n\n            return { kind: \"conditional\", condition, whenTrue, whenFalse };\n        }\n\n        return this.parseValue();\n    }\n\n    parseValue(): Operand {\n        return this.parseCoalesce();\n    }\n\n    private parseCoalesce(): Operand {\n        return this.parseBinary(COALESCE_OPERATORS, () => this.parseBitwiseOr());\n    }\n\n    private parseBitwiseOr(): Operand {\n        return this.parseBinary(BITWISE_OR_OPERATORS, () => this.parseBitwiseXor());\n    }\n\n    private parseBitwiseXor(): Operand {\n        return this.parseBinary(BITWISE_XOR_OPERATORS, () => this.parseBitwiseAnd());\n    }\n\n    private parseBitwiseAnd(): Operand {\n        return this.parseBinary(BITWISE_AND_OPERATORS, () => this.parseShift());\n    }\n\n    private parseShift(): Operand {\n        return this.parseBinary(SHIFT_OPERATORS, () => this.parseAdditive());\n    }\n\n    private parseAdditive(): Operand {\n        return this.parseBinary(ADDITIVE_OPERATORS, () => this.parseMultiplicative());\n    }\n\n    private parseMultiplicative(): Operand {\n        return this.parseBinary(MULTIPLICATIVE_OPERATORS, () => this.parseExponent());\n    }\n\n    /** `**` is RIGHT-associative: `2 ** 3 ** 2` is 2 ** 9, not 8 ** 2. */\n    private parseExponent(): Operand {\n        const left = this.parseOperand();\n\n        if (this.stream.isPunctuation(\"**\") === false) {\n            return left;\n        }\n\n        this.stream.next();\n\n        return { kind: \"arithmetic\", call: \"power\", left, right: this.parseExponent() };\n    }\n\n    /** Left-associative, so `a - b - c` is `(a - b) - c` rather than `a - (b - c)`. */\n    private parseBinary(operators: Record<string, Call>, next: () => Operand): Operand {\n        let left = next();\n\n        for (;;) {\n            const token = this.stream.peek();\n\n            if (token == null || token.kind !== \"punctuation\" || operators[token.value] == null) {\n                return left;\n            }\n\n            this.stream.next();\n            left = { kind: \"arithmetic\", call: operators[token.value], left, right: next() };\n        }\n    }\n\n    private parseOperand(): Operand {\n        const token = this.stream.peek();\n\n        if (token == null) {\n            throw new Error(ERROR_MESSAGES.UNSUPPORTED(\"unexpected end of expression\"));\n        }\n\n        if (token.kind === \"string\") {\n            this.stream.next();\n            return this.withValueTransformer({ kind: \"value\", value: token.value, transformer: null, locale: null });\n        }\n\n        if (token.kind === \"number\") {\n            this.stream.next();\n            return { kind: \"value\", value: Number(token.value), transformer: null, locale: null };\n        }\n\n        // A parenthesised VALUE — `(x.price & 1)`, `(x.name ?? '')`. The boolean reading of a group\n        // is handled in parseComparison; by the time an operand sees one it is arithmetic.\n        if (token.kind === \"punctuation\" && token.value === \"(\") {\n            const conditional = this.stream.groupHoldsConditional();\n\n            this.stream.next();\n\n            if (conditional === true) {\n                const condition = this.parseOr();\n\n                this.stream.expectPunctuation(\"?\");\n                const whenTrue = this.parseValue();\n                this.stream.expectPunctuation(\":\");\n                const whenFalse = this.parseValue();\n                this.stream.expectPunctuation(\")\");\n\n                return { kind: \"conditional\", condition, whenTrue, whenFalse };\n            }\n\n            const inner = this.parseValue();\n            this.stream.expectPunctuation(\")\");\n\n            const grouped = inner.kind === \"arithmetic\" ? { ...inner, grouped: true } as Operand : inner;\n\n            return this.withGroupCall(grouped);\n        }\n\n        /**\n         * A template with interpolation, folded into `concat`.\n         *\n         * Each `${…}` was kept as source by the tokenizer and is parsed by its own stream, so it can\n         * hold anything an operand can — a property, a param, arithmetic, another template. Empty\n         * chunks are dropped: `${a}${b}` is two operands, not two operands and three empty strings.\n         */\n        if (token.kind === \"template\") {\n            this.stream.next();\n\n            const { chunks, expressions } = JSON.parse(token.value) as { chunks: string[], expressions: string[] };\n            const pieces: Operand[] = [];\n\n            for (let at = 0; at < chunks.length; at++) {\n                if (chunks[at].length > 0) {\n                    pieces.push({ kind: \"value\", value: chunks[at], transformer: null, locale: null });\n                }\n\n                if (at < expressions.length) {\n                    pieces.push(this.parseNested(expressions[at]));\n                }\n            }\n\n            if (pieces.length === 0) {\n                return { kind: \"value\", value: \"\", transformer: null, locale: null };\n            }\n\n            // One piece and no chunk means no concat to do the coercion, so the conversion has to be\n            // explicit: `` `${x.age}` `` is the STRING \"9\", not the number 9.\n            if (pieces.length === 1) {\n                const only = pieces[0];\n                const alreadyText = only.kind === \"value\" && typeof only.value === \"string\";\n\n                return alreadyText ? only : { kind: \"arithmetic\", call: \"to-string\", left: only, right: noArgument() };\n            }\n\n            return pieces.reduce((left, right) => ({ kind: \"arithmetic\", call: \"concat\", left, right }));\n        }\n\n        if (token.kind === \"bigint\") {\n            this.stream.next();\n            return { kind: \"value\", value: BigInt(token.value), transformer: null, locale: null };\n        }\n\n        if (token.kind === \"regex\") {\n            this.stream.next();\n\n            const [source, flags] = token.value.split(\"\\u0000\");\n            const pattern: ValueOperand = { kind: \"value\", value: new RegExp(source, flags), transformer: null, locale: null };\n\n            // `/^a/.test(x.name)` — the pattern is the literal, the subject is the argument, and the\n            // tree puts them the other way round: the property is what the call applies to.\n            if (this.stream.isPunctuation(\".\")) {\n                const method = this.stream.peek(1);\n\n                if (method != null && method.kind === \"identifier\" && method.value === \"test\") {\n                    this.stream.next();\n                    this.stream.next();\n                    this.stream.expectPunctuation(\"(\");\n\n                    const subject = this.parseValue();\n                    this.stream.expectPunctuation(\")\");\n\n                    return { kind: \"arithmetic\", call: \"matches\", left: subject, right: pattern };\n                }\n            }\n\n            return pattern;\n        }\n\n        if (token.kind === \"punctuation\" && token.value === \"~\") {\n            this.stream.next();\n\n            // Unary, so the tree carries the operand and no argument\n            return { kind: \"arithmetic\", call: \"bit-not\", left: this.parseOperand(), right: noArgument() };\n        }\n\n        if (token.kind === \"punctuation\" && token.value === \"-\") {\n            this.stream.next();\n            const numberToken = this.stream.next();\n\n            if (numberToken.kind !== \"number\") {\n                throw new Error(ERROR_MESSAGES.UNSUPPORTED(\"unary '-' on a non-number\"));\n            }\n\n            return { kind: \"value\", value: -Number(numberToken.value), transformer: null, locale: null };\n        }\n\n        if (token.kind === \"punctuation\" && token.value === \"[\") {\n            return this.parseArrayLiteralOperand();\n        }\n\n        if (token.kind === \"identifier\") {\n            return this.parseIdentifierOperand();\n        }\n\n        throw new Error(ERROR_MESSAGES.UNSUPPORTED(String(token.value)));\n    }\n\n    /**\n     * Parses an inline array of literals, e.g. `[\"active\", \"pending\"]`, and the\n     * membership test that follows it: `[...].includes(entity.property)`.\n     */\n    private parseArrayLiteralOperand(): Operand {\n        this.stream.expectPunctuation(\"[\");\n        const elements: unknown[] = [];\n\n        while (!this.stream.isPunctuation(\"]\")) {\n            const element = this.parseOperand();\n\n            if (element.kind !== \"value\" || element.transformer != null) {\n                throw new Error(ERROR_MESSAGES.UNSUPPORTED(\"a non-literal element in an array literal\"));\n            }\n\n            elements.push(element.value);\n\n            if (!this.stream.matchPunctuation(\",\")) {\n                break;\n            }\n        }\n\n        this.stream.expectPunctuation(\"]\");\n\n        const array: ValueOperand = { kind: \"value\", value: elements, transformer: null, locale: null };\n\n        // The only supported use is a membership test on a schema property\n        if (this.stream.isPunctuation(\".\") || this.stream.isPunctuation(\"?.\")) {\n            this.stream.next();\n            const method = this.stream.next();\n\n            if (method.kind !== \"identifier\" || method.value !== \"includes\") {\n                throw new Error(ERROR_MESSAGES.UNSUPPORTED(`'.${method.value}' on an array literal`));\n            }\n\n            this.stream.expectPunctuation(\"(\");\n            const argument = this.parseOperand();\n            this.stream.expectPunctuation(\")\");\n\n            if (argument.kind === \"method-call\") {\n                throw new Error(ERROR_MESSAGES.UNSUPPORTED(\"nested method call inside .includes()\"));\n            }\n\n            if (argument.kind === \"arithmetic\" || argument.kind === \"conditional\") {\n                throw new Error(ERROR_MESSAGES.UNSUPPORTED(\"arithmetic inside .includes()\"));\n            }\n\n            return { kind: \"method-call\", target: array, method: \"includes\", argument };\n        }\n\n        return array;\n    }\n\n    private parseIdentifierOperand(): Operand {\n        const root = this.stream.next().value;\n\n        // Keyword literals\n        if (root === \"true\" || root === \"false\") {\n            return { kind: \"value\", value: root === \"true\", transformer: null, locale: null };\n        }\n\n        if (root === \"null\") {\n            return { kind: \"value\", value: null, transformer: null, locale: null };\n        }\n\n        if (root === \"undefined\") {\n            return { kind: \"value\", value: undefined, transformer: null, locale: null };\n        }\n\n        if (root === \"void\") {\n            this.stream.next(); // the '0'\n            return { kind: \"value\", value: undefined, transformer: null, locale: null };\n        }\n\n        const binding = this.scope.get(root);\n\n        if (binding != null) {\n            if (binding.kind === \"inlined\") {\n                this.stream.splice(binding.tokens);\n                return this.parseOperand();\n            }\n\n            return this.parseChain({ kind: binding.kind, path: [...binding.path] });\n        }\n\n        // A bare variable from the outer scope — its value cannot be derived from source text\n        throw new Error(ERROR_MESSAGES.VARIABLE_VALUE(root));\n    }\n\n    /**\n     * Parses the segments after an entity/params root: dot access, bracket\n     * access, transform methods and comparator methods.\n     */\n    private parseChain(options: { kind: \"property\" | \"param\", path: string[] }): Operand {\n        const path = options.path;\n        let transformer: Transformer | null = null;\n        let locale: string | null = null;\n\n        while (true) {\n            if (this.stream.matchPunctuation(\".\") || this.stream.matchPunctuation(\"?.\")) {\n                const segment = this.stream.next();\n\n                if (segment.kind !== \"identifier\") {\n                    throw new Error(ERROR_MESSAGES.UNSUPPORTED(`'.${segment.value}'`));\n                }\n\n                // Method call\n                if (this.stream.isPunctuation(\"(\")) {\n                    const method = segment.value;\n\n                    if (TRANSFORM_METHODS[method] != null) {\n                        this.stream.expectPunctuation(\"(\");\n                        this.stream.expectPunctuation(\")\");\n                        transformer = TRANSFORM_METHODS[method].transformer;\n                        locale = TRANSFORM_METHODS[method].locale;\n                        continue;\n                    }\n\n                    if (COMPARATOR_METHODS[method] != null) {\n                        this.stream.expectPunctuation(\"(\");\n                        const argument = this.parseOperand();\n                        this.stream.expectPunctuation(\")\");\n\n                        if (argument.kind === \"method-call\") {\n                            throw new Error(ERROR_MESSAGES.UNSUPPORTED(`nested method call inside .${method}()`));\n                        }\n\n                        if (argument.kind === \"arithmetic\" || argument.kind === \"conditional\") {\n                            throw new Error(ERROR_MESSAGES.UNSUPPORTED(`arithmetic inside .${method}()`));\n                        }\n\n                        return {\n                            kind: \"method-call\",\n                            target: this.resolveChain(options.kind, path, transformer, locale),\n                            method: method as MethodCallOperand[\"method\"],\n                            argument\n                        };\n                    }\n\n                    throw new Error(ERROR_MESSAGES.UNSUPPORTED(`method '.${method}()'`));\n                }\n\n                if (transformer != null) {\n                    throw new Error(ERROR_MESSAGES.UNSUPPORTED(\"property access after a transform method\"));\n                }\n\n                path.push(segment.value);\n                continue;\n            }\n\n            if (this.stream.matchPunctuation(\"[\")) {\n                path.push(this.parseBracketSegment(options.kind));\n                this.stream.expectPunctuation(\"]\");\n                continue;\n            }\n\n            break;\n        }\n\n        return this.resolveChain(options.kind, path, transformer, locale);\n    }\n\n    private parseBracketSegment(kind: \"property\" | \"param\"): string {\n        const token = this.stream.next();\n\n        // Literal segment: entity[\"name\"]\n        if (token.kind === \"string\") {\n            return token.value;\n        }\n\n        // Param-driven segment: entity[p.name] — the property depends on the\n        // param VALUE, so the resulting template is tied to these params.\n        // Stryker disable next-line all: documented equivalent cluster (see\n        // docs/mutation-backlog.md) — every mutation of this four-conjunct guard reroutes\n        // bracket access between two paths that both collapse to NOT_PARSABLE; the\n        // experiment recorded there aimed 30 tests at this line and killed none.\n        const binding = token.kind === \"identifier\" ? this.scope.get(token.value) : undefined;\n\n        if (kind === \"property\" && binding != null && binding.kind === \"param\") {\n            const paramPath: string[] = [...binding.path];\n\n            while (this.stream.matchPunctuation(\".\") || this.stream.matchPunctuation(\"?.\")) {\n                paramPath.push(this.stream.next().value);\n            }\n\n            const resolved = resolveParamPath(this.paramsName ?? token.value, paramPath, this.params);\n\n            if (typeof resolved !== \"string\") {\n                throw new ParamDependentParseError(ERROR_MESSAGES.PROPERTY_NOT_FOUND(paramPath.join(\".\")));\n            }\n\n            this.structurallyDependsOnParams = true;\n            return resolved;\n        }\n\n        throw new Error(ERROR_MESSAGES.UNSUPPORTED(`bracket access '[${token.value}]'`));\n    }\n\n    private resolveChain(kind: \"property\" | \"param\", path: string[], transformer: Transformer | null, locale: string | null): PropertyOperand | ParamOperand {\n\n        if (kind === \"param\") {\n            if (path.length === 0) {\n                // `params` alone is a variable, not a value we can resolve\n                throw new Error(ERROR_MESSAGES.PARAM_PATH_NOT_FOUND(this.paramsName ?? \"params\", this.params));\n            }\n\n            return { kind: \"param\", path, transformer, locale };\n        }\n\n        const pathString = path.join(\".\");\n        const property = this.schema.properties.find(w => w.getAssignmentPath() == pathString);\n\n        if (property == null) {\n            // `.length` on a string/array property — a real schema property named\n            // `length` wins (checked above); otherwise treat it as a transformer\n            if (path.length > 1 && path[path.length - 1] === \"length\" && transformer == null) {\n                const parentPath = path.slice(0, -1).join(\".\");\n                const parent = this.schema.properties.find(w => w.getAssignmentPath() == parentPath);\n\n                // Vector is deliberately absent. Its length is the dimension count declared\n                // in the schema — a constant, not data — so a filter on it answers a question\n                // nobody asks, and pushing it down would need `json_array_length` on a\n                // backend storing JSON and something else entirely on one with a native\n                // vector column. Not parsing it leaves a clear error instead of a dialect gap.\n                if (parent != null && (parent.type === SchemaTypes.String || parent.type === SchemaTypes.Array)) {\n                    return { kind: \"property\", property: parent, transformer: \"length\", locale: null };\n                }\n            }\n\n            throw new Error(ERROR_MESSAGES.PROPERTY_NOT_FOUND(pathString));\n        }\n\n        return { kind: \"property\", property, transformer, locale };\n    }\n\n    /**\n     * A call on a parenthesised value: `(x.name).toLowerCase()`, `(x.age + 1).length`. Any operand can\n     * receive one here, unlike a property chain, which carries at most one transform.\n     */\n    private withGroupCall(operand: Operand): Operand {\n        let receiver = operand;\n\n        while (this.stream.isPunctuation(\".\") || this.stream.isPunctuation(\"?.\")) {\n            const segment = this.stream.peek(1);\n\n            if (segment == null || segment.kind !== \"identifier\") {\n                break;\n            }\n\n            if (segment.value === \"length\" && !this.stream.isPunctuation(\"(\", 2)) {\n                this.stream.next();\n                this.stream.next();\n\n                receiver = { kind: \"arithmetic\", call: \"length\", left: receiver, right: noArgument() };\n                continue;\n            }\n\n            const transform = TRANSFORM_METHODS[segment.value];\n\n            if (transform != null) {\n                this.stream.next();\n                this.stream.next();\n                this.stream.expectPunctuation(\"(\");\n                this.stream.expectPunctuation(\")\");\n\n                receiver = {\n                    kind: \"arithmetic\",\n                    call: transform.transformer,\n                    left: receiver,\n                    right: transform.locale == null ? noArgument() : { kind: \"value\", value: transform.locale, transformer: null, locale: null }\n                };\n                continue;\n            }\n\n            // A comparator method needs a property target, which only an ungrouped chain produces\n            if (COMPARATOR_METHODS[segment.value] != null && receiver.kind === \"property\") {\n                this.stream.next();\n                this.stream.next();\n                this.stream.expectPunctuation(\"(\");\n                const argument = this.parseOperand();\n                this.stream.expectPunctuation(\")\");\n\n                if (argument.kind !== \"property\" && argument.kind !== \"value\" && argument.kind !== \"param\") {\n                    throw new Error(ERROR_MESSAGES.UNSUPPORTED(`'.${segment.value}()' on that argument`));\n                }\n\n                return { kind: \"method-call\", target: receiver, method: segment.value as MethodCallOperand[\"method\"], argument };\n            }\n\n            break;\n        }\n\n        return receiver;\n    }\n\n    private withValueTransformer(operand: ValueOperand): ValueOperand {\n        if (this.stream.isPunctuation(\".\")) {\n            const method = this.stream.peek(1);\n\n            // Stryker disable next-line all: documented equivalent cluster (see\n        // docs/mutation-backlog.md) — the guard's conjuncts each route to a rejection that\n        // collapses to NOT_PARSABLE with an indistinguishable message; 18 targeted tests\n        // killed none of these.\n        if (method != null && method.kind === \"identifier\" && TRANSFORM_METHODS[method.value] != null) {\n                this.stream.next(); // .\n                this.stream.next(); // method name\n                this.stream.expectPunctuation(\"(\");\n                this.stream.expectPunctuation(\")\");\n\n                operand.transformer = TRANSFORM_METHODS[method.value].transformer;\n                operand.locale = TRANSFORM_METHODS[method.value].locale;\n            }\n        }\n\n        return operand;\n    }\n\n    // #region Condition building\n\n    private buildComparison(left: Operand, operator: { comparator: Comparator, negated: boolean, strict: boolean }, right: Operand): Expression {\n\n        // methodCall == true/false — fold the boolean into negation\n        if (left.kind === \"method-call\") {\n            if (operator.comparator === \"equals\" && right.kind === \"value\" && typeof right.value === \"boolean\") {\n                const comparator = this.buildMethodComparator(left);\n                const comparedToFalse = right.value === false;\n                comparator.negated = comparator.negated !== (operator.negated !== comparedToFalse);\n                return comparator;\n            }\n\n            throw new Error(ERROR_MESSAGES.UNSUPPORTED(\"comparing a method call to a non-boolean\"));\n        }\n\n        if (right.kind === \"method-call\") {\n            throw new Error(ERROR_MESSAGES.UNSUPPORTED(\"method call on the right side of a comparison\"));\n        }\n\n        if (needsBrackets(left) || needsBrackets(right)) {\n            throw new Error(ERROR_MESSAGES.UNSUPPORTED(\n                \"a bitwise or nullish operator compared without brackets, which JavaScript reads the other way round\"\n            ));\n        }\n\n        if (left.kind === \"arithmetic\" || right.kind === \"arithmetic\" || left.kind === \"conditional\" || right.kind === \"conditional\") {\n            if (containsProperty(left) === false && containsProperty(right) === false) {\n                throw new Error(ERROR_MESSAGES.UNSUPPORTED(\"arithmetic that references no schema property\"));\n            }\n\n            return new ComparatorExpression({\n                comparator: operator.comparator,\n                negated: operator.negated,\n                strict: operator.strict,\n                left: this.createOperandExpression(left),\n                right: this.createOperandExpression(right)\n            });\n        }\n\n        if (left.kind === \"property\" && right.kind === \"property\") {\n            return new ComparatorExpression({\n                comparator: operator.comparator,\n                negated: operator.negated,\n                strict: operator.strict,\n                left: this.createPropertyExpression(left),\n                right: this.createPropertyExpression(right)\n            });\n        }\n\n        // Only a loose comparison coerces. `===` records `strict` and honouring it is the point.\n        if (left.kind === \"property\" && right.kind !== \"property\") {\n            return this.buildPropertyComparator(left, operator, right, /* applyConverter */ !operator.strict);\n        }\n\n        if (right.kind === \"property\" && left.kind !== \"property\") {\n            const swapped = { ...operator, comparator: SWAPPED_COMPARATORS[operator.comparator] };\n            return this.buildPropertyComparator(right, swapped, left, /* applyConverter */ !operator.strict);\n        }\n\n        const settled = this.settleConstantComparison(left, operator, right);\n\n        if (settled != null) {\n            return settled;\n        }\n\n        throw new Error(ERROR_MESSAGES.UNSUPPORTED(\"comparison requires a schema property on at least one side\"));\n    }\n\n    /**\n     * The answer a comparison of two constants gives, when that answer is `true`. The other answer\n     * excludes every row, which has no expression node.\n     */\n    private settleConstantComparison(left: Operand, operator: { comparator: Comparator, negated: boolean, strict: boolean }, right: Operand): Expression | null {\n        const leftValue = this.constantOf(left);\n        const rightValue = this.constantOf(right);\n\n        if (leftValue === UNKNOWN_UNTIL_ROW || rightValue === UNKNOWN_UNTIL_ROW) {\n            return null;\n        }\n\n        const answer = evaluate(new ComparatorExpression({\n            comparator: operator.comparator,\n            negated: operator.negated,\n            strict: operator.strict,\n            left: new ValueExpression({ value: leftValue }),\n            right: new ValueExpression({ value: rightValue })\n        }), {});\n\n        if (answer === true) {\n            return Expression.EMPTY;\n        }\n\n        // Params decided this, so the refusal must not be cached against the source: the same filter\n        // with other params can be a tautology.\n        if (left.kind === \"param\" || right.kind === \"param\") {\n            throw new ParamDependentParseError(ERROR_MESSAGES.UNSUPPORTED(\"a params comparison no row satisfies\"));\n        }\n\n        return null;\n    }\n\n    /** The value an operand holds already, for the operands that do not depend on a row. */\n    private constantOf(operand: Operand): unknown {\n        if (operand.kind === \"value\" && operand.transformer == null) {\n            return operand.value;\n        }\n\n        if (operand.kind === \"param\" && operand.transformer == null) {\n            this.structurallyDependsOnParams = true;\n            return resolveParamPath(this.paramsName ?? \"params\", operand.path, this.params);\n        }\n\n        return UNKNOWN_UNTIL_ROW;\n    }\n\n    private buildStandalone(operand: Operand): Expression {\n\n        if (operand.kind === \"method-call\") {\n            return this.buildMethodComparator(operand);\n        }\n\n        if (operand.kind === \"property\") {\n            // Truthy shorthand on `.length`: a length is truthy exactly when > 0\n            if (operand.transformer === \"length\") {\n                return this.buildPropertyComparator(operand, COMPARISON_OPERATORS[\">\"], { kind: \"value\", value: 0, transformer: null, locale: null }, /* applyConverter */ true);\n            }\n\n            // Truthy shorthand: `w.isActive` → isActive === true\n            return this.buildPropertyComparator(operand, COMPARISON_OPERATORS[\"===\"], { kind: \"value\", value: true, transformer: null, locale: null }, /* applyConverter */ true);\n        }\n\n        // A boolean-valued call standing alone IS the predicate\n        if (operand.kind === \"arithmetic\" && operand.call === \"matches\") {\n            return new ComparatorExpression({\n                comparator: \"equals\",\n                negated: false,\n                strict: false,\n                left: this.createOperandExpression(operand),\n                right: new ValueExpression({ value: true })\n            });\n        }\n\n        if (operand.kind === \"arithmetic\" || operand.kind === \"conditional\") {\n            throw new Error(ERROR_MESSAGES.UNSUPPORTED(\"arithmetic used as a condition rather than compared\"));\n        }\n\n        // Constant `true` — a tautology, which parseAnd/parseOr simplify away\n        if (operand.kind === \"value\" && operand.value === true && operand.transformer == null) {\n            return Expression.EMPTY;\n        }\n\n        throw new Error(ERROR_MESSAGES.UNSUPPORTED(\"a filter condition must reference a schema property\"));\n    }\n\n    private buildMethodComparator(operand: MethodCallOperand): ComparatorExpression {\n        const { target, method, argument } = operand;\n\n        if (target.kind === \"property\") {\n            if (argument.kind === \"property\") {\n                throw new Error(ERROR_MESSAGES.UNSUPPORTED(`.${method}() comparing two schema properties`));\n            }\n\n            // Method arguments skip type conversion — only the value serializer applies\n            return this.buildPropertyComparator(target, { comparator: COMPARATOR_METHODS[method], negated: false, strict: false }, argument, /* applyConverter */ false);\n        }\n\n        // [\"a\", \"b\"].includes(x.prop) / params.list.includes(x.prop) —\n        // membership test with the collection on the left\n        if (method === \"includes\" && argument.kind === \"property\") {\n            if (target.transformer != null) {\n                throw new Error(ERROR_MESSAGES.UNSUPPORTED(\"transform method on a collection used with .includes()\"));\n            }\n\n            return new ComparatorExpression({\n                comparator: \"includes\",\n                negated: false,\n                strict: false,\n                left: this.createValueExpression(target, argument.property, /* applyConverter */ false),\n                right: this.createPropertyExpression(argument)\n            });\n        }\n\n        throw new Error(ERROR_MESSAGES.UNSUPPORTED(`.${method}() on a non-property target`));\n    }\n\n    private buildPropertyComparator(property: PropertyOperand, operator: { comparator: Comparator, negated: boolean, strict: boolean }, value: ValueOperand | ParamOperand, applyConverter: boolean): ComparatorExpression {\n\n        const isStringMatch = operator.comparator === \"starts-with\" || operator.comparator === \"ends-with\" || operator.comparator === \"includes\";\n\n        // `.length` compares a NUMBER, so the paired property's serializer and\n        // type converter must not touch the value; and a length has no meaning\n        // inside a string-matching comparator\n        if (property.transformer === \"length\") {\n            if (isStringMatch) {\n                throw new Error(ERROR_MESSAGES.UNSUPPORTED(\"'.length' with startsWith/endsWith/includes\"));\n            }\n\n            return new ComparatorExpression({\n                comparator: operator.comparator,\n                negated: operator.negated,\n                strict: operator.strict,\n                left: this.createPropertyExpression(property),\n                right: this.createValueExpression(value, null, /* applyConverter */ false)\n            });\n        }\n\n        return new ComparatorExpression({\n            comparator: operator.comparator,\n            negated: operator.negated,\n            strict: operator.strict,\n            left: this.createPropertyExpression(property),\n            right: this.createValueExpression(value, property.property, applyConverter)\n        });\n    }\n\n    /**\n     * Any operand as an expression.\n     *\n     * Values inside arithmetic take no paired property: the result is a computed number, so the\n     * property's serializer and type converter do not describe it — the same reason `.length` skips\n     * them.\n     */\n    private createOperandExpression(operand: Operand): Expression {\n\n        if (operand.kind === \"conditional\") {\n            return new CallExpression({\n                call: \"conditional\",\n                expression: operand.condition,\n                arguments: [this.createOperandExpression(operand.whenTrue), this.createOperandExpression(operand.whenFalse)]\n            });\n        }\n\n        if (operand.kind === \"arithmetic\") {\n            return new CallExpression({\n                call: operand.call,\n                expression: this.createOperandExpression(operand.left),\n                arguments: operand.right === NO_ARGUMENT\n                    ? []\n                    : operand.extra == null\n                        ? [this.createOperandExpression(operand.right)]\n                        : [this.createOperandExpression(operand.right), this.createOperandExpression(operand.extra)]\n            });\n        }\n\n        if (operand.kind === \"property\") {\n            return this.createPropertyExpression(operand);\n        }\n\n        if (operand.kind === \"method-call\") {\n            throw new Error(ERROR_MESSAGES.UNSUPPORTED(\"a method call inside arithmetic\"));\n        }\n\n        return this.createValueExpression(operand, null, /* applyConverter */ false);\n    }\n\n    private createPropertyExpression(operand: PropertyOperand): Expression {\n        return asCall(new PropertyExpression({ property: operand.property }), operand.transformer, operand.locale);\n    }\n\n    private createValueExpression(operand: ValueOperand | ParamOperand, pairedProperty: PropertyInfo<any> | null, applyConverter: boolean): Expression {\n\n        if (operand.kind === \"param\") {\n            return asCall(\n                new ParamReferenceExpression({ paramPath: operand.path, pairedProperty, applyConverter }),\n                operand.transformer,\n                operand.locale\n            );\n        }\n\n        const expression = new ValueExpression({ value: resolvePairedValue(operand.value, pairedProperty, applyConverter) });\n\n        return asCall(expression, operand.transformer, operand.locale);\n    }\n\n    // #endregion\n}\n\n// #endregion\n\n// #region Template binding\n\n/**\n * Deep-clones a template into a consumer-facing tree, resolving parameter\n * placeholders against the supplied params.  Always clones so cached templates\n * can never be mutated by consumers.\n */\nconst bindExpression = (expression: Expression, paramsName: string | null, params: unknown): Expression => {\n\n    if (expression instanceof ParamReferenceExpression) {\n        const raw = resolveParamPath(paramsName ?? \"params\", expression.paramPath, params);\n\n        return new ValueExpression({ value: resolvePairedValue(raw, expression.pairedProperty, expression.applyConverter) });\n    }\n\n    if (expression instanceof ValueExpression) {\n        return new ValueExpression({ value: expression.value });\n    }\n\n    if (expression instanceof PropertyExpression) {\n        return new PropertyExpression({ property: expression.property });\n    }\n\n    if (expression instanceof ComparatorExpression) {\n        return new ComparatorExpression({\n            comparator: expression.comparator,\n            negated: expression.negated,\n            strict: expression.strict,\n            left: expression.left ? bindExpression(expression.left, paramsName, params) : undefined,\n            right: expression.right ? bindExpression(expression.right, paramsName, params) : undefined\n        });\n    }\n\n    if (expression instanceof OperatorExpression) {\n        return new OperatorExpression({\n            operator: expression.operator,\n            left: expression.left ? bindExpression(expression.left, paramsName, params) : undefined,\n            right: expression.right ? bindExpression(expression.right, paramsName, params) : undefined\n        });\n    }\n\n    if (expression instanceof CallExpression) {\n        return new CallExpression({\n            call: expression.call,\n            expression: bindExpression(expression.expression, paramsName, params),\n            arguments: expression.arguments.map(argument => bindExpression(argument, paramsName, params)),\n        });\n    }\n\n    return expression;\n}\n\n/**\n * Wraps an operand in the call a transform method named, if there was one.\n *\n * `Transformer` and `Call` share these three names, so the transform IS the call name. A locale\n * becomes the call's first argument, which is where it belongs — it qualifies the casing, not the\n * property.\n */\nconst asCall = (inner: Expression, transformer: Transformer | null, locale: string | null): Expression => {\n\n    if (transformer == null) {\n        return inner;\n    }\n\n    return new CallExpression({\n        call: transformer,\n        expression: inner,\n        arguments: locale == null ? [] : [new ValueExpression({ value: locale })],\n    });\n};\n\n// #endregion\n\n// #region Function source handling\n\n/** What an identifier in a filter body stands for. */\ntype Binding =\n    | { kind: \"property\", path: string[] }\n    | { kind: \"param\", path: string[] }\n    | { kind: \"inlined\", tokens: Token[] };\n\ntype Scope = Map<string, Binding>;\n\ntype FunctionShape = {\n    scope: Scope;\n    paramsName: string | null;\n    body: string;\n}\n\n/** Binds every name a destructuring pattern introduces to the path it reads. */\nconst bindPattern = (stream: TokenStream, kind: \"property\" | \"param\", path: string[], scope: Scope): void => {\n\n    if (!stream.matchPunctuation(\"{\")) {\n        const name = stream.next();\n\n        if (name.kind !== \"identifier\") {\n            throw new Error(ERROR_MESSAGES.UNSUPPORTED(`parameter '${name.value}'`));\n        }\n\n        scope.set(name.value, { kind, path });\n        return;\n    }\n\n    while (!stream.matchPunctuation(\"}\")) {\n        const key = stream.next();\n\n        if (key.kind !== \"identifier\") {\n            throw new Error(ERROR_MESSAGES.UNSUPPORTED(`destructured key '${key.value}'`));\n        }\n\n        if (stream.matchPunctuation(\":\")) {\n            bindPattern(stream, kind, [...path, key.value], scope);\n        } else {\n            scope.set(key.value, { kind, path: [...path, key.value] });\n        }\n\n        if (!stream.matchPunctuation(\",\")) {\n            stream.expectPunctuation(\"}\");\n            return;\n        }\n    }\n}\n\n/** Reads a filter's parameter list — the entity alone, or the `[entity, params]` pair — into a scope. */\nconst buildScope = (parameterNames: string, hasParams: boolean): { scope: Scope, paramsName: string | null } => {\n\n    const stream = new TokenStream(tokenize(parameterNames));\n    const scope: Scope = new Map();\n\n    if (!stream.matchPunctuation(\"[\")) {\n        bindPattern(stream, \"property\", [], scope);\n        return { scope, paramsName: null };\n    }\n\n    bindPattern(stream, \"property\", [], scope);\n\n    if (hasParams && stream.matchPunctuation(\",\") && !stream.isPunctuation(\"]\")) {\n        bindPattern(stream, \"param\", [], scope);\n    }\n\n    return { scope, paramsName: wholeParamsName(scope) };\n}\n\n/** The name the whole params object was given, when it was not destructured. Error messages only. */\nconst wholeParamsName = (scope: Scope): string | null => {\n    for (const [name, binding] of scope) {\n        if (binding.kind === \"param\" && binding.path.length === 0) {\n            return name;\n        }\n    }\n\n    return null;\n}\n\n/**\n * Splits stringified filter source into parameter names and the expression\n * body, unwrapping single-return block bodies.\n */\nconst resolveFunctionShape = (stringifiedFunction: string, hasParams: boolean): FunctionShape => {\n\n    const source = stringifiedFunction.trim();\n\n    let parameterNames: string;\n    let body: string;\n\n    // `function (x) { ... }` / `function name(x) { ... }` — what ES5-targeting\n    // transpilers rewrite every arrow filter into\n    const functionHead = /^function\\b[^(]*\\(/.exec(source);\n\n    if (functionHead != null) {\n        const parametersEnd = source.indexOf(\")\", functionHead[0].length);\n\n        if (parametersEnd === -1) {\n            throw new Error(\"Invalid Function\");\n        }\n\n        parameterNames = source.slice(functionHead[0].length, parametersEnd).trim();\n        body = source.slice(parametersEnd + 1).trim();\n    } else {\n        const arrowIndex = source.indexOf(\"=>\");\n\n        if (arrowIndex === -1) {\n            throw new Error(\"Invalid Function\");\n        }\n\n        parameterNames = source.substring(0, arrowIndex).trim();\n        body = source.substring(arrowIndex + 2).trim();\n\n        // Strip wrapping parens: (entity) or ([x, p])\n        if (parameterNames.startsWith(\"(\") && parameterNames.endsWith(\")\")) {\n            parameterNames = parameterNames.slice(1, -1).trim();\n        }\n    }\n\n    if (parameterNames.length === 0) {\n        throw new Error(\"Invalid Function\");\n    }\n\n    const { scope, paramsName } = buildScope(parameterNames, hasParams);\n\n    return { scope, paramsName, body };\n}\n\n// #endregion\n\n// #region Cache\n\ntype ParsedTemplate = {\n    template: Expression;\n    paramsName: string | null;\n}\n\n// Keyed by schema instance so identical filter source on different schemas can\n// never collide; entries live only as long as the schema does\nconst templateCache = new WeakMap<CompiledSchema<any>, Map<string, ParsedTemplate>>();\nconst MAX_CACHED_TEMPLATES_PER_SCHEMA = 1024;\n\nconst getCachedTemplate = (schema: CompiledSchema<any>, source: string): ParsedTemplate | null => {\n    return templateCache.get(schema)?.get(source) ?? null;\n}\n\nconst setCachedTemplate = (schema: CompiledSchema<any>, source: string, entry: ParsedTemplate) => {\n    let bySource = templateCache.get(schema);\n\n    if (bySource == null) {\n        bySource = new Map<string, ParsedTemplate>();\n        templateCache.set(schema, bySource);\n    }\n\n    // Filter source strings come from static code, so this cap should never be\n    // hit in practice — it only guards against unbounded dynamic generation.\n    // Stryker disable next-line all: the cap is a pure resource bound — every mutation of\n    // it (never clear, always clear, off-by-one) parses identically and differs only in\n    // memory growth, which no observable boundary can assert.\n    if (bySource.size >= MAX_CACHED_TEMPLATES_PER_SCHEMA) {\n        bySource.clear();\n    }\n\n    bySource.set(source, entry);\n}\n\n// #endregion\n\nexport const combineExpressions = (...expressions: Expression[]): Expression => {\n\n    if (expressions.length === 0) {\n        throw new Error(\"combineExpressions requires at least 1 expression\");\n    }\n\n\n    if (expressions.length === 1) {\n        return expressions[0];\n    }\n\n    // Start with the first expression\n    let result = expressions[0];\n\n    // Loop through remaining expressions and combine them\n    for (let i = 1; i < expressions.length; i++) {\n        result = new OperatorExpression({\n            operator: \"&&\",\n            left: result,\n            right: expressions[i]\n        });\n    }\n\n    return result;\n};\n\n/**\n * Parses an expression SOURCE FRAGMENT against one schema and one root name.\n *\n * `toExpression` starts from a function and works out its own roots. This starts from text, which\n * is what a caller has when it has split a larger predicate apart — `p.rank > 10` lifted out of\n * `([p, m]) => p.rank > 10 && m.won === true`.\n *\n * **A fragment naming anything other than `rootName` returns `NOT_PARSABLE`, and that is the\n * point.** It is how a caller discovers which side of a join a conjunct belongs to: parse it\n * against each side in turn, and exactly one succeeds for a single-side condition. A condition\n * spanning both fails against both, which is the correct answer — it cannot be pushed to either.\n *\n * No params: a fragment carrying a params reference has no bag to resolve it against here, so it\n * fails rather than binding to nothing.\n *\n * Deliberately NOT cached. The cache is keyed by function source, and a fragment is not a function\n * — two different lambdas can contain the same fragment text against different schemas.\n */\nexport const parseFragment = (schema: CompiledSchema<any>, body: string, rootName: string): Expression => {\n    try {\n        const stream = new TokenStream(tokenize(body));\n        const scope: Scope = new Map([[rootName, { kind: \"property\", path: [] }]]);\n        const parser = new ExpressionParser(schema, stream, scope, null, undefined);\n\n        return foldConstantCalls(parser.parse());\n    } catch {\n        // The failure is expected and informative — see above — so it is not logged. A caller that\n        // parses one conjunct against two schemas would otherwise warn on every successful split.\n        return Expression.NOT_PARSABLE;\n    }\n};\n\n/** What the parser refused, from a throw that may not be an `Error`. */\nconst refusalOf = (error: unknown): string =>\n    error instanceof Error ? error.message : String(error);\n\nexport const toExpression = <T extends any, P extends any>(schema: CompiledSchema<any>, fn: Filter<T> | ParamsFilter<T, P>, params?: P) => {\n    const stringifiedFunction = fn.toString();\n\n    const warn = (error: unknown) => logger.warn(\"Error parsing expression\", {\n        error,\n        collectionName: schema.collectionName,\n        params,\n        selector: stringifiedFunction\n    });\n\n    const cached = getCachedTemplate(schema, stringifiedFunction);\n\n    if (cached != null) {\n        // A cached failure — the warning was already logged when it was discovered. The template\n        // carries what was refused, and `.explain()` is usually called once the cache is warm.\n        if (Expression.isNotParsable(cached.template)) {\n            return cached.template;\n        }\n\n        try {\n            return foldConstantCalls(bindExpression(cached.template, cached.paramsName, params));\n        } catch (error) {\n            // Binding failures are param-dependent by nature — never cached\n            warn(error);\n            return Expression.notParsable(refusalOf(error));\n        }\n    }\n\n    let paramsName: string | null = null;\n    let template: Expression;\n    let structurallyDependsOnParams: boolean;\n\n    try {\n        const shape = resolveFunctionShape(stringifiedFunction, params != null);\n        const stream = new TokenStream(tokenize(shape.body));\n        const parser = new ExpressionParser(schema, stream, shape.scope, shape.paramsName, params);\n        paramsName = shape.paramsName;\n        template = parser.parseBody();\n        structurallyDependsOnParams = parser.structurallyDependsOnParams;\n    } catch (error) {\n        // Cache the failure so a hot query on an unsupported filter doesn't\n        // re-parse and re-warn on every execution.  Param-dependent failures are\n        // exempt: the same source can succeed with different params.\n        const refused = Expression.notParsable(refusalOf(error));\n\n        if (!(error instanceof ParamDependentParseError)) {\n            setCachedTemplate(schema, stringifiedFunction, { template: refused, paramsName: null });\n        }\n\n        warn(error);\n        return refused;\n    }\n\n    // Templates whose structure was resolved from param values are only\n    // valid for this exact params object — parse those fresh every time\n    if (!structurallyDependsOnParams) {\n        setCachedTemplate(schema, stringifiedFunction, { template, paramsName });\n    }\n\n    try {\n        return foldConstantCalls(bindExpression(template, paramsName, params));\n    } catch (error) {\n        warn(error);\n        return Expression.notParsable(refusalOf(error));\n    }\n}\n","import { QueryOptionExecutionTarget } from \"../plugins\";\nimport { CompiledSchemaCore, PropertyInfo } from \"../schema\";\n\n/**\n * JSON-safe form of a literal. Tagged only where JSON cannot carry the value as it is.\n *\n * See `Expression.toJson`.\n */\nexport type SerializedValue =\n    | string | number | boolean | null\n    | SerializedValue[]\n    | { date: string }\n    | { undefined: true }\n    | { number: \"NaN\" | \"Infinity\" | \"-Infinity\" }\n    | { regex: { source: string, flags: string } }\n    | { bigint: string };\n\n/** JSON-safe form of an expression tree. See `Expression.toJson`. */\nexport type SerializedExpression =\n    | { type: \"empty\" }\n    | { type: \"not-parsable\"; reason?: string }\n    | { type: \"operator\"; operator: Operator; left?: SerializedExpression; right?: SerializedExpression }\n    | {\n        type: \"comparator\";\n        comparator: Comparator;\n        negated: boolean;\n        strict: boolean;\n        left?: SerializedExpression;\n        right?: SerializedExpression;\n    }\n    | { type: \"call\"; call: Call; expression: SerializedExpression; arguments: SerializedExpression[] }\n    | { type: \"property\"; path: string }\n    | { type: \"value\"; value: SerializedValue };\n\nconst valueToJson = (value: unknown): SerializedValue => {\n    if (value === undefined) {\n        return { undefined: true };\n    }\n\n    if (value === null) {\n        return null;\n    }\n\n    if (value instanceof Date) {\n        // ISO rather than epoch millis: it survives a human reading the payload, and an invalid\n        // Date has no ISO form — so it is caught here rather than becoming a silent `null`.\n        return { date: value.toISOString() };\n    }\n\n    if (Array.isArray(value)) {\n        return value.map(valueToJson);\n    }\n\n    if (typeof value === \"number\" && Number.isFinite(value) === false) {\n        // `JSON.stringify` turns all three of these into `null`, which would compare as a different\n        // value entirely rather than failing.\n        return { number: Number.isNaN(value) ? \"NaN\" : value > 0 ? \"Infinity\" : \"-Infinity\" };\n    }\n\n    if (typeof value === \"string\" || typeof value === \"number\" || typeof value === \"boolean\") {\n        return value;\n    }\n\n    if (value instanceof RegExp) {\n        return { regex: { source: value.source, flags: value.flags } };\n    }\n\n    // `JSON.stringify` throws outright on a bigint rather than losing it quietly, so this is the one\n    // tag that turns a crash into a value\n    if (typeof value === \"bigint\") {\n        return { bigint: value.toString() };\n    }\n\n    throw new Error(\n        `Cannot serialize this filter value: only strings, numbers, booleans, null, undefined, Dates and arrays of those can cross a wire.  ` +\n        `Received: ${Object.prototype.toString.call(value)}`\n    );\n};\n\nconst valueFromJson = (value: SerializedValue): unknown => {\n    if (value === null || typeof value !== \"object\") {\n        return value;\n    }\n\n    if (Array.isArray(value)) {\n        return value.map(valueFromJson);\n    }\n\n    if (\"date\" in value) {\n        return new Date(value.date);\n    }\n\n    if (\"undefined\" in value) {\n        return undefined;\n    }\n\n    if (\"regex\" in value) {\n        return new RegExp(value.regex.source, value.regex.flags);\n    }\n\n    if (\"bigint\" in value) {\n        return BigInt(value.bigint);\n    }\n\n    return value.number === \"NaN\"\n        ? Number.NaN\n        : value.number === \"Infinity\" ? Number.POSITIVE_INFINITY : Number.NEGATIVE_INFINITY;\n};\n\nexport type ParsedExpression = {\n    expression: Expression;\n    // Will be memory when trying to query on an untracked computed property or on a function\n    executionTarget: QueryOptionExecutionTarget;\n}\n\n/**\n * The base class for all expression types.\n */\nexport abstract class Expression {\n    /** The type of the expression. */\n    abstract readonly type: ExpressionType;\n    /** The left-hand side of the expression (if applicable). */\n    left?: Expression;\n    /** The right-hand side of the expression (if applicable). */\n    right?: Expression;\n\n    constructor(left?: Expression, right?: Expression) {\n        this.left = left;\n        this.right = right;\n    }\n\n    static get EMPTY() {\n        return new EmptyExpression();\n    }\n\n    static get NOT_PARSABLE() {\n        return new NotParsableExpression();\n    }\n\n    /** `NOT_PARSABLE`, carrying what the parser refused. */\n    static notParsable(reason: string) {\n        return new NotParsableExpression(reason);\n    }\n\n    static isEmpty(expression: Expression) {\n        return expression.type === \"empty\" || expression instanceof EmptyExpression;\n    }\n\n    static isNotParsable(expression: Expression) {\n        return expression.type === \"not-parsable\" || expression instanceof NotParsableExpression;\n    }\n\n    /**\n     * Turns a tree into plain JSON, so a whole query can cross a wire.\n     *\n     * On the class rather than beside it, because this is the type's own REPRESENTATION — there is one\n     * right answer and it belongs with the thing being represented, next to `EMPTY` and `isEmpty`.\n     * Rendering a tree into some other language (`toSql`, `toMql`, `evaluate`) is a different kind of\n     * thing: there are many, each belongs to its consumer, and none of them is canonical.\n     *\n     * ## Why it is this small\n     *\n     * Of the seven node types a bound tree can contain, exactly one holds anything JSON cannot carry:\n     * `PropertyExpression`, whose live `PropertyInfo` has functions, a parent chain and caches. It\n     * reduces to a property PATH — `PropertyInfo.id` IS the dotted path, and `getProperty` is keyed by\n     * exactly that — so rebinding is one lookup.\n     *\n     * `ParamReferenceExpression` never appears: it is a parse-time placeholder that binding replaces\n     * with a plain `ValueExpression` holding the resolved value. A serialized tree is always already\n     * bound, so there is no params object to send alongside it.\n     *\n     * Switches on `type` rather than using the `isXExpression` guards, which live in `../assertions`\n     * and import this module — the guards test the same discriminant, so nothing is lost.\n     */\n    static toJson(expression: Expression): SerializedExpression {\n\n        if (expression.type === \"operator\") {\n            const operator = expression as OperatorExpression;\n\n            return {\n                type: \"operator\",\n                operator: operator.operator,\n                ...(operator.left != null && { left: Expression.toJson(operator.left) }),\n                ...(operator.right != null && { right: Expression.toJson(operator.right) }),\n            };\n        }\n\n        if (expression.type === \"comparator\") {\n            const comparator = expression as ComparatorExpression;\n\n            return {\n                type: \"comparator\",\n                comparator: comparator.comparator,\n                negated: comparator.negated,\n                strict: comparator.strict,\n                ...(comparator.left != null && { left: Expression.toJson(comparator.left) }),\n                ...(comparator.right != null && { right: Expression.toJson(comparator.right) }),\n            };\n        }\n\n        if (expression.type === \"call\") {\n            const call = expression as CallExpression;\n\n            return {\n                type: \"call\",\n                call: call.call,\n                expression: Expression.toJson(call.expression),\n                arguments: call.arguments.map(Expression.toJson),\n            };\n        }\n\n        if (expression.type === \"property\") {\n            const property = expression as PropertyExpression;\n\n            return {\n                type: \"property\",\n                // The dotted path, which is exactly the key `getProperty` is looking up\n                path: property.property.id,\n            };\n        }\n\n        if (expression.type === \"value\") {\n            const value = expression as ValueExpression;\n\n            return {\n                type: \"value\",\n                value: valueToJson(value.value),\n            };\n        }\n\n        if (expression.type === \"empty\") {\n            return { type: \"empty\" };\n        }\n\n        const reason = (expression as NotParsableExpression).reason;\n\n        return reason == null ? { type: \"not-parsable\" } : { type: \"not-parsable\", reason };\n    }\n\n    /**\n     * Rebuilds a tree from JSON, rebinding every property against `schema`.\n     *\n     * The schema is SUPPLIED rather than read out of the payload. A filter always belongs to a known\n     * collection, and the RECEIVER's schema is the authority on what its properties are — taking an\n     * id from the payload would mean rebinding against a schema the sender chose, which is backwards\n     * for anything crossing a trust boundary.\n     *\n     * @throws when a property path is not declared by `schema`. Not `NOT_PARSABLE`: on a receiver, a\n     * filter that silently stops filtering returns rows the requester excluded, which is the one\n     * failure here worse than an error.\n     */\n    static fromJson(json: SerializedExpression, schema: CompiledSchemaCore<any>): Expression {\n\n        const child = (node: SerializedExpression | undefined) => node == null ? undefined : Expression.fromJson(node, schema);\n\n        if (json.type === \"operator\") {\n            return new OperatorExpression({ operator: json.operator, left: child(json.left), right: child(json.right) });\n        }\n\n        if (json.type === \"comparator\") {\n            return new ComparatorExpression({\n                comparator: json.comparator,\n                negated: json.negated,\n                strict: json.strict,\n                left: child(json.left),\n                right: child(json.right),\n            });\n        }\n\n        if (json.type === \"call\") {\n            if (json.expression == null) {\n                throw new Error(\n                    `Cannot deserialize a filter: a '${json.call}' call carries no operand.  ` +\n                    `Collection: ${schema.collectionName}.`\n                );\n            }\n\n            return new CallExpression({\n                call: json.call,\n                expression: Expression.fromJson(json.expression, schema),\n                arguments: (json.arguments ?? []).map(argument => Expression.fromJson(argument, schema)),\n            });\n        }\n\n        if (json.type === \"property\") {\n            const property = schema.getProperty(json.path);\n\n            if (property == null) {\n                throw new Error(\n                    `Cannot deserialize a filter: this schema does not declare the property it names.  ` +\n                    `Property: ${json.path}, Collection: ${schema.collectionName}.  ` +\n                    `The two sides disagree about the shape of the data, so the filter cannot be applied.`\n                );\n            }\n\n            return new PropertyExpression({ property });\n        }\n\n        if (json.type === \"value\") {\n            return new ValueExpression({ value: valueFromJson(json.value) });\n        }\n\n        if (json.type === \"empty\") {\n            return Expression.EMPTY;\n        }\n\n        return json.reason == null ? Expression.NOT_PARSABLE : Expression.notParsable(json.reason);\n    }\n}\n\nexport class EmptyExpression extends Expression {\n    readonly type = \"empty\" as const;\n}\n\nexport class NotParsableExpression extends Expression {\n    readonly type = \"not-parsable\" as const;\n\n    /** What the parser refused, when it knows. `.explain()` prints it beside the source. */\n    readonly reason?: string;\n\n    constructor(reason?: string) {\n        super();\n        this.reason = reason;\n    }\n}\n\n/**\n * A class representing a comparison operation (e.g., equals, greater-than).\n */\nexport class ComparatorExpression extends Expression {\n    /** The type of the expression (always 'comparator'). */\n    readonly type = \"comparator\" as const;\n    /** The comparator operation (e.g., equals, greater-than). */\n    comparator: Comparator;\n    /** Whether the comparison is negated (e.g., not equals). */\n    negated: boolean;\n    /** Whether the comparison is strict (type-sensitive). */\n    strict: boolean;\n\n    constructor(\n        options: {\n            comparator: Comparator,\n            negated: boolean,\n            strict: boolean,\n            left?: Expression,\n            right?: Expression\n        }\n    ) {\n        super(options.left, options.right);\n        this.comparator = options.comparator;\n        this.negated = options.negated;\n        this.strict = options.strict;\n    }\n}\n\n/**\n * A class representing a logical operator (e.g., &&, ||).\n */\nexport class OperatorExpression extends Expression {\n    /** The type of the expression (always 'operator'). */\n    readonly type = \"operator\" as const;\n    /** The logical operator. */\n    operator: Operator;\n\n    constructor(options: { operator: Operator, left?: Expression, right?: Expression }) {\n        super(options.left, options.right);\n        this.operator = options.operator;\n    }\n}\n\n/**\n * A class representing a property path.\n */\nexport class PropertyExpression extends Expression {\n    /** The type of the expression (always 'property'). */\n    readonly type = \"property\" as const;\n    /** The property info for the path. */\n    property: PropertyInfo<any>;\n\n    constructor(options: { property: PropertyInfo<any> }) {\n        super();\n        this.property = options.property;\n    }\n}\n\nexport class CallExpression extends Expression {\n    readonly type = \"call\" as const;\n    call: Call;\n    expression: Expression;\n    /** Empty for a unary call. */\n    arguments: Expression[];\n\n    constructor(options: { call: Call, expression: Expression, arguments?: Expression[] }) {\n        super();\n        this.call = options.call;\n        this.expression = options.expression;\n        this.arguments = options.arguments ?? [];\n    }\n\n}\n\n/**\n * A class representing a literal value.\n */\nexport class ValueExpression extends Expression {\n    /** The type of the expression (always 'value'). */\n    readonly type = \"value\" as const;\n    /** The literal value. */\n    value: unknown;\n\n    constructor(options: {\n        value: unknown\n    }) {\n        super();\n        this.value = options.value;\n    }\n}\n\n\n/**\n * The set of possible expression types.\n */\nexport type ExpressionType = \"operator\" | \"comparator\" | \"property\" | \"value\" | \"call\" | \"empty\" | \"not-parsable\";\n\n/**\n * Supported value transformations that can be applied to values.\n * `length` reads the length of a string or array property.\n */\nexport type Transformer = \"to-lower-case\" | \"to-upper-case\" | \"length\";\n\n/**\n * The names claimed so far. A name absent here is not refused — `specs/filter-expressions.md` lists\n * both the refusals and their reasons, and is longer than this union.\n */\nexport type Call =\n    | \"to-lower-case\" | \"to-upper-case\" | \"length\" | \"trim\" | \"trim-start\" | \"trim-end\"\n    | \"index-of\" | \"substring\" | \"concat\" | \"replace\" | \"replace-all\"\n    | \"absolute\" | \"floor\" | \"ceiling\" | \"round\" | \"sign\" | \"square-root\" | \"power\"\n    | \"add\" | \"subtract\" | \"multiply\" | \"divide\" | \"modulo\"\n    | \"utc-year\" | \"utc-month\" | \"utc-day-of-month\" | \"utc-day-of-week\"\n    | \"utc-hour\" | \"utc-minute\" | \"utc-second\" | \"utc-millisecond\" | \"epoch-ms\"\n    | \"to-string\" | \"to-number\" | \"to-boolean\" | \"type-of\"\n    | \"some\" | \"every\"\n    | \"power\"\n    | \"bit-and\" | \"bit-or\" | \"bit-xor\" | \"bit-not\" | \"shift-left\" | \"shift-right\" | \"shift-right-unsigned\"\n    | \"conditional\" | \"coalesce\" | \"matches\";\n\n/**\n * Supported comparator operations for expressions.\n */\nexport type Comparator =\n    | \"equals\"\n    | \"starts-with\"\n    | \"includes\"\n    | \"ends-with\"\n    | \"greater-than\"\n    | \"greater-than-equals\"\n    | \"less-than\"\n    | \"less-than-equals\";\n\n/**\n * Supported logical operators for expressions.\n */\nexport type Operator = \"&&\" | \"||\";\n\n/**\n * A function that filters a value of type T and returns a boolean.\n */\nexport type Filter<T extends any> = (value: T) => boolean;\n\n/**\n * A function that filters a value of type T with additional parameters P.\n */\nexport type ParamsFilter<T extends any, P> = (payload: [T, P]) => boolean;\n\n/**\n * A filter that can be either a simple filter or a parameterized filter.\n */\nexport type CompositeFilter<T extends any, P = never> = Filter<T> | ParamsFilter<T, P>;\n\n/**\n * An object that can be filtered using a composite filter and optional parameters.\n */\nexport type Filterable<T extends any, P = any> = {\n    /** The filter function. */\n    filter: CompositeFilter<T, P>;\n    /** Optional parameters for the filter. */\n    params?: P;\n};","import { PropertyInfo } from \"../schema\";\nimport { CallExpression, Expression, PropertyExpression } from \"./types\";\n\n/**\n * An operand with the calls wrapping it, innermost first — the order they are applied in.\n *\n * The nodes rather than their names: a binary call carries arguments, and a consumer that only knows\n * the name renders `LOWER(col)` correctly and `col + ?` not at all.\n */\nexport type PeeledOperand = { operand: Expression, calls: CallExpression[] };\n\n/**\n * Separates an operand from the calls applied to it.\n *\n * `null` when there is no operand beneath the calls. Every consumer needs this to decide whether a\n * comparator side is a property or a value, so it lives here rather than in each translator.\n */\nexport function peelCalls(expression: Expression | undefined): PeeledOperand | null {\n    const calls: CallExpression[] = [];\n    let current = expression;\n\n    while (current != null && current.type === \"call\") {\n        calls.unshift(current as CallExpression);\n        current = (current as CallExpression).expression;\n    }\n\n    return current == null ? null : { operand: current, calls };\n}\n\nexport function childrenOf(expression: Expression): Expression[] {\n\n    if (expression.type === \"call\") {\n        const call = expression as CallExpression;\n\n        return [call.expression, ...(call.arguments ?? [])].filter(child => child != null);\n    }\n\n    const children: Expression[] = [];\n\n    if (expression.left != null) {\n        children.push(expression.left);\n    }\n\n    if (expression.right != null) {\n        children.push(expression.right);\n    }\n\n    return children;\n}\n\n/**\n * Extracts all properties referenced in an expression\n * @param expression The expression to analyze\n * @returns Array of PropertyInfo objects referenced in the expression\n */\nexport function getProperties(expression: Expression): PropertyInfo<any>[] {\n    const properties: PropertyInfo<any>[] = [];\n\n    function traverse(expr: Expression) {\n        // If this is a property expression, add it to our collection\n        if (expr.type === \"property\") {\n            properties.push((expr as PropertyExpression).property);\n        }\n\n        for (const child of childrenOf(expr)) {\n            traverse(child);\n        }\n    }\n\n    traverse(expression);\n    return properties;\n}\n\nexport function forEach(expression: Expression, callback: (expression: Expression) => boolean) {\n    function traverse(expr: Expression): boolean {\n        // Call the callback for this expression\n        // If callback returns false, stop traversing\n        if (!callback(expr)) {\n            return false;\n        }\n\n        for (const child of childrenOf(expr)) {\n            if (!traverse(child)) {\n                return false;\n            }\n        }\n\n        return true;\n    }\n\n    traverse(expression);\n}","import type { SchemaDefinition } from \"./SchemaDefinition\";\nimport type { SchemaBase } from \"./property/base/SchemaBase\";\nimport type { SchemaArray } from \"./property/types/SchemaArray\";\nimport type { SchemaVector } from \"./property/types/SchemaVector\";\nimport type { SchemaObject } from \"./property/types/SchemaObject\";\nimport type { PropertyInfo } from \"./PropertyInfo\";\nimport type { DeepPartial } from \"../types\";\nimport type { SchemaFunction } from \"./table\";\nimport type { SchemaOptional, SchemaTag } from \"./property/modifiers\";\nimport type { Branded } from \"../utilities/types\";\nimport type { SchemaSubscriptionOptions } from \"./communication/broadcast\";\n\nexport type DefaultValue<T, I = never> = T | ((injected: I) => T);\nexport type FunctionBody<TEntity, TResult> = (entity: TEntity, collectionName: CollectionName) => TResult;\nexport type IdType = string | number;\nexport type ForeignKey<T extends {}> = { \n    schema: CompiledSchema<T>, \n    property: PropertyInfo<T> \n};\n\nexport enum SchemaTypes {\n    Array = \"Array\",\n    Boolean = \"Boolean\",\n    Date = \"Date\",\n    Number = \"Number\",\n    Object = \"Object\",\n    String = \"String\",\n    Definition = \"Definition\",\n    Function = \"Function\",\n    Computed = \"Computed\",\n    /**\n     * Content in, reference out. The only type whose write shape differs from its stored\n     * shape, and a leaf on purpose — see `SchemaFile`.\n     */\n    File = \"File\",\n    /**\n     * A fixed-length list of numbers, carrying its dimension count — see `SchemaVector`.\n     *\n     * Value-shaped exactly like `s.array(s.number())`, which is why every array codegen\n     * handler accepts it. It is a distinct type only so a backend can recognise it and store\n     * it natively; nothing else needs to tell the two apart.\n     */\n    Vector = \"Vector\"\n}\n\nexport type ArrayShape = string | number | Date | {};\n\n\n/**\n * What a file property gives back: where the bytes are and what they are.\n *\n * Declared in core so `InferType` can name it. Core never reads or writes the bytes — it only\n * carries this shape — and `@routier/blob-plugin` is what puts one here.\n */\nexport type FileReferenceValue = {\n    /** Where the bytes live, content-addressed by the blob plugin. */\n    key: string;\n    /** Byte length. */\n    size: number;\n    /** Media type as supplied at upload. */\n    contentType: string;\n    /** SHA-256 of the bytes, lowercase hex. */\n    checksum: string;\n    /** The name to show a user. Not part of the key. */\n    fileName: string;\n};\n\n/**\n * What a file property ACCEPTS: content, or a reference you already have.\n *\n * `Blob` covers `File`, which is what an `<input type=\"file\">` yields. A reference is accepted\n * too, so re-saving an entity that was read from the database does not have to re-upload it.\n */\nexport type FileContentValue =\n    | FileReferenceValue\n    | Uint8Array\n    | ArrayBuffer\n    | Blob\n    | string;\n\n/**\n * What a vector property holds, in and out: a plain list of numbers.\n *\n * Named rather than written inline because the inference rules have to recognise it after a\n * modifier has erased which class produced it — the same problem `FileReferenceValue` solves\n * above, and for the same reason.\n */\nexport type VectorValue = number[];\n\n/**\n * What `s.string({ ... })` accepts.\n *\n * Declarations only. Core stores them and never acts on them; a backend that can use one does.\n */\nexport type StringOptions = {\n    /**\n     * The longest value the property is declared to hold.\n     *\n     * MySQL uses it for `VARCHAR(maxLength)`; without it every string column is\n     * `VARCHAR(255)`, which silently truncates longer values. Other backends ignore it. Core\n     * never validates a value against it — see `SchemaBase.maxLength`.\n     */\n    maxLength?: number;\n};\n\nexport type ExpandedProperty = ExpandedChildProperty & {\n    assignmentPath: string;\n    selectorPath: string;\n    properties: Map<string, ExpandedChildProperty>;\n    childDegree: number;\n};\n\nexport type ExpandedChildProperty = {\n    propertyName: string;\n    type: SchemaTypes;\n    isNullableOrOptional: boolean;\n    isReadonly: boolean;\n    isIdentity: boolean;\n    isUnmapped: boolean;\n}\n\nexport enum HashType {\n    Ids = \"Ids\",\n    Object = \"Object\"\n}\n\nexport type HashFunction<TEntity extends {}> = {\n    (entity: InferCreateType<TEntity>, type: HashType.Object): string;\n    (entity: InferType<TEntity>, type: HashType.Ids): string;\n}\n\nexport type GetHashTypeFunction<TEntity extends {}> = {\n    (entity: InferCreateType<TEntity>): HashType.Object;\n    (entity: InferType<TEntity>): HashType.Ids;\n}\n\nexport type ChangeTrackingType = \"proxy\" | \"diff\" | \"immutable\";\n\nexport type IndexType = \"single\" | \"compound\" | \"unique\" | \"primary-key\"\nexport type Index = {\n    properties: PropertyInfo<any>[],\n    type: IndexType;\n    name: string;\n}\n\n/**\n * Represents changes to subscriptions, categorizing them by modifications to\n * entities (additions, updates, removals) or query-driven removals.\n * @template T - The type of the entities in the subscription.\n */\nexport type SubscriptionChanges<T extends {}> = {\n    /**\n     * Entities that have been added to the subscription.\n     */\n    adds: InferType<T>[];\n    /**\n     * Entities that have been updated within the subscription.\n     */\n    updates: InferType<T>[];\n    /**\n     * Entities that have been removed from the subscription.\n     */\n    removals: InferType<T>[];\n    /**\n     * Entities that have been added/updated/removed from the subscription and it is unknown \n     * if the entities have been added/updated/removed.\n     */\n    unknown: InferType<T>[];\n}\n\nexport interface ISchemaSubscription<T extends {}> extends Disposable {\n    send(changes: SubscriptionChanges<T>): void;\n    onMessage(callback: (changes: SubscriptionChanges<T>) => void): void;\n}\n\nexport type Enrich<TEntity extends {}> = {\n    (entity: InferType<TEntity>, changeTrackingType: ChangeTrackingType): InferType<TEntity>;\n    (entity: InferCreateType<TEntity>, changeTrackingType: ChangeTrackingType): InferCreateType<TEntity>;\n}\nexport type Prepare<TEntity extends {}> = {\n    (entity: InferCreateType<TEntity>): InferCreateType<TEntity>;\n    (entity: InferType<TEntity>): InferType<TEntity>;\n}\nexport type Preprocess<TEntity extends {}> = {\n    (entity: InferCreateType<TEntity>): InferType<TEntity>;\n    (entity: InferType<TEntity>): InferType<TEntity>;\n}\n\nexport type SetProperties<TEntity extends {}> = (destination: DeepPartial<InferType<TEntity> | InferCreateType<TEntity>>, source: DeepPartial<InferType<TEntity> | InferCreateType<TEntity>>) => void;\n\nexport type CompiledSchemaCore<TEntity extends {}> = Omit<CompiledSchema<TEntity>, \"createSubscription\">;\n\nexport type CompiledSchemaWithMetadata<TEntity extends {}, TMetadata> = {\n    readonly metadata: TMetadata;\n} & CompiledSchema<TEntity>;\n\n/**\n * Represents a fully compiled schema with all utilities and metadata for an entity type.\n */\nexport type CompiledSchema<TEntity extends {}> = {\n\n    deserializePartial: (item: Record<string, unknown>, properties: PropertyInfo<TEntity>[]) => DeepPartial<InferType<TEntity>>;\n\n    createSubscription: (abortSignal?: AbortSignal, scope?: string, options?: SchemaSubscriptionOptions) => ISchemaSubscription<TEntity>;\n    /** Returns the property info for a given id (full path) */\n    getProperty: (id: string) => PropertyInfo<TEntity>;\n    /** Returns the ID of the given entity. */\n    getId: (entity: InferType<TEntity>) => IdType;\n    /** Returns a deep clone of the given entity. */\n    clone: (entity: InferType<TEntity>) => InferType<TEntity>;\n    /**\n     * Returns a deep clone of a record that is still in the STORAGE shape — renamed properties\n     * under their `from` names rather than their in-memory names.\n     *\n     * `clone` reads in-memory names, so it returns `undefined` for every renamed property of a\n     * stored record. Use this when copying rows a store holds before they have been deserialized.\n     * Generated on first call; schemas that are never cloned in storage shape never build it.\n     */\n    cloneStorage: (entity: InferType<TEntity>) => InferType<TEntity>;\n    /** Removes unmapped or extraneous properties from the entity. */\n    strip: (entity: InferType<TEntity>) => InferType<TEntity>;\n    /** Prepares a new entity for creation, applying defaults and transformations. */\n    prepare: Prepare<TEntity>;\n    /** Merges the source entity into the destination entity. */\n    merge: (destination: InferType<TEntity> | InferCreateType<TEntity>, source: InferType<TEntity>) => InferType<TEntity>;\n    /** Indicates if the schema has identity properties. */\n    hasIdentities: boolean;\n    /** List of properties that are identity keys. */\n    idProperties: PropertyInfo<TEntity>[];\n    /** All property metadata for the schema. */\n    properties: PropertyInfo<TEntity>[],\n    /** The hash type used for this schema. */\n    hashType: HashType;\n    /** Computes a hash for the given entity. */\n    hash: HashFunction<TEntity>;\n    /** Returns the hash type for the given entity. */\n    getHashType: GetHashTypeFunction<TEntity>;\n    /** Compares two entities for equality. */\n    compare: (a: InferType<TEntity>, fromDb: InferType<TEntity>) => boolean;\n    /** Deserializes an entity from storage format. */\n    deserialize: (entity: InferType<TEntity>) => InferType<TEntity>;\n    /** Sets 1 or many properties from the source object onto the destination object with change tracking. */\n    set: SetProperties<TEntity>;\n    /** Combines serializing and preparing an entity for saving. */\n    preprocess: Preprocess<TEntity>;\n    /** Combines deserializing and enriching an entity for selection. */\n    postprocess: Enrich<TEntity>;\n\n    /** Serializes an entity to storage format. */\n    serialize: (entity: InferType<TEntity>) => InferType<TEntity>;\n    /** Unique id for the schema. */\n    id: SchemaId,\n    /** The name of the collection for this schema. */\n    collectionName: CollectionName;\n    /** Returns all IDs for the given entity (usually a single-element tuple). */\n    getIds: (entity: InferType<TEntity>) => [IdType];\n    /** Enriches the entity with change tracking or other metadata. */\n    enrich: Enrich<TEntity>;\n    /** Indicates if the schema has identity keys. */\n    hasIdentityKeys: boolean;\n    /** Returns a deeply frozen (immutable) version of the entity. */\n    freeze: (entity: InferType<TEntity>) => InferType<TEntity>;\n    /** Enables change tracking on the entity. */\n    enableChangeTracking: (entity: InferType<TEntity>) => InferType<TEntity>;\n    /** The schema definition object. */\n    definition: SchemaDefinition<TEntity>;\n    /** Returns all indexes defined for this schema. */\n    getIndexes: () => Index[];\n    /** Compares two entities for Id equality. */\n    compareIds: (a: InferType<TEntity>, b: InferType<TEntity>) => boolean;\n}\n\nexport type PropertySerializer<T extends any> = (value: T) => string | number;\nexport type PropertyDeserializer<T extends any> = (value: string | number) => T;\n\n/**\n * A two-way transform between the application value and the stored value.\n *\n * Both directions may be async. Held as a live reference rather than stringified, so a\n * closure works and `injected` is a convenience rather than the only way in.\n */\nexport type PropertyTransform<T extends any> = {\n    /**\n     * Application value to stored value. Runs before the plugin sees it. May be async.\n     *\n     * `entity` is there for the one-way case: a transform with no `from` derives a value\n     * rather than converting one, which is what `computed` does.\n     */\n    to: (value: T, entity: Record<string, unknown>) => unknown | Promise<unknown>;\n\n    /**\n     * Stored value back to application value. Runs after the plugin returns it.\n     *\n     * Optional. Leave it out and the transform is one-way: the stored value is the value.\n     */\n    from?: (value: unknown) => T | Promise<T>;\n\n    /**\n     * What the column becomes, when the stored form is not the property's own type.\n     *\n     * Defaults to the property's own type, so nothing changes unless you say it does. A\n     * library that always produces text — a cipher, a compressor — sets this once, and the\n     * caller who uses that library never writes it.\n     */\n    stores?: SchemaTypes;\n\n    /**\n     * Whether a filter on this property can still run in the database.\n     *\n     * Defaults to `none`, which rejects the filter rather than returning wrong rows. Set\n     * `equality` only when `to` is deterministic.\n     */\n    comparable?: 'equality' | 'none';\n};\n\nexport type SchemaId = Branded<number, \"SchemaId\">;\nexport type CollectionName = Branded<string, \"CollectionName\">;\n\nexport type SchemaModifiers = \"default\" | \"deserialize\" |\n    \"identity\" | \"key\" |\n    \"nullable\" | \"optional\" |\n    \"readonly\" | \"serialize\" |\n    \"unmapped\" | \"computed\" |\n    \"distinct\" | \"searchable\";\n\n/**\n * What a tagged property infers to.\n *\n * `tag()` is metadata and must not change a type, but `SchemaTag<T>` carries the same `T` as\n * whatever it wrapped without carrying which class that was. For a string `T` is already\n * `string`; for an object `T` is the map of child schemas, which only the `SchemaObject`\n * branch below knows how to unwrap. Falling through to the generic `SchemaBase` branch\n * therefore handed the raw map back, so `s.object({ key: s.string() }).tag('x')` typed\n * `key` as `SchemaString` instead of `string` — everything ran, and only the types lied.\n *\n * An array is distinguishable because `SchemaArray`'s parameter is the ELEMENT schema, so a\n * tagged array arrives here as a `SchemaBase` rather than a plain map.\n */\ntype InferTagged<C> = ResolveWrapped<C>;\n\n/**\n * What a wrapping modifier's inner type resolves to.\n *\n * `SchemaOptional`, `SchemaNullable` and `SchemaTag` all carry the same `C` as whatever they\n * wrapped, without carrying which class that was, so each has to work out what it is holding.\n * Three shapes are possible:\n *\n * - an already-resolved value (`string` from `s.string()`, a file reference from `s.file()`)\n * - an ELEMENT schema, which is what `SchemaArray` parameterises on\n * - a map of child schemas, which is what `SchemaObject` parameterises on\n *\n * Getting this wrong is silent. The map branch applied to an already-resolved object walks\n * its keys and infers `never` for each, so `s.file().optional()` typed as\n * `{ key: never, size: never, ... }` — which no value can satisfy and no test would catch at\n * runtime.\n */\ntype ResolveWrapped<C> =\n    C extends string | number | boolean | Date | FileReferenceValue ? C :\n    C extends VectorValue ? C :\n    C extends SchemaBase<any, any> ? InferPrimitive<C>[] :\n    { [K in keyof C]: InferPrimitive<C[K]> };\n\ntype InferPrimitive<T> =\n    T extends SchemaOptional<infer C, infer __> ? ResolveWrapped<C> :\n    T extends SchemaTag<infer C, infer __> ? InferTagged<C> :\n    // Before the generic `SchemaBase` branch below, which would see `X = number[]` and map\n    // the element through `InferPrimitive<number>` — no branch matches a bare `number`, so a\n    // vector would type as `never[]`: assignable from nothing, and invisible at runtime.\n    T extends SchemaVector<infer __, infer ___> ? VectorValue :\n    T extends SchemaArray<infer Y, infer __> ? InferPrimitive<Y>[]\n    : T extends SchemaObject<infer Obj, infer _> ?\n    { [K in keyof Obj]: InferPrimitive<Obj[K]> } : // Process nested objects\n    T extends SchemaFunction<infer F, infer __> ? F : T extends SchemaBase<infer X, infer _> ?\n    X extends Array<infer A> ? InferPrimitive<A>[] : X : // Extract the primitive type\n    never;\n\nexport type InferType<T> = T extends CompiledSchema<infer R> ? InferCompiledSchema<R> : T extends {} ? InferCompiledSchema<T> : T;\nexport type InferCreateType<T> = T extends CompiledSchema<infer R> ? InferCompiledCreateSchema<R> : T extends {} ? InferCompiledCreateSchema<T> : unknown;\nexport type InferMappedType<T> = T extends SchemaBase<infer K, infer __> ? InferType<K> : InferCompiledSchema<T>;\nexport type InferRoot<T> = T extends CompiledSchema<infer R> ? R : never;\n\ntype HasModifier<T, K extends keyof T, M extends SchemaModifiers> =\n    T[K] extends SchemaBase<any, infer Mods> ?\n    M extends Mods ? true : false :\n    false;\n\ntype IsPlainProperty<T, K extends keyof T> =\n    [\n        HasModifier<T, K, \"readonly\">,\n        HasModifier<T, K, \"optional\">,\n        HasModifier<T, K, \"nullable\">\n    ] extends [\n        false,\n        false,\n        false\n    ] ? true : false;\n\ntype IsCreateExcluded<T, K extends keyof T> =\n    [\n        HasModifier<T, K, \"identity\">,\n        HasModifier<T, K, \"computed\">,\n        HasModifier<T, K, \"unmapped\">\n    ] extends [\n        false,\n        false,\n        false\n    ] ? false : true;\n\ntype IsCreateOptional<T, K extends keyof T> =\n    [\n        HasModifier<T, K, \"optional\">,\n        HasModifier<T, K, \"default\">\n    ] extends [\n        false,\n        false\n    ] ? false : true;\n\ntype IsCreateNullable<T, K extends keyof T> =\n    HasModifier<T, K, \"nullable\"> extends true ? true : false;\n\n/**\n * What a property ACCEPTS on the way in, which is not always what it gives back.\n *\n * Only a file differs today: you assign content and read a reference. Matching on the read\n * type rather than on `SchemaFile` itself is deliberate — it keeps working through every\n * modifier. `s.file().optional()` is a `SchemaOptional`, `s.file().tag('x')` is a\n * `SchemaTag`, and neither carries the original class, so a check against the class alone\n * would silently stop accepting content the moment anyone added a modifier.\n *\n * Assignability is required in BOTH directions, and the tuple wrappers are load-bearing.\n * One-way `extends` matches `never` — which is assignable to everything — so a generic\n * property over `Record<string, unknown>` resolved to file content and broke the Dexie\n * plugin's types. It also matched any object that merely happens to have these five fields\n * plus more. Mutual assignability admits the reference shape and nothing else, and the\n * tuples stop the conditional distributing over a union.\n */\ntype InferWritePrimitive<T> =\n    [InferPrimitive<T>] extends [FileReferenceValue]\n    ? [FileReferenceValue] extends [InferPrimitive<T>] ? FileContentValue : InferPrimitive<T>\n    : InferPrimitive<T>;\n\ntype InferCreateProperty<T, K extends keyof T> =\n    IsCreateNullable<T, K> extends true ? null | InferWritePrimitive<T[K]> : InferWritePrimitive<T[K]>;\n\ntype InferCompiledSchema<T> = CoalesceEmpty<{\n    [K in keyof T as IsPlainProperty<T, K> extends true ? K : never]: InferPrimitive<T[K]>\n}, {\n        readonly [K in keyof T as HasModifier<T, K, \"readonly\"> extends true ? K : never]: InferPrimitive<T[K]>\n    }, {\n        [K in keyof T as HasModifier<T, K, \"optional\"> extends true ? K : never]?: InferPrimitive<T[K]>\n    }, {\n        [K in keyof T as HasModifier<T, K, \"nullable\"> extends true ? K : never]: null | InferPrimitive<T[K]>\n}>;\n\ntype InferCompiledCreateSchema<T> = {\n    [K in keyof T as IsCreateExcluded<T, K> extends true ? never\n        : IsCreateOptional<T, K> extends true ? K : never]?: InferCreateProperty<T, K>\n} & {\n    [K in keyof T as IsCreateExcluded<T, K> extends true ? never\n        : IsCreateOptional<T, K> extends true ? never : K]: InferCreateProperty<T, K>\n};\n\ntype IsEmptyObject<T> = keyof T extends never ? true : false;\ntype CoalesceEmpty<T1 extends {}, T2 extends {}, T3 extends {}, T4 extends {}> = (IsEmptyObject<T1> extends true ? {} : T1) & (IsEmptyObject<T2> extends true ? {} : T2) & (IsEmptyObject<T3> extends true ? {} : T3) & (IsEmptyObject<T4> extends true ? {} : T4);\n","/**\n * Levelled logging, resolved once.\n *\n * Three things about the previous implementation drove this shape:\n *\n *  - **There was no way to turn logging off.** `globalThis.__ROUTIER_DEBUG__` was only ever\n *    compared against `true`, so setting it to `false` did nothing — while\n *    `docs/how-to/debug-logging.md` documented exactly that as the way to force logging off.\n *    A documented switch that silently does nothing is worse than no switch.\n *  - **`NODE_ENV === 'test'` enabled it.** Every Jest run therefore logged, because Jest always\n *    sets `NODE_ENV=test`. Measured on the S7 stress scenario, which drives ~2,000 saves through\n *    a plugin that logs three lines per query: 12.4s with logging, ~6s without. Test runners also\n *    capture console output by snapshotting a stack trace per call, so the cost is far above what\n *    writing to a terminal would suggest — and the output buries whatever the failure was.\n *  - **It was all-or-nothing, and re-resolved per call.** An error could not be kept while debug\n *    was dropped, and every one of the ~97 call sites re-read `globalThis` and `process.env`.\n *\n * Levels are compared numerically against a value cached at module load. Measured against a\n * no-op console at 200k calls: an enabled call costs ~70ns, a call rejected by the gate ~3ns.\n * Building the arguments the call site passes in accounts for ~0.2ns of that 3ns, which is why\n * this keeps the ordinary `logger.debug(msg, payload)` signature instead of taking a thunk —\n * a lazy API would recover 0.3% of an enabled call's cost and would have to change every call\n * site to do it.\n */\n\n/** Ordered from most severe to most verbose. `silent` discards everything. */\nexport const LOG_LEVELS = ['silent', 'error', 'warn', 'info', 'debug'] as const;\n\nexport type LogLevel = (typeof LOG_LEVELS)[number];\n\n/** Numeric rank, so a gate is one integer comparison. */\nconst RANK: Record<LogLevel, number> = {\n    silent: 0,\n    error: 1,\n    warn: 2,\n    info: 3,\n    debug: 4,\n};\n\nconst isLogLevel = (value: unknown): value is LogLevel =>\n    typeof value === 'string' && (LOG_LEVELS as readonly string[]).includes(value);\n\n/**\n * Resolves the configured level, in precedence order.\n *\n * Ordered most specific first: an explicit level beats a boolean flag, a boolean flag beats an\n * environment variable, and an environment variable beats an inference from `NODE_ENV`. Anything\n * unrecognised is ignored rather than treated as an error — a typo'd level should not take down\n * an application, and `silent` is the safe direction to fall back to.\n */\nconst resolveLevel = (): LogLevel => {\n    if (typeof globalThis !== 'undefined') {\n        const g = globalThis as { __ROUTIER_LOG_LEVEL__?: unknown; __ROUTIER_DEBUG__?: unknown };\n\n        if (isLogLevel(g.__ROUTIER_LOG_LEVEL__)) {\n            return g.__ROUTIER_LOG_LEVEL__;\n        }\n\n        // Both directions honoured. `=== false` used to fall through to the NODE_ENV checks\n        // below and re-enable the logging it was asked to suppress.\n        if (g.__ROUTIER_DEBUG__ === true) return 'debug';\n        if (g.__ROUTIER_DEBUG__ === false) return 'silent';\n    }\n\n    // There is deliberately no `import.meta.env` branch, although the documentation used to\n    // promise one. It could never work: this package is bundled with rspack, which replaces\n    // `import.meta` with `undefined`, so the check would read the *library's* build-time\n    // environment rather than the application's — and referencing `import.meta` at all is a parse\n    // error under a CommonJS build target, which is how the test suite loads this file. Vite and\n    // similar apps set `__ROUTIER_LOG_LEVEL__` or `__ROUTIER_DEBUG__` from their own\n    // `import.meta.env`, which is what the docs now describe.\n    if (typeof process !== 'undefined' && process.env != null) {\n        if (isLogLevel(process.env.ROUTIER_LOG_LEVEL)) {\n            return process.env.ROUTIER_LOG_LEVEL as LogLevel;\n        }\n\n        const debug = process.env.DEBUG;\n        if (debug === 'routier' || debug === '*') return 'debug';\n\n        const env = process.env.NODE_ENV?.toLowerCase();\n\n        if (env === 'dev' || env === 'development') return 'debug';\n    }\n\n    // Warnings are on unless something turns them off.\n    //\n    // Routier warns when a query returns correct rows a slower way than it could, or when a filter\n    // compares types that can never match. Both are the caller's to act on, and a default of\n    // `silent` meant the only people who ever saw them were the ones who already knew to look.\n    return 'warn';\n};\n\nlet level: LogLevel = resolveLevel();\nlet rank = RANK[level];\n\n/**\n * Overrides the level for the rest of the process.\n *\n * The configuration above is read once, at import, which is what makes the gate cheap — but it\n * also means an application that decides its verbosity after startup, or a test that wants to\n * assert on output, has no way in. This is that way in.\n */\nexport const setLogLevel = (next: LogLevel): void => {\n    if (isLogLevel(next) === false) {\n        throw new Error(`Unknown log level \"${next}\". Expected one of: ${LOG_LEVELS.join(', ')}`);\n    }\n\n    level = next;\n    rank = RANK[next];\n};\n\nexport const getLogLevel = (): LogLevel => level;\n\n/** Re-reads the environment. For tests that change it after this module was imported. */\nexport const resetLogLevel = (): void => {\n    level = resolveLevel();\n    rank = RANK[level];\n};\n\n/**\n * Whether a message at this level would be emitted.\n *\n * For the rare call site whose *arguments* are expensive to build — a serialization, a deep\n * clone, a join over a large collection. An ordinary payload object is not worth guarding; see\n * the measurement in the header.\n */\nexport const isLogLevelEnabled = (at: LogLevel): boolean => rank >= RANK[at];\n\ntype ConsoleMethod = 'log' | 'info' | 'warn' | 'error' | 'debug' | 'table';\n\nconst emit = (at: LogLevel, method: ConsoleMethod, args: unknown[]) => {\n    if (rank < RANK[at]) {\n        return;\n    }\n\n    // Resolved at call time rather than captured once: test harnesses and browser devtools both\n    // replace console methods after modules have loaded, and a captured reference would keep\n    // writing past the replacement.\n    (console[method] as (...a: unknown[]) => void)(...args);\n};\n\nexport const logger = {\n    /** General-purpose output. Carried at `info`, since `log` names a console method, not a level. */\n    log: (...args: unknown[]): void => emit('info', 'log', args),\n    info: (...args: unknown[]): void => emit('info', 'info', args),\n    warn: (...args: unknown[]): void => emit('warn', 'warn', args),\n    error: (...args: unknown[]): void => emit('error', 'error', args),\n    debug: (...args: unknown[]): void => emit('debug', 'debug', args),\n    /** Diagnostic tabular output; verbose by nature, so it sits at `debug`. */\n    table: (...args: unknown[]): void => emit('debug', 'table', args),\n};\n","__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n        if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n            Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n        }\n    }\n};","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","// define __esModule on exports\n__webpack_require__.r = (exports) => {\n\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n\t}\n\tObject.defineProperty(exports, '__esModule', { value: true });\n};","export * from './callSource';\nexport * from './evaluate';\nexport * from './fold';\nexport * from './parser';\nexport * from './types';\nexport * from './utils';\nexport * from './constants';"],"names":["EXPRESSION_TYPES","isDate","assertDate","data","TypeError","assertIsNotNull","message","assertIsArray","Array","assertString","assertInstanceOf","value","Instance","assertIsNumber","isObjectWithType","isExpression","isOperatorExpression","isComparatorExpression","isPropertyExpression","isValueExpression","isCallExpression","isEmptyExpression","isNotParsableExpression","CALL_SOURCE","renderCallAsJs","call","renderOperand","renderArgs","source","operand","pattern","args","EXPRESSION_TYPE_SET","Object","UNRESOLVED","Symbol","ARITHMETIC","left","right","applyCall","String","lower","RegExp","arithmetic","operandValue","expression","row","condition","evaluate","undefined","inner","argument","resolved","equals","strict","Date","compare","comparator","asComparable","a","b","comparable","evaluateComparator","item","result","toPredicate","toStrictPredicate","Error","CallExpression","ComparatorExpression","OperatorExpression","ValueExpression","childrenOf","FOLDABLE","Set","COERCES_TO_TEXT","isFrozenPrimitive","readsAProperty","isConstant","foldConstantCalls","folded","foldedOperandValue","calls","outermost","logger","SchemaTypes","Expression","PropertyExpression","ERROR_MESSAGES","path","params","JSON","parseUnknown","ParamDependentParseError","converters","v","Boolean","Number","MULTI_CHARACTER_PUNCTUATION","SINGLE_CHARACTER_PUNCTUATION","sourceKeyed","entries","STRING_ESCAPES","regexCanStartHere","tokens","previous","isIdentifierStart","char","isIdentifierPart","isDigit","isHexDigit","decodeCodeEscape","backslashIndex","kind","start","end","parseInt","length","digits","d","tokenize","i","inClass","j","current","flags","quote","chunks","expressions","escaped","decoded","depth","at","closing","nextChar","radixPrefix","signLength","multi","w","TokenStream","bracketed","offset","token","after","COMPARISON_OPERATORS","LOOSER_THAN_COMPARISON","needsBrackets","MULTIPLICATIVE_OPERATORS","ADDITIVE_OPERATORS","SHIFT_OPERATORS","BITWISE_AND_OPERATORS","BITWISE_XOR_OPERATORS","BITWISE_OR_OPERATORS","COALESCE_OPERATORS","containsProperty","DECLARATION_KEYWORDS","UNKNOWN_UNTIL_ROW","NO_ARGUMENT","noArgument","NEVER","and","or","COMPARATOR_METHODS","TRANSFORM_METHODS","SWAPPED_COMPARATORS","ParamReferenceExpression","options","resolveParamPath","paramsName","name","resolvePairedValue","pairedProperty","applyConverter","ExpressionParser","schema","stream","scope","answer","keyword","next","endsHere","whenTrue","subject","matching","pending","everyLabel","byDefault","anyCaseBroke","label","test","body","reached","term","afterSwitch","noCaseMatched","whenFalse","operatorToken","nested","operators","conditional","grouped","pieces","only","alreadyText","BigInt","method","numberToken","elements","element","array","root","binding","transformer","locale","segment","paramPath","pathString","property","parentPath","parent","receiver","transform","operator","comparedToFalse","swapped","settled","leftValue","rightValue","target","isStringMatch","asCall","bindExpression","raw","bindPattern","key","buildScope","parameterNames","hasParams","Map","wholeParamsName","resolveFunctionShape","stringifiedFunction","functionHead","parametersEnd","arrowIndex","templateCache","WeakMap","MAX_CACHED_TEMPLATES_PER_SCHEMA","getCachedTemplate","setCachedTemplate","entry","bySource","combineExpressions","parseFragment","rootName","parser","refusalOf","error","toExpression","fn","warn","cached","template","structurallyDependsOnParams","shape","refused","valueToJson","valueFromJson","EmptyExpression","NotParsableExpression","reason","json","child","node","peelCalls","children","getProperties","properties","traverse","expr","forEach","callback","HashType","LOG_LEVELS","RANK","isLogLevel","resolveLevel","globalThis","g","process","debug","env","level","rank","setLogLevel","getLogLevel","resetLogLevel","isLogLevelEnabled","emit","console"],"mappings":"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"}