@routier/core 0.7.0 → 0.8.0

package/dist/index.cjs

@@ -465,6 +465,14 @@ class FunctionFactoryBuilder extends ContainerBlock {
         this._params.push(...params);
         return this;
     }
+    /**
+     * Adds a factory parameter carrying `value` and returns its name, for generated code to
+     * refer to. See `CodeBuilder.bind` for why values travel this way.
+     */ bind(value) {
+        const parameter = this.createParameter(value);
+        this._params.push(parameter);
+        return parameter.name;
+    }
     return() {
         this._return = true;
         return this;
@@ -580,6 +588,26 @@ class IfBuilder extends ContainerBlock {
     }
 }
 class CodeBuilder extends ContainerBlock {
+    _bindings = [];
+    /**
+     * Makes `value` available to the generated function under the returned name.
+     *
+     * Generated code must never reach a runtime value by its source name or by pasting its
+     * source text: a minifier renames the declaration and cannot see inside the generated
+     * string, and pasted source loses the scope it closed over (#40, #46). A binding is passed
+     * in as a real value when the function is compiled, so it survives any bundler.
+     */ bind(value, name = `binding${this._bindings.length}`) {
+        this._bindings.push({
+            name,
+            value
+        });
+        return name;
+    }
+    getBindings() {
+        return [
+            ...this._bindings
+        ];
+    }
     toString() {
         return this._lines.map((line)=>typeof line === 'string' ? this.indent(line) : line.toString()).join('\n\n');
     }
@@ -914,6 +942,8 @@ class IdSet {
 
 // EXTERNAL MODULE: ./src/schema/types.ts
 var types = __webpack_require__(537);
+// EXTERNAL MODULE: ./src/schema/utils/storageDates.ts
+var storageDates = __webpack_require__(894);
 // EXTERNAL MODULE: ./src/results/Result.ts
 var Result = __webpack_require__(718);
 // EXTERNAL MODULE: ./src/utilities/uuid.ts
@@ -979,29 +1009,17 @@ class MemoryDataCollection {
         }
         throw new Error(`Id Property '${property.name}' must be string or number, found '${property.type}'`);
     }
-    _dateColumns;
-    /** Date columns, by the name a stored record uses. Nested dates live inside a JSON column. */ get dateColumns() {
-        if (this._dateColumns == null) {
-            this._dateColumns = this.schema.properties.filter((property)=>property.type === types/* .SchemaTypes.Date */.L.Date && property.getAssignmentPath().includes(".") === false).map((property)=>property.getResolvedName());
-        }
-        return this._dateColumns;
-    }
     /**
      * The record this collection keeps.
      *
      * A copy, so a caller holding the entity cannot write into the store afterwards. Dates are held
-     * as Dates: a predicate compares a Date, and a stored ISO string never matches one.
+     * as Dates, at the root, in objects and in arrays: a predicate compares a Date, and a stored ISO
+     * string never matches one. A durable subclass hydrates parsed JSON through here too.
      */ toStored(item) {
-        const columns = this.dateColumns;
         const stored = {
             ...item
         };
-        for(let i = 0, length = columns.length; i < length; i++){
-            const value = stored[columns[i]];
-            if (typeof value === "string") {
-                stored[columns[i]] = new Date(value);
-            }
-        }
+        (0,storageDates/* .getStorageDateReviver */.T)(this.schema)?.(stored);
         return stored;
     }
     seed(items) {
@@ -1821,6 +1839,7 @@ __webpack_require__.d(__webpack_exports__, {
   getProperties: () => (/* reexport safe */ _utils__rspack_import_5.oY),
   operandValue: () => (/* reexport safe */ _evaluate__rspack_import_1.Vv),
   parseFragment: () => (/* reexport safe */ _parser__rspack_import_3.oH),
+  parseSelector: () => (/* reexport safe */ _parser__rspack_import_3.Pl),
   peelCalls: () => (/* reexport safe */ _utils__rspack_import_5.CC),
   renderCallAsJs: () => (/* reexport safe */ _callSource__rspack_import_0.a),
   toExpression: () => (/* reexport safe */ _parser__rspack_import_3.MY),
@@ -1847,6 +1866,7 @@ __webpack_require__.d(__webpack_exports__, {
 91(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
 __webpack_require__.d(__webpack_exports__, {
   MY: () => (toExpression),
+  Pl: () => (parseSelector),
   oH: () => (parseFragment),
   pg: () => (combineExpressions)
 });
@@ -1855,6 +1875,7 @@ __webpack_require__.d(__webpack_exports__, {
 /* import */ var _schema__rspack_import_2 = __webpack_require__(537);
 /* import */ var _evaluate__rspack_import_3 = __webpack_require__(379);
 /* import */ var _fold__rspack_import_4 = __webpack_require__(43);
+/* import */ var _utils__rspack_import_6 = __webpack_require__(63);
 /* import */ var _types__rspack_import_1 = __webpack_require__(27);
 
 
@@ -1862,6 +1883,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}`,
@@ -2469,6 +2491,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([
@@ -2646,13 +2671,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();
@@ -2674,6 +2704,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();
@@ -2937,7 +3032,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"}`
@@ -3229,7 +3324,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 {
@@ -3323,7 +3418,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 {
@@ -3333,9 +3428,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);
@@ -3480,10 +3586,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);
@@ -3517,6 +3652,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"));
         }
@@ -3730,6 +3869,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) {
@@ -4065,6 +4207,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 (0,_utils__rspack_import_6/* .getProperties */.oY)(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
 
 
 },
@@ -4801,7 +5041,7 @@ var TrampolinePipeline = __webpack_require__(416);
 
 
 },
-640(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+756(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
 
 // EXPORTS
 __webpack_require__.d(__webpack_exports__, {
@@ -4813,6 +5053,7 @@ __webpack_require__.d(__webpack_exports__, {
   CacheDbPlugin: () => (/* reexport */ CacheDbPlugin),
   Query: () => (/* reexport */ Query),
   splitSendableOptions: () => (/* reexport */ splitSendableOptions),
+  withInnerSide: () => (/* reexport */ withInnerSide),
   executeJoin: () => (/* reexport */ executeJoin),
   formatExplanation: () => (/* reexport */ formatExplanation),
   parameteriseDocument: () => (/* reexport */ parameteriseDocument),
@@ -4843,13 +5084,13 @@ __webpack_require__.d(__webpack_exports__, {
   readJoinKey: () => (/* reexport */ readJoinKey),
   loadJoinInnerSide: () => (/* reexport */ loadJoinInnerSide),
   DataTranslator: () => (/* reexport */ DataTranslator),
+  reportRenamedProperties: () => (/* reexport */ reportRenamedProperties),
   serializeBulkPersist: () => (/* reexport */ serializeBulkPersist),
-  toEntityShape: () => (/* reexport */ toEntityShape),
   TelemetryDbPlugin: () => (/* reexport */ TelemetryDbPlugin),
-  withExecutedQueries: () => (/* reexport */ withExecutedQueries),
+  toEntityShape: () => (/* reexport */ toEntityShape),
   createRequestHandler: () => (/* reexport */ createRequestHandler),
   SqlTranslator: () => (/* reexport */ SqlTranslator),
-  withInnerSide: () => (/* reexport */ withInnerSide),
+  withExecutedQueries: () => (/* reexport */ withExecutedQueries),
   QueryOrdering: () => (/* reexport */ types_QueryOrdering),
   describeFilterAsJs: () => (/* reexport */ describeFilterAsJs),
   serializeQueryOptions: () => (/* reexport */ serializeQueryOptions),
@@ -5823,9 +6064,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.
  *
@@ -5854,6 +6098,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.
@@ -6305,7 +6574,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.",
@@ -6807,6 +7075,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";
@@ -6824,6 +7166,7 @@ var types_QueryOrdering = /*#__PURE__*/ function(QueryOrdering) {
 
 
 
+
 // EXTERNAL MODULE: ./src/expressions/evaluate.ts
 var evaluate = __webpack_require__(379);
 // EXTERNAL MODULE: ./src/expressions/fold.ts
@@ -6837,6 +7180,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",
@@ -6850,6 +7196,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.
  *
@@ -6865,7 +7212,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);
@@ -7732,6 +8084,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.
      *
@@ -7939,7 +8300,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"
             });
@@ -7966,7 +8329,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;
@@ -7995,7 +8358,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) {
@@ -8007,6 +8370,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));
@@ -8015,7 +8384,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
@@ -8093,14 +8464,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") {
@@ -8276,7 +8647,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;
     }
@@ -8285,12 +8656,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;
 };
@@ -8332,7 +8703,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);
@@ -8790,6 +9161,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";
@@ -8828,7 +9223,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
@@ -8845,14 +9240,10 @@ class QueryOptionsCollection {
                         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");
-                        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");
@@ -8864,26 +9255,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"))) {
@@ -8990,6 +9374,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()
@@ -9067,19 +9454,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();
@@ -9277,13 +9693,14 @@ function toPromise(fn) {
 
 
 },
-755(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+862(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
 
 // EXPORTS
 __webpack_require__.d(__webpack_exports__, {
   SchemaTransform: () => (/* reexport */ SchemaTransform),
   SchemaComputed: () => (/* reexport */ SchemaComputed),
   extractTypeInfo: () => (/* reexport */ extractTypeInfo),
+  getStorageDateReviver: () => (/* reexport */ storageDates/* .getStorageDateReviver */.T),
   SchemaTracked: () => (/* reexport */ SchemaTracked),
   SchemaFile: () => (/* reexport */ SchemaFile),
   SchemaNumber: () => (/* reexport */ SchemaNumber),
@@ -9300,12 +9717,12 @@ __webpack_require__.d(__webpack_exports__, {
   SchemaArray: () => (/* reexport */ SchemaArray),
   SchemaKey: () => (/* reexport */ SchemaKey),
   SchemaOptional: () => (/* reexport */ SchemaOptional),
-  hasPrimitiveElements: () => (/* reexport */ hasPrimitiveElements),
+  hasPrimitiveElements: () => (/* reexport */ propertyKind/* .hasPrimitiveElements */.L),
   SchemaDefault: () => (/* reexport */ SchemaDefault),
   SchemaIndex: () => (/* reexport */ SchemaIndex),
   SchemaVector: () => (/* reexport */ SchemaVector),
   HashType: () => (/* reexport */ types/* .HashType */.$),
-  isArrayValued: () => (/* reexport */ isArrayValued),
+  isArrayValued: () => (/* reexport */ propertyKind/* .isArrayValued */.l),
   SchemaBase: () => (/* reexport */ SchemaBase),
   createStandardJsonSchemaProps: () => (/* reexport */ createStandardJsonSchemaProps),
   propertyInfoToJsonSchema: () => (/* reexport */ propertyInfoToJsonSchema),
@@ -10526,78 +10943,9 @@ class SlotPath {
 
 // EXTERNAL MODULE: ./src/errors/SchemaError.ts
 var SchemaError = __webpack_require__(131);
-;// CONCATENATED MODULE: ./src/codegen/utils.ts
-/**
- * Counts non-overlapping occurrences of a term in text.
- *
- * Behavior:
- * - Case-sensitive matching
- * - If the search term is composed entirely of word characters (A–Z, a–z, 0–9, _),
- *   enforce whole-word boundaries so "red" does not match inside "redder".
- * - If the search term contains any non-word character (e.g. "=>", "()", "::"),
- *   match anywhere without boundary checks (useful for symbols).
- * - Non-overlapping matches (after a hit, advances by term length)
- * - Optimized single-character fast path; otherwise uses indexOf loop
- *
- * Examples:
- * - countWordOccurance("red redder red", "red") => 2
- * - countWordOccurance("()=>{}", "=>") => 1
- * - countWordOccurance("aaaa", "aa") => 2 (non-overlapping)
- *
- * @param text The source text to scan
- * @param word The term to match (must be non-empty)
- * @returns The number of occurrences found
- */ const countWordOccurance = (text, word)=>{
-    const wl = word.length;
-    const tl = text.length;
-    if (wl === 0 || wl > tl) return 0;
-    // Fast path for single-character words
-    if (wl === 1) {
-        let c = 0;
-        const code = word.charCodeAt(0);
-        for(let i = 0; i < tl; i++)if (text.charCodeAt(i) === code) c++;
-        return c;
-    }
-    let count = 0;
-    let i = 0;
-    function isWordCharCode(c) {
-        return c >= 48 && c <= 57 // 0-9
-         || c >= 65 && c <= 90 // A-Z
-         || c >= 97 && c <= 122 // a-z
-         || c === 95; // _
-    }
-    // Decide whether to enforce word boundaries based on the search term
-    let enforceWordBoundaries = true;
-    for(let k = 0; k < wl; k++){
-        const cc = word.charCodeAt(k);
-        if (!isWordCharCode(cc)) {
-            enforceWordBoundaries = false;
-            break;
-        }
-    }
-    while(true){
-        i = text.indexOf(word, i);
-        if (i === -1) break;
-        if (enforceWordBoundaries) {
-            const left = i - 1;
-            const right = i + wl;
-            const leftOk = left < 0 || !isWordCharCode(text.charCodeAt(left));
-            const rightOk = right >= tl || !isWordCharCode(text.charCodeAt(right));
-            if (leftOk && rightOk) count++;
-        } else {
-            // No boundary enforcement for symbol-containing terms
-            count++;
-        }
-        i += wl; // non-overlapping word matches
-    }
-    return count;
-};
-
 ;// CONCATENATED MODULE: ./src/codegen/handlers/types.ts
 
 
-
-
 /**
  * Terminal link for chains that apply only to a subset of properties (keys,
  * identities).  Returning the builder marks every other property as
@@ -10773,34 +11121,16 @@ class PropertyInfoHandler {
         }
         enriched.property(`${property.name}: ${entitySelectorPath}`);
     }
-    toNamedFunction(stringifiedFunction, parent) {
-        const name = `_${(0,uuid/* .uuid */.u)()}`;
-        const builder = parent.function(name);
-        const occurences = countWordOccurance(stringifiedFunction, "=>");
-        if (occurences > 0) {
-            const split = stringifiedFunction.split("=>").map((w)=>w.trim());
-            const parameters = split[0].replace(/\(|\)/g, "").split(",");
-            let body = split[1];
-            if (occurences > 1) {
-                // we have a function that returns a function
-                const index = stringifiedFunction.indexOf("=>");
-                body = stringifiedFunction.slice(index + 2, stringifiedFunction.length);
-            }
-            if (body.startsWith("{") === true && body.endsWith("}")) {
-                // Remove brackets, wrapping function will have them
-                builder.appendBody(body.slice(1, body.length - 1));
-                return {
-                    builder,
-                    parameters
-                };
-            }
-            builder.appendBody(`return ${body};`);
-            return {
-                builder,
-                parameters
-            };
-        }
-        throw new Error("Only arrow functions are allowed in the schema definition:  function () {}  --->  () => {}");
+    /**
+     * Binds a function the schema author supplied (a default, a computed, a serializer) into
+     * the generated code and returns the expression that calls it with `args`.
+     *
+     * The function is passed in by value rather than pasted in as source text. Pasted source
+     * loses the scope it was written in, so a default that called an imported helper threw, and
+     * it had to be parsed back apart, which only worked for arrows: a bundler that lowers arrows
+     * to `function` expressions, or renames what they refer to, broke every schema (#46).
+     */ emitBoundCall(target, fn, args) {
+        return `${target.bind(fn)}(${args.join(", ")})`;
     }
 }
 
@@ -10960,28 +11290,21 @@ class EnrichmentPrimitiveHandler extends PropertyInfoHandler {
 class EnrichmentFunctionHandler extends PropertyInfoHandler {
     handle(property, builder) {
         if (property.functionBody != null && property.type === types/* .SchemaTypes.Function */.L.Function) {
-            const parameterNames = [
+            const factory = builder.get("factory");
+            const args = [
                 "enriched",
                 "collectionName"
             ];
             if (property.injected != null) {
-                const factory = builder.get("factory");
-                const parameter = factory.createParameter(property.injected);
-                factory.parameters(parameter);
-                parameterNames.push(parameter.name);
-            }
-            const declarationsSlot = builder.get("factory.function.declarations");
-            // Unwrap the functions to removing currying
-            const defaultFunctionWithParameters = this.toNamedFunction(property.functionBody.toString(), declarationsSlot);
-            defaultFunctionWithParameters.builder.parameters(...parameterNames.map((w, i)=>({
-                    name: defaultFunctionWithParameters.parameters[i],
-                    callName: w
-                })));
+                args.push(factory.bind(property.injected));
+            }
             const slot = builder.get("factory.function.assignment");
             const enrichedAssignmentPath = property.getAssignmentPath({
                 parent: "enriched"
             });
-            slot.assign(enrichedAssignmentPath).value(defaultFunctionWithParameters.builder.toCallable());
+            // The definition is curried: calling it with the entity returns the function the
+            // property holds
+            slot.assign(enrichedAssignmentPath).value(this.emitBoundCall(factory, property.functionBody, args));
             return builder;
         }
         return super.handle(property, builder);
@@ -11036,34 +11359,17 @@ class EnrichmentDefaultFunctionHandler extends PropertyInfoHandler {
     handle(property, builder) {
         if (property.defaultValue != null && typeof property.defaultValue === "function") {
             this.setEnrichedProperty(property, builder);
-            // we need to add the call for this function too, want to create an if
-            const declarationsSlot = builder.get("factory.function.declarations");
-            if (property.injected != null) {
-                const factory = builder.get("factory");
-                if (factory == null) {
-                    throw new Error("Error building enricher, could not find slot for factory");
-                }
-                const parameter = factory.createParameter(property.injected);
-                factory.parameters(parameter);
-                const defaultFunctionWithParameters = this.toNamedFunction(property.defaultValue.toString(), declarationsSlot);
-                // This is ok, defaults can only inject one parameter anyways
-                defaultFunctionWithParameters.builder.parameters(...defaultFunctionWithParameters.parameters.map((w)=>({
-                        name: w,
-                        callName: parameter.name
-                    })));
-                const ifsSlot = builder.get("factory.function.ifs");
-                const enrichedAssignmentPath = property.getAssignmentPath({
-                    parent: "enriched"
-                });
-                ifsSlot.if(`${enrichedAssignmentPath} == null`).appendBody(`${enrichedAssignmentPath} = ${defaultFunctionWithParameters.builder.toCallable()}`);
-                return builder;
-            }
-            const defaultFunction = this.toNamedFunction(property.defaultValue.toString(), declarationsSlot);
+            const factory = builder.get("factory");
+            // Defaults take at most one argument: the injected value, when there is one
+            const args = property.injected != null ? [
+                factory.bind(property.injected)
+            ] : [];
+            const call = this.emitBoundCall(factory, property.defaultValue, args);
             const ifsSlot = builder.get("factory.function.ifs");
             const enrichedAssignmentPath = property.getAssignmentPath({
                 parent: "enriched"
             });
-            ifsSlot.if(`${enrichedAssignmentPath} == null`).appendBody(`${enrichedAssignmentPath} = ${defaultFunction.builder.toCallable()}`);
+            ifsSlot.if(`${enrichedAssignmentPath} == null`).appendBody(`${enrichedAssignmentPath} = ${call}`);
             return builder;
         }
         return super.handle(property, builder);
@@ -11076,22 +11382,15 @@ class EnrichmentDefaultFunctionHandler extends PropertyInfoHandler {
 class EnrichmentComputedValueHandler extends PropertyInfoHandler {
     handle(property, builder) {
         if (property.functionBody != null && property.type === types/* .SchemaTypes.Computed */.L.Computed) {
-            const parameterNames = [
+            const factory = builder.get("factory");
+            const args = [
                 "enriched",
                 "collectionName"
             ];
             if (property.injected != null) {
-                const factory = builder.get("factory");
-                const parameter = factory.createParameter(property.injected);
-                factory.parameters(parameter);
-                parameterNames.push(parameter.name);
-            }
-            const declarationsSlot = builder.get("factory.function.declarations");
-            const defaultFunctionWithParameters = this.toNamedFunction(property.functionBody.toString(), declarationsSlot);
-            defaultFunctionWithParameters.builder.parameters(...parameterNames.map((w, i)=>({
-                    name: defaultFunctionWithParameters.parameters[i],
-                    callName: w
-                })));
+                args.push(factory.bind(property.injected));
+            }
+            const call = this.emitBoundCall(factory, property.functionBody, args);
             // Compute-once semantics for computed keys/identities: an existing value is
             // carried into the enriched literal and never recomputed — a key must stay
             // stable once assigned (content-hash ids would otherwise churn as the
@@ -11104,44 +11403,15 @@ class EnrichmentComputedValueHandler extends PropertyInfoHandler {
             const enrichedAssignmentPath = property.getAssignmentPath({
                 parent: "enriched"
             });
-            ifsSlot.if(`${enrichedAssignmentPath} == null`).appendBody(`${enrichedAssignmentPath} = ${defaultFunctionWithParameters.builder.toCallable()}`);
+            ifsSlot.if(`${enrichedAssignmentPath} == null`).appendBody(`${enrichedAssignmentPath} = ${call}`);
             return builder;
         }
         return super.handle(property, builder);
     }
 }
 
-;// CONCATENATED MODULE: ./src/schema/utils/propertyKind.ts
-
-/**
- * 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/* .SchemaTypes.Array */.L.Array,
-    types/* .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/* .SchemaTypes.String */.L.String,
-    types/* .SchemaTypes.Number */.L.Number,
-    types/* .SchemaTypes.Boolean */.L.Boolean
-]);
-const hasPrimitiveElements = (type, elementType)=>type === types/* .SchemaTypes.Vector */.L.Vector || PRIMITIVE_ELEMENT_TYPES.has(elementType);
-
+// EXTERNAL MODULE: ./src/schema/utils/propertyKind.ts
+var propertyKind = __webpack_require__(575);
 ;// CONCATENATED MODULE: ./src/codegen/handlers/enrichment/EnrichmentArrayHandler.ts
 
 
@@ -11151,7 +11421,7 @@ const hasPrimitiveElements = (type, elementType)=>type === types/* .SchemaTypes.
  * mark the root entity dirty instead of being silently lost on save.
  */ class EnrichmentArrayHandler extends PropertyInfoHandler {
     handle(property, builder) {
-        if (isArrayValued(property.type)) {
+        if ((0,propertyKind/* .isArrayValued */.l)(property.type)) {
             // Place the property in the enriched literal like any other leaf
             this.setEnrichedProperty(property, builder);
             const enrichedPath = property.getAssignmentPath({
@@ -11193,13 +11463,10 @@ class MergeDefaultFunctionHandler extends PropertyInfoHandler {
         // we are changing merge to be more like enrich so we can handle injections
         // we may need to change more.  Need to move towards factories
         if (property.defaultValue != null && typeof property.defaultValue === "function") {
-            const defaultFunctionParameters = [];
-            if (property.injected != null) {
-                const factory = builder.get("factory");
-                const parameter = factory.createParameter(property.injected);
-                factory.parameters(parameter);
-                defaultFunctionParameters.push(parameter.name);
-            }
+            const factory = builder.get("factory");
+            const args = property.injected != null ? [
+                factory.bind(property.injected)
+            ] : [];
             // A defaulted property still merges from the source; the default only fills
             // the gap when neither side has a value
             this.emitMergeCopy(property, builder, {
@@ -11215,15 +11482,9 @@ class MergeDefaultFunctionHandler extends PropertyInfoHandler {
             const assignmentPath = property.getAssignmentPath({
                 parent: "destination"
             });
-            const declarationsSlot = builder.get("factory.function.header");
-            const defaultFunctionWithParameters = this.toNamedFunction(property.defaultValue.toString(), declarationsSlot);
-            defaultFunctionWithParameters.builder.parameters(...defaultFunctionParameters.map((w, i)=>({
-                    name: defaultFunctionWithParameters.parameters[i],
-                    callName: w
-                })));
             const defaultIf = ifsSlot.if(`${selectorPath} == null`);
             this.emitDestinationAncestorGuards(property, defaultIf);
-            defaultIf.appendBody(`${assignmentPath} = ${defaultFunctionWithParameters.builder.toCallable()}`);
+            defaultIf.appendBody(`${assignmentPath} = ${this.emitBoundCall(factory, property.defaultValue, args)}`);
             return builder;
         }
         return super.handle(property, builder);
@@ -11264,28 +11525,20 @@ class MergePrimitiveHandler extends PropertyInfoHandler {
 class MergeComputedValueHandler extends PropertyInfoHandler {
     handle(property, builder) {
         if (property.functionBody != null && property.type === types/* .SchemaTypes.Computed */.L.Computed) {
-            const parameterNames = [
+            const factory = builder.get("factory");
+            const args = [
                 "source",
                 "collectionName"
             ];
             if (property.injected != null) {
-                const factory = builder.get("factory");
-                const parameter = factory.createParameter(property.injected);
-                factory.parameters(parameter);
-                parameterNames.push(parameter.name);
-            }
-            const declarationsSlot = builder.get("factory.function.header");
-            const defaultFunctionWithParameters = this.toNamedFunction(property.functionBody.toString(), declarationsSlot);
-            defaultFunctionWithParameters.builder.parameters(...parameterNames.map((w, i)=>({
-                    name: defaultFunctionWithParameters.parameters[i],
-                    callName: w
-                })));
+                args.push(factory.bind(property.injected));
+            }
             const slot = builder.get("factory.function.assignments");
             const enrichedAssignmentPath = property.getAssignmentPath({
                 parent: "destination"
             });
             // We want to recompute the value always in case there are changes
-            slot.assign(enrichedAssignmentPath).value(defaultFunctionWithParameters.builder.toCallable());
+            slot.assign(enrichedAssignmentPath).value(this.emitBoundCall(factory, property.functionBody, args));
             return builder;
         }
         return super.handle(property, builder);
@@ -11358,7 +11611,7 @@ class MergeFunctionHandler extends PropertyInfoHandler {
  * reference is adopted as-is — same as the primitive copy this replaces.
  */ class MergeArrayHandler extends PropertyInfoHandler {
     handle(property, builder) {
-        if (isArrayValued(property.type)) {
+        if ((0,propertyKind/* .isArrayValued */.l)(property.type)) {
             const selectorPath = property.getSelectrorPath({
                 parent: "source",
                 assignmentType: "FORCE_NULLABLE_OR_OPTIONAL"
@@ -11695,7 +11948,7 @@ class CloneArrayHandler extends PropertyInfoHandler {
         super(), this.useFromPropertyName = useFromPropertyName;
     }
     handle(property, builder) {
-        if (isArrayValued(property.type)) {
+        if ((0,propertyKind/* .isArrayValued */.l)(property.type)) {
             // Arrays are leaf properties — they have no child PropertyInfos, so the
             // copy must happen here for every array, including nullable/optional ones.
             // The `!== undefined` guard below covers absent values; an explicit null is copied as
@@ -11721,7 +11974,7 @@ class CloneArrayHandler extends PropertyInfoHandler {
             // across merges), and a Proxy cannot pass a structured-clone boundary.
             const elementType = property.innerSchema?.type;
             let copyExpression;
-            if (hasPrimitiveElements(property.type, elementType)) {
+            if ((0,propertyKind/* .hasPrimitiveElements */.L)(property.type, elementType)) {
                 copyExpression = `[...${entitySelectorPath}]`;
             } else if (elementType === types/* .SchemaTypes.Date */.L.Date) {
                 copyExpression = `${entitySelectorPath}.map(function (v) { return v == null ? v : new Date(v); })`;
@@ -11840,7 +12093,7 @@ class CloneObjectHandler extends PropertyInfoHandler {
         // Anything that copies by assignment. An array-valued property must not land here:
         // assigning the reference shares it with the source, which is the whole point of
         // CloneArrayHandler.
-        if (property.type != types/* .SchemaTypes.Object */.L.Object && isArrayValued(property.type) === false) {
+        if (property.type != types/* .SchemaTypes.Object */.L.Object && (0,propertyKind/* .isArrayValued */.l)(property.type) === false) {
             const slot = builder.get("if");
             const useFromPropertyName = this.useFromPropertyName;
             const entitySelectorPath = property.getSelectrorPath({
@@ -11903,7 +12156,7 @@ class CloneHandlerBuilder {
 
 class CompareArrayHandler extends PropertyInfoHandler {
     handle(property, builder) {
-        if (isArrayValued(property.type)) {
+        if ((0,propertyKind/* .isArrayValued */.l)(property.type)) {
             let compare = builder.getOrDefault("result.variable.compare");
             const leftCompare = property.getSelectrorPath({
                 parent: "a"
@@ -12198,7 +12451,6 @@ class DeserializeDeserializerHandler extends PropertyInfoHandler {
     handle(property, builder) {
         if (property.valueDeserializer != null) {
             let objectBuilder = builder.getOrDefault("result.variable.object");
-            const assignmentBuilder = builder.getOrDefault("functions");
             // Read the incoming record by `from` (storage) name
             const entitySelectorPath = property.getSelectrorPath({
                 parent: "unserialized",
@@ -12211,18 +12463,16 @@ class DeserializeDeserializerHandler extends PropertyInfoHandler {
                     name: "object"
                 });
             }
-            const defaultFunctionWithParameters = this.toNamedFunction(property.valueDeserializer.toString(), assignmentBuilder);
-            defaultFunctionWithParameters.builder.parameters(...defaultFunctionWithParameters.parameters.map((_, i)=>({
-                    name: defaultFunctionWithParameters.parameters[i],
-                    callName: entitySelectorPath
-                })));
+            const call = this.emitBoundCall(builder, property.valueDeserializer, [
+                entitySelectorPath
+            ]);
             if (property.parent == null) {
-                objectBuilder.property(`${property.name}: ${defaultFunctionWithParameters.builder.toCallable()}`);
+                objectBuilder.property(`${property.name}: ${call}`);
                 return builder;
             }
             const slotPath = new SlotPath(...property.getParentPathArray());
             objectBuilder = objectBuilder.get(slotPath.get());
-            objectBuilder.property(`${property.name}: ${defaultFunctionWithParameters.builder.toCallable()}`);
+            objectBuilder.property(`${property.name}: ${call}`);
             return builder;
         }
         return super.handle(property, builder);
@@ -12248,7 +12498,7 @@ class DeserializeDeserializerHandler extends PropertyInfoHandler {
         return `[...${selector}]`;
     }
     handle(property, builder) {
-        if (isArrayValued(property.type)) {
+        if ((0,propertyKind/* .isArrayValued */.l)(property.type)) {
             const slotPath = new SlotPath("result.variable.object");
             // Create the result object when this is the first property iterated —
             // handler output cannot depend on schema property order
@@ -12489,7 +12739,7 @@ class HashComputedValueHandler extends PropertyInfoHandler {
  * objects would collapse every value to "[object Object]" and collide.
  */ class HashArrayHandler extends PropertyInfoHandler {
     handle(property, builder) {
-        if (isArrayValued(property.type)) {
+        if ((0,propertyKind/* .isArrayValued */.l)(property.type)) {
             let stringBuilder = builder.getOrDefault("hash-object-return.variable.string");
             const entitySelectorPath = property.getSelectrorPath({
                 parent: "entity"
@@ -12654,7 +12904,7 @@ class EnableChangeTrackingObjectHandler extends PropertyInfoHandler {
  * mark the root entity dirty instead of being silently lost on save.
  */ class EnableChangeTrackingArrayHandler extends PropertyInfoHandler {
     handle(property, builder) {
-        if (isArrayValued(property.type)) {
+        if ((0,propertyKind/* .isArrayValued */.l)(property.type)) {
             const assignmentSlot = builder.get("assignment");
             const childSelectorPath = property.getSelectrorPath({
                 parent: "entity"
@@ -12731,7 +12981,7 @@ class FreezeObjectHandler extends PropertyInfoHandler {
 
 class FreezeArrayHandler extends PropertyInfoHandler {
     handle(property, builder) {
-        if (isArrayValued(property.type)) {
+        if ((0,propertyKind/* .isArrayValued */.l)(property.type)) {
             const assignmentSlot = builder.get("assignment");
             const childSelectorPath = property.getSelectrorPath({
                 parent: "entity"
@@ -12867,7 +13117,6 @@ class SerializeSerializerHandler extends PropertyInfoHandler {
     handle(property, builder) {
         if (property.valueSerializer != null) {
             const slot = builder.getOrDefault("if");
-            const assignmentBuilder = builder.getOrDefault("functions");
             // Serialize maps in-memory shape -> storage shape: read the entity by
             // property name, write the result by `from` (storage) name
             const entitySelectorPath = property.getSelectrorPath({
@@ -12877,17 +13126,15 @@ class SerializeSerializerHandler extends PropertyInfoHandler {
                 parent: "result",
                 useFromPropertyName: true
             });
-            const defaultFunctionWithParameters = this.toNamedFunction(property.valueSerializer.toString(), assignmentBuilder);
-            defaultFunctionWithParameters.builder.parameters(...defaultFunctionWithParameters.parameters.map((_, i)=>({
-                    name: defaultFunctionWithParameters.parameters[i],
-                    callName: entitySelectorPath
-                })));
+            const call = this.emitBoundCall(builder, property.valueSerializer, [
+                entitySelectorPath
+            ]);
             if (property.parent == null) {
-                slot.if(`Object.hasOwn(entity, "${property.name}")`).appendBody(`${resultSelectorPath} = ${defaultFunctionWithParameters.builder.toCallable()}`);
+                slot.if(`Object.hasOwn(entity, "${property.name}")`).appendBody(`${resultSelectorPath} = ${call}`);
                 return builder;
             }
             // Nested serializer: same pattern as SerializeValueHandler — if block for parent existence, then assign via serializer
-            this.emitSerializeNestedAssignment(property, slot, defaultFunctionWithParameters.builder.toCallable());
+            this.emitSerializeNestedAssignment(property, slot, call);
             return builder;
         }
         return super.handle(property, builder);
@@ -12946,7 +13193,7 @@ class SerializeComputedHandler extends PropertyInfoHandler {
         return `[...${selector}]`;
     }
     handle(property, builder) {
-        if (isArrayValued(property.type)) {
+        if ((0,propertyKind/* .isArrayValued */.l)(property.type)) {
             const slot = builder.get("if");
             // Serialize maps in-memory shape -> storage shape: read the entity by
             // property name, write the result by `from` (storage) name
@@ -13850,8 +14097,8 @@ const arrayConverter = (property, context)=>{
                         // Create the function using new Function()
                         // If no parameters, call with just the body; otherwise spread the params
                         const fn = params.length > 0 ? new Function(...params, functionBody) : new Function(functionBody);
-                        // Wrap it so toString() returns the original arrow function string
-                        // This is needed because the schema system validates that functions are arrow functions
+                        // Wrap it so toString() returns the original arrow function string, so
+                        // serializing the rehydrated schema writes the same functionSource again
                         recreatedFn = Object.assign(fn, {
                             toString: ()=>functionSource
                         });
@@ -13860,7 +14107,7 @@ const arrayConverter = (property, context)=>{
                         recreatedFn = ()=>{
                             throw new Error(`Cannot recreate computed property ${computedProp.name}: ${e instanceof Error ? e.message : 'unknown error'}`);
                         };
-                        // Ensure toString returns an arrow function for validation
+                        // Keep functionSource re-parseable if this schema is serialized again
                         Object.assign(recreatedFn, {
                             toString: ()=>`() => { throw new Error("Cannot recreate computed property ${computedProp.name}"); }`
                         });
@@ -13997,39 +14244,16 @@ class SetHandlerBuilder {
     }
 }
 
-;// CONCATENATED MODULE: ./src/schema/SchemaDefinition.ts
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-function assertPropertyHandled(generatorName, property, result) {
-    if (result == null) {
-        throw new Error(`Schema compilation failed: no '${generatorName}' code generator handles property '${property.getAssignmentPath()}' (type: ${property.type}). Add a handler for this property shape or mark it not applicable in the ${generatorName} chain.`);
-    }
-}
-function createChangeTracker() {
+;// CONCATENATED MODULE: ./src/schema/changeTracker.ts
+/**
+ * Builds the proxy factory that change-tracks an entity.
+ *
+ * Generated schema code receives the result as a bound value — a parameter of the generated
+ * factory — and never refers to this module by name. Name references do not survive a minifier,
+ * which renames the declaration but cannot see inside generated source text (#40, #46). The
+ * returned function holds no per-entity state, so one per compiled schema is shared by every
+ * entity it tracks.
+ */ function createChangeTracker() {
     const DIRTY_ENTITY_MARKER = "isDirty";
     const CHANGES_ENTITY_KEY = "changes";
     const ORIGINAL_ENTITY_KEY = "original";
@@ -14128,6 +14352,40 @@ function createChangeTracker() {
         return new Proxy(entity, proxyHandler);
     };
 }
+
+;// CONCATENATED MODULE: ./src/schema/SchemaDefinition.ts
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+function assertPropertyHandled(generatorName, property, result) {
+    if (result == null) {
+        throw new Error(`Schema compilation failed: no '${generatorName}' code generator handles property '${property.getAssignmentPath()}' (type: ${property.type}). Add a handler for this property shape or mark it not applicable in the ${generatorName} chain.`);
+    }
+}
 class SchemaDefinition extends SchemaBase {
     instance;
     type = types/* .SchemaTypes.Definition */.L.Definition;
@@ -14178,10 +14436,22 @@ class SchemaDefinition extends SchemaBase {
             throw e;
         }
     }
-    createFunction(builder, ...fnArgs) {
+    /**
+     * Compiles `builder` into a function taking `fnArgs`.
+     *
+     * A builder with bindings is compiled one level out: an outer function whose parameters are
+     * the bindings, called once here with their values, returns the function that is kept. The
+     * bound values become closure variables of that function, so the per-call cost is a context
+     * read rather than anything resolved by name.
+     */ createFunction(builder, ...fnArgs) {
         const body = builder.toString();
+        const bindings = builder.getBindings();
         try {
-            return Function(...fnArgs, body);
+            if (bindings.length === 0) {
+                return Function(...fnArgs, body);
+            }
+            const outer = Function(...bindings.map((w)=>w.name), `return function(${fnArgs.join(", ")}) {\n${body}\n}`);
+            return outer(...bindings.map((w)=>w.value));
         } catch (e) {
             logger/* .logger.error */.vF.error(`Error compiling schema function.  Function Body: ${body}`);
             throw e;
@@ -14314,9 +14584,11 @@ class SchemaDefinition extends SchemaBase {
             const serializeHandler = serializeHandlerBuilder.build();
             const compareIdsHandler = compareIdsHandlerBuilder.build();
             const setHandlerHanlder = setHandlerBuilder.build();
+            // Handed to the generated functions as a value, never embedded as source and called
+            // by name — a minifier renames the declaration and breaks every schema (#40).
+            const changeTracker = createChangeTracker();
             const changeTrackingCodeBuilder = new blocks/* .CodeBuilder */.Nl();
-            changeTrackingCodeBuilder.raw(`${createChangeTracker.toString()}`);
-            changeTrackingCodeBuilder.slot("declarations").variable("enableChangeTracking").value('createChangeTracker()');
+            changeTrackingCodeBuilder.bind(changeTracker, "enableChangeTracking");
             // Nested proxies are installed by assigning through already-proxied parents;
             // pause tracking during setup so those writes don't register as changes
             changeTrackingCodeBuilder.slot("pause").raw('\tconst hadTracking = entity.__tracking__ != null;\n\tif (!hadTracking) { Object.defineProperty(entity, "__tracking__", { value: { changes: {}, isDirty: false, original: {}, isPaused: false }, configurable: true, writable: true, enumerable: false }); }\n\tconst wasPaused = entity.__tracking__.isPaused;\n\tentity.__tracking__.isPaused = true;');
@@ -14345,9 +14617,10 @@ class SchemaDefinition extends SchemaBase {
             }).parameters({
                 name: "collectionName",
                 value: this.collectionName
+            }, {
+                name: "changeTracker",
+                value: changeTracker
             });
-            enricherFunctionRoot.slot("changeTracker").raw(`${createChangeTracker.toString()}`);
-            enricherFunctionRoot.slot("changeTrackerFunction").raw(`\tconst changeTracker = createChangeTracker();`);
             const enricherFunctionBody = enricherFunctionRoot.function(undefined, {
                 name: "function"
             }).parameters("entity", "changeTrackingType").return();
@@ -14582,6 +14855,8 @@ class SchemaDefinition extends SchemaBase {
             enricherFunctionBody.get("append").insert(deserializeCodeBuilder.get("result"));
             enricherFunctionBody.get("append").insert(deserializeCodeBuilder.get("if"));
             enricherFunctionRoot.replace("function", new blocks/* .FunctionBuilder */.kF(undefined).parameters("unserialized", "changeTrackingType").return());
+            // The deserialize slots moved in above call the deserializers bound on their own builder
+            enricherFunctionRoot.parameters(...deserializeCodeBuilder.getBindings());
             const postProcessGenerator = this.createReturnFunction(enricherCodeBuilder);
             const postProcessParams = enricherFunctionRoot.getParameters();
             // Combine prepare and serialize
@@ -14590,6 +14865,10 @@ class SchemaDefinition extends SchemaBase {
             preprocessCodeBuilder.get("main").insert(serializeCodeBuilder.get("assignments"));
             preprocessCodeBuilder.get("main").insert(serializeCodeBuilder.get("functions"));
             preprocessCodeBuilder.get("main").insert(serializeCodeBuilder.get("if"));
+            // Likewise the serialize slots call the serializers bound on the serialize builder
+            for (const binding of serializeCodeBuilder.getBindings()){
+                preprocessCodeBuilder.bind(binding.value, binding.name);
+            }
             const getIdsFunction = this.createFunction(idSelectorCodeBuilder, "entity");
             const getHashTypeFunction = this.createFunction(hashTypeCodeBuilder, "entity");
             const prepareFunction = this.createFunction(prepareCodeBuilder, "entity");
@@ -15231,6 +15510,8 @@ const s = {
 
 
 
+// EXTERNAL MODULE: ./src/schema/utils/storageDates.ts
+var storageDates = __webpack_require__(894);
 ;// CONCATENATED MODULE: ./src/schema/index.ts
 
 
@@ -15244,6 +15525,7 @@ const s = {
 
 
 
+
 },
 537(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
 __webpack_require__.d(__webpack_exports__, {
@@ -15280,6 +15562,129 @@ var HashType = /*#__PURE__*/ function(HashType) {
 }({});
 
 
+},
+575(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.d(__webpack_exports__, {
+  L: () => (hasPrimitiveElements),
+  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 === _types__rspack_import_0/* .SchemaTypes.Vector */.L.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__, {
@@ -15988,6 +16393,7 @@ __webpack_require__.d(__webpack_exports__, {
   formatExplanation: () => (/* reexport safe */ _plugins__rspack_import_7.formatExplanation),
   getLogLevel: () => (/* reexport safe */ _utilities__rspack_import_10.getLogLevel),
   getProperties: () => (/* reexport safe */ _expressions__rspack_import_4.getProperties),
+  getStorageDateReviver: () => (/* reexport safe */ _schema__rspack_import_9.getStorageDateReviver),
   hasPrimitiveElements: () => (/* reexport safe */ _schema__rspack_import_9.hasPrimitiveElements),
   hash: () => (/* reexport safe */ _utilities__rspack_import_10.hash),
   hashJoin: () => (/* reexport safe */ _plugins__rspack_import_7.hashJoin),
@@ -16017,12 +16423,14 @@ __webpack_require__.d(__webpack_exports__, {
   parameter: () => (/* reexport safe */ _plugins__rspack_import_7.parameter),
   parameteriseDocument: () => (/* reexport safe */ _plugins__rspack_import_7.parameteriseDocument),
   parseFragment: () => (/* reexport safe */ _expressions__rspack_import_4.parseFragment),
+  parseSelector: () => (/* reexport safe */ _expressions__rspack_import_4.parseSelector),
   peelCalls: () => (/* reexport safe */ _expressions__rspack_import_4.peelCalls),
   propertyInfoToJsonSchema: () => (/* reexport safe */ _schema__rspack_import_9.propertyInfoToJsonSchema),
   readJoinKey: () => (/* reexport safe */ _plugins__rspack_import_7.readJoinKey),
   rehydrateSchemaFromJsonSchema: () => (/* reexport safe */ _schema__rspack_import_9.rehydrateSchemaFromJsonSchema),
   rehydrateSchemaFromJsonString: () => (/* reexport safe */ _schema__rspack_import_9.rehydrateSchemaFromJsonString),
   renderCallAsJs: () => (/* reexport safe */ _expressions__rspack_import_4.renderCallAsJs),
+  reportRenamedProperties: () => (/* reexport safe */ _plugins__rspack_import_7.reportRenamedProperties),
   resetLogLevel: () => (/* reexport safe */ _utilities__rspack_import_10.resetLogLevel),
   resolveBulkPersistChanges: () => (/* reexport safe */ _utilities__rspack_import_10.resolveBulkPersistChanges),
   s: () => (/* reexport safe */ _schema__rspack_import_9.s),
@@ -16053,9 +16461,9 @@ __webpack_require__.d(__webpack_exports__, {
 /* import */ var _expressions__rspack_import_4 = __webpack_require__(138);
 /* import */ var _performance__rspack_import_5 = __webpack_require__(971);
 /* import */ var _pipeline__rspack_import_6 = __webpack_require__(314);
-/* import */ var _plugins__rspack_import_7 = __webpack_require__(640);
+/* import */ var _plugins__rspack_import_7 = __webpack_require__(756);
 /* import */ var _results__rspack_import_8 = __webpack_require__(264);
-/* import */ var _schema__rspack_import_9 = __webpack_require__(755);
+/* import */ var _schema__rspack_import_9 = __webpack_require__(862);
 /* import */ var _utilities__rspack_import_10 = __webpack_require__(222);