@routier/core 0.6.0 → 0.8.0

package/dist/plugins/index.cjs

@@ -6,6 +6,7 @@ __webpack_require__.d(__webpack_exports__, {
   assertIsArray: () => (assertIsArray),
   assertIsNotNull: () => (assertIsNotNull),
   assertString: () => (assertString),
+  isCallExpression: () => (isCallExpression),
   isComparatorExpression: () => (isComparatorExpression),
   isOperatorExpression: () => (isOperatorExpression),
   isPropertyExpression: () => (isPropertyExpression),
@@ -81,6 +82,11 @@ function isObjectWithType(value) {
  */ function isValueExpression(value) {
     return isObjectWithType(value) && value.type === "value";
 }
+/**
+ * Type guard: narrows `value` to `CallExpression` when it is an object with `type === "call"`.
+ */ function isCallExpression(value) {
+    return isObjectWithType(value) && value.type === "call";
+}
 /**
  * Type guard: narrows `value` to `EmptyExpression` when it is an object with `type === "empty"`.
  */ function isEmptyExpression(value) {
@@ -401,45 +407,374 @@ __webpack_require__.d(__webpack_exports__, {
 }
 
 
+},
+429(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.d(__webpack_exports__, {
+  a: () => (renderCallAsJs)
+});
+const CALL_SOURCE = {
+    "to-lower-case": {
+        form: "method",
+        name: "toLowerCase"
+    },
+    "to-upper-case": {
+        form: "method",
+        name: "toUpperCase"
+    },
+    "length": {
+        form: "property",
+        name: "length"
+    },
+    "trim": {
+        form: "method",
+        name: "trim"
+    },
+    "trim-start": {
+        form: "method",
+        name: "trimStart"
+    },
+    "trim-end": {
+        form: "method",
+        name: "trimEnd"
+    },
+    "index-of": {
+        form: "method",
+        name: "indexOf"
+    },
+    "substring": {
+        form: "method",
+        name: "substring"
+    },
+    "concat": {
+        form: "method",
+        name: "concat"
+    },
+    "replace": {
+        form: "method",
+        name: "replace"
+    },
+    "replace-all": {
+        form: "method",
+        name: "replaceAll"
+    },
+    "absolute": {
+        form: "function",
+        name: "Math.abs"
+    },
+    "floor": {
+        form: "function",
+        name: "Math.floor"
+    },
+    "ceiling": {
+        form: "function",
+        name: "Math.ceil"
+    },
+    "round": {
+        form: "function",
+        name: "Math.round"
+    },
+    "sign": {
+        form: "function",
+        name: "Math.sign"
+    },
+    "square-root": {
+        form: "function",
+        name: "Math.sqrt"
+    },
+    "add": {
+        form: "operator",
+        symbol: "+"
+    },
+    "subtract": {
+        form: "operator",
+        symbol: "-"
+    },
+    "multiply": {
+        form: "operator",
+        symbol: "*"
+    },
+    "divide": {
+        form: "operator",
+        symbol: "/"
+    },
+    "modulo": {
+        form: "operator",
+        symbol: "%"
+    },
+    "utc-year": {
+        form: "method",
+        name: "getUTCFullYear"
+    },
+    "utc-month": {
+        form: "method",
+        name: "getUTCMonth"
+    },
+    "utc-day-of-month": {
+        form: "method",
+        name: "getUTCDate"
+    },
+    "utc-day-of-week": {
+        form: "method",
+        name: "getUTCDay"
+    },
+    "utc-hour": {
+        form: "method",
+        name: "getUTCHours"
+    },
+    "utc-minute": {
+        form: "method",
+        name: "getUTCMinutes"
+    },
+    "utc-second": {
+        form: "method",
+        name: "getUTCSeconds"
+    },
+    "utc-millisecond": {
+        form: "method",
+        name: "getUTCMilliseconds"
+    },
+    "epoch-ms": {
+        form: "method",
+        name: "getTime"
+    },
+    "to-string": {
+        form: "function",
+        name: "String"
+    },
+    "to-number": {
+        form: "function",
+        name: "Number"
+    },
+    "to-boolean": {
+        form: "function",
+        name: "Boolean"
+    },
+    "type-of": {
+        form: "prefix",
+        keyword: "typeof"
+    },
+    "some": {
+        form: "method",
+        name: "some"
+    },
+    "every": {
+        form: "method",
+        name: "every"
+    },
+    // `Math.pow(a, b)` parses to the same call; `**` is the shorter of the two spellings
+    "power": {
+        form: "operator",
+        symbol: "**"
+    },
+    "bit-and": {
+        form: "operator",
+        symbol: "&"
+    },
+    "bit-or": {
+        form: "operator",
+        symbol: "|"
+    },
+    "bit-xor": {
+        form: "operator",
+        symbol: "^"
+    },
+    "shift-left": {
+        form: "operator",
+        symbol: "<<"
+    },
+    "shift-right": {
+        form: "operator",
+        symbol: ">>"
+    },
+    "shift-right-unsigned": {
+        form: "operator",
+        symbol: ">>>"
+    },
+    "bit-not": {
+        form: "prefix",
+        keyword: "~"
+    },
+    "coalesce": {
+        form: "operator",
+        symbol: "??"
+    },
+    "conditional": {
+        form: "conditional"
+    },
+    "matches": {
+        form: "regex-test"
+    }
+};
+/**
+ * A call rendered as the JavaScript that produced it, from operand and argument text already
+ * rendered by the caller.
+ *
+ * Takes strings so one implementation serves a live tree and a serialized one.
+ */ /**
+ * Thunked because rendering a side can record a parameter, and `regex-test` emits its argument
+ * before its operand — so the two orders have to agree.
+ */ const renderCallAsJs = (call, renderOperand, renderArgs)=>{
+    const source = CALL_SOURCE[call];
+    if (source == null) {
+        const operand = renderOperand();
+        return `${operand}.${call}(${renderArgs().join(", ")})`;
+    }
+    if (source.form === "property") {
+        return `${renderOperand()}.${source.name}`;
+    }
+    if (source.form === "regex-test") {
+        const pattern = renderArgs()[0] ?? "?";
+        return `${pattern}.test(${renderOperand()})`;
+    }
+    if (source.form === "method") {
+        const operand = renderOperand();
+        return `${operand}.${source.name}(${renderArgs().join(", ")})`;
+    }
+    if (source.form === "function") {
+        const operand = renderOperand();
+        return `${source.name}(${[
+            operand,
+            ...renderArgs()
+        ].join(", ")})`;
+    }
+    if (source.form === "prefix") {
+        // `~x`, not `~ x` — a bitwise complement is written tight, unlike `typeof`
+        const operand = renderOperand();
+        return source.keyword === "~" ? `${source.keyword}${operand}` : `${source.keyword} ${operand}`;
+    }
+    if (source.form === "conditional") {
+        const operand = renderOperand();
+        const args = renderArgs();
+        return `${operand} ? ${args[0] ?? "?"} : ${args[1] ?? "?"}`;
+    }
+    const operand = renderOperand();
+    return `${[
+        operand,
+        ...renderArgs()
+    ].join(` ${source.symbol} `)}`;
+};
+
+
 },
 379(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
 __webpack_require__.d(__webpack_exports__, {
+  Vv: () => (operandValue),
+  _3: () => (evaluate),
+  gm: () => (UNRESOLVED),
   wS: () => (toStrictPredicate)
 });
 /* import */ var _assertions__rspack_import_0 = __webpack_require__(126);
 
 /** Reads a property or literal operand, or `UNRESOLVED` when the node is not one. */ const UNRESOLVED = Symbol("unresolved");
-const applyTransformer = (value, transformer)=>{
-    if (transformer == null) {
-        return value;
+const ARITHMETIC = {
+    "add": (left, right)=>left + right,
+    "subtract": (left, right)=>left - right,
+    "multiply": (left, right)=>left * right,
+    "divide": (left, right)=>left / right,
+    "modulo": (left, right)=>left % right,
+    "power": (left, right)=>left ** right,
+    "bit-and": (left, right)=>left & right,
+    "bit-or": (left, right)=>left | right,
+    "bit-xor": (left, right)=>left ^ right,
+    "shift-left": (left, right)=>left << right,
+    "shift-right": (left, right)=>left >> right,
+    "shift-right-unsigned": (left, right)=>left >>> right
+};
+const applyCall = (call, value, args)=>{
+    // Above the guard: a template renders null as "null" in JavaScript, so these two are total.
+    if (call === "to-string") {
+        return String(value);
+    }
+    if (call === "concat") {
+        return [
+            value,
+            ...args
+        ].map(String).join("");
     }
-    // A transformer applied to an absent value has no answer, and inventing one ("" for a missing
-    // string) is how a filter starts matching rows it should not.
+    // A call applied to an absent value has no answer, and inventing one ("" for a missing string)
+    // is how a filter starts matching rows it should not.
     if (value == null) {
         return UNRESOLVED;
     }
-    if (transformer === "to-lower-case") {
-        return typeof value === "string" ? value.toLowerCase() : UNRESOLVED;
-    }
-    if (transformer === "to-upper-case") {
-        return typeof value === "string" ? value.toUpperCase() : UNRESOLVED;
+    if (call === "to-lower-case" || call === "to-upper-case") {
+        if (typeof value !== "string") {
+            return UNRESOLVED;
+        }
+        const lower = call === "to-lower-case";
+        if (args.length === 0 || args[0] == null) {
+            return lower ? value.toLowerCase() : value.toUpperCase();
+        }
+        if (typeof args[0] !== "string") {
+            return UNRESOLVED;
+        }
+        try {
+            // An explicit locale is deterministic; dropping it answers a different question in Turkish.
+            return lower ? value.toLocaleLowerCase(args[0]) : value.toLocaleUpperCase(args[0]);
+        } catch  {
+            // An invalid language tag throws RangeError; no answer beats the host's default.
+            return UNRESOLVED;
+        }
     }
-    if (transformer === "length") {
+    if (call === "length") {
         return typeof value === "string" || Array.isArray(value) ? value.length : UNRESOLVED;
     }
+    if (call === "bit-not") {
+        return typeof value === "number" ? ~value : UNRESOLVED;
+    }
+    if (call === "matches") {
+        if (typeof value !== "string" || !(args[0] instanceof RegExp)) {
+            return UNRESOLVED;
+        }
+        // `test` advances `lastIndex` on a global or sticky pattern, and the pattern is shared with
+        // the cached template, where a source evaluates fresh in JavaScript.
+        return args[0].global || args[0].sticky ? new RegExp(args[0].source, args[0].flags).test(value) : args[0].test(value);
+    }
+    const arithmetic = ARITHMETIC[call];
+    if (arithmetic != null) {
+        return typeof value === "number" && typeof args[0] === "number" ? arithmetic(value, args[0]) : UNRESOLVED;
+    }
     return UNRESOLVED;
 };
-const operand = (expression, row)=>{
+const operandValue = (expression, row)=>{
     if (expression == null) {
         return UNRESOLVED;
     }
     if ((0,_assertions__rspack_import_0.isValueExpression)(expression)) {
-        return applyTransformer(expression.value, expression.transformer);
+        return expression.value;
     }
     if ((0,_assertions__rspack_import_0.isPropertyExpression)(expression)) {
         // Through the PropertyInfo, so a nested path and a `from`-renamed segment resolve the same
         // way every other consumer of the tree resolves them.
-        return applyTransformer(expression.property.getValue(row), expression.transformer);
+        return expression.property.getValue(row);
+    }
+    if ((0,_assertions__rspack_import_0.isCallExpression)(expression)) {
+        /**
+         * `??` and `? :` are the two calls whose whole job is to answer when something is absent, so
+         * they run before the guard that refuses an absent operand.
+         */ if (expression.call === "coalesce") {
+            const left = operandValue(expression.expression, row);
+            return left === UNRESOLVED || left == null ? operandValue(expression.arguments[0], row) : left;
+        }
+        if (expression.call === "conditional") {
+            const condition = evaluate(expression.expression, row);
+            if (condition === undefined) {
+                return UNRESOLVED;
+            }
+            return operandValue(expression.arguments[condition === true ? 0 : 1], row);
+        }
+        const inner = operandValue(expression.expression, row);
+        if (inner === UNRESOLVED) {
+            return UNRESOLVED;
+        }
+        const args = [];
+        for (const argument of expression.arguments){
+            const resolved = operandValue(argument, row);
+            if (resolved === UNRESOLVED) {
+                return UNRESOLVED;
+            }
+            args.push(resolved);
+        }
+        return applyCall(expression.call, inner, args);
     }
     return UNRESOLVED;
 };
@@ -524,8 +859,8 @@ const evaluateComparator = (comparator, left, right, strict)=>{
         return left === false && right === false ? false : undefined;
     }
     if ((0,_assertions__rspack_import_0.isComparatorExpression)(expression)) {
-        const left = operand(expression.left, row);
-        const right = operand(expression.right, row);
+        const left = operandValue(expression.left, row);
+        const right = operandValue(expression.right, row);
         if (left === UNRESOLVED || right === UNRESOLVED) {
             return undefined;
         }
@@ -563,19 +898,130 @@ const evaluateComparator = (comparator, left, right, strict)=>{
     };
 
 
+},
+43(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.d(__webpack_exports__, {
+  F5: () => (foldConstantCalls)
+});
+/* import */ var _assertions__rspack_import_0 = __webpack_require__(126);
+/* import */ var _evaluate__rspack_import_3 = __webpack_require__(379);
+/* import */ var _types__rspack_import_2 = __webpack_require__(27);
+/* import */ var _utils__rspack_import_1 = __webpack_require__(63);
+
+
+
+
+/** Calls fold may compute. Absent means a plugin declines it, so a new call is opt-in. */ const FOLDABLE = new Set([
+    "to-lower-case",
+    "to-upper-case",
+    "length",
+    "bit-not",
+    "matches",
+    "to-string",
+    "concat",
+    "add",
+    "subtract",
+    "multiply",
+    "divide",
+    "modulo",
+    "power",
+    "bit-and",
+    "bit-or",
+    "bit-xor",
+    "shift-left",
+    "shift-right",
+    "shift-right-unsigned",
+    "coalesce",
+    "conditional"
+]);
+/** `String(value)` on an object is the host's rendering — a Date carries its timezone. */ const COERCES_TO_TEXT = new Set([
+    "to-string",
+    "concat"
+]);
+const isFrozenPrimitive = (value)=>value == null || typeof value !== "object";
+const readsAProperty = (expression)=>{
+    if ((0,_assertions__rspack_import_0.isPropertyExpression)(expression)) {
+        return true;
+    }
+    return (0,_utils__rspack_import_1/* .childrenOf */.LU)(expression).some(readsAProperty);
+};
+/** A `conditional` holds a condition where every other call holds a value. */ const isConstant = (call)=>{
+    if (!FOLDABLE.has(call.call) || !call.arguments.every(_assertions__rspack_import_0.isValueExpression)) {
+        return false;
+    }
+    if (COERCES_TO_TEXT.has(call.call) && [
+        call.expression,
+        ...call.arguments
+    ].some((operand)=>(0,_assertions__rspack_import_0.isValueExpression)(operand) && !isFrozenPrimitive(operand.value))) {
+        return false;
+    }
+    return call.call === "conditional" ? !readsAProperty(call.expression) : (0,_assertions__rspack_import_0.isValueExpression)(call.expression);
+};
+/** Computes every call whose operand and arguments are all literals. Runs after `bindExpression`. */ const foldConstantCalls = (expression)=>{
+    if ((0,_assertions__rspack_import_0.isCallExpression)(expression)) {
+        const folded = new _types__rspack_import_2/* .CallExpression */.DG({
+            call: expression.call,
+            expression: foldConstantCalls(expression.expression),
+            arguments: expression.arguments.map(foldConstantCalls)
+        });
+        if (!isConstant(folded)) {
+            return folded;
+        }
+        const value = (0,_evaluate__rspack_import_3/* .operandValue */.Vv)(folded, {});
+        return value === _evaluate__rspack_import_3/* .UNRESOLVED */.gm ? folded : new _types__rspack_import_2/* .ValueExpression */.Ko({
+            value
+        });
+    }
+    if ((0,_assertions__rspack_import_0.isComparatorExpression)(expression)) {
+        return new _types__rspack_import_2/* .ComparatorExpression */.bQ({
+            comparator: expression.comparator,
+            negated: expression.negated,
+            strict: expression.strict,
+            left: expression.left == null ? undefined : foldConstantCalls(expression.left),
+            right: expression.right == null ? undefined : foldConstantCalls(expression.right)
+        });
+    }
+    if ((0,_assertions__rspack_import_0.isOperatorExpression)(expression)) {
+        return new _types__rspack_import_2/* .OperatorExpression */.fw({
+            operator: expression.operator,
+            left: expression.left == null ? undefined : foldConstantCalls(expression.left),
+            right: expression.right == null ? undefined : foldConstantCalls(expression.right)
+        });
+    }
+    return expression;
+};
+/** The value a literal operand binds as once the calls on it are computed. Throws if it cannot. */ const foldedOperandValue = (operand, calls)=>{
+    if (calls.length === 0) {
+        return operand.value;
+    }
+    // `peelCalls` returns calls innermost first, so the last one evaluates the whole chain.
+    const outermost = calls[calls.length - 1];
+    const value = readsAProperty(outermost) ? UNRESOLVED : operandValue(outermost, {});
+    if (value === UNRESOLVED) {
+        throw new Error(`'${calls.map((call)=>call.call).join("', '")}' cannot be computed on the literal ` + `'${String(operand.value)}'.`);
+    }
+    return value;
+};
+
+
 },
 91(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
 __webpack_require__.d(__webpack_exports__, {
   MY: () => (toExpression)
 });
-/* import */ var _utilities__rspack_import_3 = __webpack_require__(581);
+/* import */ var _utilities__rspack_import_4 = __webpack_require__(581);
 /* import */ var _assertions__rspack_import_0 = __webpack_require__(126);
 /* import */ var _schema__rspack_import_2 = __webpack_require__(537);
+/* import */ var _evaluate__rspack_import_3 = __webpack_require__(379);
+/* import */ var _fold__rspack_import_5 = __webpack_require__(43);
 /* import */ var _types__rspack_import_1 = __webpack_require__(27);
 
 
 
 
+
+
+
 // Error message constants
 const ERROR_MESSAGES = {
     PROPERTY_NOT_FOUND: (path)=>`Error parsing query, could not find PropertyInfo for path: ${path}`,
@@ -621,8 +1067,13 @@ const converters = {
 };
 // Longest first so multi-character punctuation wins over its prefixes
 const MULTI_CHARACTER_PUNCTUATION = [
+    ">>>",
     "===",
     "!==",
+    "**",
+    "<<",
+    ">>",
+    "??",
     "?.",
     "&&",
     "||",
@@ -659,9 +1110,17 @@ const SINGLE_CHARACTER_PUNCTUATION = new Set([
     "?",
     ":",
     "&",
-    "|"
+    "|",
+    "^",
+    "~"
 ]);
-const STRING_ESCAPES = {
+/**
+ * A lookup table keyed by source text.
+ *
+ * Null-prototype: `TRANSFORM_METHODS["toString"]` otherwise returns `Object.prototype.toString`,
+ * which is truthy, and the parser reads a method it does not support as one it does.
+ */ const sourceKeyed = (entries)=>Object.assign(Object.create(null), entries);
+const STRING_ESCAPES = sourceKeyed({
     "n": "\n",
     "r": "\r",
     "t": "\t",
@@ -669,6 +1128,24 @@ const STRING_ESCAPES = {
     "f": "\f",
     "v": "\v",
     "0": "\0"
+});
+/**
+ * Whether a `/` here opens a regex rather than dividing.
+ *
+ * A regex cannot follow a value. Everything else — the start of the source, an operator, an opening
+ * bracket, a comma — is a position where only a regex makes sense.
+ */ const regexCanStartHere = (tokens)=>{
+    const previous = tokens[tokens.length - 1];
+    if (previous == null) {
+        return true;
+    }
+    if (previous.kind === "number" || previous.kind === "string" || previous.kind === "bigint" || previous.kind === "regex") {
+        return false;
+    }
+    if (previous.kind === "identifier") {
+        return false;
+    }
+    return previous.value !== ")" && previous.value !== "]";
 };
 const isIdentifierStart = (char)=>/[a-zA-Z_$]/.test(char);
 const isIdentifierPart = (char)=>/[a-zA-Z0-9_$]/.test(char);
@@ -718,6 +1195,51 @@ const isHexDigit = (char)=>isDigit(char) || char >= "a" && char <= "f" || char >
             i++;
             continue;
         }
+        /**
+         * A regex literal, told from division by what came before it.
+         *
+         * `/` after a value — a number, string, identifier, `)` or `]` — is division. Anywhere else
+         * it opens a regex. That is the same rule a JavaScript lexer uses, and it is why `x.a / 2`
+         * and `/^a/.test(x.a)` can share a character.
+         */ if (char === "/" && source[i + 1] !== "/" && source[i + 1] !== "*" && regexCanStartHere(tokens)) {
+            let value = "";
+            let inClass = false;
+            let j = i + 1;
+            while(j < source.length){
+                const current = source[j];
+                if (current === "\\") {
+                    value += current + (source[j + 1] ?? "");
+                    j += 2;
+                    continue;
+                }
+                if (current === "[") {
+                    inClass = true;
+                } else if (current === "]") {
+                    inClass = false;
+                } else if (current === "/" && inClass === false) {
+                    break;
+                } else if (current === "\n") {
+                    throw new Error(ERROR_MESSAGES.UNSUPPORTED("unterminated regular expression"));
+                }
+                value += current;
+                j++;
+            }
+            if (j >= source.length) {
+                throw new Error(ERROR_MESSAGES.UNSUPPORTED("unterminated regular expression"));
+            }
+            j++;
+            let flags = "";
+            while(j < source.length && isIdentifierPart(source[j])){
+                flags += source[j];
+                j++;
+            }
+            i = j;
+            tokens.push({
+                kind: "regex",
+                value: `${value}\u0000${flags}`
+            });
+            continue;
+        }
         // Comments
         if (char === "/" && source[i + 1] === "/") {
             while(i < source.length && source[i] !== "\n"){
@@ -737,6 +1259,8 @@ const isHexDigit = (char)=>isDigit(char) || char >= "a" && char <= "f" || char >
         if (char === "'" || char === "\"" || char === "`") {
             const quote = char;
             let value = "";
+            const chunks = [];
+            const expressions = [];
             i++;
             while(i < source.length && source[i] !== quote){
                 if (source[i] === "\\") {
@@ -751,8 +1275,43 @@ const isHexDigit = (char)=>isDigit(char) || char >= "a" && char <= "f" || char >
                     i += 2;
                     continue;
                 }
-                if (quote === "`" && source[i] === "$" && source[i + 1] === "{") {
-                    throw new Error(ERROR_MESSAGES.UNSUPPORTED("template literal interpolation"));
+                /**
+                 * An interpolation. The literal so far becomes a chunk and the expression source is
+                 * kept whole, to be parsed by its own stream — nesting means the inner source can
+                 * hold anything, including another template.
+                 */ if (quote === "`" && source[i] === "$" && source[i + 1] === "{") {
+                    let depth = 1;
+                    let expression = "";
+                    let at = i + 2;
+                    while(at < source.length && depth > 0){
+                        const current = source[at];
+                        if (current === "{") {
+                            depth++;
+                        } else if (current === "}") {
+                            depth--;
+                            if (depth === 0) {
+                                break;
+                            }
+                        } else if (current === "'" || current === '"' || current === "`") {
+                            const closing = current;
+                            expression += current;
+                            at++;
+                            while(at < source.length && source[at] !== closing){
+                                expression += source[at] === "\\" ? source[at] + (source[at + 1] ?? "") : source[at];
+                                at += source[at] === "\\" ? 2 : 1;
+                            }
+                        }
+                        expression += source[at];
+                        at++;
+                    }
+                    if (depth > 0) {
+                        throw new Error(ERROR_MESSAGES.UNSUPPORTED("unterminated template interpolation"));
+                    }
+                    chunks.push(value);
+                    expressions.push(expression);
+                    value = "";
+                    i = at + 1;
+                    continue;
                 }
                 value += source[i];
                 i++;
@@ -761,6 +1320,17 @@ const isHexDigit = (char)=>isDigit(char) || char >= "a" && char <= "f" || char >
                 throw new Error(ERROR_MESSAGES.UNSUPPORTED("unterminated string literal"));
             }
             i++; // consume closing quote
+            if (expressions.length > 0) {
+                chunks.push(value);
+                tokens.push({
+                    kind: "template",
+                    value: JSON.stringify({
+                        chunks,
+                        expressions
+                    })
+                });
+                continue;
+            }
             tokens.push({
                 kind: "string",
                 value
@@ -804,6 +1374,14 @@ const isHexDigit = (char)=>isDigit(char) || char >= "a" && char <= "f" || char >
                     }
                 }
             }
+            if (source[i] === "n") {
+                i++;
+                tokens.push({
+                    kind: "bigint",
+                    value: value.replace(/_/g, "")
+                });
+                continue;
+            }
             tokens.push({
                 kind: "number",
                 value: value.replace(/_/g, "")
@@ -854,6 +1432,24 @@ const isHexDigit = (char)=>isDigit(char) || char >= "a" && char <= "f" || char >
     constructor(tokens){
         this.tokens = tokens;
     }
+    /** Inserts tokens at the cursor, bracketed so they keep their own precedence. */ splice(tokens) {
+        const bracketed = [
+            {
+                kind: "punctuation",
+                value: "("
+            },
+            ...tokens,
+            {
+                kind: "punctuation",
+                value: ")"
+            }
+        ];
+        this.tokens = [
+            ...this.tokens.slice(0, this.index),
+            ...bracketed,
+            ...this.tokens.slice(this.index)
+        ];
+    }
     get isAtEnd() {
         return this.index >= this.tokens.length;
     }
@@ -868,10 +1464,108 @@ const isHexDigit = (char)=>isDigit(char) || char >= "a" && char <= "f" || char >
         this.index++;
         return token;
     }
+    /** The tokens of one statement's value, through the `;` or block end that closes it. */ takeStatementTokens() {
+        const tokens = [];
+        let depth = 0;
+        while(!this.isAtEnd){
+            const token = this.peek();
+            if (token.kind === "punctuation") {
+                if (token.value === "(" || token.value === "[" || token.value === "{") {
+                    depth++;
+                } else if (token.value === ")" || token.value === "]" || token.value === "}") {
+                    if (depth === 0) {
+                        break;
+                    }
+                    depth--;
+                } else if (token.value === ";" && depth === 0) {
+                    this.next();
+                    break;
+                }
+            }
+            tokens.push(this.next());
+        }
+        if (tokens.length === 0) {
+            throw new Error(ERROR_MESSAGES.UNSUPPORTED("a declaration with no value"));
+        }
+        return tokens;
+    }
     isPunctuation(value, offset = 0) {
         const token = this.peek(offset);
         return token != null && token.kind === "punctuation" && token.value === value;
     }
+    /**
+     * Whether the group starting here holds a value rather than a condition.
+     *
+     * `(a && b)` is a boolean sub-expression; `(x.name ?? '') === 'ada'` and `(x.name).length` are
+     * values. Only the token after the matching bracket tells them apart, so the decision is made by
+     * looking ahead rather than by parsing one way and catching the failure — a rewind on exception
+     * would swallow a genuine syntax error inside the group and report it as something else.
+     */ groupIsValue() {
+        let depth = 0;
+        let at = this.index;
+        for(; at < this.tokens.length; at++){
+            const token = this.tokens[at];
+            if (token.kind !== "punctuation") {
+                continue;
+            }
+            if (token.value === "(") {
+                depth++;
+                continue;
+            }
+            if (token.value === ")") {
+                depth--;
+                if (depth === 0) {
+                    break;
+                }
+            }
+        }
+        const after = this.tokens[at + 1];
+        if (after == null || after.kind !== "punctuation") {
+            return false;
+        }
+        return COMPARISON_OPERATORS[after.value] != null || after.value === "." || after.value === "?.";
+    }
+    /** Whether a `?` sits at the top level of what is left, so this is a conditional. */ holdsConditional() {
+        let depth = 0;
+        for(let at = this.index; at < this.tokens.length; at++){
+            const token = this.tokens[at];
+            if (token.kind !== "punctuation") {
+                continue;
+            }
+            if (token.value === "(" || token.value === "[") {
+                depth++;
+            } else if (token.value === ")" || token.value === "]") {
+                depth--;
+            } else if (token.value === "?" && depth === 0) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /** Whether the group starting here is `( … ? … : … )` rather than a plain value. */ groupHoldsConditional() {
+        let depth = 0;
+        for(let at = this.index; at < this.tokens.length; at++){
+            const token = this.tokens[at];
+            if (token.kind !== "punctuation") {
+                continue;
+            }
+            if (token.value === "(") {
+                depth++;
+                continue;
+            }
+            if (token.value === ")") {
+                depth--;
+                if (depth === 0) {
+                    return false;
+                }
+                continue;
+            }
+            if (token.value === "?" && depth === 1) {
+                return true;
+            }
+        }
+        return false;
+    }
     matchPunctuation(value) {
         if (this.isPunctuation(value)) {
             this.index++;
@@ -885,12 +1579,104 @@ const isHexDigit = (char)=>isDigit(char) || char >= "a" && char <= "f" || char >
         }
     }
 }
-const COMPARATOR_METHODS = {
+/**
+ * Calls JavaScript binds LOOSER than a comparison.
+ *
+ * This grammar reads a comparison's operands as values, which puts these tighter than they belong:
+ * `x.flags & 6 === 2` is `x.flags & (6 === 2)` in JavaScript and would be read here as
+ * `(x.flags & 6) === 2`. The two answer differently, so an ungrouped one is refused rather than
+ * reinterpreted — the filter then runs in memory against the caller's own function, which is right by
+ * construction. Brackets say which was meant, and JavaScript itself makes an unbracketed `??` mix a
+ * syntax error for the same reason.
+ */ const LOOSER_THAN_COMPARISON = [
+    "bit-and",
+    "bit-or",
+    "bit-xor",
+    "coalesce"
+];
+const needsBrackets = (operand)=>operand.kind === "arithmetic" && operand.grouped !== true && LOOSER_THAN_COMPARISON.includes(operand.call);
+/** JavaScript precedence: `*`, `/`, `%` bind tighter than `+` and `-`. */ const MULTIPLICATIVE_OPERATORS = sourceKeyed({
+    "*": "multiply",
+    "/": "divide",
+    "%": "modulo"
+});
+const ADDITIVE_OPERATORS = sourceKeyed({
+    "+": "add",
+    "-": "subtract"
+});
+const SHIFT_OPERATORS = sourceKeyed({
+    "<<": "shift-left",
+    ">>": "shift-right",
+    ">>>": "shift-right-unsigned"
+});
+const BITWISE_AND_OPERATORS = sourceKeyed({
+    "&": "bit-and"
+});
+const BITWISE_XOR_OPERATORS = sourceKeyed({
+    "^": "bit-xor"
+});
+const BITWISE_OR_OPERATORS = sourceKeyed({
+    "|": "bit-or"
+});
+const COALESCE_OPERATORS = sourceKeyed({
+    "??": "coalesce"
+});
+/** Whether a schema property is reachable in here, which decides which side of a comparison it is. */ const containsProperty = (operand)=>{
+    if (operand.kind === "property") {
+        return true;
+    }
+    if (operand.kind === "conditional") {
+        // A comparison always names a schema property, so the condition alone settles it
+        return true;
+    }
+    if (operand.kind === "opaque") {
+        return operand.reads.some(containsProperty);
+    }
+    return operand.kind === "arithmetic" && (containsProperty(operand.left) || containsProperty(operand.right) || operand.extra != null && containsProperty(operand.extra));
+};
+const DECLARATION_KEYWORDS = new Set([
+    "const",
+    "let",
+    "var"
+]);
+/** An operand whose value only a row can supply. */ const UNKNOWN_UNTIL_ROW = Symbol("unknown until row");
+/** The empty argument slot of a unary call. Compared by identity, so a real `undefined` still counts. */ const NO_ARGUMENT = Object.freeze({
+    kind: "value",
+    value: undefined,
+    transformer: null,
+    locale: null
+});
+const noArgument = ()=>NO_ARGUMENT;
+/** A predicate no row satisfies. Never reaches a tree: no expression node means "match nothing". */ const NEVER = "never";
+const and = (left, right)=>{
+    if (_types__rspack_import_1/* .Expression.isEmpty */.r4.isEmpty(left)) {
+        return right;
+    }
+    if (_types__rspack_import_1/* .Expression.isEmpty */.r4.isEmpty(right)) {
+        return left;
+    }
+    return new _types__rspack_import_1/* .OperatorExpression */.fw({
+        operator: "&&",
+        left,
+        right
+    });
+};
+const or = (left, right)=>{
+    if (_types__rspack_import_1/* .Expression.isEmpty */.r4.isEmpty(left) || _types__rspack_import_1/* .Expression.isEmpty */.r4.isEmpty(right)) {
+        return _types__rspack_import_1/* .Expression.EMPTY */.r4.EMPTY;
+    }
+    return new _types__rspack_import_1/* .OperatorExpression */.fw({
+        operator: "||",
+        left,
+        right
+    });
+};
+const COMPARATOR_METHODS = sourceKeyed({
     startsWith: "starts-with",
     endsWith: "ends-with",
     includes: "includes"
-};
-const TRANSFORM_METHODS = {
+});
+const TRANSFORM_METHODS = sourceKeyed({
     toLowerCase: {
         transformer: "to-lower-case",
         locale: null
@@ -907,8 +1693,8 @@ const TRANSFORM_METHODS = {
         transformer: "to-upper-case",
         locale: "en-US"
     }
-};
-const COMPARISON_OPERATORS = {
+});
+const COMPARISON_OPERATORS = sourceKeyed({
     "==": {
         comparator: "equals",
         negated: false,
@@ -949,7 +1735,7 @@ const COMPARISON_OPERATORS = {
         negated: false,
         strict: false
     }
-};
+});
 const SWAPPED_COMPARATORS = {
     "equals": "equals",
     "greater-than": "less-than",
@@ -1020,16 +1806,21 @@ const resolveParamPath = (paramsName, path, data)=>{
  */ class ExpressionParser {
     schema;
     stream;
-    entityName;
+    scope;
     paramsName;
     params;
+    /**
+     * Whether this parses a value selector rather than a filter, and so reads a call it has no node for
+     * as an `OpaqueOperand` instead of refusing it.
+     */ readsValues;
     /** Set when a param value shaped the tree itself (e.g. x[p.name]) — such templates cannot be cached. */ structurallyDependsOnParams = false;
-    constructor(schema, stream, entityName, paramsName, params){
+    constructor(schema, stream, scope, paramsName, params, readsValues = false){
         this.schema = schema;
         this.stream = stream;
-        this.entityName = entityName;
+        this.scope = scope;
         this.paramsName = paramsName;
         this.params = params;
+        this.readsValues = readsValues;
     }
     parse() {
         const expression = this.parseOr();
@@ -1038,24 +1829,263 @@ const resolveParamPath = (paramsName, path, data)=>{
         }
         return expression;
     }
-    // || binds loosest, so it sits at the root of the parse
-    parseOr() {
-        let left = this.parseAnd();
-        while(this.stream.matchPunctuation("||")){
-            const right = this.parseAnd();
-            // A tautology (`true`) absorbs the whole disjunction
-            if (_types__rspack_import_1/* .Expression.isEmpty */.r4.isEmpty(left) || _types__rspack_import_1/* .Expression.isEmpty */.r4.isEmpty(right)) {
-                left = _types__rspack_import_1/* .Expression.EMPTY */.r4.EMPTY;
-                continue;
-            }
-            left = new _types__rspack_import_1/* .OperatorExpression */.fw({
-                operator: "||",
-                left,
-                right
-            });
+    parseBody() {
+        if (!this.stream.isPunctuation("{")) {
+            return this.parse();
         }
-        return left;
-    }
+        const answer = this.parseBlock();
+        if (!this.stream.isAtEnd) {
+            throw new Error(ERROR_MESSAGES.UNSUPPORTED(`unexpected token '${this.stream.peek()?.value}'`));
+        }
+        if (answer === NEVER) {
+            throw new Error(ERROR_MESSAGES.UNSUPPORTED("a predicate no row can satisfy"));
+        }
+        return answer;
+    }
+    /**
+     * What a value selector returns: one value, or the fields of an object literal.
+     *
+     * A block body is read only when it does nothing but return, which is what a transpiler makes of an
+     * arrow function. Anything more is refused, and the caller falls back to running the function.
+     */ parseSelector() {
+        const block = this.stream.matchPunctuation("{");
+        if (block) {
+            const keyword = this.stream.next();
+            if (keyword.kind !== "identifier" || keyword.value !== "return") {
+                throw new Error(ERROR_MESSAGES.UNSUPPORTED("a selector block that does more than return"));
+            }
+        }
+        const selected = this.stream.isPunctuation("{") ? this.parseObjectLiteral() : this.stream.isPunctuation("(") && this.stream.isPunctuation("{", 1) ? this.parseBracketedObjectLiteral() : this.parseInterpolation();
+        if (block) {
+            this.stream.matchPunctuation(";");
+            this.stream.expectPunctuation("}");
+        }
+        if (!this.stream.isAtEnd) {
+            throw new Error(ERROR_MESSAGES.UNSUPPORTED(`unexpected token '${this.stream.peek()?.value}'`));
+        }
+        return selected;
+    }
+    /** `({ … })`, the arrow body that returns an object. */ parseBracketedObjectLiteral() {
+        this.stream.expectPunctuation("(");
+        const fields = this.parseObjectLiteral();
+        this.stream.expectPunctuation(")");
+        return fields;
+    }
+    /**
+     * The fields of an object literal, each one value.
+     *
+     * A field's value is read without a top-level conditional, which needs brackets here: the look-ahead
+     * for a `?` does not stop at the comma that ends the field.
+     */ parseObjectLiteral() {
+        this.stream.expectPunctuation("{");
+        const fields = [];
+        while(!this.stream.matchPunctuation("}")){
+            const key = this.stream.next();
+            if (key.kind !== "identifier" && key.kind !== "string") {
+                throw new Error(ERROR_MESSAGES.UNSUPPORTED(`the object key '${key.value}'`));
+            }
+            fields.push({
+                name: key.value,
+                operand: this.stream.matchPunctuation(":") ? this.parseValue() : this.parseShorthand(key)
+            });
+            if (!this.stream.matchPunctuation(",")) {
+                this.stream.expectPunctuation("}");
+                break;
+            }
+        }
+        return fields;
+    }
+    /** `{ name }`, which reads what the parameter list bound `name` to. */ parseShorthand(key) {
+        const binding = key.kind === "identifier" ? this.scope.get(key.value) : undefined;
+        if (binding == null || binding.kind === "inlined") {
+            throw new Error(ERROR_MESSAGES.VARIABLE_VALUE(key.value));
+        }
+        return this.parseChain({
+            kind: binding.kind,
+            path: [
+                ...binding.path
+            ]
+        });
+    }
+    /** The expression a `{ … }` block answers with. */ parseBlock() {
+        this.stream.expectPunctuation("{");
+        const answer = this.parseStatements();
+        this.stream.expectPunctuation("}");
+        return answer;
+    }
+    /** Statements up to the one that returns. What follows a `return` is never read, as in JavaScript. */ parseStatements() {
+        if (this.stream.isPunctuation("}") || this.stream.isAtEnd) {
+            throw new Error(ERROR_MESSAGES.UNSUPPORTED("a block body that returns nothing"));
+        }
+        const keyword = this.stream.peek();
+        if (keyword == null || keyword.kind !== "identifier") {
+            throw new Error(ERROR_MESSAGES.UNSUPPORTED(`a statement starting '${keyword?.value}'`));
+        }
+        if (DECLARATION_KEYWORDS.has(keyword.value)) {
+            this.declare();
+            return this.parseStatements();
+        }
+        if (keyword.value === "return") {
+            this.stream.next();
+            const answer = this.parseReturnedCondition();
+            this.stream.matchPunctuation(";");
+            return answer;
+        }
+        if (keyword.value === "if") {
+            return this.parseIfStatement();
+        }
+        if (keyword.value === "switch") {
+            return this.parseSwitchStatement();
+        }
+        throw new Error(ERROR_MESSAGES.UNSUPPORTED(`the statement '${keyword.value}'`));
+    }
+    /**
+     * Binds a `const`/`let`/`var` name to the tokens of its initializer — tokens rather than a parsed
+     * expression, so the name works as an operand, an argument, or a call receiver alike.
+     */ declare() {
+        this.stream.next();
+        const name = this.stream.next();
+        if (name.kind !== "identifier") {
+            throw new Error(ERROR_MESSAGES.UNSUPPORTED(`the declaration '${name.value}'`));
+        }
+        this.stream.expectPunctuation("=");
+        this.scope.set(name.value, {
+            kind: "inlined",
+            tokens: this.stream.takeStatementTokens()
+        });
+    }
+    /** `return false` on its own, which no row satisfies, and every other returned condition. */ parseReturnedCondition() {
+        const next = this.stream.peek();
+        const after = this.stream.peek(1);
+        const endsHere = after == null || after.kind === "punctuation" && (after.value === ";" || after.value === "}");
+        if (next != null && next.kind === "identifier" && next.value === "false" && endsHere) {
+            this.stream.next();
+            return NEVER;
+        }
+        return this.parseOr();
+    }
+    parseIfStatement() {
+        this.stream.next();
+        this.stream.expectPunctuation("(");
+        const condition = this.parseOr();
+        this.stream.expectPunctuation(")");
+        const whenTrue = this.parseBranch();
+        if (this.stream.peek()?.value === "else") {
+            this.stream.next();
+            return this.either(condition, whenTrue, this.parseBranch());
+        }
+        // Without an `else`, the statements after the `if` are the other branch
+        return this.either(condition, whenTrue, this.parseStatements());
+    }
+    /** One arm of an `if`: a block, or a single statement. */ parseBranch() {
+        return this.stream.isPunctuation("{") ? this.parseBlock() : this.parseStatements();
+    }
+    /** A `switch` over one subject, as the disjunction of its cases. */ parseSwitchStatement() {
+        this.stream.next();
+        this.stream.expectPunctuation("(");
+        const subject = this.parseValue();
+        this.stream.expectPunctuation(")");
+        this.stream.expectPunctuation("{");
+        let matching = null;
+        let pending = [];
+        let everyLabel = [];
+        let byDefault = null;
+        let anyCaseBroke = false;
+        while(!this.stream.matchPunctuation("}")){
+            const label = this.stream.next();
+            if (label.kind !== "identifier" || label.value !== "case" && label.value !== "default") {
+                throw new Error(ERROR_MESSAGES.UNSUPPORTED(`'${label.value}' inside a switch`));
+            }
+            if (label.value === "case") {
+                const test = this.buildComparison(subject, COMPARISON_OPERATORS["==="], this.parseValue());
+                pending.push(test);
+                everyLabel.push(test);
+            }
+            this.stream.expectPunctuation(":");
+            // `case 'a':` with no body of its own runs the next case's body
+            if (this.stream.peek()?.value === "case" || this.stream.peek()?.value === "default") {
+                continue;
+            }
+            if (this.stream.peek()?.value === "break") {
+                this.stream.next();
+                this.stream.matchPunctuation(";");
+                anyCaseBroke = true;
+                pending = [];
+                continue;
+            }
+            const body = this.parseCaseBody();
+            if (label.value === "default") {
+                byDefault = body === NEVER ? null : body;
+                continue;
+            }
+            if (body !== NEVER && pending.length > 0) {
+                const reached = pending.reduce((left, right)=>or(left, right));
+                const term = _types__rspack_import_1/* .Expression.isEmpty */.r4.isEmpty(body) ? reached : and(reached, body);
+                matching = matching == null ? term : or(matching, term);
+            }
+            pending = [];
+        }
+        // Falling out of the switch continues after it, so the statements there are the default too
+        const afterSwitch = byDefault == null && !this.stream.isPunctuation("}") && !this.stream.isAtEnd ? this.parseStatements() : NEVER;
+        if (afterSwitch !== NEVER) {
+            // A `break` also continues after the switch, so its case would take that answer rather
+            // than none — a distinction this rewrite cannot carry
+            if (anyCaseBroke) {
+                throw new Error(ERROR_MESSAGES.UNSUPPORTED("a switch that breaks and then falls into more statements"));
+            }
+            byDefault = afterSwitch;
+        }
+        // A `default` runs only when every case failed, wherever it was written
+        if (byDefault != null) {
+            const noCaseMatched = everyLabel.length === 0 ? byDefault : and(this.negateExpression(everyLabel.reduce((left, right)=>or(left, right))), byDefault);
+            matching = matching == null ? noCaseMatched : or(matching, noCaseMatched);
+        }
+        return matching ?? NEVER;
+    }
+    /** One case body, and the `break` that may follow its `return`. */ parseCaseBody() {
+        const answer = this.parseStatements();
+        if (this.stream.peek()?.value === "break") {
+            this.stream.next();
+            this.stream.matchPunctuation(";");
+        }
+        return answer;
+    }
+    /**
+     * The predicate an `if`/`else` answers: `(condition && whenTrue) || (!condition && whenFalse)`,
+     * with each case below that form after a constant branch cancels out.
+     */ either(condition, whenTrue, whenFalse) {
+        if (whenTrue === NEVER) {
+            return whenFalse === NEVER ? NEVER : and(this.negateExpression(condition), whenFalse);
+        }
+        if (whenFalse === NEVER) {
+            return and(condition, whenTrue);
+        }
+        if (_types__rspack_import_1/* .Expression.isEmpty */.r4.isEmpty(whenTrue)) {
+            return or(condition, whenFalse);
+        }
+        if (_types__rspack_import_1/* .Expression.isEmpty */.r4.isEmpty(whenFalse)) {
+            return or(this.negateExpression(condition), whenTrue);
+        }
+        return or(and(condition, whenTrue), and(this.negateExpression(condition), whenFalse));
+    }
+    // || binds loosest, so it sits at the root of the parse
+    parseOr() {
+        let left = this.parseAnd();
+        while(this.stream.matchPunctuation("||")){
+            const right = this.parseAnd();
+            // A tautology (`true`) absorbs the whole disjunction
+            if (_types__rspack_import_1/* .Expression.isEmpty */.r4.isEmpty(left) || _types__rspack_import_1/* .Expression.isEmpty */.r4.isEmpty(right)) {
+                left = _types__rspack_import_1/* .Expression.EMPTY */.r4.EMPTY;
+                continue;
+            }
+            left = new _types__rspack_import_1/* .OperatorExpression */.fw({
+                operator: "||",
+                left,
+                right
+            });
+        }
+        return left;
+    }
     parseAnd() {
         let left = this.parseUnary();
         while(this.stream.matchPunctuation("&&")){
@@ -1085,10 +2115,18 @@ const resolveParamPath = (paramsName, path, data)=>{
     /**
      * Applies `!` to an already-parsed expression: comparators flip their
      * negated flag, compound expressions distribute via De Morgan's laws.
+     *
+     * Builds a new tree rather than flipping the flag in place, because an `if` uses its condition
+     * twice — once negated — and a shared node would carry the flip into both branches.
      */ negateExpression(expression) {
         if (expression instanceof _types__rspack_import_1/* .ComparatorExpression */.bQ) {
-            expression.negated = !expression.negated;
-            return expression;
+            return new _types__rspack_import_1/* .ComparatorExpression */.bQ({
+                comparator: expression.comparator,
+                negated: !expression.negated,
+                strict: expression.strict,
+                left: expression.left,
+                right: expression.right
+            });
         }
         if (expression instanceof _types__rspack_import_1/* .OperatorExpression */.fw && expression.left != null && expression.right != null) {
             return new _types__rspack_import_1/* .OperatorExpression */.fw({
@@ -1100,25 +2138,125 @@ const resolveParamPath = (paramsName, path, data)=>{
         throw new Error(ERROR_MESSAGES.UNSUPPORTED("'!' on this expression"));
     }
     parseComparison() {
-        // Parenthesized group
-        if (this.stream.matchPunctuation("(")) {
+        /**
+         * A parenthesised group is either a boolean sub-expression or a VALUE — `(a && b)` against
+         * `(x.name ?? '') === 'ada'` — and which one it is is only known at the closing bracket, by
+         * what follows. So the boolean reading is tried first and rewound if a comparator turns up.
+         */ if (this.stream.isPunctuation("(") && this.stream.groupIsValue() === false) {
+            this.stream.next();
             const expression = this.parseOr();
             this.stream.expectPunctuation(")");
-            const trailing = this.stream.peek();
-            if (trailing != null && trailing.kind === "punctuation" && COMPARISON_OPERATORS[trailing.value] != null) {
-                throw new Error(ERROR_MESSAGES.UNSUPPORTED("comparison against a parenthesized expression"));
-            }
             return expression;
         }
-        const left = this.parseOperand();
+        const left = this.parseValue();
         const operatorToken = this.stream.peek();
         if (operatorToken != null && operatorToken.kind === "punctuation" && COMPARISON_OPERATORS[operatorToken.value] != null) {
             this.stream.next();
-            const right = this.parseOperand();
+            const right = this.parseValue();
             return this.buildComparison(left, COMPARISON_OPERATORS[operatorToken.value], right);
         }
         return this.buildStandalone(left);
     }
+    /**
+     * A value, at JavaScript's precedence.
+     *
+     * Lowest first: the conditional operator, then nullish coalescing, then the bitwise levels, then
+     * the shifts, then the arithmetic. Comparison sits between the shifts and the bitwise levels in
+     * JavaScript, but a comparison is a boolean and is handled by `parseComparison` above, so this
+     * chain skips it — a bitwise operand here is always a value.
+     */ /**
+     * An operand from its own source, sharing this parser's schema and parameter names.
+     *
+     * A structural dependence found inside propagates outward: the template it belongs to cannot be
+     * cached either.
+     */ parseNested(source) {
+        const nested = new ExpressionParser(this.schema, new TokenStream(tokenize(source)), this.scope, this.paramsName, this.params, this.readsValues);
+        const operand = nested.parseInterpolation();
+        // Leftover tokens mean the interpolation held something this reads only part of. Silently
+        // keeping the part it understood is the worst outcome available: `${x.age > 5 ? "a" : "b"}`
+        // would become `x.age`, and the filter would answer a question nobody asked.
+        if (nested.stream.isAtEnd === false) {
+            throw new Error(ERROR_MESSAGES.UNSUPPORTED("an interpolation this parser reads only part of"));
+        }
+        if (nested.structurallyDependsOnParams === true) {
+            this.structurallyDependsOnParams = true;
+        }
+        return operand;
+    }
+    /**
+     * The whole of one `${…}`.
+     *
+     * A conditional is read here rather than in `parseValue`, because an interpolation is the one
+     * place a conditional appears without brackets around it.
+     */ parseInterpolation() {
+        if (this.stream.holdsConditional()) {
+            const condition = this.parseOr();
+            this.stream.expectPunctuation("?");
+            const whenTrue = this.parseValue();
+            this.stream.expectPunctuation(":");
+            const whenFalse = this.parseValue();
+            return {
+                kind: "conditional",
+                condition,
+                whenTrue,
+                whenFalse
+            };
+        }
+        return this.parseValue();
+    }
+    parseValue() {
+        return this.parseCoalesce();
+    }
+    parseCoalesce() {
+        return this.parseBinary(COALESCE_OPERATORS, ()=>this.parseBitwiseOr());
+    }
+    parseBitwiseOr() {
+        return this.parseBinary(BITWISE_OR_OPERATORS, ()=>this.parseBitwiseXor());
+    }
+    parseBitwiseXor() {
+        return this.parseBinary(BITWISE_XOR_OPERATORS, ()=>this.parseBitwiseAnd());
+    }
+    parseBitwiseAnd() {
+        return this.parseBinary(BITWISE_AND_OPERATORS, ()=>this.parseShift());
+    }
+    parseShift() {
+        return this.parseBinary(SHIFT_OPERATORS, ()=>this.parseAdditive());
+    }
+    parseAdditive() {
+        return this.parseBinary(ADDITIVE_OPERATORS, ()=>this.parseMultiplicative());
+    }
+    parseMultiplicative() {
+        return this.parseBinary(MULTIPLICATIVE_OPERATORS, ()=>this.parseExponent());
+    }
+    /** `**` is RIGHT-associative: `2 ** 3 ** 2` is 2 ** 9, not 8 ** 2. */ parseExponent() {
+        const left = this.parseOperand();
+        if (this.stream.isPunctuation("**") === false) {
+            return left;
+        }
+        this.stream.next();
+        return {
+            kind: "arithmetic",
+            call: "power",
+            left,
+            right: this.parseExponent()
+        };
+    }
+    /** Left-associative, so `a - b - c` is `(a - b) - c` rather than `a - (b - c)`. */ parseBinary(operators, next) {
+        let left = next();
+        for(;;){
+            const token = this.stream.peek();
+            if (token == null || token.kind !== "punctuation" || operators[token.value] == null) {
+                return left;
+            }
+            this.stream.next();
+            left = {
+                kind: "arithmetic",
+                call: operators[token.value],
+                left,
+                right: next()
+            };
+        }
+    }
     parseOperand() {
         const token = this.stream.peek();
         if (token == null) {
@@ -1142,6 +2280,131 @@ const resolveParamPath = (paramsName, path, data)=>{
                 locale: null
             };
         }
+        // A parenthesised VALUE — `(x.price & 1)`, `(x.name ?? '')`. The boolean reading of a group
+        // is handled in parseComparison; by the time an operand sees one it is arithmetic.
+        if (token.kind === "punctuation" && token.value === "(") {
+            const conditional = this.stream.groupHoldsConditional();
+            this.stream.next();
+            if (conditional === true) {
+                const condition = this.parseOr();
+                this.stream.expectPunctuation("?");
+                const whenTrue = this.parseValue();
+                this.stream.expectPunctuation(":");
+                const whenFalse = this.parseValue();
+                this.stream.expectPunctuation(")");
+                return {
+                    kind: "conditional",
+                    condition,
+                    whenTrue,
+                    whenFalse
+                };
+            }
+            const inner = this.parseValue();
+            this.stream.expectPunctuation(")");
+            const grouped = inner.kind === "arithmetic" ? {
+                ...inner,
+                grouped: true
+            } : inner;
+            return this.withGroupCall(grouped);
+        }
+        /**
+         * A template with interpolation, folded into `concat`.
+         *
+         * Each `${…}` was kept as source by the tokenizer and is parsed by its own stream, so it can
+         * hold anything an operand can — a property, a param, arithmetic, another template. Empty
+         * chunks are dropped: `${a}${b}` is two operands, not two operands and three empty strings.
+         */ if (token.kind === "template") {
+            this.stream.next();
+            const { chunks, expressions } = JSON.parse(token.value);
+            const pieces = [];
+            for(let at = 0; at < chunks.length; at++){
+                if (chunks[at].length > 0) {
+                    pieces.push({
+                        kind: "value",
+                        value: chunks[at],
+                        transformer: null,
+                        locale: null
+                    });
+                }
+                if (at < expressions.length) {
+                    pieces.push(this.parseNested(expressions[at]));
+                }
+            }
+            if (pieces.length === 0) {
+                return {
+                    kind: "value",
+                    value: "",
+                    transformer: null,
+                    locale: null
+                };
+            }
+            // One piece and no chunk means no concat to do the coercion, so the conversion has to be
+            // explicit: `` `${x.age}` `` is the STRING "9", not the number 9.
+            if (pieces.length === 1) {
+                const only = pieces[0];
+                const alreadyText = only.kind === "value" && typeof only.value === "string";
+                return alreadyText ? only : {
+                    kind: "arithmetic",
+                    call: "to-string",
+                    left: only,
+                    right: noArgument()
+                };
+            }
+            return pieces.reduce((left, right)=>({
+                    kind: "arithmetic",
+                    call: "concat",
+                    left,
+                    right
+                }));
+        }
+        if (token.kind === "bigint") {
+            this.stream.next();
+            return {
+                kind: "value",
+                value: BigInt(token.value),
+                transformer: null,
+                locale: null
+            };
+        }
+        if (token.kind === "regex") {
+            this.stream.next();
+            const [source, flags] = token.value.split("\u0000");
+            const pattern = {
+                kind: "value",
+                value: new RegExp(source, flags),
+                transformer: null,
+                locale: null
+            };
+            // `/^a/.test(x.name)` — the pattern is the literal, the subject is the argument, and the
+            // tree puts them the other way round: the property is what the call applies to.
+            if (this.stream.isPunctuation(".")) {
+                const method = this.stream.peek(1);
+                if (method != null && method.kind === "identifier" && method.value === "test") {
+                    this.stream.next();
+                    this.stream.next();
+                    this.stream.expectPunctuation("(");
+                    const subject = this.parseValue();
+                    this.stream.expectPunctuation(")");
+                    return {
+                        kind: "arithmetic",
+                        call: "matches",
+                        left: subject,
+                        right: pattern
+                    };
+                }
+            }
+            return pattern;
+        }
+        if (token.kind === "punctuation" && token.value === "~") {
+            this.stream.next();
+            // Unary, so the tree carries the operand and no argument
+            return {
+                kind: "arithmetic",
+                call: "bit-not",
+                left: this.parseOperand(),
+                right: noArgument()
+            };
+        }
         if (token.kind === "punctuation" && token.value === "-") {
             this.stream.next();
             const numberToken = this.stream.next();
@@ -1199,6 +2462,9 @@ const resolveParamPath = (paramsName, path, data)=>{
             if (argument.kind === "method-call") {
                 throw new Error(ERROR_MESSAGES.UNSUPPORTED("nested method call inside .includes()"));
             }
+            if (argument.kind === "arithmetic" || argument.kind === "conditional" || argument.kind === "opaque") {
+                throw new Error(ERROR_MESSAGES.UNSUPPORTED("arithmetic inside .includes()"));
+            }
             return {
                 kind: "method-call",
                 target: array,
@@ -1244,16 +2510,17 @@ const resolveParamPath = (paramsName, path, data)=>{
                 locale: null
             };
         }
-        if (root === this.entityName) {
-            return this.parseChain({
-                kind: "property",
-                root
-            });
-        }
-        if (this.paramsName != null && root === this.paramsName) {
+        const binding = this.scope.get(root);
+        if (binding != null) {
+            if (binding.kind === "inlined") {
+                this.stream.splice(binding.tokens);
+                return this.parseOperand();
+            }
             return this.parseChain({
-                kind: "param",
-                root
+                kind: binding.kind,
+                path: [
+                    ...binding.path
+                ]
             });
         }
         // A bare variable from the outer scope — its value cannot be derived from source text
@@ -1263,7 +2530,7 @@ const resolveParamPath = (paramsName, path, data)=>{
      * Parses the segments after an entity/params root: dot access, bracket
      * access, transform methods and comparator methods.
      */ parseChain(options) {
-        const path = [];
+        const path = options.path;
         let transformer = null;
         let locale = null;
         while(true){
@@ -1289,6 +2556,9 @@ const resolveParamPath = (paramsName, path, data)=>{
                         if (argument.kind === "method-call") {
                             throw new Error(ERROR_MESSAGES.UNSUPPORTED(`nested method call inside .${method}()`));
                         }
+                        if (argument.kind === "arithmetic" || argument.kind === "conditional" || argument.kind === "opaque") {
+                            throw new Error(ERROR_MESSAGES.UNSUPPORTED(`arithmetic inside .${method}()`));
+                        }
                         return {
                             kind: "method-call",
                             target: this.resolveChain(options.kind, path, transformer, locale),
@@ -1296,9 +2566,20 @@ const resolveParamPath = (paramsName, path, data)=>{
                             argument
                         };
                     }
+                    if (this.readsValues) {
+                        return this.withGroupCall(this.opaqueCall(this.resolveChain(options.kind, path, transformer, locale)));
+                    }
                     throw new Error(ERROR_MESSAGES.UNSUPPORTED(`method '.${method}()'`));
                 }
                 if (transformer != null) {
+                    if (this.readsValues) {
+                        return this.withGroupCall({
+                            kind: "opaque",
+                            reads: [
+                                this.resolveChain(options.kind, path, transformer, locale)
+                            ]
+                        });
+                    }
                     throw new Error(ERROR_MESSAGES.UNSUPPORTED("property access after a transform method"));
                 }
                 path.push(segment.value);
@@ -1325,12 +2606,15 @@ const resolveParamPath = (paramsName, path, data)=>{
         // docs/mutation-backlog.md) — every mutation of this four-conjunct guard reroutes
         // bracket access between two paths that both collapse to NOT_PARSABLE; the
         // experiment recorded there aimed 30 tests at this line and killed none.
-        if (kind === "property" && token.kind === "identifier" && this.paramsName != null && token.value === this.paramsName) {
-            const paramPath = [];
+        const binding = token.kind === "identifier" ? this.scope.get(token.value) : undefined;
+        if (kind === "property" && binding != null && binding.kind === "param") {
+            const paramPath = [
+                ...binding.path
+            ];
             while(this.stream.matchPunctuation(".") || this.stream.matchPunctuation("?.")){
                 paramPath.push(this.stream.next().value);
             }
-            const resolved = resolveParamPath(this.paramsName, paramPath, this.params);
+            const resolved = resolveParamPath(this.paramsName ?? token.value, paramPath, this.params);
             if (typeof resolved !== "string") {
                 throw new ParamDependentParseError(ERROR_MESSAGES.PROPERTY_NOT_FOUND(paramPath.join(".")));
             }
@@ -1383,6 +2667,96 @@ const resolveParamPath = (paramsName, path, data)=>{
             locale
         };
     }
+    /**
+     * A call on a parenthesised value: `(x.name).toLowerCase()`, `(x.age + 1).length`. Any operand can
+     * receive one here, unlike a property chain, which carries at most one transform.
+     */ withGroupCall(operand) {
+        let receiver = operand;
+        while(this.stream.isPunctuation(".") || this.stream.isPunctuation("?.")){
+            const segment = this.stream.peek(1);
+            if (segment == null || segment.kind !== "identifier") {
+                break;
+            }
+            if (segment.value === "length" && !this.stream.isPunctuation("(", 2)) {
+                this.stream.next();
+                this.stream.next();
+                receiver = {
+                    kind: "arithmetic",
+                    call: "length",
+                    left: receiver,
+                    right: noArgument()
+                };
+                continue;
+            }
+            const transform = TRANSFORM_METHODS[segment.value];
+            if (transform != null) {
+                this.stream.next();
+                this.stream.next();
+                this.stream.expectPunctuation("(");
+                this.stream.expectPunctuation(")");
+                receiver = {
+                    kind: "arithmetic",
+                    call: transform.transformer,
+                    left: receiver,
+                    right: transform.locale == null ? noArgument() : {
+                        kind: "value",
+                        value: transform.locale,
+                        transformer: null,
+                        locale: null
+                    }
+                };
+                continue;
+            }
+            // A comparator method needs a property target, which only an ungrouped chain produces
+            if (COMPARATOR_METHODS[segment.value] != null && receiver.kind === "property") {
+                this.stream.next();
+                this.stream.next();
+                this.stream.expectPunctuation("(");
+                const argument = this.parseOperand();
+                this.stream.expectPunctuation(")");
+                if (argument.kind !== "property" && argument.kind !== "value" && argument.kind !== "param") {
+                    throw new Error(ERROR_MESSAGES.UNSUPPORTED(`'.${segment.value}()' on that argument`));
+                }
+                return {
+                    kind: "method-call",
+                    target: receiver,
+                    method: segment.value,
+                    argument
+                };
+            }
+            // Any other member or call of a value, which a selector reads through
+            if (this.readsValues) {
+                this.stream.next();
+                this.stream.next();
+                receiver = this.stream.isPunctuation("(") ? this.opaqueCall(receiver) : {
+                    kind: "opaque",
+                    reads: [
+                        receiver
+                    ]
+                };
+                continue;
+            }
+            break;
+        }
+        return receiver;
+    }
+    /** A call with no node of its own, from its `(`, kept for what its receiver and arguments read. */ opaqueCall(receiver) {
+        const reads = [
+            receiver
+        ];
+        this.stream.expectPunctuation("(");
+        while(!this.stream.matchPunctuation(")")){
+            reads.push(this.parseValue());
+            if (!this.stream.matchPunctuation(",")) {
+                this.stream.expectPunctuation(")");
+                break;
+            }
+        }
+        return {
+            kind: "opaque",
+            reads
+        };
+    }
     withValueTransformer(operand) {
         if (this.stream.isPunctuation(".")) {
             const method = this.stream.peek(1);
@@ -1416,12 +2790,26 @@ const resolveParamPath = (paramsName, path, data)=>{
         if (right.kind === "method-call") {
             throw new Error(ERROR_MESSAGES.UNSUPPORTED("method call on the right side of a comparison"));
         }
-        if (left.kind === "property" && right.kind === "property") {
-            // Casing transformers are only valid with string-matching comparators,
-            // which cannot produce a property-to-property comparison
-            if (left.transformer === "to-lower-case" || left.transformer === "to-upper-case" || right.transformer === "to-lower-case" || right.transformer === "to-upper-case") {
-                throw new Error(ERROR_MESSAGES.UNSUPPORTED("transform method outside of startsWith/endsWith/includes"));
+        // A comparison is a tree a backend renders, and this operand has no node in one
+        if (left.kind === "opaque" || right.kind === "opaque") {
+            throw new Error(ERROR_MESSAGES.UNSUPPORTED("a call with no expression form inside a comparison"));
+        }
+        if (needsBrackets(left) || needsBrackets(right)) {
+            throw new Error(ERROR_MESSAGES.UNSUPPORTED("a bitwise or nullish operator compared without brackets, which JavaScript reads the other way round"));
+        }
+        if (left.kind === "arithmetic" || right.kind === "arithmetic" || left.kind === "conditional" || right.kind === "conditional") {
+            if (containsProperty(left) === false && containsProperty(right) === false) {
+                throw new Error(ERROR_MESSAGES.UNSUPPORTED("arithmetic that references no schema property"));
             }
+            return new _types__rspack_import_1/* .ComparatorExpression */.bQ({
+                comparator: operator.comparator,
+                negated: operator.negated,
+                strict: operator.strict,
+                left: this.createOperandExpression(left),
+                right: this.createOperandExpression(right)
+            });
+        }
+        if (left.kind === "property" && right.kind === "property") {
             return new _types__rspack_import_1/* .ComparatorExpression */.bQ({
                 comparator: operator.comparator,
                 negated: operator.negated,
@@ -1430,18 +2818,63 @@ const resolveParamPath = (paramsName, path, data)=>{
                 right: this.createPropertyExpression(right)
             });
         }
+        // Only a loose comparison coerces. `===` records `strict` and honouring it is the point.
         if (left.kind === "property" && right.kind !== "property") {
-            return this.buildPropertyComparator(left, operator, right, /* applyConverter */ true);
+            return this.buildPropertyComparator(left, operator, right, /* applyConverter */ !operator.strict);
         }
         if (right.kind === "property" && left.kind !== "property") {
             const swapped = {
                 ...operator,
                 comparator: SWAPPED_COMPARATORS[operator.comparator]
             };
-            return this.buildPropertyComparator(right, swapped, left, /* applyConverter */ true);
+            return this.buildPropertyComparator(right, swapped, left, /* applyConverter */ !operator.strict);
+        }
+        const settled = this.settleConstantComparison(left, operator, right);
+        if (settled != null) {
+            return settled;
         }
         throw new Error(ERROR_MESSAGES.UNSUPPORTED("comparison requires a schema property on at least one side"));
     }
+    /**
+     * The answer a comparison of two constants gives, when that answer is `true`. The other answer
+     * excludes every row, which has no expression node.
+     */ settleConstantComparison(left, operator, right) {
+        const leftValue = this.constantOf(left);
+        const rightValue = this.constantOf(right);
+        if (leftValue === UNKNOWN_UNTIL_ROW || rightValue === UNKNOWN_UNTIL_ROW) {
+            return null;
+        }
+        const answer = (0,_evaluate__rspack_import_3/* .evaluate */._3)(new _types__rspack_import_1/* .ComparatorExpression */.bQ({
+            comparator: operator.comparator,
+            negated: operator.negated,
+            strict: operator.strict,
+            left: new _types__rspack_import_1/* .ValueExpression */.Ko({
+                value: leftValue
+            }),
+            right: new _types__rspack_import_1/* .ValueExpression */.Ko({
+                value: rightValue
+            })
+        }), {});
+        if (answer === true) {
+            return _types__rspack_import_1/* .Expression.EMPTY */.r4.EMPTY;
+        }
+        // Params decided this, so the refusal must not be cached against the source: the same filter
+        // with other params can be a tautology.
+        if (left.kind === "param" || right.kind === "param") {
+            throw new ParamDependentParseError(ERROR_MESSAGES.UNSUPPORTED("a params comparison no row satisfies"));
+        }
+        return null;
+    }
+    /** The value an operand holds already, for the operands that do not depend on a row. */ constantOf(operand) {
+        if (operand.kind === "value" && operand.transformer == null) {
+            return operand.value;
+        }
+        if (operand.kind === "param" && operand.transformer == null) {
+            this.structurallyDependsOnParams = true;
+            return resolveParamPath(this.paramsName ?? "params", operand.path, this.params);
+        }
+        return UNKNOWN_UNTIL_ROW;
+    }
     buildStandalone(operand) {
         if (operand.kind === "method-call") {
             return this.buildMethodComparator(operand);
@@ -1464,6 +2897,21 @@ const resolveParamPath = (paramsName, path, data)=>{
                 locale: null
             }, /* applyConverter */ true);
         }
+        // A boolean-valued call standing alone IS the predicate
+        if (operand.kind === "arithmetic" && operand.call === "matches") {
+            return new _types__rspack_import_1/* .ComparatorExpression */.bQ({
+                comparator: "equals",
+                negated: false,
+                strict: false,
+                left: this.createOperandExpression(operand),
+                right: new _types__rspack_import_1/* .ValueExpression */.Ko({
+                    value: true
+                })
+            });
+        }
+        if (operand.kind === "arithmetic" || operand.kind === "conditional") {
+            throw new Error(ERROR_MESSAGES.UNSUPPORTED("arithmetic used as a condition rather than compared"));
+        }
         // Constant `true` — a tautology, which parseAnd/parseOr simplify away
         if (operand.kind === "value" && operand.value === true && operand.transformer == null) {
             return _types__rspack_import_1/* .Expression.EMPTY */.r4.EMPTY;
@@ -1516,12 +2964,6 @@ const resolveParamPath = (paramsName, path, data)=>{
                 right: this.createValueExpression(value, null, /* applyConverter */ false)
             });
         }
-        // Casing transformers on a property are only meaningful with string-matching
-        // comparators; on relational comparators the plugins would silently
-        // ignore them and return wrong data
-        if (property.transformer != null && !isStringMatch) {
-            throw new Error(ERROR_MESSAGES.UNSUPPORTED("transform method outside of startsWith/endsWith/includes"));
-        }
         return new _types__rspack_import_1/* .ComparatorExpression */.bQ({
             comparator: operator.comparator,
             negated: operator.negated,
@@ -1530,31 +2972,63 @@ const resolveParamPath = (paramsName, path, data)=>{
             right: this.createValueExpression(value, property.property, applyConverter)
         });
     }
+    /**
+     * Any operand as an expression.
+     *
+     * Values inside arithmetic take no paired property: the result is a computed number, so the
+     * property's serializer and type converter do not describe it — the same reason `.length` skips
+     * them.
+     */ createOperandExpression(operand) {
+        if (operand.kind === "conditional") {
+            return new _types__rspack_import_1/* .CallExpression */.DG({
+                call: "conditional",
+                expression: operand.condition,
+                arguments: [
+                    this.createOperandExpression(operand.whenTrue),
+                    this.createOperandExpression(operand.whenFalse)
+                ]
+            });
+        }
+        if (operand.kind === "arithmetic") {
+            return new _types__rspack_import_1/* .CallExpression */.DG({
+                call: operand.call,
+                expression: this.createOperandExpression(operand.left),
+                arguments: operand.right === NO_ARGUMENT ? [] : operand.extra == null ? [
+                    this.createOperandExpression(operand.right)
+                ] : [
+                    this.createOperandExpression(operand.right),
+                    this.createOperandExpression(operand.extra)
+                ]
+            });
+        }
+        if (operand.kind === "property") {
+            return this.createPropertyExpression(operand);
+        }
+        if (operand.kind === "method-call") {
+            throw new Error(ERROR_MESSAGES.UNSUPPORTED("a method call inside arithmetic"));
+        }
+        if (operand.kind === "opaque") {
+            throw new Error(ERROR_MESSAGES.UNSUPPORTED("a call with no expression form inside arithmetic"));
+        }
+        return this.createValueExpression(operand, null, /* applyConverter */ false);
+    }
     createPropertyExpression(operand) {
-        const expression = new _types__rspack_import_1/* .PropertyExpression */.ep({
+        return asCall(new _types__rspack_import_1/* .PropertyExpression */.ep({
             property: operand.property
-        });
-        expression.transformer = operand.transformer;
-        expression.locale = operand.locale;
-        return expression;
+        }), operand.transformer, operand.locale);
     }
     createValueExpression(operand, pairedProperty, applyConverter) {
         if (operand.kind === "param") {
-            const expression = new ParamReferenceExpression({
+            return asCall(new ParamReferenceExpression({
                 paramPath: operand.path,
                 pairedProperty,
                 applyConverter
-            });
-            expression.transformer = operand.transformer;
-            expression.locale = operand.locale;
-            return expression;
+            }), operand.transformer, operand.locale);
         }
         const expression = new _types__rspack_import_1/* .ValueExpression */.Ko({
             value: resolvePairedValue(operand.value, pairedProperty, applyConverter)
         });
-        expression.transformer = operand.transformer;
-        expression.locale = operand.locale;
-        return expression;
+        return asCall(expression, operand.transformer, operand.locale);
     }
 }
 // #endregion
@@ -1566,46 +3040,128 @@ const resolveParamPath = (paramsName, path, data)=>{
  */ const bindExpression = (expression, paramsName, params)=>{
     if (expression instanceof ParamReferenceExpression) {
         const raw = resolveParamPath(paramsName ?? "params", expression.paramPath, params);
-        const bound = new _types__rspack_import_1/* .ValueExpression */.Ko({
+        return new _types__rspack_import_1/* .ValueExpression */.Ko({
             value: resolvePairedValue(raw, expression.pairedProperty, expression.applyConverter)
         });
-        bound.transformer = expression.transformer;
-        bound.locale = expression.locale;
-        return bound;
     }
     if (expression instanceof _types__rspack_import_1/* .ValueExpression */.Ko) {
-        const clone = new _types__rspack_import_1/* .ValueExpression */.Ko({
+        return new _types__rspack_import_1/* .ValueExpression */.Ko({
             value: expression.value
         });
-        clone.transformer = expression.transformer;
-        clone.locale = expression.locale;
-        return clone;
     }
     if (expression instanceof _types__rspack_import_1/* .PropertyExpression */.ep) {
-        const clone = new _types__rspack_import_1/* .PropertyExpression */.ep({
+        return new _types__rspack_import_1/* .PropertyExpression */.ep({
             property: expression.property
         });
-        clone.transformer = expression.transformer;
-        clone.locale = expression.locale;
-        return clone;
     }
-    if (expression instanceof _types__rspack_import_1/* .ComparatorExpression */.bQ) {
-        return new _types__rspack_import_1/* .ComparatorExpression */.bQ({
-            comparator: expression.comparator,
-            negated: expression.negated,
-            strict: expression.strict,
-            left: expression.left ? bindExpression(expression.left, paramsName, params) : undefined,
-            right: expression.right ? bindExpression(expression.right, paramsName, params) : undefined
-        });
+    if (expression instanceof _types__rspack_import_1/* .ComparatorExpression */.bQ) {
+        return new _types__rspack_import_1/* .ComparatorExpression */.bQ({
+            comparator: expression.comparator,
+            negated: expression.negated,
+            strict: expression.strict,
+            left: expression.left ? bindExpression(expression.left, paramsName, params) : undefined,
+            right: expression.right ? bindExpression(expression.right, paramsName, params) : undefined
+        });
+    }
+    if (expression instanceof _types__rspack_import_1/* .OperatorExpression */.fw) {
+        return new _types__rspack_import_1/* .OperatorExpression */.fw({
+            operator: expression.operator,
+            left: expression.left ? bindExpression(expression.left, paramsName, params) : undefined,
+            right: expression.right ? bindExpression(expression.right, paramsName, params) : undefined
+        });
+    }
+    if (expression instanceof _types__rspack_import_1/* .CallExpression */.DG) {
+        return new _types__rspack_import_1/* .CallExpression */.DG({
+            call: expression.call,
+            expression: bindExpression(expression.expression, paramsName, params),
+            arguments: expression.arguments.map((argument)=>bindExpression(argument, paramsName, params))
+        });
+    }
+    return expression;
+};
+/**
+ * Wraps an operand in the call a transform method named, if there was one.
+ *
+ * `Transformer` and `Call` share these three names, so the transform IS the call name. A locale
+ * becomes the call's first argument, which is where it belongs — it qualifies the casing, not the
+ * property.
+ */ const asCall = (inner, transformer, locale)=>{
+    if (transformer == null) {
+        return inner;
+    }
+    return new _types__rspack_import_1/* .CallExpression */.DG({
+        call: transformer,
+        expression: inner,
+        arguments: locale == null ? [] : [
+            new _types__rspack_import_1/* .ValueExpression */.Ko({
+                value: locale
+            })
+        ]
+    });
+};
+/** Binds every name a destructuring pattern introduces to the path it reads. */ const bindPattern = (stream, kind, path, scope)=>{
+    if (!stream.matchPunctuation("{")) {
+        const name = stream.next();
+        if (name.kind !== "identifier") {
+            throw new Error(ERROR_MESSAGES.UNSUPPORTED(`parameter '${name.value}'`));
+        }
+        scope.set(name.value, {
+            kind,
+            path
+        });
+        return;
+    }
+    while(!stream.matchPunctuation("}")){
+        const key = stream.next();
+        if (key.kind !== "identifier") {
+            throw new Error(ERROR_MESSAGES.UNSUPPORTED(`destructured key '${key.value}'`));
+        }
+        if (stream.matchPunctuation(":")) {
+            bindPattern(stream, kind, [
+                ...path,
+                key.value
+            ], scope);
+        } else {
+            scope.set(key.value, {
+                kind,
+                path: [
+                    ...path,
+                    key.value
+                ]
+            });
+        }
+        if (!stream.matchPunctuation(",")) {
+            stream.expectPunctuation("}");
+            return;
+        }
+    }
+};
+/** Reads a filter's parameter list — the entity alone, or the `[entity, params]` pair — into a scope. */ const buildScope = (parameterNames, hasParams)=>{
+    const stream = new TokenStream(tokenize(parameterNames));
+    const scope = new Map();
+    if (!stream.matchPunctuation("[")) {
+        bindPattern(stream, "property", [], scope);
+        return {
+            scope,
+            paramsName: null
+        };
+    }
+    bindPattern(stream, "property", [], scope);
+    if (hasParams && stream.matchPunctuation(",") && !stream.isPunctuation("]")) {
+        bindPattern(stream, "param", [], scope);
     }
-    if (expression instanceof _types__rspack_import_1/* .OperatorExpression */.fw) {
-        return new _types__rspack_import_1/* .OperatorExpression */.fw({
-            operator: expression.operator,
-            left: expression.left ? bindExpression(expression.left, paramsName, params) : undefined,
-            right: expression.right ? bindExpression(expression.right, paramsName, params) : undefined
-        });
+    return {
+        scope,
+        paramsName: wholeParamsName(scope)
+    };
+};
+/** The name the whole params object was given, when it was not destructured. Error messages only. */ const wholeParamsName = (scope)=>{
+    for (const [name, binding] of scope){
+        if (binding.kind === "param" && binding.path.length === 0) {
+            return name;
+        }
     }
-    return expression;
+    return null;
 };
 /**
  * Splits stringified filter source into parameter names and the expression
@@ -1636,33 +3192,12 @@ const resolveParamPath = (paramsName, path, data)=>{
             parameterNames = parameterNames.slice(1, -1).trim();
         }
     }
-    let entityName;
-    let paramsName = null;
-    if (parameterNames.startsWith("[") && parameterNames.endsWith("]")) {
-        const destructured = parameterNames.slice(1, -1).split(",").map((w)=>w.trim());
-        entityName = destructured[0];
-        if (hasParams) {
-            paramsName = destructured[1] ?? null;
-        }
-    } else {
-        entityName = parameterNames;
-    }
-    if (entityName == null || entityName.length === 0) {
+    if (parameterNames.length === 0) {
         throw new Error("Invalid Function");
     }
-    // Unwrap a single-return block body: { return <expression>; }
-    if (body.startsWith("{")) {
-        const inner = body.slice(1, body.lastIndexOf("}")).trim();
-        if (!inner.startsWith("return")) {
-            throw new Error(ERROR_MESSAGES.UNSUPPORTED("block body without a single return statement"));
-        }
-        body = inner.slice("return".length).trim();
-        if (body.endsWith(";")) {
-            body = body.slice(0, -1).trim();
-        }
-    }
+    const { scope, paramsName } = buildScope(parameterNames, hasParams);
     return {
-        entityName,
+        scope,
         paramsName,
         body
     };
@@ -1730,17 +3265,27 @@ const combineExpressions = (...expressions)=>{
  */ const parseFragment = (schema, body, rootName)=>{
     try {
         const stream = new TokenStream(tokenize(body));
-        const parser = new ExpressionParser(schema, stream, rootName, null, undefined);
-        return parser.parse();
+        const scope = new Map([
+            [
+                rootName,
+                {
+                    kind: "property",
+                    path: []
+                }
+            ]
+        ]);
+        const parser = new ExpressionParser(schema, stream, scope, null, undefined);
+        return foldConstantCalls(parser.parse());
     } catch  {
         // The failure is expected and informative — see above — so it is not logged. A caller that
         // parses one conjunct against two schemas would otherwise warn on every successful split.
         return Expression.NOT_PARSABLE;
     }
 };
+/** What the parser refused, from a throw that may not be an `Error`. */ const refusalOf = (error)=>error instanceof Error ? error.message : String(error);
 const toExpression = (schema, fn, params)=>{
     const stringifiedFunction = fn.toString();
-    const warn = (error)=>_utilities__rspack_import_3/* .logger.warn */.vF.warn("Error parsing expression", {
+    const warn = (error)=>_utilities__rspack_import_4/* .logger.warn */.vF.warn("Error parsing expression", {
             error,
             collectionName: schema.collectionName,
             params,
@@ -1748,16 +3293,17 @@ const toExpression = (schema, fn, params)=>{
         });
     const cached = getCachedTemplate(schema, stringifiedFunction);
     if (cached != null) {
-        // A cached failure — the warning was already logged when it was discovered
+        // A cached failure — the warning was already logged when it was discovered. The template
+        // carries what was refused, and `.explain()` is usually called once the cache is warm.
         if (_types__rspack_import_1/* .Expression.isNotParsable */.r4.isNotParsable(cached.template)) {
-            return _types__rspack_import_1/* .Expression.NOT_PARSABLE */.r4.NOT_PARSABLE;
+            return cached.template;
         }
         try {
-            return bindExpression(cached.template, cached.paramsName, params);
+            return (0,_fold__rspack_import_5/* .foldConstantCalls */.F5)(bindExpression(cached.template, cached.paramsName, params));
         } catch (error) {
             // Binding failures are param-dependent by nature — never cached
             warn(error);
-            return _types__rspack_import_1/* .Expression.NOT_PARSABLE */.r4.NOT_PARSABLE;
+            return _types__rspack_import_1/* .Expression.notParsable */.r4.notParsable(refusalOf(error));
         }
     }
     let paramsName = null;
@@ -1766,22 +3312,23 @@ const toExpression = (schema, fn, params)=>{
     try {
         const shape = resolveFunctionShape(stringifiedFunction, params != null);
         const stream = new TokenStream(tokenize(shape.body));
-        const parser = new ExpressionParser(schema, stream, shape.entityName, shape.paramsName, params);
+        const parser = new ExpressionParser(schema, stream, shape.scope, shape.paramsName, params);
         paramsName = shape.paramsName;
-        template = parser.parse();
+        template = parser.parseBody();
         structurallyDependsOnParams = parser.structurallyDependsOnParams;
     } catch (error) {
         // Cache the failure so a hot query on an unsupported filter doesn't
         // re-parse and re-warn on every execution.  Param-dependent failures are
         // exempt: the same source can succeed with different params.
+        const refused = _types__rspack_import_1/* .Expression.notParsable */.r4.notParsable(refusalOf(error));
         if (!(error instanceof ParamDependentParseError)) {
             setCachedTemplate(schema, stringifiedFunction, {
-                template: _types__rspack_import_1/* .Expression.NOT_PARSABLE */.r4.NOT_PARSABLE,
+                template: refused,
                 paramsName: null
             });
         }
         warn(error);
-        return _types__rspack_import_1/* .Expression.NOT_PARSABLE */.r4.NOT_PARSABLE;
+        return refused;
     }
     // Templates whose structure was resolved from param values are only
     // valid for this exact params object — parse those fresh every time
@@ -1792,17 +3339,116 @@ const toExpression = (schema, fn, params)=>{
         });
     }
     try {
-        return bindExpression(template, paramsName, params);
+        return (0,_fold__rspack_import_5/* .foldConstantCalls */.F5)(bindExpression(template, paramsName, params));
     } catch (error) {
         warn(error);
-        return _types__rspack_import_1/* .Expression.NOT_PARSABLE */.r4.NOT_PARSABLE;
+        return _types__rspack_import_1/* .Expression.notParsable */.r4.notParsable(refusalOf(error));
+    }
+};
+const collectReads = (operand, into)=>{
+    switch(operand.kind){
+        case "property":
+            into.add(operand.property);
+            return;
+        case "method-call":
+            collectReads(operand.target, into);
+            collectReads(operand.argument, into);
+            return;
+        case "arithmetic":
+            collectReads(operand.left, into);
+            collectReads(operand.right, into);
+            if (operand.extra != null) {
+                collectReads(operand.extra, into);
+            }
+            return;
+        case "conditional":
+            for (const property of getProperties(operand.condition)){
+                into.add(property);
+            }
+            collectReads(operand.whenTrue, into);
+            collectReads(operand.whenFalse, into);
+            return;
+        case "opaque":
+            for (const read of operand.reads){
+                collectReads(read, into);
+            }
+            return;
     }
 };
+const selectedValue = (operand)=>{
+    const found = new Set();
+    collectReads(operand, found);
+    const reads = [
+        ...found
+    ];
+    return {
+        property: reads.length === 1 ? reads[0] : null,
+        reads,
+        isDirectProperty: operand.kind === "property" && operand.transformer == null
+    };
+};
+// Keyed like the template cache. A selector takes no params, so every result is cacheable
+const selectorCache = new WeakMap();
+/**
+ * Reads a sort, map, group or `nearest` selector with the grammar filters use, for what its value is
+ * read from.
+ *
+ * Not for evaluating it: the caller's function stays the value, and nothing here renders one. A plugin
+ * decides from the result whether it can run the option. One that orders or projects by column cannot
+ * run a value that is not the property itself, and one that runs the function over stored rows cannot
+ * run it over a renamed property.
+ *
+ * So the grammar is wider here than for a filter. A call it has no node for, such as `getFullYear()`,
+ * is kept for the operands it reads rather than refused, since the function it came from still runs.
+ *
+ * `not-parsable` is not logged. The option runs as it did before the selector was parsed.
+ *
+ * Cached by function source per schema, like `toExpression`. The result is shared, so it is read-only.
+ */ const parseSelector = (schema, selector)=>{
+    const source = selector.toString();
+    let bySource = selectorCache.get(schema);
+    const cached = bySource?.get(source);
+    if (cached != null) {
+        return cached;
+    }
+    let parsed;
+    try {
+        const shape = resolveFunctionShape(source, false);
+        const parser = new ExpressionParser(schema, new TokenStream(tokenize(shape.body)), shape.scope, null, undefined, true);
+        const selected = parser.parseSelector();
+        parsed = Array.isArray(selected) ? {
+            kind: "object",
+            fields: selected.map((field)=>({
+                    name: field.name,
+                    ...selectedValue(field.operand)
+                }))
+        } : {
+            kind: "value",
+            value: selectedValue(selected)
+        };
+    } catch (error) {
+        parsed = {
+            kind: "not-parsable",
+            reason: refusalOf(error)
+        };
+    }
+    if (bySource == null) {
+        bySource = new Map();
+        selectorCache.set(schema, bySource);
+    }
+    // Stryker disable next-line all: the same resource bound as the template cache's
+    if (bySource.size >= MAX_CACHED_TEMPLATES_PER_SCHEMA) {
+        bySource.clear();
+    }
+    bySource.set(source, parsed);
+    return parsed;
+}; // #endregion
 
 
 },
 27(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
 __webpack_require__.d(__webpack_exports__, {
+  DG: () => (CallExpression),
   Ko: () => (ValueExpression),
   bQ: () => (ComparatorExpression),
   ep: () => (PropertyExpression),
@@ -1812,59 +3458,69 @@ __webpack_require__.d(__webpack_exports__, {
 const valueToJson = (value)=>{
     if (value === undefined) {
         return {
-            k: "undefined"
+            undefined: true
         };
     }
     if (value === null) {
-        return {
-            k: "raw",
-            v: null
-        };
+        return null;
     }
     if (value instanceof Date) {
         // ISO rather than epoch millis: it survives a human reading the payload, and an invalid
         // Date has no ISO form — so it is caught here rather than becoming a silent `null`.
         return {
-            k: "date",
-            v: value.toISOString()
+            date: value.toISOString()
         };
     }
     if (Array.isArray(value)) {
-        return {
-            k: "array",
-            v: value.map(valueToJson)
-        };
+        return value.map(valueToJson);
     }
     if (typeof value === "number" && Number.isFinite(value) === false) {
         // `JSON.stringify` turns all three of these into `null`, which would compare as a different
         // value entirely rather than failing.
         return {
-            k: "number",
-            v: Number.isNaN(value) ? "NaN" : value > 0 ? "Infinity" : "-Infinity"
+            number: Number.isNaN(value) ? "NaN" : value > 0 ? "Infinity" : "-Infinity"
         };
     }
     if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+        return value;
+    }
+    if (value instanceof RegExp) {
         return {
-            k: "raw",
-            v: value
+            regex: {
+                source: value.source,
+                flags: value.flags
+            }
+        };
+    }
+    // `JSON.stringify` throws outright on a bigint rather than losing it quietly, so this is the one
+    // tag that turns a crash into a value
+    if (typeof value === "bigint") {
+        return {
+            bigint: value.toString()
         };
     }
     throw new Error(`Cannot serialize this filter value: only strings, numbers, booleans, null, undefined, Dates and arrays of those can cross a wire.  ` + `Received: ${Object.prototype.toString.call(value)}`);
 };
 const valueFromJson = (value)=>{
-    if (value.k === "undefined") {
-        return undefined;
+    if (value === null || typeof value !== "object") {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        return value.map(valueFromJson);
     }
-    if (value.k === "date") {
-        return new Date(value.v);
+    if ("date" in value) {
+        return new Date(value.date);
     }
-    if (value.k === "array") {
-        return value.v.map(valueFromJson);
+    if ("undefined" in value) {
+        return undefined;
+    }
+    if ("regex" in value) {
+        return new RegExp(value.regex.source, value.regex.flags);
     }
-    if (value.k === "number") {
-        return value.v === "NaN" ? Number.NaN : value.v === "Infinity" ? Number.POSITIVE_INFINITY : Number.NEGATIVE_INFINITY;
+    if ("bigint" in value) {
+        return BigInt(value.bigint);
     }
-    return value.v;
+    return value.number === "NaN" ? Number.NaN : value.number === "Infinity" ? Number.POSITIVE_INFINITY : Number.NEGATIVE_INFINITY;
 };
 /**
  * The base class for all expression types.
@@ -1881,6 +3537,9 @@ const valueFromJson = (value)=>{
     static get NOT_PARSABLE() {
         return new NotParsableExpression();
     }
+    /** `NOT_PARSABLE`, carrying what the parser refused. */ static notParsable(reason) {
+        return new NotParsableExpression(reason);
+    }
     static isEmpty(expression) {
         return expression.type === "empty" || expression instanceof EmptyExpression;
     }
@@ -1897,7 +3556,7 @@ const valueFromJson = (value)=>{
      *
      * ## Why it is this small
      *
-     * Of the six node types a bound tree can contain, exactly one holds anything JSON cannot carry:
+     * Of the seven node types a bound tree can contain, exactly one holds anything JSON cannot carry:
      * `PropertyExpression`, whose live `PropertyInfo` has functions, a parent chain and caches. It
      * reduces to a property PATH — `PropertyInfo.id` IS the dotted path, and `getProperty` is keyed by
      * exactly that — so rebinding is one lookup.
@@ -1912,7 +3571,7 @@ const valueFromJson = (value)=>{
         if (expression.type === "operator") {
             const operator = expression;
             return {
-                t: "operator",
+                type: "operator",
                 operator: operator.operator,
                 ...operator.left != null && {
                     left: Expression.toJson(operator.left)
@@ -1925,7 +3584,7 @@ const valueFromJson = (value)=>{
         if (expression.type === "comparator") {
             const comparator = expression;
             return {
-                t: "comparator",
+                type: "comparator",
                 comparator: comparator.comparator,
                 negated: comparator.negated,
                 strict: comparator.strict,
@@ -1937,29 +3596,41 @@ const valueFromJson = (value)=>{
                 }
             };
         }
+        if (expression.type === "call") {
+            const call = expression;
+            return {
+                type: "call",
+                call: call.call,
+                expression: Expression.toJson(call.expression),
+                arguments: call.arguments.map(Expression.toJson)
+            };
+        }
         if (expression.type === "property") {
             const property = expression;
             return {
-                t: "property",
+                type: "property",
                 // The dotted path, which is exactly the key `getProperty` is looking up
-                path: property.property.id,
-                transformer: property.transformer,
-                locale: property.locale
+                path: property.property.id
             };
         }
         if (expression.type === "value") {
             const value = expression;
             return {
-                t: "value",
-                value: valueToJson(value.value),
-                transformer: value.transformer,
-                locale: value.locale
+                type: "value",
+                value: valueToJson(value.value)
+            };
+        }
+        if (expression.type === "empty") {
+            return {
+                type: "empty"
             };
         }
-        return expression.type === "empty" ? {
-            t: "empty"
+        const reason = expression.reason;
+        return reason == null ? {
+            type: "not-parsable"
         } : {
-            t: "not-parsable"
+            type: "not-parsable",
+            reason
         };
     }
     /**
@@ -1975,14 +3646,14 @@ const valueFromJson = (value)=>{
      * failure here worse than an error.
      */ static fromJson(json, schema) {
         const child = (node)=>node == null ? undefined : Expression.fromJson(node, schema);
-        if (json.t === "operator") {
+        if (json.type === "operator") {
             return new OperatorExpression({
                 operator: json.operator,
                 left: child(json.left),
                 right: child(json.right)
             });
         }
-        if (json.t === "comparator") {
+        if (json.type === "comparator") {
             return new ComparatorExpression({
                 comparator: json.comparator,
                 negated: json.negated,
@@ -1991,27 +3662,34 @@ const valueFromJson = (value)=>{
                 right: child(json.right)
             });
         }
-        if (json.t === "property") {
+        if (json.type === "call") {
+            if (json.expression == null) {
+                throw new Error(`Cannot deserialize a filter: a '${json.call}' call carries no operand.  ` + `Collection: ${schema.collectionName}.`);
+            }
+            return new CallExpression({
+                call: json.call,
+                expression: Expression.fromJson(json.expression, schema),
+                arguments: (json.arguments ?? []).map((argument)=>Expression.fromJson(argument, schema))
+            });
+        }
+        if (json.type === "property") {
             const property = schema.getProperty(json.path);
             if (property == null) {
                 throw new Error(`Cannot deserialize a filter: this schema does not declare the property it names.  ` + `Property: ${json.path}, Collection: ${schema.collectionName}.  ` + `The two sides disagree about the shape of the data, so the filter cannot be applied.`);
             }
-            const rebuilt = new PropertyExpression({
+            return new PropertyExpression({
                 property
             });
-            rebuilt.transformer = json.transformer;
-            rebuilt.locale = json.locale;
-            return rebuilt;
         }
-        if (json.t === "value") {
-            const rebuilt = new ValueExpression({
+        if (json.type === "value") {
+            return new ValueExpression({
                 value: valueFromJson(json.value)
             });
-            rebuilt.transformer = json.transformer;
-            rebuilt.locale = json.locale;
-            return rebuilt;
         }
-        return json.t === "empty" ? Expression.EMPTY : Expression.NOT_PARSABLE;
+        if (json.type === "empty") {
+            return Expression.EMPTY;
+        }
+        return json.reason == null ? Expression.NOT_PARSABLE : Expression.notParsable(json.reason);
     }
 }
 class EmptyExpression extends Expression {
@@ -2019,6 +3697,11 @@ class EmptyExpression extends Expression {
 }
 class NotParsableExpression extends Expression {
     type = "not-parsable";
+    /** What the parser refused, when it knows. `.explain()` prints it beside the source. */ reason;
+    constructor(reason){
+        super();
+        this.reason = reason;
+    }
 }
 /**
  * A class representing a comparison operation (e.g., equals, greater-than).
@@ -2049,20 +3732,28 @@ class NotParsableExpression extends Expression {
  */ class PropertyExpression extends Expression {
     /** The type of the expression (always 'property'). */ type = "property";
     /** The property info for the path. */ property;
-    transformer = null;
-    locale = null;
     constructor(options){
         super();
         this.property = options.property;
     }
 }
+class CallExpression extends Expression {
+    type = "call";
+    call;
+    expression;
+    /** Empty for a unary call. */ arguments;
+    constructor(options){
+        super();
+        this.call = options.call;
+        this.expression = options.expression;
+        this.arguments = options.arguments ?? [];
+    }
+}
 /**
  * A class representing a literal value.
  */ class ValueExpression extends Expression {
     /** The type of the expression (always 'value'). */ type = "value";
     /** The literal value. */ value;
-    transformer = null;
-    locale = null;
     constructor(options){
         super();
         this.value = options.value;
@@ -2073,8 +3764,43 @@ class NotParsableExpression extends Expression {
 },
 63(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
 __webpack_require__.d(__webpack_exports__, {
-  j: () => (forEach)
+  LU: () => (childrenOf),
+  jJ: () => (forEach)
 });
+/**
+ * Separates an operand from the calls applied to it.
+ *
+ * `null` when there is no operand beneath the calls. Every consumer needs this to decide whether a
+ * comparator side is a property or a value, so it lives here rather than in each translator.
+ */ function peelCalls(expression) {
+    const calls = [];
+    let current = expression;
+    while(current != null && current.type === "call"){
+        calls.unshift(current);
+        current = current.expression;
+    }
+    return current == null ? null : {
+        operand: current,
+        calls
+    };
+}
+function childrenOf(expression) {
+    if (expression.type === "call") {
+        const call = expression;
+        return [
+            call.expression,
+            ...call.arguments ?? []
+        ].filter((child)=>child != null);
+    }
+    const children = [];
+    if (expression.left != null) {
+        children.push(expression.left);
+    }
+    if (expression.right != null) {
+        children.push(expression.right);
+    }
+    return children;
+}
 /**
  * Extracts all properties referenced in an expression
  * @param expression The expression to analyze
@@ -2086,12 +3812,8 @@ __webpack_require__.d(__webpack_exports__, {
         if (expr.type === "property") {
             properties.push(expr.property);
         }
-        // Traverse left and right expressions if they exist
-        if (expr.left) {
-            traverse(expr.left);
-        }
-        if (expr.right) {
-            traverse(expr.right);
+        for (const child of childrenOf(expr)){
+            traverse(child);
         }
     }
     traverse(expression);
@@ -2104,14 +3826,8 @@ function forEach(expression, callback) {
         if (!callback(expr)) {
             return false;
         }
-        // Traverse left and right expressions if they exist
-        if (expr.left) {
-            if (!traverse(expr.left)) {
-                return false;
-            }
-        }
-        if (expr.right) {
-            if (!traverse(expr.right)) {
+        for (const child of childrenOf(expr)){
+            if (!traverse(child)) {
                 return false;
             }
         }
@@ -2392,32 +4108,86 @@ __webpack_require__.d(__webpack_exports__, {
   H: () => (QueryOptionsCollection)
 });
 /* import */ var _assertions__rspack_import_1 = __webpack_require__(126);
-/* import */ var _expressions_utils__rspack_import_0 = __webpack_require__(63);
+/* import */ var _expressions_utils__rspack_import_2 = __webpack_require__(63);
+/* import */ var _schema_types__rspack_import_0 = __webpack_require__(537);
+/* import */ var _utilities__rspack_import_3 = __webpack_require__(581);
+
+
 
 
+/** What a schema type is called in JavaScript, where one exists. A value of any other type cannot equal it. */ const JAVASCRIPT_TYPE_OF = {
+    [_schema_types__rspack_import_0/* .SchemaTypes.Number */.L.Number]: "number",
+    [_schema_types__rspack_import_0/* .SchemaTypes.String */.L.String]: "string",
+    [_schema_types__rspack_import_0/* .SchemaTypes.Boolean */.L.Boolean]: "boolean",
+    [_schema_types__rspack_import_0/* .SchemaTypes.Date */.L.Date]: "object"
+};
+const mismatchedSide = (property, value)=>{
+    if (property == null || value == null || !(0,_assertions__rspack_import_1.isPropertyExpression)(property) || !(0,_assertions__rspack_import_1.isValueExpression)(value)) {
+        return null;
+    }
+    const expected = JAVASCRIPT_TYPE_OF[property.property.type];
+    if (expected == null || value.value == null || typeof value.value === expected) {
+        return null;
+    }
+    return {
+        property,
+        value,
+        expected
+    };
+};
+/** A strict comparison whose answer is the same for every row, because the types cannot be equal. */ const comparesTypesThatCannotMatch = (expression)=>{
+    if (!(0,_assertions__rspack_import_1.isComparatorExpression)(expression) || expression.strict !== true) {
+        return false;
+    }
+    if (expression.comparator !== "equals") {
+        return false;
+    }
+    return mismatchedSide(expression.left, expression.right) != null || mismatchedSide(expression.right, expression.left) != null;
+};
+/** `JSON.stringify` throws on a BigInt, and this runs inside the guard that exists to catch one. */ const describeLiteral = (value)=>typeof value === "string" ? `"${value}"` : String(value);
+const mismatchWarning = (expression)=>{
+    const side = mismatchedSide(expression.left, expression.right) ?? mismatchedSide(expression.right, expression.left);
+    const outcome = expression.negated ? "every row matches" : "no row matches";
+    return `Routier: '${side.property.property.getAssignmentPath()}' is a ${side.expected}, and this filter ` + `compares it against ${describeLiteral(side.value.value)}, which is a ${typeof side.value.value}. ` + `A strict comparison between them is the same answer for every row, so ${outcome} and the filter ` + `runs in memory. https://routier.dev/guides/strict-comparison-types`;
+};
+/**
+ * An item as one dispatch receives it: a new object, so a report written on it stays with that dispatch.
+ *
+ * A database option starts `executed` again, because a report is only an answer from the plugin that
+ * made it. A memory option keeps the reason core planned it with. A join's inner options are copied the
+ * same way, since a plugin can report on them too.
+ */ const toDispatchItem = (item)=>{
+    const option = item.option;
+    const value = option.name === "join" ? {
+        ...option.value,
+        innerOptions: option.value.innerOptions.forDispatch()
+    } : option.value;
+    return {
+        index: item.index,
+        option: option.target === "database" ? {
+            ...option,
+            value,
+            reason: "executed"
+        } : {
+            ...option,
+            value
+        }
+    };
+};
 class QueryOptionsCollection {
     options = new Map();
     nextExecutionTarget = "database";
     nextExecutionReason = null;
     nextIndex = 0;
     enumeratedItems = [];
+    dirty = true;
+    /** The collection a `splitAt`/`split` half came from. A capability report belongs to it. */ origin = null;
     /** Cuts over to memory execution, keeping the first cause. See `MemoryExecutionReason`. */ cutOverToMemory(reason) {
         this.nextExecutionTarget = "memory";
         if (this.nextExecutionReason == null) {
             this.nextExecutionReason = reason;
         }
     }
-    /**
-     * True when `split()` or `splitAt()` produced this collection.
-     *
-     * Those rebuild each half by re-adding its options, which re-derives execution targets
-     * without the options that caused them — a post-join filter alone in the memory half
-     * derives back to `"database"`. Anything reading `target` as a report of where work runs
-     * has to reject a derived collection; see `explainQuery`.
-     */ derived = false;
-    get isDerived() {
-        return this.derived;
-    }
     get items() {
         return this.options;
     }
@@ -2442,7 +4212,7 @@ class QueryOptionsCollection {
             }
         }
         if (name === "filter") {
-            // Need to check for unmapped and renamed properties
+            // Need to check for unmapped properties
             const filterValue = value;
             // A tautology (`x => true`) filters nothing — skip it entirely so
             // plugins never see it
@@ -2452,19 +4222,20 @@ class QueryOptionsCollection {
             if (filterValue.expression.type === "not-parsable") {
                 this.cutOverToMemory("not-parsable");
             } else {
-                (0,_expressions_utils__rspack_import_0/* .forEach */.j)(filterValue.expression, (expression)=>{
+                (0,_expressions_utils__rspack_import_2/* .forEach */.jJ)(filterValue.expression, (expression)=>{
                     if ((0,_assertions__rspack_import_1.isPropertyExpression)(expression) && expression.property.isUnmapped) {
                         // Cut over to memory execution, unmapped properties are not in the database and
                         // cannot be queried
                         this.cutOverToMemory("unmapped-property");
                         return false;
                     }
-                    if ((0,_assertions__rspack_import_1.isPropertyExpression)(expression) && expression.property.hasRenamedSegments) {
-                        // Cut over to memory execution: the plugin stores data under the
-                        // `from` (storage) names, but filter selectors reference the
-                        // in-memory names.  Memory execution runs after deserialization,
-                        // where the in-memory names exist
-                        this.cutOverToMemory("renamed-property");
+                    // A renamed property stays with the database. Whether the backend can read a
+                    // `from` name is the plugin's to know, not this collection's: the property
+                    // travels with the option, and a plugin that cannot resolve it reports it
+                    // back — see `reportRenamedProperties`
+                    if (comparesTypesThatCannotMatch(expression)) {
+                        _utilities__rspack_import_3/* .logger.warn */.vF.warn(mismatchWarning(expression));
+                        this.cutOverToMemory("predicate-error");
                         return false;
                     }
                     return true;
@@ -2473,28 +4244,26 @@ class QueryOptionsCollection {
         }
         if (name === "sort") {
             const sortValue = value;
-            // Same rule as filters: sort selectors reference in-memory names, which
-            // only exist after deserialization when the property is renamed or unmapped
+            // Same rule as filters: an unmapped property only exists after deserialization. A
+            // renamed one stays with the database, for the plugin to resolve or report
             if (sortValue.property != null && sortValue.property.isUnmapped) {
                 this.cutOverToMemory("unmapped-property");
-            } else if (sortValue.property != null && sortValue.property.hasRenamedSegments) {
-                this.cutOverToMemory("renamed-property");
             }
         }
         if (name === "nearest") {
             const nearestValue = value;
-            // Same rule as sort, and for the same reason: the plugin stores the vector under
-            // the `from` name, and an unmapped property is not stored at all. Both are only
-            // readable after deserialization, which is where memory execution runs.
-            //
-            // This is also what lets every translator's in-memory fallback read the column by
-            // its resolved name — anything whose storage name differs never reaches them.
+            // Same rule as sort, and for the same reason: an unmapped property is not stored at
+            // all, so it is only readable after deserialization, which is where memory execution
+            // runs. A vector stored under a `from` name is the plugin's to resolve or report.
             if (nearestValue.property != null && nearestValue.property.isUnmapped) {
                 this.cutOverToMemory("unmapped-property");
-            } else if (nearestValue.property != null && nearestValue.property.hasRenamedSegments) {
-                this.cutOverToMemory("renamed-property");
             }
         }
+        if ((name === "filter" || name === "sort") && (this.options.has("skip") || this.options.has("take"))) {
+            // SQL emits WHERE before LIMIT and Mongo's find() filters before skipping, so an option
+            // written after a window can only see the windowed rows if it runs after it.
+            this.cutOverToMemory("after-window");
+        }
         if (name === "join") {
             const joinValue = value;
             // A join whose two sides live on different plugins cannot be sent to EITHER of
@@ -2507,18 +4276,24 @@ class QueryOptionsCollection {
                 this.cutOverToMemory("cross-plugin-join");
             }
         }
+        // `executed` is the plan, not a record: nothing has run when an option is added. Every
+        // consumer reads it after the plugin returned, so the optimistic window is never observed.
         const item = {
             index: this.nextIndex,
-            option: {
+            option: this.nextExecutionTarget === "database" ? {
                 name,
-                target: this.nextExecutionTarget,
                 value,
-                ...this.nextExecutionReason == null ? {} : {
-                    reason: this.nextExecutionReason
-                }
+                target: "database",
+                reason: "executed"
+            } : {
+                name,
+                value,
+                target: "memory",
+                reason: this.nextExecutionReason ?? "not-parsable"
             }
         };
         this.nextIndex++;
+        this.dirty = true;
         const found = this.options.get(name);
         this.options.set(name, [
             ...found ?? [],
@@ -2563,8 +4338,6 @@ class QueryOptionsCollection {
         const sortedItems = this.enumeratedItems.toSorted((a, b)=>a.index - b.index);
         const before = new QueryOptionsCollection();
         const after = new QueryOptionsCollection();
-        before.derived = true;
-        after.derived = true;
         let at = null;
         for(let i = 0, length = sortedItems.length; i < length; i++){
             const { option } = sortedItems[i];
@@ -2573,8 +4346,10 @@ class QueryOptionsCollection {
                 continue;
             }
             const destination = at == null ? before : after;
-            destination.add(option.name, option.value);
+            destination.adopt(sortedItems[i]);
         }
+        before.origin = this.origin ?? this;
+        after.origin = this.origin ?? this;
         return {
             before,
             at,
@@ -2588,6 +4363,9 @@ class QueryOptionsCollection {
      * the shared collection before executing. Without restoring, a re-executed terminal —
      * the whole point of a subscribed queryable — stacks its option a second time and
      * runs it over the first execution's scalar result.
+     *
+     * The item objects are shared with the snapshot. Nothing reports on them, because every
+     * dispatch sends a `forDispatch` copy, so a restore brings back no reports.
      */ snapshot() {
         const options = new Map([
             ...this.options.entries()
@@ -2606,23 +4384,128 @@ class QueryOptionsCollection {
             this.nextExecutionReason = nextExecutionReason;
             this.nextIndex = nextIndex;
             this.enumeratedItems = [];
+            // Clearing the list is not enough now that staleness is a flag rather than a count:
+            // without this, `resolveEnumeration` believes the empty list is current and every read
+            // of the collection sees no options at all.
+            this.dirty = true;
+        };
+    }
+    /** Takes an item as it stands — same object, same index, same target and reason. */ adopt(item) {
+        const found = this.options.get(item.option.name);
+        this.options.set(item.option.name, [
+            ...found ?? [],
+            item
+        ]);
+        this.nextIndex = Math.max(this.nextIndex, item.index + 1);
+        this.dirty = true;
+    }
+    /**
+     * A plugin reporting that its engine cannot express one option.
+     *
+     * Core marks the rest of the database phase `not-reached`, because the database has to stop
+     * there — a window applied in front of a filter that was not applied returns the wrong rows.
+     * Passing the cascade through core is what makes it impossible for a plugin to mark a
+     * non-contiguous cut.
+     *
+     * A report names a culprit and never un-names one, so reports commute.
+     *
+     * The option is not moved to the memory arm. It stays where it was planned, which is what keeps
+     * a redirect distinguishable from something core sent to memory in the first place.
+     */ reportMissingCapability(item) {
+        this.report(item, "missing-capability");
+    }
+    /**
+     * A plugin reporting that its engine would answer one option differently from JavaScript.
+     *
+     * Same cascade as `reportMissingCapability`, and a separate reason because the caller can act on
+     * one and not the other. See `DatabaseExecutionReason`.
+     */ reportEngineDivergence(item) {
+        this.report(item, "engine-divergence");
+    }
+    report(item, reason) {
+        // A half can only see its own slice, and the database has to stop for the whole dispatch.
+        if (this.origin != null) {
+            this.origin.report(item, reason);
+            return;
+        }
+        this.resolveEnumeration();
+        for (const candidate of this.enumeratedItems){
+            if (candidate.option.target !== "database" || candidate.index < item.index) {
+                continue;
+            }
+            if (candidate.index === item.index) {
+                candidate.option.reason = reason;
+                continue;
+            }
+            if (candidate.option.reason === "executed") {
+                candidate.option.reason = "not-reached";
+            }
+        }
+    }
+    /**
+     * A copy of the collection for one dispatch to a plugin, with nothing reported on it.
+     *
+     * Capability is answered per dispatch, so a report is only an answer for the execution that
+     * produced it. Reports are written onto items, and the items of a queryable's collection
+     * outlive any one execution: a snapshot shares them, and a subscription dispatches the same
+     * query on every change. A report left on them replays options the plugin did run on the
+     * next execution, such as a `skip` applied twice over rows already windowed, or hands a
+     * renamed filter to memory that the engine could have run.
+     *
+     * Each item keeps its index, name, value and target. A half from `split`/`splitAt` is copied
+     * with a copy of its origin, and its items are that copy's items, so a report on the half still
+     * cascades over the whole dispatch without reaching the collection it was copied from.
+     */ forDispatch() {
+        if (this.origin == null) {
+            return this.copyForDispatch().copy;
+        }
+        const { copy: root, copies } = this.origin.copyForDispatch();
+        const half = new QueryOptionsCollection();
+        this.resolveEnumeration();
+        for (const item of this.enumeratedItems){
+            // An item added to the half after it was split has no counterpart in the origin
+            half.adopt(copies.get(item) ?? toDispatchItem(item));
+        }
+        half.origin = root;
+        return half;
+    }
+    copyForDispatch() {
+        const copy = new QueryOptionsCollection();
+        const copies = new Map();
+        this.resolveEnumeration();
+        for (const item of this.enumeratedItems){
+            const copied = toDispatchItem(item);
+            copies.set(item, copied);
+            copy.adopt(copied);
+        }
+        copy.nextExecutionTarget = this.nextExecutionTarget;
+        copy.nextExecutionReason = this.nextExecutionReason;
+        copy.nextIndex = this.nextIndex;
+        return {
+            copy,
+            copies
         };
     }
+    /** The options the database did not run, in the order they were written. */ notExecuted() {
+        this.resolveEnumeration();
+        return this.enumeratedItems.filter((item)=>item.option.target === "database" && item.option.reason !== "executed").toSorted((a, b)=>a.index - b.index);
+    }
     split() {
         this.resolveEnumeration();
         const sortedItems = this.enumeratedItems.toSorted((a, b)=>a.index - b.index);
         const memoryQueryOptionsCollection = new QueryOptionsCollection();
         const databaseQueryOptionsCollection = new QueryOptionsCollection();
-        memoryQueryOptionsCollection.derived = true;
-        databaseQueryOptionsCollection.derived = true;
         for(let i = 0, length = sortedItems.length; i < length; i++){
             const sortedItem = sortedItems[i];
-            if (sortedItem.option.target === "database") {
-                databaseQueryOptionsCollection.add(sortedItem.option.name, sortedItem.option.value);
-                continue;
-            }
-            memoryQueryOptionsCollection.add(sortedItem.option.name, sortedItem.option.value);
-        }
+            const half = sortedItem.option.target === "database" ? databaseQueryOptionsCollection : memoryQueryOptionsCollection;
+            // The ITEM, not its name and value. Re-adding would re-derive target and reason from a
+            // fresh cascade, and a memory option re-added alone comes back out as `database` with no
+            // reason at all. Sharing it also means a plugin's report on the database half is the
+            // same object the explanation reads.
+            half.adopt(sortedItem);
+        }
+        memoryQueryOptionsCollection.origin = this.origin ?? this;
+        databaseQueryOptionsCollection.origin = this.origin ?? this;
         return {
             memory: memoryQueryOptionsCollection,
             database: databaseQueryOptionsCollection
@@ -2668,8 +4551,11 @@ class QueryOptionsCollection {
         ].flat().toSorted((a, b)=>a.index - b.index);
     }
     resolveEnumeration() {
-        if (this.enumeratedItems.length != this.nextIndex) {
+        // A flag, not a count: adopting leaves gaps in the indexes, so `length !== nextIndex` is
+        // true forever on a half and the enumeration rebuilds on every read.
+        if (this.dirty === true) {
             this.enumeratedItems = this.getEnumeration();
+            this.dirty = false;
         }
     }
     forEach(iterator) {
@@ -2760,42 +4646,164 @@ class PluginEventResult extends BaseResult {
             throw new Error(`Expected success result, but got ${result.ok}: ${result.error}`);
         }
     }
-}
-
-
-},
-537(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-__webpack_require__.d(__webpack_exports__, {
-  L: () => (SchemaTypes)
-});
-var SchemaTypes = /*#__PURE__*/ function(SchemaTypes) {
-    SchemaTypes["Array"] = "Array";
-    SchemaTypes["Boolean"] = "Boolean";
-    SchemaTypes["Date"] = "Date";
-    SchemaTypes["Number"] = "Number";
-    SchemaTypes["Object"] = "Object";
-    SchemaTypes["String"] = "String";
-    SchemaTypes["Definition"] = "Definition";
-    SchemaTypes["Function"] = "Function";
-    SchemaTypes["Computed"] = "Computed";
-    /**
-     * Content in, reference out. The only type whose write shape differs from its stored
-     * shape, and a leaf on purpose — see `SchemaFile`.
-     */ SchemaTypes["File"] = "File";
-    /**
-     * A fixed-length list of numbers, carrying its dimension count — see `SchemaVector`.
-     *
-     * Value-shaped exactly like `s.array(s.number())`, which is why every array codegen
-     * handler accepts it. It is a distinct type only so a backend can recognise it and store
-     * it natively; nothing else needs to tell the two apart.
-     */ SchemaTypes["Vector"] = "Vector";
-    return SchemaTypes;
-}({});
-var HashType = /*#__PURE__*/ (/* unused pure expression or super */ null && (function(HashType) {
-    HashType["Ids"] = "Ids";
-    HashType["Object"] = "Object";
-    return HashType;
-}({})));
+}
+
+
+},
+537(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.d(__webpack_exports__, {
+  L: () => (SchemaTypes)
+});
+var SchemaTypes = /*#__PURE__*/ function(SchemaTypes) {
+    SchemaTypes["Array"] = "Array";
+    SchemaTypes["Boolean"] = "Boolean";
+    SchemaTypes["Date"] = "Date";
+    SchemaTypes["Number"] = "Number";
+    SchemaTypes["Object"] = "Object";
+    SchemaTypes["String"] = "String";
+    SchemaTypes["Definition"] = "Definition";
+    SchemaTypes["Function"] = "Function";
+    SchemaTypes["Computed"] = "Computed";
+    /**
+     * Content in, reference out. The only type whose write shape differs from its stored
+     * shape, and a leaf on purpose — see `SchemaFile`.
+     */ SchemaTypes["File"] = "File";
+    /**
+     * A fixed-length list of numbers, carrying its dimension count — see `SchemaVector`.
+     *
+     * Value-shaped exactly like `s.array(s.number())`, which is why every array codegen
+     * handler accepts it. It is a distinct type only so a backend can recognise it and store
+     * it natively; nothing else needs to tell the two apart.
+     */ SchemaTypes["Vector"] = "Vector";
+    return SchemaTypes;
+}({});
+var HashType = /*#__PURE__*/ (/* unused pure expression or super */ null && (function(HashType) {
+    HashType["Ids"] = "Ids";
+    HashType["Object"] = "Object";
+    return HashType;
+}({})));
+
+
+},
+575(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.d(__webpack_exports__, {
+  l: () => (isArrayValued)
+});
+/* import */ var _types__rspack_import_0 = __webpack_require__(537);
+
+/**
+ * Types whose runtime value is a JS array.
+ *
+ * `Array` and `Vector` are the same thing to every layer that copies, compares, hashes or
+ * freezes a value — a vector is a list of numbers and nothing more. They differ only where a
+ * backend chooses storage, which is the one place that should ask for `SchemaTypes.Vector` by
+ * name.
+ *
+ * This exists so adding a third array-shaped type is one edit rather than a hunt through
+ * twelve handlers. Missing one of those is silent in the worst way: a vector that clones by
+ * reference is shared with the change tracker's copy, so overwriting an embedding produces no
+ * diff and the save reports nothing to do.
+ */ const ARRAY_VALUED_TYPES = new Set([
+    _types__rspack_import_0/* .SchemaTypes.Array */.L.Array,
+    _types__rspack_import_0/* .SchemaTypes.Vector */.L.Vector
+]);
+/** True when the property's value is a JS array and needs value rather than reference semantics. */ const isArrayValued = (type)=>ARRAY_VALUED_TYPES.has(type);
+/**
+ * True when the property's elements are primitives, so a spread is a sufficient copy.
+ *
+ * A vector is always numbers, so it never needs the per-element deep copy an array of objects
+ * or dates does.
+ */ const PRIMITIVE_ELEMENT_TYPES = new Set([
+    _types__rspack_import_0/* .SchemaTypes.String */.L.String,
+    _types__rspack_import_0/* .SchemaTypes.Number */.L.Number,
+    _types__rspack_import_0/* .SchemaTypes.Boolean */.L.Boolean
+]);
+const hasPrimitiveElements = (type, elementType)=>type === SchemaTypes.Vector || PRIMITIVE_ELEMENT_TYPES.has(elementType);
+
+
+},
+894(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.d(__webpack_exports__, {
+  T: () => (getStorageDateReviver)
+});
+/* import */ var _types__rspack_import_0 = __webpack_require__(537);
+/* import */ var _propertyKind__rspack_import_1 = __webpack_require__(575);
+
+
+const collectDatePaths = (properties, paths)=>{
+    for (const property of properties){
+        // The stored value belongs to whoever wrote it: a custom serializer, deserializer or
+        // transform reads it back, and would be handed a Date it did not expect. Unmapped
+        // properties are never stored.
+        if (property.valueSerializer != null || property.valueDeserializer != null || property.transform != null || property.isUnmapped) {
+            continue;
+        }
+        if (property.type === _types__rspack_import_0/* .SchemaTypes.Object */.L.Object) {
+            collectDatePaths(property.children, paths);
+            continue;
+        }
+        const isArray = (0,_propertyKind__rspack_import_1/* .isArrayValued */.l)(property.type) && property.innerSchema?.type === _types__rspack_import_0/* .SchemaTypes.Date */.L.Date;
+        if (property.type !== _types__rspack_import_0/* .SchemaTypes.Date */.L.Date && isArray === false) {
+            continue;
+        }
+        paths.push({
+            segments: [
+                ...property.getParentPathArray({
+                    useFromPropertyName: true
+                }),
+                property.getResolvedName()
+            ],
+            isArray
+        });
+    }
+};
+const reviveAt = (record, path)=>{
+    const { segments } = path;
+    let parent = record;
+    for(let i = 0, length = segments.length - 1; i < length; i++){
+        parent = parent[segments[i]];
+        // An absent or null parent holds no date
+        if (parent == null || typeof parent !== "object") {
+            return;
+        }
+    }
+    const key = segments[segments.length - 1];
+    const value = parent[key];
+    if (path.isArray === false) {
+        if (typeof value === "string") {
+            parent[key] = new Date(value);
+        }
+        return;
+    }
+    if (Array.isArray(value)) {
+        for(let i = 0, length = value.length; i < length; i++){
+            if (typeof value[i] === "string") {
+                value[i] = new Date(value[i]);
+            }
+        }
+    }
+};
+/** Per schema: `null` for a schema with no dates, so a caller can skip the pass. */ const revivers = new WeakMap();
+/**
+ * The reviver for `schema`'s records, or `null` when it declares no dates.
+ *
+ * Built once per compiled schema. A read revives every row it returns, so the paths are resolved
+ * here rather than per row.
+ */ const getStorageDateReviver = (schema)=>{
+    const cached = revivers.get(schema);
+    if (cached !== undefined) {
+        return cached;
+    }
+    const paths = [];
+    collectDatePaths(schema.properties, paths);
+    const reviver = paths.length === 0 ? null : (record)=>{
+        for(let i = 0, length = paths.length; i < length; i++){
+            reviveAt(record, paths[i]);
+        }
+    };
+    revivers.set(schema, reviver);
+    return reviver;
+};
 
 
 },
@@ -2889,12 +4897,14 @@ const isLogLevel = (value)=>typeof value === 'string' && LOG_LEVELS.includes(val
         const debug = process.env.DEBUG;
         if (debug === 'routier' || debug === '*') return 'debug';
         const env = "production"?.toLowerCase();
-        // `test` is deliberately absent. It used to be here, which meant no test suite anywhere
-        // could run Routier quietly. Opt in with DEBUG=routier or ROUTIER_LOG_LEVEL when a test
-        // needs the output.
         if (env === 'dev' || env === 'development') return 'debug';
     }
-    return 'silent';
+    // Warnings are on unless something turns them off.
+    //
+    // Routier warns when a query returns correct rows a slower way than it could, or when a filter
+    // compares types that can never match. Both are the caller's to act on, and a default of
+    // `silent` meant the only people who ever saw them were the ones who already knew to look.
+    return 'warn';
 };
 let level = resolveLevel();
 let rank = RANK[level];
@@ -3057,6 +5067,7 @@ __webpack_require__.r(__webpack_exports__);
 
 // EXPORTS
 __webpack_require__.d(__webpack_exports__, {
+  describeFilters: () => (/* reexport */ describeFilters),
   DEFAULT_SEMI_JOIN_KEY_THRESHOLD: () => (/* reexport */ DEFAULT_SEMI_JOIN_KEY_THRESHOLD),
   TranslatedArrayValue: () => (/* reexport */ TranslatedArrayValue),
   collectingSink: () => (/* reexport */ collectingSink),
@@ -3064,15 +5075,18 @@ __webpack_require__.d(__webpack_exports__, {
   CacheDbPlugin: () => (/* reexport */ CacheDbPlugin),
   Query: () => (/* reexport */ Query),
   splitSendableOptions: () => (/* reexport */ splitSendableOptions),
+  withInnerSide: () => (/* reexport */ withInnerSide),
   executeJoin: () => (/* reexport */ executeJoin),
   formatExplanation: () => (/* reexport */ formatExplanation),
-  serializePersistResult: () => (/* reexport */ serializePersistResult),
+  parameteriseDocument: () => (/* reexport */ parameteriseDocument),
   mappedResultColumns: () => (/* reexport */ mappedResultColumns),
   explainQuery: () => (/* reexport */ explainQuery),
+  parameter: () => (/* reexport */ parameter),
+  serializePersistResult: () => (/* reexport */ serializePersistResult),
+  applyInnerOptions: () => (/* reexport */ applyInnerOptions),
   cosineDistance: () => (/* reexport */ cosineDistance),
   RetryDbPlugin: () => (/* reexport */ RetryDbPlugin),
   BatchingDbPlugin: () => (/* reexport */ BatchingDbPlugin),
-  applyInnerOptions: () => (/* reexport */ applyInnerOptions),
   MEMORY_EXECUTION_EXPLANATIONS: () => (/* reexport */ MEMORY_EXECUTION_EXPLANATIONS),
   TupleTranslator: () => (/* reexport */ TupleTranslator),
   TranslatedSingleValue: () => (/* reexport */ TranslatedSingleValue),
@@ -3080,27 +5094,33 @@ __webpack_require__.d(__webpack_exports__, {
   TranslatedGroupValue: () => (/* reexport */ TranslatedGroupValue),
   deserializeBulkPersist: () => (/* reexport */ deserializeBulkPersist),
   EXECUTED_QUERIES_UNSUPPORTED: () => (/* reexport */ EXECUTED_QUERIES_UNSUPPORTED),
-  joinInPlugin: () => (/* reexport */ joinInPlugin),
+  executedQueriesOf: () => (/* reexport */ executedQueriesOf),
   deserializePersistResult: () => (/* reexport */ deserializePersistResult),
+  joinInPlugin: () => (/* reexport */ joinInPlugin),
   loggerSink: () => (/* reexport */ loggerSink),
   nearestBy: () => (/* reexport */ nearestBy),
-  readJoinKey: () => (/* reexport */ readJoinKey),
   hashJoin: () => (/* reexport */ hashJoin),
   EphemeralDataPlugin: () => (/* reexport */ EphemeralDataPlugin),
   QueryOptionsCollection: () => (/* reexport */ QueryOptionsCollection/* .QueryOptionsCollection */.H),
-  serializeBulkPersist: () => (/* reexport */ serializeBulkPersist),
-  toEntityShape: () => (/* reexport */ toEntityShape),
+  describeUnparsableFilter: () => (/* reexport */ describeUnparsableFilter),
+  readJoinKey: () => (/* reexport */ readJoinKey),
   loadJoinInnerSide: () => (/* reexport */ loadJoinInnerSide),
   DataTranslator: () => (/* reexport */ DataTranslator),
-  withExecutedQueries: () => (/* reexport */ withExecutedQueries),
+  reportRenamedProperties: () => (/* reexport */ reportRenamedProperties),
+  serializeBulkPersist: () => (/* reexport */ serializeBulkPersist),
   TelemetryDbPlugin: () => (/* reexport */ TelemetryDbPlugin),
+  toEntityShape: () => (/* reexport */ toEntityShape),
   createRequestHandler: () => (/* reexport */ createRequestHandler),
   SqlTranslator: () => (/* reexport */ SqlTranslator),
+  withExecutedQueries: () => (/* reexport */ withExecutedQueries),
   QueryOrdering: () => (/* reexport */ types_QueryOrdering),
+  describeFilterAsJs: () => (/* reexport */ describeFilterAsJs),
   serializeQueryOptions: () => (/* reexport */ serializeQueryOptions),
-  distinctJoinKeys: () => (/* reexport */ distinctJoinKeys),
   JsonTranslator: () => (/* reexport */ JsonTranslator),
-  deserializeQueryOptions: () => (/* reexport */ deserializeQueryOptions)
+  DATABASE_EXECUTION_EXPLANATIONS: () => (/* reexport */ DATABASE_EXECUTION_EXPLANATIONS),
+  distinctJoinKeys: () => (/* reexport */ distinctJoinKeys),
+  deserializeQueryOptions: () => (/* reexport */ deserializeQueryOptions),
+  isDatabaseStep: () => (/* reexport */ isDatabaseStep)
 });
 
 ;// CONCATENATED MODULE: ./src/plugins/resultShape.ts
@@ -3209,6 +5229,10 @@ class DataTranslator {
     translate(data) {
         const isTransformed = this.query.options.hasTransformations();
         this.query.options.forEach((item)=>{
+            // The plugin reported it could not run this one, so the memory pass owns it now.
+            if (item.target === "database" && item.reason !== "executed") {
+                return;
+            }
             data = this.functionMap[item.name](data, item);
         });
         if (Array.isArray(data)) {
@@ -3621,7 +5645,7 @@ class Query {
      * Only a plugin that runs its outer query FIRST can supply these, and most run this loader
      * before anything else — so it is optional, and its absence costs a wider inner read rather
      * than a wrong one.
-     */ outerKeys)=>{
+     */ outerKeys, /** Where the inner read reports what it executed. Defaults to the outer read's own list. */ innerExecutedQueries)=>{
     const joinOption = event.operation.options.getLast("join");
     if (joinOption == null) {
         done({
@@ -3649,9 +5673,10 @@ class Query {
         action: "query",
         reason: "join inner side",
         explain: event.explain,
-        // The same array the outer read pushes into, so a join reports BOTH reads in execution
-        // order. Built fresh rather than spread, so this has to be carried explicitly.
-        executedQueries: event.executedQueries
+        // The caller decides where the inner read reports, because only it knows whether the inner
+        // side is the SAME plugin — where both reads belong in one explanation — or a different one,
+        // where a PouchDB scan filed under SqliteDbPlugin is a lie.
+        executedQueries: innerExecutedQueries ?? event.executedQueries
     };
     query(innerEvent, (result)=>{
         if (result.ok === Result/* .PluginEventResult.ERROR */.D.ERROR) {
@@ -3728,6 +5753,12 @@ class Query {
                 return;
             }
             const outerRows = outerResult.data.value ?? [];
+            if (at.reason !== "executed") {
+                // The outer read reported something, so the database phase stopped before the join.
+                // The datastore's own join branch pairs these rows.
+                done(Result/* .PluginEventResult.success */.D.success(event.id, new TranslatedArrayValue(outerRows, false)));
+                return;
+            }
             // Storage shape: the plugin returns rows as it holds them, and deserialization is what
             // `executeJoin` does per side below.
             const outerKeys = distinctJoinKeys(outerRows, at.value.outerKey, at.value.semiJoinKeyThreshold, {
@@ -3843,9 +5874,7 @@ class JsonTranslator extends DataTranslator {
                 if (field.property != null) {
                     const value = field.property.getValue(data[i]);
                     if (value != null) {
-                        // Some types do not support deserialization (Array, Function, Computed, etc), just directly set the incoming value
-                        const resolvedValue = field.property.supportsDeserialization ? field.property.deserialize(value) : value;
-                        field.property.setValue(data[i], resolvedValue);
+                        field.property.setValue(data[i], field.property.deserialize(value));
                     }
                 }
             }
@@ -3869,9 +5898,7 @@ class JsonTranslator extends DataTranslator {
                 if (field.property != null) {
                     const value = field.property.getValue(data[i]);
                     if (value != null) {
-                        // Some types do not support deserialization (Array, Function, Computed, etc), just directly set the incoming value
-                        const resolvedValue = field.property.supportsDeserialization ? field.property.deserialize(value) : value;
-                        field.property.setValue(item, resolvedValue);
+                        field.property.setValue(item, field.property.deserialize(value));
                         continue;
                     }
                     // The property exists, lets set it to the value (null/undefined)
@@ -4059,9 +6086,12 @@ class JsonTranslator extends DataTranslator {
     }
 }
 
+// EXTERNAL MODULE: ./src/schema/utils/storageDates.ts
+var storageDates = __webpack_require__(894);
 ;// CONCATENATED MODULE: ./src/plugins/translators/SqlTranslator.ts
 
 
+
 /**
  * A stored vector as a list of numbers, whatever the driver handed back.
  *
@@ -4090,6 +6120,31 @@ class SqlTranslator extends DataTranslator {
         super(query);
         this.pushedDown = pushedDown;
     }
+    /**
+     * Dates back as Dates, before the caller's selectors run over the rows.
+     *
+     * A `group` key and a `map` are the caller's lambdas, run here over rows as the engine returned them.
+     * SQLite, D1 and libSQL hand a date back as the TEXT it was stored as, which has no `getFullYear()`
+     * and groups apart from the Date the entity holds. Revived at storage paths and in place, which the
+     * datastore's deserialization still reads, and after `decodeJsonColumns`, so a date inside a JSON
+     * column is revived too. Only a string is converted, so an engine that returns a Date (PostgreSQL,
+     * PGlite, MySQL) is left alone, and so is a row already revived.
+     *
+     * Not a joined statement's rows, which are tuples, each half already deserialized. Nor rows whose
+     * `group` or `map` was handed back, which the datastore runs after deserializing them.
+     */ translate(data) {
+        const runsHere = (name)=>this.query.options.get(name).some((item)=>item.option.target === "database" && item.option.reason === "executed");
+        if (this.pushedDown.join !== true && this.query.schema != null && Array.isArray(data) && (runsHere("group") || runsHere("map"))) {
+            const reviveDates = (0,storageDates/* .getStorageDateReviver */.T)(this.query.schema);
+            for(let i = 0, length = reviveDates == null ? 0 : data.length; i < length; i++){
+                const row = data[i];
+                if (row != null && typeof row === "object") {
+                    reviveDates(row);
+                }
+            }
+        }
+        return super.translate(data);
+    }
     count(data, _) {
         if (Array.isArray(data) && data.length > 0) {
             // Count is returned as the property alias on the query.
@@ -4212,9 +6267,12 @@ class SqlTranslator extends DataTranslator {
             for(let j = 0, l = option.value.fields.length; j < l; j++){
                 const field = option.value.fields[j];
                 if (field.property != null) {
-                    const value = field.property.getValue(data[i]);
+                    const row = data[i];
+                    // A nested field arrives FLAT, under the alias the statement emitted, because
+                    // the value was read out of a JSON column. `setValue` puts it back on its path.
+                    const value = Object.prototype.hasOwnProperty.call(row, field.sourceName) ? row[field.sourceName] : field.property.getValue(row);
                     if (value != null) {
-                        field.property.setValue(data[i], field.property.deserialize(value));
+                        field.property.setValue(row, field.property.deserialize(value));
                     }
                 }
             }
@@ -4351,6 +6409,183 @@ class SqlTranslator extends DataTranslator {
 
 
 
+// EXTERNAL MODULE: ./src/expressions/callSource.ts
+var callSource = __webpack_require__(429);
+;// CONCATENATED MODULE: ./src/plugins/query/describeFilter.ts
+
+
+const COMPARATOR_OPERATORS = {
+    "equals": "===",
+    "greater-than": ">",
+    "greater-than-equals": ">=",
+    "less-than": "<",
+    "less-than-equals": "<="
+};
+/** The three comparators that read as a method call rather than an operator. */ const COMPARATOR_METHODS = {
+    "starts-with": "startsWith",
+    "includes": "includes",
+    "ends-with": "endsWith"
+};
+const renderProperty = (property)=>property.property.getPathArray().join(".");
+/**
+ * The predicate as JavaScript, with every value replaced by `?`.
+ *
+ * Rendered from the parsed tree rather than from the function's source. The tree is what the
+ * backend was actually given, so this cannot drift from what ran; and a value reaching the tree
+ * as a literal is indistinguishable from one arriving through a params object, which is what
+ * makes both come out as `?` the way SQL treats them.
+ */ const describeFilterAsJs = (expression)=>{
+    const parameters = [];
+    const hold = (value)=>{
+        parameters.push(value);
+        return "?";
+    };
+    const side = (part)=>{
+        if (part == null) {
+            return "?";
+        }
+        if ((0,assertions.isPropertyExpression)(part)) {
+            return renderProperty(part);
+        }
+        if ((0,assertions.isValueExpression)(part)) {
+            return hold(part.value);
+        }
+        if ((0,assertions.isCallExpression)(part)) {
+            return (0,callSource/* .renderCallAsJs */.a)(part.call, ()=>side(part.expression), ()=>part.arguments.map(side));
+        }
+        return walk(part);
+    };
+    const walk = (current)=>{
+        if ((0,assertions.isOperatorExpression)(current)) {
+            const operator = current.operator === "&&" ? "&&" : "||";
+            return `(${side(current.left)} ${operator} ${side(current.right)})`;
+        }
+        if ((0,assertions.isComparatorExpression)(current)) {
+            const method = COMPARATOR_METHODS[current.comparator];
+            // Evaluated LEFT then RIGHT, always: the parameter order has to match the reading
+            // order of the text, or the values line up against the wrong placeholders.
+            const left = side(current.left);
+            const right = side(current.right);
+            if (method != null) {
+                const call = `${left}.${method}(${right})`;
+                return current.negated ? `${call} === false` : call;
+            }
+            const symbol = COMPARATOR_OPERATORS[current.comparator];
+            if (symbol == null) {
+                return `${left} ${current.comparator} ${right}`;
+            }
+            return `${left} ${current.negated ? negate(symbol) : symbol} ${right}`;
+        }
+        if ((0,assertions.isCallExpression)(current)) {
+            return (0,callSource/* .renderCallAsJs */.a)(current.call, ()=>side(current.expression), ()=>current.arguments.map(side));
+        }
+        if (current.type === "empty") {
+            return "(no filter)";
+        }
+        return current.type === "not-parsable" ? "(not parsable)" : `(unsupported: ${current.type})`;
+    };
+    return {
+        text: walk(expression),
+        parameters
+    };
+};
+const negate = (symbol)=>{
+    switch(symbol){
+        case "===":
+            return "!==";
+        case ">":
+            return "<=";
+        case ">=":
+            return "<";
+        case "<":
+            return ">=";
+        case "<=":
+            return ">";
+        default:
+            return `!${symbol}`;
+    }
+};
+/**
+ * Marks a value inside a query document so it is replaced by `?` rather than printed.
+ *
+ * A document language carries its values inline, so there is nothing in the shape itself to say
+ * which parts are operators and which are data. A dialect wraps the data as it builds the
+ * document, and `parameteriseDocument` reads the wrapper.
+ */ const PARAMETER = Symbol("routier.parameter");
+const parameter = (value)=>({
+        [PARAMETER]: value
+    });
+const isParameter = (value)=>typeof value === "object" && value !== null && PARAMETER in value;
+/**
+ * Renders a query DOCUMENT with its values replaced by `?`.
+ *
+ * Language-agnostic on purpose: an MQL filter and a Mango selector are both plain objects, and so
+ * is whatever a future document store wants reported. The dialect decides the shape; this only
+ * decides how it is written down.
+ *
+ * A value not wrapped by `parameter` is structural — an operator name, a field path, a nesting
+ * level — and is printed as it is. That is the whole distinction, and it has to be made where the
+ * document is built, because by the time it is an object the two are the same kind of thing.
+ */ const parameteriseDocument = (document)=>{
+    const parameters = [];
+    const render = (value)=>{
+        if (isParameter(value)) {
+            parameters.push(value[PARAMETER]);
+            return "?";
+        }
+        if (Array.isArray(value)) {
+            return `[${value.map(render).join(", ")}]`;
+        }
+        if (typeof value === "object" && value !== null) {
+            const entries = Object.entries(value).map(([key, nested])=>`${JSON.stringify(key)}: ${render(nested)}`);
+            return `{ ${entries.join(", ")} }`;
+        }
+        return JSON.stringify(value) ?? String(value);
+    };
+    return {
+        text: render(document),
+        parameters
+    };
+};
+/**
+ * Every filter on a query, as one description.
+ *
+ * Filters accumulate — `.where(a).where(b)` is `a && b` — so they are reported as one predicate
+ * rather than several, which is how the caller thinks of them and how a SQL plugin renders them
+ * into one `WHERE`. Parameters run left to right across the whole thing, matching the text.
+ *
+ * A filter that could not be parsed falls back to its source. Mixing the two is deliberate: one
+ * unparsable filter does not make the others unreadable, and seeing which one it was is the
+ * point.
+ */ const describeFilters = (filters)=>{
+    const parameters = [];
+    const parts = filters.map((entry)=>{
+        const described = entry.expression?.type === "not-parsable" ? describeUnparsableFilter(entry.filter, entry.expression.reason) : describeFilterAsJs(entry.expression);
+        parameters.push(...described.parameters);
+        return described.text;
+    });
+    if (parts.length === 0) {
+        return {
+            text: "(no filter)",
+            parameters: []
+        };
+    }
+    return {
+        text: parts.length === 1 ? parts[0] : parts.join(" && "),
+        parameters
+    };
+};
+/**
+ * A predicate core could not parse, shown as the caller wrote it.
+ *
+ * This is the case where the source matters most: an unparsable filter is why the query did not
+ * push down, and the reason codes say that it happened without showing what it was. There are no
+ * parameters — nothing was extracted, because nothing was understood.
+ */ const describeUnparsableFilter = (filter, reason)=>({
+        text: typeof filter === "function" ? `${String(filter)} — ${reason ?? "could not be parsed"}, evaluated in memory` : "(not parsable)",
+        parameters: []
+    });
+
 ;// CONCATENATED MODULE: ./src/plugins/query/explain.ts
 
 /**
@@ -4361,16 +6596,26 @@ class SqlTranslator extends DataTranslator {
  */ const MEMORY_EXECUTION_EXPLANATIONS = {
     "not-parsable": "A filter could not be parsed into an expression tree, so it and every option after it run in memory.",
     "unmapped-property": "The property is not stored in the database, so it can only be read after deserialization.",
-    "renamed-property": "The property is stored under a different name, and selectors use the in-memory name, so it can only be read after deserialization.",
     "map-rename": "A map renames or drops properties, so every option after it refers to names the database does not have.",
     "after-nearest": "A similarity search orders and limits rows, and the plugin cannot report whether it performed the search, so every option after it runs in memory.",
     "after-join": "A join produces [outer, inner] tuples rather than entities, and the plugin cannot report how it joined, so every option after it runs in memory.",
-    "cross-plugin-join": "The two sides of this join live on different plugins, so neither can read the other's rows and the join runs in the datastore."
+    "cross-plugin-join": "The two sides of this join live on different plugins, so neither can read the other's rows and the join runs in the datastore.",
+    "after-window": "A skip or take runs before this option, and SQL applies WHERE before LIMIT, so pushing it down would window rows this option had not seen yet. It runs in memory over the windowed rows instead.",
+    "predicate-error": "A strict comparison compares a column against a value of a type it can never equal, so the answer is the same for every row and the filter runs in memory. Check the types in the filter."
 };
 const EXECUTED_QUERIES_UNSUPPORTED = "This plugin did not report what it executed. It may not support explain.";
-const DATABASE_STEP_DESCRIPTION = "These options are sent to the plugin.";
-const MEMORY_STEP_DESCRIPTION = "Routier runs these over the rows the database returned, after deserializing them.";
-const UNNARROWED_READ_DESCRIPTION = "No option could be pushed down, so the plugin reads the whole collection.";
+/**
+ * Why an option planned for the database did not run there. `executed` has no sentence: it needs no
+ * explaining, and a step made of executed options is a database step like any other.
+ */ const DATABASE_EXECUTION_EXPLANATIONS = {
+    "missing-capability": "The plugin's engine cannot express this option, so it runs in memory over the rows the plugin did return. Only the plugin can know this — an engine's capabilities are not visible from here.",
+    "engine-divergence": "The plugin's engine would answer this option differently from JavaScript, so it runs in memory instead and the rows match what the predicate means. Nothing in the query needs changing.",
+    "not-reached": "The database stopped at an option it could not express, so this one runs in memory too. Carrying on would apply it to rows the earlier option had not filtered."
+};
+/**
+ * TypeScript does not narrow a union from a discriminant nested inside a property, so the two kinds
+ * of step need a guard rather than an inline check.
+ */ const isDatabaseStep = (step)=>step.executedIn.kind === "database";
 /**
  * The reportable shape of one option's value.
  *
@@ -4451,12 +6696,16 @@ const explainedOptionsOf = (options)=>{
     options.forEach((option)=>explained.push(explainedOptionOf(option, index++)));
     return explained;
 };
+/** Every sentence, whoever decided — the summary reads the same either way. */ const EXPLANATIONS = {
+    ...MEMORY_EXECUTION_EXPLANATIONS,
+    ...DATABASE_EXECUTION_EXPLANATIONS
+};
 const summarize = (steps)=>{
     const reasons = [];
     let database = 0;
     let memory = 0;
     for (const step of steps){
-        if (step.executedIn === "database") {
+        if (isDatabaseStep(step)) {
             database += step.options.length;
             continue;
         }
@@ -4466,7 +6715,7 @@ const summarize = (steps)=>{
         }
     }
     const counts = `${database} ${database === 1 ? "option ran" : "options ran"} in the database, ${memory} ran in memory.`;
-    const causes = reasons.map((reason)=>MEMORY_EXECUTION_EXPLANATIONS[reason]).join(" ");
+    const causes = reasons.map((reason)=>EXPLANATIONS[reason]).join(" ");
     return {
         database,
         memory,
@@ -4474,50 +6723,87 @@ const summarize = (steps)=>{
         explanation: causes.length === 0 ? counts : `${counts} ${causes}`
     };
 };
-/**
- * Groups options into consecutive runs that execute in the same place.
- *
- * A step boundary is where execution moves, and a reader has to see the statement as step 1 OF
- * 2 to understand it is not the whole query. Cutting over to memory is a ratchet, so the
- * database options are always a prefix and there are at most two steps.
- *
- * A database step is emitted even when NO option pushed down, because the plugin is dispatched
- * either way — `createQueryPayload` always builds a database event. Without it, the worst case
- * the feature exists to expose reports "0 in the database" while the backend reads the whole
- * table, which is the opposite of the truth.
- */ const toExecutionSteps = (options)=>{
+const outcomeOf = (option)=>{
+    if (option.target === "memory") {
+        return {
+            executedIn: "memory",
+            reason: option.reason,
+            explanation: MEMORY_EXECUTION_EXPLANATIONS[option.reason]
+        };
+    }
+    if (option.reason === "executed") {
+        return {
+            executedIn: "database",
+            reason: null,
+            explanation: null
+        };
+    }
+    return {
+        executedIn: "memory",
+        reason: option.reason,
+        explanation: DATABASE_EXECUTION_EXPLANATIONS[option.reason]
+    };
+};
+/** Whether an option belongs to the step already open, or starts a new one. */ const continuesStep = (current, outcome)=>{
+    if (current == null) {
+        return false;
+    }
+    if (current.executedIn.kind === "database") {
+        return outcome.reason == null;
+    }
+    // `?? null` because a step with no reason omits the key, and `undefined === null` is false —
+    // without it every option started a step of its own
+    return outcome.reason != null && (current.reason ?? null) === outcome.reason;
+};
+const toExecutionSteps = (options, ranIn)=>{
     const steps = [];
     let index = 0;
     options.forEach((option)=>{
         const explained = explainedOptionOf(option, index++);
         const current = steps[steps.length - 1];
-        if (current != null && current.executedIn === option.target) {
+        const outcome = outcomeOf(option);
+        // Grouped by outcome, not by target: an option the database could not express and one core
+        // sent to memory both run in memory, for different reasons a reader needs told apart.
+        if (continuesStep(current, outcome) === true) {
             current.options.push(explained);
             return;
         }
-        steps.push({
-            step: steps.length + 1,
+        steps.push(outcome.reason == null ? {
+            step: 0,
             of: 0,
-            executedIn: option.target,
-            description: option.target === "database" ? DATABASE_STEP_DESCRIPTION : MEMORY_STEP_DESCRIPTION,
+            executedIn: ranIn,
             options: [
                 explained
             ],
-            ...option.reason == null ? {} : {
-                reason: option.reason,
-                explanation: MEMORY_EXECUTION_EXPLANATIONS[option.reason]
-            }
+            executedQueries: []
+        } : {
+            step: 0,
+            of: 0,
+            executedIn: {
+                kind: "memory"
+            },
+            options: [
+                explained
+            ],
+            reason: outcome.reason,
+            explanation: outcome.explanation ?? undefined
         });
     });
-    if (steps[0]?.executedIn !== "database") {
+    // A database step even when nothing pushed down: the plugin is dispatched either way, so
+    // reporting "0 in the database" while the backend reads the whole table is the opposite of
+    // the truth.
+    if (steps[0]?.executedIn.kind !== "database") {
         steps.unshift({
             step: 0,
             of: 0,
-            executedIn: "database",
-            description: UNNARROWED_READ_DESCRIPTION,
-            options: []
+            executedIn: ranIn,
+            options: [],
+            executedQueries: []
         });
     }
+    return steps;
+};
+/** Numbers a finished list, so `step 1 of 3` reads as the shape of the whole query. */ const numbered = (steps)=>{
     for(let i = 0; i < steps.length; i++){
         steps[i].step = i + 1;
         steps[i].of = steps.length;
@@ -4532,10 +6818,11 @@ const summarize = (steps)=>{
  * post-join filter alone in the memory half derives back to `"database"`, and the document
  * would report memory work as having run in the database.
  */ const explainQuery = (options, context)=>{
-    if (options.isDerived === true) {
-        throw new Error("explainQuery was given a collection produced by split() or splitAt(). Those re-derive " + "execution targets without the options that caused them, so the explanation would report " + "memory work as having run in the database. Pass the collection as it was resolved, " + "before splitting.");
-    }
-    const executionSteps = toExecutionSteps(options);
+    const executionSteps = numbered(toExecutionSteps(options, {
+        kind: "database",
+        database: context.database,
+        plugin: context.pluginKind
+    }));
     return {
         collection: context.collection,
         database: context.database,
@@ -4562,7 +6849,7 @@ const summarize = (steps)=>{
         // Only the first database step: a plugin reports what IT ran, and everything it ran
         // was sent as one dispatch. Stamping the same statements onto a second database step
         // would claim they ran twice.
-        if (step.executedIn !== "database" || attached === true) {
+        if (isDatabaseStep(step) === false || attached === true) {
             return {
                 ...step,
                 options: [
@@ -4595,8 +6882,47 @@ const summarize = (steps)=>{
         executionSteps
     };
 };
+/**
+ * Adds the step for a cross-plugin join's inner side.
+ *
+ * Appended by the executor rather than derived from the options, because the inner side's options
+ * live on the join, in its own collection, and were never part of this query's chain. It goes before
+ * the memory steps that consume it — the join cannot run until both sides are read.
+ */ /**
+ * Every statement the query ran, across every database it touched, in execution order.
+ *
+ * A step is a place, so the statements live on the steps — this is for a caller that wants them all
+ * without caring which plugin ran which.
+ */ const executedQueriesOf = (explanation)=>explanation.executionSteps.flatMap((step)=>isDatabaseStep(step) ? step.executedQueries : []);
+const withInnerSide = (explanation, innerSide)=>{
+    const step = {
+        step: 0,
+        of: 0,
+        executedIn: {
+            kind: "database",
+            database: innerSide.database,
+            plugin: innerSide.plugin
+        },
+        options: [],
+        executedQueries: innerSide.executedQueries
+    };
+    const firstMemory = explanation.executionSteps.findIndex((current)=>isDatabaseStep(current) === false);
+    const at = firstMemory === -1 ? explanation.executionSteps.length : firstMemory;
+    const executionSteps = numbered([
+        ...explanation.executionSteps.slice(0, at),
+        step,
+        ...explanation.executionSteps.slice(at)
+    ]);
+    return {
+        ...explanation,
+        executionSteps,
+        summary: summarize(executionSteps)
+    };
+};
 
 ;// CONCATENATED MODULE: ./src/plugins/query/formatExplanation.ts
+
+
 const OPTION_LABEL_WIDTH = 8;
 const WRAP_WIDTH = 68;
 /** Wraps `text` to `WRAP_WIDTH`, prefixing every line with `indent`. */ const wrap = (text, indent)=>{
@@ -4622,29 +6948,41 @@ const COMPARATOR_SYMBOLS = {
     "less-than": "<",
     "less-than-equals": "<="
 };
-const describeValue = (value)=>{
-    if (value == null) {
+/** Typed against the union so a new OBJECT tag is a compile error here, not an "undefined" in output. */ const describeValue = (value)=>{
+    if (value === null) {
+        return "null";
+    }
+    if (value === undefined) {
         return "?";
     }
-    if (value.k === "raw") {
-        return typeof value.v === "string" ? `"${value.v}"` : String(value.v);
+    if (Array.isArray(value)) {
+        return `[${value.map(describeValue).join(", ")}]`;
+    }
+    if (typeof value !== "object") {
+        return typeof value === "string" ? `"${value}"` : String(value);
+    }
+    if ("date" in value) {
+        return value.date;
     }
-    if (value.k === "date") {
-        return value.v;
+    if ("undefined" in value) {
+        return "undefined";
     }
-    if (value.k === "array") {
-        return `[${value.v.map(describeValue).join(", ")}]`;
+    if ("regex" in value) {
+        return `/${value.regex.source}/${value.regex.flags}`;
     }
-    return value.k === "undefined" ? "undefined" : String(value.v);
+    if ("bigint" in value) {
+        return `${value.bigint}n`;
+    }
+    return value.number;
 };
 /** Renders a serialized expression back to something close to the source predicate. */ const describeExpression = (expression)=>{
     if (expression == null) {
         return "?";
     }
-    if (expression.t === "operator") {
+    if (expression.type === "operator") {
         return `${describeExpression(expression.left)} ${expression.operator} ${describeExpression(expression.right)}`;
     }
-    if (expression.t === "comparator") {
+    if (expression.type === "comparator") {
         const left = describeExpression(expression.left);
         const right = describeExpression(expression.right);
         const symbol = COMPARATOR_SYMBOLS[expression.comparator];
@@ -4653,13 +6991,24 @@ const describeValue = (value)=>{
         }
         return `${left} ${expression.negated === true ? "!==" : symbol} ${right}`;
     }
-    if (expression.t === "property") {
+    if (expression.type === "property") {
         return expression.path;
     }
-    if (expression.t === "value") {
+    if (expression.type === "value") {
         return describeValue(expression.value);
     }
-    return expression.t === "empty" ? "(no filter)" : "(not parsable)";
+    if (expression.type === "call") {
+        return (0,callSource/* .renderCallAsJs */.a)(expression.call, ()=>describeExpression(expression.expression), ()=>(expression.arguments ?? []).map(describeExpression));
+    }
+    if (expression.type === "empty") {
+        return "(no filter)";
+    }
+    // Distinguishable from "(not parsable)", which means the parser gave up and this runs in memory
+    if (expression.type === "not-parsable") {
+        return expression.reason == null ? "(not parsable)" : `(not parsable: ${expression.reason})`;
+    }
+    // Unreachable while the union is exhausted above; a payload from a newer sender is not.
+    return `(unsupported: ${expression.type})`;
 };
 const describeOption = (option)=>{
     const detail = option.detail;
@@ -4687,18 +7036,35 @@ const describeOption = (option)=>{
     }
     return "";
 };
+/**
+ * The sentence for a kind of step.
+ *
+ * Here rather than on the step: it is one of two constants keyed off `executedIn`, so carrying it in
+ * the payload put prose beside the field it was derived from.
+ */ const DATABASE_STEP_DESCRIPTION = "These options are sent to the plugin.";
+const MEMORY_STEP_DESCRIPTION = "Routier runs these over the rows the database returned, after deserializing them.";
+const UNNARROWED_READ_DESCRIPTION = "No option could be pushed down, so the plugin reads the whole collection.";
+/** `database · orders.db · SqliteDbPlugin`, so a cross-plugin join says who ran what. */ const whereItRan = (step)=>isDatabaseStep(step) ? `database · ${step.executedIn.database} · ${step.executedIn.plugin}` : "memory";
 const formatStep = (step, lines)=>{
-    const reason = step.reason == null ? "" : `  [${step.reason}]`;
-    lines.push(`  STEP ${step.step} of ${step.of} — ${step.executedIn}${reason}`);
-    lines.push(...wrap(step.description, "    "));
-    if (step.explanation != null) {
-        lines.push(...wrap(step.explanation, "    "));
+    const reason = isDatabaseStep(step) || step.reason == null ? "" : `  [${step.reason}]`;
+    lines.push(`  STEP ${step.step} of ${step.of} — ${whereItRan(step)}${reason}`);
+    if (isDatabaseStep(step)) {
+        lines.push(...wrap(step.options.length === 0 ? UNNARROWED_READ_DESCRIPTION : DATABASE_STEP_DESCRIPTION, "    "));
+    } else {
+        lines.push(...wrap(MEMORY_STEP_DESCRIPTION, "    "));
+        if (step.explanation != null) {
+            lines.push(...wrap(step.explanation, "    "));
+        }
     }
     lines.push("");
     for (const option of step.options){
         lines.push(`    ${option.name.padEnd(OPTION_LABEL_WIDTH)} ${describeOption(option)}`.trimEnd());
     }
-    for (const executed of step.executedQueries ?? []){
+    if (isDatabaseStep(step) === false) {
+        lines.push("");
+        return;
+    }
+    for (const executed of step.executedQueries){
         lines.push("");
         lines.push(...executed.text.split("\n").map((line)=>`    ${line}`));
         if (executed.parameters != null && executed.parameters.length > 0) {
@@ -4731,6 +7097,80 @@ const formatStep = (step, lines)=>{
     return lines.join("\n");
 };
 
+// EXTERNAL MODULE: ./src/expressions/utils.ts
+var utils = __webpack_require__(63);
+;// CONCATENATED MODULE: ./src/plugins/query/renames.ts
+
+
+const PROPERTY_READING_OPTIONS = [
+    "filter",
+    "sort",
+    "nearest",
+    "map",
+    "group"
+];
+const namesRenamedProperty = (expression)=>{
+    let found = false;
+    if (expression == null) {
+        return found;
+    }
+    (0,utils/* .forEach */.jJ)(expression, (node)=>{
+        if ((0,assertions.isPropertyExpression)(node) && node.property.hasRenamedSegments) {
+            found = true;
+            return false;
+        }
+        return true;
+    });
+    return found;
+};
+const isRenamed = (property)=>property != null && property.hasRenamedSegments;
+/**
+ * Whether a selector's value is read from a renamed property, whether it is that property or computed
+ * from it: `r => r.dueDate.getTime()` reads `dueDate` all the same. Every property it reads when the
+ * selector was parsed, and otherwise the property recorded for it.
+ */ const readsRenamedValue = (value)=>value != null && (value.reads != null ? value.reads.some(isRenamed) : isRenamed(value.property));
+const readsRenamedField = (fields)=>fields != null && fields.some(readsRenamedValue);
+const readsRenamedProperty = (name, value)=>{
+    switch(name){
+        case "filter":
+            return namesRenamedProperty(value.expression);
+        case "map":
+            // A projection reads each field it selects
+            return readsRenamedField(value.fields);
+        case "group":
+            // A group reads its key, then copies every field of the row into its members: every schema
+            // property, or what a `map` before it selected
+            return readsRenamedValue(value.key) || readsRenamedField(value.fields);
+        default:
+            return readsRenamedValue(value);
+    }
+};
+/**
+ * Hands back every option over a property stored under a `.from()` name, for the datastore to run
+ * in memory.
+ *
+ * Core keeps such an option with the database, because only the plugin knows whether its backend
+ * reads storage names. One that translates the option — SQL renders the column from
+ * `getResolvedName()` — needs nothing from here. One that runs the caller's lambda over rows as it
+ * stores them reads a key the row does not have, and answers wrongly without an error: that plugin
+ * calls this before it reads anything, and the datastore finishes the query after deserialization,
+ * where the in-memory names exist.
+ *
+ * Reported as `missing-capability`: the backend cannot express the option as written, and like
+ * every capability, that is only knowable by the plugin.
+ *
+ * @param names Which options to check, for a plugin that resolves some of them itself — Mongo renders
+ * filters and sorts through the stored path, and runs `nearest`, `map` and `group` in JavaScript.
+ */ const reportRenamedProperties = (options, names = PROPERTY_READING_OPTIONS)=>{
+    for (const name of names){
+        for (const item of options.get(name)){
+            if (readsRenamedProperty(name, item.option.value)) {
+                options.reportMissingCapability(item);
+            }
+        }
+    }
+};
+
 ;// CONCATENATED MODULE: ./src/plugins/query/types.ts
 var types_QueryOrdering = /*#__PURE__*/ function(QueryOrdering) {
     QueryOrdering["Descending"] = "desc";
@@ -4747,8 +7187,12 @@ var types_QueryOrdering = /*#__PURE__*/ function(QueryOrdering) {
 
 
 
+
+
 // EXTERNAL MODULE: ./src/expressions/evaluate.ts
 var evaluate = __webpack_require__(379);
+// EXTERNAL MODULE: ./src/expressions/fold.ts
+var fold = __webpack_require__(43);
 ;// CONCATENATED MODULE: ./src/plugins/wire/query.ts
 
 
@@ -4758,6 +7202,9 @@ var evaluate = __webpack_require__(379);
  * Everything except `map` and `group`. Those two are defined BY a closure — the projection is the
  * option — and no data form of them exists to send. Nothing else needs its closure: a sort is a
  * property and a direction, a filter is an expression tree, `nearest` is a vector and a count.
+ *
+ * Except a sort or `nearest` whose selector computes its value, such as `x => x.name.length`. It is sent
+ * as the property it reads, and the receiver would order by that instead. See `isSendable`.
  */ const SENDABLE = new Set([
     "skip",
     "take",
@@ -4771,6 +7218,7 @@ var evaluate = __webpack_require__(379);
     "sum",
     "distinct"
 ]);
+const isSendable = (name, value)=>SENDABLE.has(name) && (name !== "sort" && name !== "nearest" || value.isDirectProperty !== false);
 /**
  * Splits options into the PREFIX that can be sent and the remainder that cannot.
  *
@@ -4786,7 +7234,12 @@ var evaluate = __webpack_require__(379);
     const local = new QueryOptionsCollection/* .QueryOptionsCollection */.H();
     let stopped = false;
     options.forEach((option)=>{
-        if (stopped === false && SENDABLE.has(option.name) === false) {
+        // Reported by the plugin, so it belongs to the datastore, and so does everything after it —
+        // a report cascades to the end of the database phase, which keeps what is left a prefix
+        if (option.target === "database" && option.reason !== "executed") {
+            return;
+        }
+        if (stopped === false && isSendable(option.name, option.value) === false) {
             stopped = true;
         }
         (stopped ? local : sendable).add(option.name, option.value);
@@ -4949,7 +7402,7 @@ const serializeQueryOptions = (options)=>{
                 }
             case "filter":
                 {
-                    const expression = types/* .Expression.fromJson */.r4.fromJson(option.value.expression, schema);
+                    const expression = (0,fold/* .foldConstantCalls */.F5)(types/* .Expression.fromJson */.r4.fromJson(option.value.expression, schema));
                     options.add("filter", {
                         filter: (0,evaluate/* .toStrictPredicate */.wS)(expression),
                         expression,
@@ -5633,7 +8086,8 @@ var TrampolinePipeline = __webpack_require__(416);
     if (!(0,assertions.isPropertyExpression)(left) || !(0,assertions.isValueExpression)(right)) {
         return null;
     }
-    if (left.property.isKey !== true || left.transformer != null || right.value == null) {
+    // A called property is a CallExpression, so it fails the isPropertyExpression check above
+    if (left.property.isKey !== true || right.value == null) {
         return null;
     }
     return {
@@ -5652,6 +8106,15 @@ class EphemeralDataPlugin {
      */ get databaseName() {
         return this._databaseName;
     }
+    /**
+     * Whether the records this plugin holds are in storage shape, keyed by `from` names.
+     *
+     * True for every store of what the datastore serialized, which is why a renamed property is
+     * reported and records are cloned and keyed by their storage names. The datastore's change probe
+     * holds rows the broadcast has already deserialized, so it reads them by in-memory names instead.
+     */ get holdsStorageShape() {
+        return true;
+    }
     /**
      * All-or-nothing across every collection in the save.
      *
@@ -5859,7 +8322,9 @@ class EphemeralDataPlugin {
      * join discards the surplus. Same pairs either way.
      */ resolveJoinInnerSide(event, outerKeys, done) {
         const joinOption = event.operation.options.getLast("join");
-        if (joinOption == null) {
+        // Not reached when an option before it was reported: the datastore's own join branch pairs
+        // the rows this read returns.
+        if (joinOption == null || joinOption.reason !== "executed") {
             done({
                 ok: "success"
             });
@@ -5886,7 +8351,7 @@ class EphemeralDataPlugin {
             const innerRows = [];
             // Records are held in STORAGE shape, so the key is read by its resolved column name.
             const innerKey = joinOption.value.innerKey;
-            const keyColumn = innerKey.property?.getResolvedName() ?? innerKey.propertyName;
+            const keyColumn = this.holdsStorageShape ? innerKey.property?.getResolvedName() ?? innerKey.propertyName : innerKey.propertyName;
             for (const record of innerCollection.values()){
                 if (outerKeys != null && outerKeys.has(record[keyColumn]) === false) {
                     continue;
@@ -5915,7 +8380,7 @@ class EphemeralDataPlugin {
      * to fall back to `structuredClone`, which is roughly an order of magnitude slower and was paid
      * on EVERY read of EVERY schema that renames a property.
      */ recordCloner(schema) {
-        const hasRenamedProperties = schema.properties.some((property)=>property.from != null);
+        const hasRenamedProperties = this.holdsStorageShape && schema.properties.some((property)=>property.from != null);
         return hasRenamedProperties ? schema.cloneStorage : schema.clone;
     }
     query(event, done) {
@@ -5927,6 +8392,12 @@ class EphemeralDataPlugin {
             const schema = operation.schema;
             const collection = this.resolveCollection(schema);
             const cloneRecord = this.recordCloner(schema);
+            // Records are held in storage shape and every option below runs the caller's lambda
+            // over them, so a `from` property is read by a name the record does not have. Handed
+            // back, and the datastore runs it after deserialization.
+            if (this.holdsStorageShape) {
+                reportRenamedProperties(operation.options);
+            }
             collection.load((r)=>{
                 if (r.ok === Result/* .Result.ERROR */.Q.ERROR) {
                     done(Result/* .PluginEventResult.error */.D.error(event.id, r.error));
@@ -5935,7 +8406,9 @@ class EphemeralDataPlugin {
                 const orderedOptions = [];
                 operation.options.forEach((o)=>orderedOptions.push(o));
                 let leadingFilterCount = 0;
-                while(leadingFilterCount < orderedOptions.length && orderedOptions[leadingFilterCount].name === "filter"){
+                // Stops at a reported filter too: the database phase ends there, and the datastore
+                // runs it and everything after it.
+                while(leadingFilterCount < orderedOptions.length && orderedOptions[leadingFilterCount].name === "filter" && orderedOptions[leadingFilterCount].reason === "executed"){
                     leadingFilterCount++;
                 }
                 // Key-equality fast path: when a leading filter's parsed expression pins
@@ -6006,15 +8479,21 @@ class EphemeralDataPlugin {
                  * collection to pair it with three rows.
                  *
                  * `cloned` is in storage shape, so the keys are read by resolved column name.
-                 */ // No statement to quote — an ephemeral store walks its own records. Said
-                // plainly so `.explain()` does not leave a reader wondering whether the
-                // plugin simply failed to report. Before the inner side, to match execution order.
+                 */ /**
+                 * No statement to quote — an ephemeral store walks its own records — so the scan
+                 * is said plainly, and the PREDICATE is reported as JavaScript beside it. A count
+                 * alone leaves a reader unable to tell a filter that matched nothing from one
+                 * that was never applied.
+                 *
+                 * Before the inner side, to match execution order.
+                 */ const described = describeFilters(operation.options.get("filter").filter((entry)=>entry.option.reason === "executed").map((entry)=>entry.option.value));
                 event.executedQueries.push({
-                    text: `${operation.schema.collectionName}: scanned ${cloned.length} in-memory ${cloned.length === 1 ? "record" : "records"}`
+                    text: `${operation.schema.collectionName}: scanned ${cloned.length} in-memory ` + `${cloned.length === 1 ? "record" : "records"}, filter ${described.text}`,
+                    parameters: described.parameters.length > 0 ? described.parameters : undefined
                 });
                 const joinOption = operation.options.getLast("join");
-                const outerKeys = joinOption == null ? null : distinctJoinKeys(cloned, joinOption.value.outerKey, joinOption.value.semiJoinKeyThreshold, {
-                    storageShape: true
+                const outerKeys = joinOption == null || joinOption.reason !== "executed" ? null : distinctJoinKeys(cloned, joinOption.value.outerKey, joinOption.value.semiJoinKeyThreshold, {
+                    storageShape: this.holdsStorageShape
                 });
                 this.resolveJoinInnerSide(event, outerKeys, (joinResult)=>{
                     if (joinResult.ok === "error") {
@@ -6185,6 +8664,29 @@ class TelemetryDbPlugin {
             return JSON.stringify(option.value ?? null);
     }
 };
+/**
+ * Restores a `Date` that `structuredClone` produced outside this realm.
+ *
+ * The clone is a real date and fails `instanceof Date`, which is what a caller checks. Mutated in
+ * place because the clone is already private to this call.
+ */ const CacheDbPlugin_reviveDates = (value)=>{
+    if (value == null || typeof value !== "object") {
+        return value;
+    }
+    if (Object.prototype.toString.call(value) === "[object Date]") {
+        return value instanceof Date ? value : new Date(value);
+    }
+    if (Array.isArray(value)) {
+        for(let i = 0, length = value.length; i < length; i++){
+            value[i] = CacheDbPlugin_reviveDates(value[i]);
+        }
+        return value;
+    }
+    for (const key of Object.keys(value)){
+        value[key] = CacheDbPlugin_reviveDates(value[key]);
+    }
+    return value;
+};
 class CacheDbPlugin {
     plugin;
     max;
@@ -6223,7 +8725,7 @@ class CacheDbPlugin {
      * the next update would be written UNCHECKED with no error anywhere.
      * Pinned by `datastore/src/collections/wrapperStacking.test.ts`.
      */ rebuild(entry) {
-        return new entry.construct(structuredClone(entry.value), entry.isTransformed);
+        return new entry.construct(CacheDbPlugin_reviveDates(structuredClone(entry.value)), entry.isTransformed);
     }
     query(event, done) {
         const key = this.keyFor(event);
@@ -6246,6 +8748,14 @@ class CacheDbPlugin {
                 done(result);
                 return;
             }
+            // A partial answer must never be cached. When the plugin reports an option it cannot
+            // express, these rows are what came back BEFORE the datastore finished the query — and a
+            // later hit skips the plugin entirely, so nothing would report and the rows would be
+            // returned as if they were the whole answer. Unfiltered, silently.
+            if (event.operation.options.notExecuted().length > 0) {
+                done(Result/* .PluginEventResult.success */.D.success(event.id, result.data));
+                return;
+            }
             this.store(key, result.data);
             // The caller gets a rebuilt value too, not the one just stored, so that mutating
             // the result of a MISS cannot corrupt what the next hit returns.