@routier/core 0.7.0 → 0.8.0

package/dist/plugins/index.js

@@ -1019,6 +1019,7 @@ __webpack_require__.d(__webpack_exports__, {
 
 
 
+
 // Error message constants
 const ERROR_MESSAGES = {
     PROPERTY_NOT_FOUND: (path)=>`Error parsing query, could not find PropertyInfo for path: ${path}`,
@@ -1626,6 +1627,9 @@ const COALESCE_OPERATORS = sourceKeyed({
         // 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([
@@ -1803,13 +1807,18 @@ const resolveParamPath = (paramsName, path, data)=>{
     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, scope, paramsName, params){
+    constructor(schema, stream, scope, paramsName, params, readsValues = false){
         this.schema = schema;
         this.stream = stream;
         this.scope = scope;
         this.paramsName = paramsName;
         this.params = params;
+        this.readsValues = readsValues;
     }
     parse() {
         const expression = this.parseOr();
@@ -1831,6 +1840,71 @@ const resolveParamPath = (paramsName, path, data)=>{
         }
         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();
@@ -2094,7 +2168,7 @@ const resolveParamPath = (paramsName, path, data)=>{
      * 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);
+        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"}`
@@ -2386,7 +2460,7 @@ 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") {
+            if (argument.kind === "arithmetic" || argument.kind === "conditional" || argument.kind === "opaque") {
                 throw new Error(ERROR_MESSAGES.UNSUPPORTED("arithmetic inside .includes()"));
             }
             return {
@@ -2480,7 +2554,7 @@ 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") {
+                        if (argument.kind === "arithmetic" || argument.kind === "conditional" || argument.kind === "opaque") {
                             throw new Error(ERROR_MESSAGES.UNSUPPORTED(`arithmetic inside .${method}()`));
                         }
                         return {
@@ -2490,9 +2564,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);
@@ -2637,10 +2722,39 @@ const resolveParamPath = (paramsName, path, data)=>{
                     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);
@@ -2674,6 +2788,10 @@ 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"));
         }
+        // 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"));
         }
@@ -2887,6 +3005,9 @@ const resolveParamPath = (paramsName, path, data)=>{
         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) {
@@ -3222,6 +3343,104 @@ const toExpression = (schema, fn, params)=>{
         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
 
 
 },
@@ -3929,6 +4148,30 @@ const mismatchWarning = (expression)=>{
     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";
@@ -3967,7 +4210,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
@@ -3984,14 +4227,10 @@ class QueryOptionsCollection {
                         this.cutOverToMemory("unmapped-property");
                         return false;
                     }
-                    if ((0,_assertions__rspack_import_1/* .isPropertyExpression */.e3)(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");
-                        return false;
-                    }
+                    // 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");
@@ -4003,26 +4242,19 @@ 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"))) {
@@ -4129,6 +4361,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()
@@ -4206,19 +4441,48 @@ class QueryOptionsCollection {
         }
     }
     /**
-     * Forgets what any previous dispatch reported.
+     * 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. The items are shared with any snapshot, so a report mutated in place otherwise
-     * survives a restore and a second terminal on the same queryable replays options the plugin
-     * did run — a `skip` applied twice, over rows already windowed.
-     */ forgetReports() {
+     * 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){
-            if (item.option.target === "database") {
-                item.option.reason = "executed";
-            }
+            // 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();
@@ -4418,6 +4682,128 @@ var HashType = /*#__PURE__*/ (/* unused pure expression or super */ null && (fun
 }({})));
 
 
+},
+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;
+};
+
+
 },
 76(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
 __webpack_require__.d(__webpack_exports__, {
@@ -4692,9 +5078,10 @@ __webpack_require__.d(__webpack_exports__, {
   QB: () => (/* reexport */ RetryDbPlugin),
   m6: () => (/* reexport */ executeJoin),
   i1: () => (/* reexport */ parameteriseDocument),
-  __: () => (/* reexport */ toEntityShape),
+  wk: () => (/* reexport */ reportRenamedProperties),
   VW: () => (/* reexport */ applyInnerOptions),
   B2: () => (/* reexport */ describeUnparsableFilter),
+  __: () => (/* reexport */ toEntityShape),
   Jd: () => (/* reexport */ EphemeralDataPlugin),
   Pl: () => (/* reexport */ deserializePersistResult),
   JF: () => (/* reexport */ DataTranslator),
@@ -5685,9 +6072,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.
  *
@@ -5716,6 +6106,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.
@@ -6167,7 +6582,6 @@ const isParameter = (value)=>typeof value === "object" && value !== null && PARA
  */ 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.",
@@ -6669,6 +7083,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 */.e3)(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";
@@ -6686,6 +7174,7 @@ var types_QueryOrdering = /*#__PURE__*/ function(QueryOrdering) {
 
 
 
+
 // EXTERNAL MODULE: ./src/expressions/evaluate.ts
 var evaluate = __webpack_require__(379);
 // EXTERNAL MODULE: ./src/expressions/fold.ts
@@ -6699,6 +7188,9 @@ var fold = __webpack_require__(43);
  * 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",
@@ -6712,6 +7204,7 @@ var fold = __webpack_require__(43);
     "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.
  *
@@ -6727,7 +7220,12 @@ var fold = __webpack_require__(43);
     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);
@@ -7594,6 +8092,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.
      *
@@ -7801,7 +8308,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"
             });
@@ -7828,7 +8337,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;
@@ -7857,7 +8366,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) {
@@ -7869,6 +8378,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));
@@ -7877,7 +8392,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
@@ -7955,14 +8472,14 @@ class EphemeralDataPlugin {
                  * that was never applied.
                  *
                  * Before the inner side, to match execution order.
-                 */ const described = describeFilters(operation.options.get("filter").map((entry)=>entry.option.value));
+                 */ 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"}, 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") {
@@ -8138,7 +8655,7 @@ class TelemetryDbPlugin {
  *
  * 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 reviveDates = (value)=>{
+ */ const CacheDbPlugin_reviveDates = (value)=>{
     if (value == null || typeof value !== "object") {
         return value;
     }
@@ -8147,12 +8664,12 @@ class TelemetryDbPlugin {
     }
     if (Array.isArray(value)) {
         for(let i = 0, length = value.length; i < length; i++){
-            value[i] = reviveDates(value[i]);
+            value[i] = CacheDbPlugin_reviveDates(value[i]);
         }
         return value;
     }
     for (const key of Object.keys(value)){
-        value[key] = reviveDates(value[key]);
+        value[key] = CacheDbPlugin_reviveDates(value[key]);
     }
     return value;
 };
@@ -8194,7 +8711,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(reviveDates(structuredClone(entry.value)), entry.isTransformed);
+        return new entry.construct(CacheDbPlugin_reviveDates(structuredClone(entry.value)), entry.isTransformed);
     }
     query(event, done) {
         const key = this.keyFor(event);
@@ -8650,6 +9167,7 @@ var __webpack_exports__nearestBy = __webpack_exports__.iG;
 var __webpack_exports__parameter = __webpack_exports__.Wi;
 var __webpack_exports__parameteriseDocument = __webpack_exports__.i1;
 var __webpack_exports__readJoinKey = __webpack_exports__.qy;
+var __webpack_exports__reportRenamedProperties = __webpack_exports__.wk;
 var __webpack_exports__semiJoinFilter = __webpack_exports__.lA;
 var __webpack_exports__serializeBulkPersist = __webpack_exports__.n;
 var __webpack_exports__serializePersistResult = __webpack_exports__.yR;
@@ -8658,6 +9176,6 @@ var __webpack_exports__splitSendableOptions = __webpack_exports__.PP;
 var __webpack_exports__toEntityShape = __webpack_exports__.__;
 var __webpack_exports__withExecutedQueries = __webpack_exports__.Kg;
 var __webpack_exports__withInnerSide = __webpack_exports__.oJ;
-export { __webpack_exports__BatchingDbPlugin as BatchingDbPlugin, __webpack_exports__CacheDbPlugin as CacheDbPlugin, __webpack_exports__ConcurrencyDbPlugin as ConcurrencyDbPlugin, __webpack_exports__DATABASE_EXECUTION_EXPLANATIONS as DATABASE_EXECUTION_EXPLANATIONS, __webpack_exports__DEFAULT_SEMI_JOIN_KEY_THRESHOLD as DEFAULT_SEMI_JOIN_KEY_THRESHOLD, __webpack_exports__DataTranslator as DataTranslator, __webpack_exports__EXECUTED_QUERIES_UNSUPPORTED as EXECUTED_QUERIES_UNSUPPORTED, __webpack_exports__EphemeralDataPlugin as EphemeralDataPlugin, __webpack_exports__JsonTranslator as JsonTranslator, __webpack_exports__MEMORY_EXECUTION_EXPLANATIONS as MEMORY_EXECUTION_EXPLANATIONS, __webpack_exports__Query as Query, __webpack_exports__QueryOptionsCollection as QueryOptionsCollection, __webpack_exports__QueryOrdering as QueryOrdering, __webpack_exports__RetryDbPlugin as RetryDbPlugin, __webpack_exports__SqlTranslator as SqlTranslator, __webpack_exports__TelemetryDbPlugin as TelemetryDbPlugin, __webpack_exports__TranslatedArrayValue as TranslatedArrayValue, __webpack_exports__TranslatedGroupValue as TranslatedGroupValue, __webpack_exports__TranslatedSingleValue as TranslatedSingleValue, __webpack_exports__TupleTranslator as TupleTranslator, __webpack_exports__applyInnerOptions as applyInnerOptions, __webpack_exports__collectingSink as collectingSink, __webpack_exports__cosineDistance as cosineDistance, __webpack_exports__createRequestHandler as createRequestHandler, __webpack_exports__describeFilterAsJs as describeFilterAsJs, __webpack_exports__describeFilters as describeFilters, __webpack_exports__describeUnparsableFilter as describeUnparsableFilter, __webpack_exports__deserializeBulkPersist as deserializeBulkPersist, __webpack_exports__deserializePersistResult as deserializePersistResult, __webpack_exports__deserializeQueryOptions as deserializeQueryOptions, __webpack_exports__distinctJoinKeys as distinctJoinKeys, __webpack_exports__executeJoin as executeJoin, __webpack_exports__executedQueriesOf as executedQueriesOf, __webpack_exports__explainQuery as explainQuery, __webpack_exports__formatExplanation as formatExplanation, __webpack_exports__hashJoin as hashJoin, __webpack_exports__isDatabaseStep as isDatabaseStep, __webpack_exports__joinInPlugin as joinInPlugin, __webpack_exports__loadJoinInnerSide as loadJoinInnerSide, __webpack_exports__loggerSink as loggerSink, __webpack_exports__mappedResultColumns as mappedResultColumns, __webpack_exports__nearestBy as nearestBy, __webpack_exports__parameter as parameter, __webpack_exports__parameteriseDocument as parameteriseDocument, __webpack_exports__readJoinKey as readJoinKey, __webpack_exports__semiJoinFilter as semiJoinFilter, __webpack_exports__serializeBulkPersist as serializeBulkPersist, __webpack_exports__serializePersistResult as serializePersistResult, __webpack_exports__serializeQueryOptions as serializeQueryOptions, __webpack_exports__splitSendableOptions as splitSendableOptions, __webpack_exports__toEntityShape as toEntityShape, __webpack_exports__withExecutedQueries as withExecutedQueries, __webpack_exports__withInnerSide as withInnerSide };
+export { __webpack_exports__BatchingDbPlugin as BatchingDbPlugin, __webpack_exports__CacheDbPlugin as CacheDbPlugin, __webpack_exports__ConcurrencyDbPlugin as ConcurrencyDbPlugin, __webpack_exports__DATABASE_EXECUTION_EXPLANATIONS as DATABASE_EXECUTION_EXPLANATIONS, __webpack_exports__DEFAULT_SEMI_JOIN_KEY_THRESHOLD as DEFAULT_SEMI_JOIN_KEY_THRESHOLD, __webpack_exports__DataTranslator as DataTranslator, __webpack_exports__EXECUTED_QUERIES_UNSUPPORTED as EXECUTED_QUERIES_UNSUPPORTED, __webpack_exports__EphemeralDataPlugin as EphemeralDataPlugin, __webpack_exports__JsonTranslator as JsonTranslator, __webpack_exports__MEMORY_EXECUTION_EXPLANATIONS as MEMORY_EXECUTION_EXPLANATIONS, __webpack_exports__Query as Query, __webpack_exports__QueryOptionsCollection as QueryOptionsCollection, __webpack_exports__QueryOrdering as QueryOrdering, __webpack_exports__RetryDbPlugin as RetryDbPlugin, __webpack_exports__SqlTranslator as SqlTranslator, __webpack_exports__TelemetryDbPlugin as TelemetryDbPlugin, __webpack_exports__TranslatedArrayValue as TranslatedArrayValue, __webpack_exports__TranslatedGroupValue as TranslatedGroupValue, __webpack_exports__TranslatedSingleValue as TranslatedSingleValue, __webpack_exports__TupleTranslator as TupleTranslator, __webpack_exports__applyInnerOptions as applyInnerOptions, __webpack_exports__collectingSink as collectingSink, __webpack_exports__cosineDistance as cosineDistance, __webpack_exports__createRequestHandler as createRequestHandler, __webpack_exports__describeFilterAsJs as describeFilterAsJs, __webpack_exports__describeFilters as describeFilters, __webpack_exports__describeUnparsableFilter as describeUnparsableFilter, __webpack_exports__deserializeBulkPersist as deserializeBulkPersist, __webpack_exports__deserializePersistResult as deserializePersistResult, __webpack_exports__deserializeQueryOptions as deserializeQueryOptions, __webpack_exports__distinctJoinKeys as distinctJoinKeys, __webpack_exports__executeJoin as executeJoin, __webpack_exports__executedQueriesOf as executedQueriesOf, __webpack_exports__explainQuery as explainQuery, __webpack_exports__formatExplanation as formatExplanation, __webpack_exports__hashJoin as hashJoin, __webpack_exports__isDatabaseStep as isDatabaseStep, __webpack_exports__joinInPlugin as joinInPlugin, __webpack_exports__loadJoinInnerSide as loadJoinInnerSide, __webpack_exports__loggerSink as loggerSink, __webpack_exports__mappedResultColumns as mappedResultColumns, __webpack_exports__nearestBy as nearestBy, __webpack_exports__parameter as parameter, __webpack_exports__parameteriseDocument as parameteriseDocument, __webpack_exports__readJoinKey as readJoinKey, __webpack_exports__reportRenamedProperties as reportRenamedProperties, __webpack_exports__semiJoinFilter as semiJoinFilter, __webpack_exports__serializeBulkPersist as serializeBulkPersist, __webpack_exports__serializePersistResult as serializePersistResult, __webpack_exports__serializeQueryOptions as serializeQueryOptions, __webpack_exports__splitSendableOptions as splitSendableOptions, __webpack_exports__toEntityShape as toEntityShape, __webpack_exports__withExecutedQueries as withExecutedQueries, __webpack_exports__withInnerSide as withInnerSide };
 
 //# sourceMappingURL=index.js.map