@routier/core 0.7.0 → 0.8.0

package/dist/index.js

@@ -463,6 +463,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;
@@ -578,6 +586,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');
     }
@@ -912,6 +940,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
@@ -977,29 +1007,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) {
@@ -1805,6 +1823,7 @@ __webpack_require__.d(__webpack_exports__, {
   LU: () => (/* reexport safe */ _utils__rspack_import_5.LU),
   MY: () => (/* reexport safe */ _parser__rspack_import_3.MY),
   Nb: () => (/* reexport safe */ _callSource__rspack_import_0.N),
+  Pl: () => (/* reexport safe */ _parser__rspack_import_3.Pl),
   SC: () => (/* reexport safe */ _types__rspack_import_4.SC),
   Sm: () => (/* reexport safe */ _types__rspack_import_4.Sm),
   Sv: () => (/* reexport safe */ _fold__rspack_import_2.Sv),
@@ -1845,6 +1864,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)
 });
@@ -1853,6 +1873,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);
 
 
@@ -1860,6 +1881,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}`,
@@ -2467,6 +2489,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([
@@ -2644,13 +2669,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();
@@ -2672,6 +2702,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();
@@ -2935,7 +3030,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"}`
@@ -3227,7 +3322,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 {
@@ -3321,7 +3416,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 {
@@ -3331,9 +3426,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);
@@ -3478,10 +3584,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);
@@ -3515,6 +3650,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"));
         }
@@ -3728,6 +3867,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) {
@@ -4063,6 +4205,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
 
 
 },
@@ -4799,7 +5039,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__, {
@@ -4828,9 +5068,10 @@ __webpack_require__.d(__webpack_exports__, {
   QB: () => (/* reexport */ RetryDbPlugin),
   m6: () => (/* reexport */ executeJoin),
   i1: () => (/* reexport */ parameteriseDocument),
-  __: () => (/* reexport */ toEntityShape),
+  wk: () => (/* reexport */ reportRenamedProperties),
   VW: () => (/* reexport */ applyInnerOptions),
   B2: () => (/* reexport */ describeUnparsableFilter),
+  __: () => (/* reexport */ toEntityShape),
   Jd: () => (/* reexport */ EphemeralDataPlugin),
   Pl: () => (/* reexport */ deserializePersistResult),
   JF: () => (/* reexport */ DataTranslator),
@@ -5821,9 +6062,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.
  *
@@ -5852,6 +6096,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.
@@ -6303,7 +6572,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.",
@@ -6805,6 +7073,80 @@ const formatStep = (step, lines)=>{
     return lines.join("\n");
 };
 
+// EXTERNAL MODULE: ./src/expressions/utils.ts
+var utils = __webpack_require__(63);
+;// CONCATENATED MODULE: ./src/plugins/query/renames.ts
+
+
+const PROPERTY_READING_OPTIONS = [
+    "filter",
+    "sort",
+    "nearest",
+    "map",
+    "group"
+];
+const namesRenamedProperty = (expression)=>{
+    let found = false;
+    if (expression == null) {
+        return found;
+    }
+    (0,utils/* .forEach */.jJ)(expression, (node)=>{
+        if ((0,assertions/* .isPropertyExpression */.e3)(node) && node.property.hasRenamedSegments) {
+            found = true;
+            return false;
+        }
+        return true;
+    });
+    return found;
+};
+const isRenamed = (property)=>property != null && property.hasRenamedSegments;
+/**
+ * Whether a selector's value is read from a renamed property, whether it is that property or computed
+ * from it: `r => r.dueDate.getTime()` reads `dueDate` all the same. Every property it reads when the
+ * selector was parsed, and otherwise the property recorded for it.
+ */ const readsRenamedValue = (value)=>value != null && (value.reads != null ? value.reads.some(isRenamed) : isRenamed(value.property));
+const readsRenamedField = (fields)=>fields != null && fields.some(readsRenamedValue);
+const readsRenamedProperty = (name, value)=>{
+    switch(name){
+        case "filter":
+            return namesRenamedProperty(value.expression);
+        case "map":
+            // A projection reads each field it selects
+            return readsRenamedField(value.fields);
+        case "group":
+            // A group reads its key, then copies every field of the row into its members: every schema
+            // property, or what a `map` before it selected
+            return readsRenamedValue(value.key) || readsRenamedField(value.fields);
+        default:
+            return readsRenamedValue(value);
+    }
+};
+/**
+ * Hands back every option over a property stored under a `.from()` name, for the datastore to run
+ * in memory.
+ *
+ * Core keeps such an option with the database, because only the plugin knows whether its backend
+ * reads storage names. One that translates the option — SQL renders the column from
+ * `getResolvedName()` — needs nothing from here. One that runs the caller's lambda over rows as it
+ * stores them reads a key the row does not have, and answers wrongly without an error: that plugin
+ * calls this before it reads anything, and the datastore finishes the query after deserialization,
+ * where the in-memory names exist.
+ *
+ * Reported as `missing-capability`: the backend cannot express the option as written, and like
+ * every capability, that is only knowable by the plugin.
+ *
+ * @param names Which options to check, for a plugin that resolves some of them itself — Mongo renders
+ * filters and sorts through the stored path, and runs `nearest`, `map` and `group` in JavaScript.
+ */ const reportRenamedProperties = (options, names = PROPERTY_READING_OPTIONS)=>{
+    for (const name of names){
+        for (const item of options.get(name)){
+            if (readsRenamedProperty(name, item.option.value)) {
+                options.reportMissingCapability(item);
+            }
+        }
+    }
+};
+
 ;// CONCATENATED MODULE: ./src/plugins/query/types.ts
 var types_QueryOrdering = /*#__PURE__*/ function(QueryOrdering) {
     QueryOrdering["Descending"] = "desc";
@@ -6822,6 +7164,7 @@ var types_QueryOrdering = /*#__PURE__*/ function(QueryOrdering) {
 
 
 
+
 // EXTERNAL MODULE: ./src/expressions/evaluate.ts
 var evaluate = __webpack_require__(379);
 // EXTERNAL MODULE: ./src/expressions/fold.ts
@@ -6835,6 +7178,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",
@@ -6848,6 +7194,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.
  *
@@ -6863,7 +7210,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);
@@ -7730,6 +8082,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.
      *
@@ -7937,7 +8298,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"
             });
@@ -7964,7 +8327,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;
@@ -7993,7 +8356,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) {
@@ -8005,6 +8368,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));
@@ -8013,7 +8382,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
@@ -8091,14 +8462,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") {
@@ -8274,7 +8645,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;
     }
@@ -8283,12 +8654,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;
 };
@@ -8330,7 +8701,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);
@@ -8788,6 +9159,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";
@@ -8826,7 +9221,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
@@ -8843,14 +9238,10 @@ class QueryOptionsCollection {
                         this.cutOverToMemory("unmapped-property");
                         return false;
                     }
-                    if ((0,_assertions__rspack_import_1/* .isPropertyExpression */.e3)(expression) && expression.property.hasRenamedSegments) {
-                        // Cut over to memory execution: the plugin stores data under the
-                        // `from` (storage) names, but filter selectors reference the
-                        // in-memory names.  Memory execution runs after deserialization,
-                        // where the in-memory names exist
-                        this.cutOverToMemory("renamed-property");
-                        return false;
-                    }
+                    // A renamed property stays with the database. Whether the backend can read a
+                    // `from` name is the plugin's to know, not this collection's: the property
+                    // travels with the option, and a plugin that cannot resolve it reports it
+                    // back — see `reportRenamedProperties`
                     if (comparesTypesThatCannotMatch(expression)) {
                         _utilities__rspack_import_3/* .logger.warn */.vF.warn(mismatchWarning(expression));
                         this.cutOverToMemory("predicate-error");
@@ -8862,26 +9253,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"))) {
@@ -8988,6 +9372,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()
@@ -9065,19 +9452,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();
@@ -9275,11 +9691,11 @@ 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__, {
-  ly: () => (/* reexport */ isArrayValued),
+  ly: () => (/* reexport */ propertyKind/* .isArrayValued */.l),
   Qc: () => (/* reexport */ SchemaDate),
   dF: () => (/* reexport */ SchemaDefinition),
   VG: () => (/* reexport */ compiledSchemaToJsonSchema),
@@ -9290,7 +9706,7 @@ __webpack_require__.d(__webpack_exports__, {
   qQ: () => (/* reexport */ SchemaIdentity),
   _t: () => (/* reexport */ SchemaDistinct),
   PG: () => (/* reexport */ SchemaNumber),
-  LL: () => (/* reexport */ hasPrimitiveElements),
+  LL: () => (/* reexport */ propertyKind/* .hasPrimitiveElements */.L),
   IB: () => (/* reexport */ SchemaTracked),
   L$: () => (/* reexport */ rehydrateSchemaFromJsonSchema),
   CW: () => (/* reexport */ SchemaSerialize),
@@ -9306,10 +9722,11 @@ __webpack_require__.d(__webpack_exports__, {
   w_: () => (/* reexport */ SchemaBoolean),
   Od: () => (/* reexport */ extractTypeInfo),
   r5: () => (/* reexport */ SchemaComputed),
-  UX: () => (/* reexport */ propertyInfoToJsonSchema),
+  TH: () => (/* reexport */ storageDates/* .getStorageDateReviver */.T),
   XM: () => (/* reexport */ SchemaString),
   Cg: () => (/* reexport */ SchemaFile),
   FR: () => (/* reexport */ SchemaBase),
+  UX: () => (/* reexport */ propertyInfoToJsonSchema),
   s: () => (/* reexport */ s),
   yV: () => (/* reexport */ SchemaTag),
   ge: () => (/* reexport */ SchemaSearchable),
@@ -10524,78 +10941,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
@@ -10771,34 +11119,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(", ")})`;
     }
 }
 
@@ -10958,28 +11288,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);
@@ -11034,34 +11357,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);
@@ -11074,22 +11380,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
@@ -11102,44 +11401,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
 
 
@@ -11149,7 +11419,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({
@@ -11191,13 +11461,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, {
@@ -11213,15 +11480,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);
@@ -11262,28 +11523,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);
@@ -11356,7 +11609,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"
@@ -11693,7 +11946,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
@@ -11719,7 +11972,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); })`;
@@ -11838,7 +12091,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({
@@ -11901,7 +12154,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"
@@ -12196,7 +12449,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",
@@ -12209,18 +12461,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);
@@ -12246,7 +12496,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
@@ -12487,7 +12737,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"
@@ -12652,7 +12902,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"
@@ -12729,7 +12979,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"
@@ -12865,7 +13115,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({
@@ -12875,17 +13124,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);
@@ -12944,7 +13191,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
@@ -13848,8 +14095,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
                         });
@@ -13858,7 +14105,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}"); }`
                         });
@@ -13995,39 +14242,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";
@@ -14126,6 +14350,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;
@@ -14176,10 +14434,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;
@@ -14312,9 +14582,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;');
@@ -14343,9 +14615,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();
@@ -14580,6 +14853,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
@@ -14588,6 +14863,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");
@@ -15229,6 +15508,8 @@ const s = {
 
 
 
+// EXTERNAL MODULE: ./src/schema/utils/storageDates.ts
+var storageDates = __webpack_require__(894);
 ;// CONCATENATED MODULE: ./src/schema/index.ts
 
 
@@ -15242,6 +15523,7 @@ const s = {
 
 
 
+
 },
 537(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
 __webpack_require__.d(__webpack_exports__, {
@@ -15278,6 +15560,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__, {
@@ -15896,6 +16301,7 @@ __webpack_require__.d(__webpack_exports__, {
   PGb: () => (/* reexport safe */ _schema__rspack_import_9.PG),
   PPB: () => (/* reexport safe */ _plugins__rspack_import_7.PP),
   PlD: () => (/* reexport safe */ _plugins__rspack_import_7.Pl),
+  PlK: () => (/* reexport safe */ _expressions__rspack_import_4.Pl),
   Pr0: () => (/* reexport safe */ _plugins__rspack_import_7.Pr),
   Q7C: () => (/* reexport safe */ _results__rspack_import_8.Q7),
   QBn: () => (/* reexport safe */ _plugins__rspack_import_7.QB),
@@ -15908,6 +16314,7 @@ __webpack_require__.d(__webpack_exports__, {
   Smt: () => (/* reexport safe */ _expressions__rspack_import_4.Sm),
   Sv9: () => (/* reexport safe */ _expressions__rspack_import_4.Sv),
   TFx: () => (/* reexport safe */ _schema__rspack_import_9.TF),
+  THL: () => (/* reexport safe */ _schema__rspack_import_9.TH),
   Tlv: () => (/* reexport safe */ _codegen__rspack_import_1.Tl),
   To4: () => (/* reexport safe */ _plugins__rspack_import_7.To),
   UQ$: () => (/* reexport safe */ _pipeline__rspack_import_6.UQ),
@@ -16019,6 +16426,7 @@ __webpack_require__.d(__webpack_exports__, {
   wSV: () => (/* reexport safe */ _expressions__rspack_import_4.wS),
   w_n: () => (/* reexport safe */ _schema__rspack_import_9.w_),
   wgE: () => (/* reexport safe */ _utilities__rspack_import_10.wg),
+  wku: () => (/* reexport safe */ _plugins__rspack_import_7.wk),
   wpC: () => (/* reexport safe */ _collections__rspack_import_2.wp),
   wtA: () => (/* reexport safe */ _schema__rspack_import_9.wt),
   xHv: () => (/* reexport safe */ _assertions__rspack_import_0.xH),
@@ -16040,9 +16448,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);
 
 
@@ -16190,6 +16598,7 @@ var __webpack_exports__forEach = __webpack_exports__.jJl;
 var __webpack_exports__formatExplanation = __webpack_exports__.vZg;
 var __webpack_exports__getLogLevel = __webpack_exports__.XML;
 var __webpack_exports__getProperties = __webpack_exports__.oYS;
+var __webpack_exports__getStorageDateReviver = __webpack_exports__.THL;
 var __webpack_exports__hasPrimitiveElements = __webpack_exports__.LLS;
 var __webpack_exports__hash = __webpack_exports__.tWU;
 var __webpack_exports__hashJoin = __webpack_exports__.Bg1;
@@ -16219,12 +16628,14 @@ var __webpack_exports__operandValue = __webpack_exports__.Vv5;
 var __webpack_exports__parameter = __webpack_exports__.Wif;
 var __webpack_exports__parameteriseDocument = __webpack_exports__.i1p;
 var __webpack_exports__parseFragment = __webpack_exports__.oHM;
+var __webpack_exports__parseSelector = __webpack_exports__.PlK;
 var __webpack_exports__peelCalls = __webpack_exports__.CCQ;
 var __webpack_exports__propertyInfoToJsonSchema = __webpack_exports__.UXe;
 var __webpack_exports__readJoinKey = __webpack_exports__.qyv;
 var __webpack_exports__rehydrateSchemaFromJsonSchema = __webpack_exports__.L$j;
 var __webpack_exports__rehydrateSchemaFromJsonString = __webpack_exports__.Dkq;
 var __webpack_exports__renderCallAsJs = __webpack_exports__.axV;
+var __webpack_exports__reportRenamedProperties = __webpack_exports__.wku;
 var __webpack_exports__resetLogLevel = __webpack_exports__.Cgm;
 var __webpack_exports__resolveBulkPersistChanges = __webpack_exports__.apy;
 var __webpack_exports__s = __webpack_exports__.s;
@@ -16247,6 +16658,6 @@ var __webpack_exports__uuid = __webpack_exports__.uRe;
 var __webpack_exports__uuidv4 = __webpack_exports__.gZm;
 var __webpack_exports__withExecutedQueries = __webpack_exports__.KgE;
 var __webpack_exports__withInnerSide = __webpack_exports__.oJY;
-export { __webpack_exports__AndBuilder as AndBuilder, __webpack_exports__ArrayBuilder as ArrayBuilder, __webpack_exports__AssignmentBuilder as AssignmentBuilder, __webpack_exports__BatchingDbPlugin as BatchingDbPlugin, __webpack_exports__Block as Block, __webpack_exports__BulkPersistChanges as BulkPersistChanges, __webpack_exports__BulkPersistResult as BulkPersistResult, __webpack_exports__CALL_SOURCE as CALL_SOURCE, __webpack_exports__CacheDbPlugin as CacheDbPlugin, __webpack_exports__CallExpression as CallExpression, __webpack_exports__CodeBuilder as CodeBuilder, __webpack_exports__ComparatorExpression as ComparatorExpression, __webpack_exports__ConcurrencyDbPlugin as ConcurrencyDbPlugin, __webpack_exports__ContainerBlock as ContainerBlock, __webpack_exports__DATABASE_EXECUTION_EXPLANATIONS as DATABASE_EXECUTION_EXPLANATIONS, __webpack_exports__DEFAULT_SEMI_JOIN_KEY_THRESHOLD as DEFAULT_SEMI_JOIN_KEY_THRESHOLD, __webpack_exports__DataTranslator as DataTranslator, __webpack_exports__EXECUTED_QUERIES_UNSUPPORTED as EXECUTED_QUERIES_UNSUPPORTED, __webpack_exports__EXPRESSION_TYPES as EXPRESSION_TYPES, __webpack_exports__EmptyExpression as EmptyExpression, __webpack_exports__EphemeralDataPlugin as EphemeralDataPlugin, __webpack_exports__Expression as Expression, __webpack_exports__FOLDABLE as FOLDABLE, __webpack_exports__FunctionBuilder as FunctionBuilder, __webpack_exports__FunctionFactoryBuilder as FunctionFactoryBuilder, __webpack_exports__HashType as HashType, __webpack_exports__IdSet as IdSet, __webpack_exports__IfBuilder as IfBuilder, __webpack_exports__JsonTranslator as JsonTranslator, __webpack_exports__LOG_LEVELS as LOG_LEVELS, __webpack_exports__MEMORY_EXECUTION_EXPLANATIONS as MEMORY_EXECUTION_EXPLANATIONS, __webpack_exports__MemoryDataCollection as MemoryDataCollection, __webpack_exports__NotParsableExpression as NotParsableExpression, __webpack_exports__ObjectBuilder as ObjectBuilder, __webpack_exports__OperatorExpression as OperatorExpression, __webpack_exports__OptimisticConcurrencyError as OptimisticConcurrencyError, __webpack_exports__PluginDestroyedError as PluginDestroyedError, __webpack_exports__PluginEventResult as PluginEventResult, __webpack_exports__PropertyExpression as PropertyExpression, __webpack_exports__PropertyInfo as PropertyInfo, __webpack_exports__Query as Query, __webpack_exports__QueryOptionsCollection as QueryOptionsCollection, __webpack_exports__QueryOrdering as QueryOrdering, __webpack_exports__RawBuilder as RawBuilder, __webpack_exports__ReadonlySchemaCollection as ReadonlySchemaCollection, __webpack_exports__Result as Result, __webpack_exports__RetryDbPlugin as RetryDbPlugin, __webpack_exports__SchemaArray as SchemaArray, __webpack_exports__SchemaBase as SchemaBase, __webpack_exports__SchemaBoolean as SchemaBoolean, __webpack_exports__SchemaCollection as SchemaCollection, __webpack_exports__SchemaComputed as SchemaComputed, __webpack_exports__SchemaDate as SchemaDate, __webpack_exports__SchemaDefault as SchemaDefault, __webpack_exports__SchemaDefinition as SchemaDefinition, __webpack_exports__SchemaDeserialize as SchemaDeserialize, __webpack_exports__SchemaDistinct as SchemaDistinct, __webpack_exports__SchemaError as SchemaError, __webpack_exports__SchemaFile as SchemaFile, __webpack_exports__SchemaForeignKey as SchemaForeignKey, __webpack_exports__SchemaFrom as SchemaFrom, __webpack_exports__SchemaFunction as SchemaFunction, __webpack_exports__SchemaIdentity as SchemaIdentity, __webpack_exports__SchemaIndex as SchemaIndex, __webpack_exports__SchemaKey as SchemaKey, __webpack_exports__SchemaNullable as SchemaNullable, __webpack_exports__SchemaNumber as SchemaNumber, __webpack_exports__SchemaObject as SchemaObject, __webpack_exports__SchemaOptional as SchemaOptional, __webpack_exports__SchemaPersistChanges as SchemaPersistChanges, __webpack_exports__SchemaPersistResult as SchemaPersistResult, __webpack_exports__SchemaReadonly as SchemaReadonly, __webpack_exports__SchemaSearchable as SchemaSearchable, __webpack_exports__SchemaSerialize as SchemaSerialize, __webpack_exports__SchemaString as SchemaString, __webpack_exports__SchemaTag as SchemaTag, __webpack_exports__SchemaTracked as SchemaTracked, __webpack_exports__SchemaTransform as SchemaTransform, __webpack_exports__SchemaTypes as SchemaTypes, __webpack_exports__SchemaVector as SchemaVector, __webpack_exports__SlotBlock as SlotBlock, __webpack_exports__SqlTranslator as SqlTranslator, __webpack_exports__StringBuilder as StringBuilder, __webpack_exports__SyncronousQueue as SyncronousQueue, __webpack_exports__TagCollection as TagCollection, __webpack_exports__TelemetryDbPlugin as TelemetryDbPlugin, __webpack_exports__TrampolinePipeline as TrampolinePipeline, __webpack_exports__TranslatedArrayValue as TranslatedArrayValue, __webpack_exports__TranslatedGroupValue as TranslatedGroupValue, __webpack_exports__TranslatedSingleValue as TranslatedSingleValue, __webpack_exports__TupleTranslator as TupleTranslator, __webpack_exports__UNRESOLVED as UNRESOLVED, __webpack_exports__ValueExpression as ValueExpression, __webpack_exports__VariableBuilder as VariableBuilder, __webpack_exports__WorkPipeline as WorkPipeline, __webpack_exports__applyInnerOptions as applyInnerOptions, __webpack_exports__assertDate as assertDate, __webpack_exports__assertInstanceOf as assertInstanceOf, __webpack_exports__assertIsArray as assertIsArray, __webpack_exports__assertIsNotNull as assertIsNotNull, __webpack_exports__assertIsNumber as assertIsNumber, __webpack_exports__assertString as assertString, __webpack_exports__cast as cast, __webpack_exports__childrenOf as childrenOf, __webpack_exports__clone as clone, __webpack_exports__collectingSink as collectingSink, __webpack_exports__combineExpressions as combineExpressions, __webpack_exports__combineQueryOptionsCollections as combineQueryOptionsCollections, __webpack_exports__compiledSchemaToJsonSchema as compiledSchemaToJsonSchema, __webpack_exports__cosineDistance as cosineDistance, __webpack_exports__createRequestHandler as createRequestHandler, __webpack_exports__createStandardJsonSchemaProps as createStandardJsonSchemaProps, __webpack_exports__describeFilterAsJs as describeFilterAsJs, __webpack_exports__describeFilters as describeFilters, __webpack_exports__describeUnparsableFilter as describeUnparsableFilter, __webpack_exports__deserializeBulkPersist as deserializeBulkPersist, __webpack_exports__deserializePersistResult as deserializePersistResult, __webpack_exports__deserializeQueryOptions as deserializeQueryOptions, __webpack_exports__distinctJoinKeys as distinctJoinKeys, __webpack_exports__evaluate as evaluate, __webpack_exports__executeJoin as executeJoin, __webpack_exports__executedQueriesOf as executedQueriesOf, __webpack_exports__explainQuery as explainQuery, __webpack_exports__extractTypeInfo as extractTypeInfo, __webpack_exports__fastHash as fastHash, __webpack_exports__foldConstantCalls as foldConstantCalls, __webpack_exports__foldedOperandValue as foldedOperandValue, __webpack_exports__forEach as forEach, __webpack_exports__formatExplanation as formatExplanation, __webpack_exports__getLogLevel as getLogLevel, __webpack_exports__getProperties as getProperties, __webpack_exports__hasPrimitiveElements as hasPrimitiveElements, __webpack_exports__hash as hash, __webpack_exports__hashJoin as hashJoin, __webpack_exports__isArrayValued as isArrayValued, __webpack_exports__isCallExpression as isCallExpression, __webpack_exports__isComparatorExpression as isComparatorExpression, __webpack_exports__isDatabaseStep as isDatabaseStep, __webpack_exports__isDate as isDate, __webpack_exports__isEmptyExpression as isEmptyExpression, __webpack_exports__isExpression as isExpression, __webpack_exports__isLogLevelEnabled as isLogLevelEnabled, __webpack_exports__isNodeRuntime as isNodeRuntime, __webpack_exports__isNotParsableExpression as isNotParsableExpression, __webpack_exports__isOperatorExpression as isOperatorExpression, __webpack_exports__isPropertyExpression as isPropertyExpression, __webpack_exports__isValueExpression as isValueExpression, __webpack_exports__joinInPlugin as joinInPlugin, __webpack_exports__loadJoinInnerSide as loadJoinInnerSide, __webpack_exports__logger as logger, __webpack_exports__loggerSink as loggerSink, __webpack_exports__mappedResultColumns as mappedResultColumns, __webpack_exports__measure as measure, __webpack_exports__nearestBy as nearestBy, __webpack_exports__noop as noop, __webpack_exports__now as now, __webpack_exports__operandValue as operandValue, __webpack_exports__parameter as parameter, __webpack_exports__parameteriseDocument as parameteriseDocument, __webpack_exports__parseFragment as parseFragment, __webpack_exports__peelCalls as peelCalls, __webpack_exports__propertyInfoToJsonSchema as propertyInfoToJsonSchema, __webpack_exports__readJoinKey as readJoinKey, __webpack_exports__rehydrateSchemaFromJsonSchema as rehydrateSchemaFromJsonSchema, __webpack_exports__rehydrateSchemaFromJsonString as rehydrateSchemaFromJsonString, __webpack_exports__renderCallAsJs as renderCallAsJs, __webpack_exports__resetLogLevel as resetLogLevel, __webpack_exports__resolveBulkPersistChanges as resolveBulkPersistChanges, __webpack_exports__s as s, __webpack_exports__semiJoinFilter as semiJoinFilter, __webpack_exports__serializeBulkPersist as serializeBulkPersist, __webpack_exports__serializePersistResult as serializePersistResult, __webpack_exports__serializeQueryOptions as serializeQueryOptions, __webpack_exports__setLogLevel as setLogLevel, __webpack_exports__splitSendableOptions as splitSendableOptions, __webpack_exports__stringifyObject as stringifyObject, __webpack_exports__toEntityShape as toEntityShape, __webpack_exports__toEventArray as toEventArray, __webpack_exports__toExpression as toExpression, __webpack_exports__toMap as toMap, __webpack_exports__toPredicate as toPredicate, __webpack_exports__toPromise as toPromise, __webpack_exports__toStrictPredicate as toStrictPredicate, __webpack_exports__unsafeCast as unsafeCast, __webpack_exports__uuid as uuid, __webpack_exports__uuidv4 as uuidv4, __webpack_exports__withExecutedQueries as withExecutedQueries, __webpack_exports__withInnerSide as withInnerSide };
+export { __webpack_exports__AndBuilder as AndBuilder, __webpack_exports__ArrayBuilder as ArrayBuilder, __webpack_exports__AssignmentBuilder as AssignmentBuilder, __webpack_exports__BatchingDbPlugin as BatchingDbPlugin, __webpack_exports__Block as Block, __webpack_exports__BulkPersistChanges as BulkPersistChanges, __webpack_exports__BulkPersistResult as BulkPersistResult, __webpack_exports__CALL_SOURCE as CALL_SOURCE, __webpack_exports__CacheDbPlugin as CacheDbPlugin, __webpack_exports__CallExpression as CallExpression, __webpack_exports__CodeBuilder as CodeBuilder, __webpack_exports__ComparatorExpression as ComparatorExpression, __webpack_exports__ConcurrencyDbPlugin as ConcurrencyDbPlugin, __webpack_exports__ContainerBlock as ContainerBlock, __webpack_exports__DATABASE_EXECUTION_EXPLANATIONS as DATABASE_EXECUTION_EXPLANATIONS, __webpack_exports__DEFAULT_SEMI_JOIN_KEY_THRESHOLD as DEFAULT_SEMI_JOIN_KEY_THRESHOLD, __webpack_exports__DataTranslator as DataTranslator, __webpack_exports__EXECUTED_QUERIES_UNSUPPORTED as EXECUTED_QUERIES_UNSUPPORTED, __webpack_exports__EXPRESSION_TYPES as EXPRESSION_TYPES, __webpack_exports__EmptyExpression as EmptyExpression, __webpack_exports__EphemeralDataPlugin as EphemeralDataPlugin, __webpack_exports__Expression as Expression, __webpack_exports__FOLDABLE as FOLDABLE, __webpack_exports__FunctionBuilder as FunctionBuilder, __webpack_exports__FunctionFactoryBuilder as FunctionFactoryBuilder, __webpack_exports__HashType as HashType, __webpack_exports__IdSet as IdSet, __webpack_exports__IfBuilder as IfBuilder, __webpack_exports__JsonTranslator as JsonTranslator, __webpack_exports__LOG_LEVELS as LOG_LEVELS, __webpack_exports__MEMORY_EXECUTION_EXPLANATIONS as MEMORY_EXECUTION_EXPLANATIONS, __webpack_exports__MemoryDataCollection as MemoryDataCollection, __webpack_exports__NotParsableExpression as NotParsableExpression, __webpack_exports__ObjectBuilder as ObjectBuilder, __webpack_exports__OperatorExpression as OperatorExpression, __webpack_exports__OptimisticConcurrencyError as OptimisticConcurrencyError, __webpack_exports__PluginDestroyedError as PluginDestroyedError, __webpack_exports__PluginEventResult as PluginEventResult, __webpack_exports__PropertyExpression as PropertyExpression, __webpack_exports__PropertyInfo as PropertyInfo, __webpack_exports__Query as Query, __webpack_exports__QueryOptionsCollection as QueryOptionsCollection, __webpack_exports__QueryOrdering as QueryOrdering, __webpack_exports__RawBuilder as RawBuilder, __webpack_exports__ReadonlySchemaCollection as ReadonlySchemaCollection, __webpack_exports__Result as Result, __webpack_exports__RetryDbPlugin as RetryDbPlugin, __webpack_exports__SchemaArray as SchemaArray, __webpack_exports__SchemaBase as SchemaBase, __webpack_exports__SchemaBoolean as SchemaBoolean, __webpack_exports__SchemaCollection as SchemaCollection, __webpack_exports__SchemaComputed as SchemaComputed, __webpack_exports__SchemaDate as SchemaDate, __webpack_exports__SchemaDefault as SchemaDefault, __webpack_exports__SchemaDefinition as SchemaDefinition, __webpack_exports__SchemaDeserialize as SchemaDeserialize, __webpack_exports__SchemaDistinct as SchemaDistinct, __webpack_exports__SchemaError as SchemaError, __webpack_exports__SchemaFile as SchemaFile, __webpack_exports__SchemaForeignKey as SchemaForeignKey, __webpack_exports__SchemaFrom as SchemaFrom, __webpack_exports__SchemaFunction as SchemaFunction, __webpack_exports__SchemaIdentity as SchemaIdentity, __webpack_exports__SchemaIndex as SchemaIndex, __webpack_exports__SchemaKey as SchemaKey, __webpack_exports__SchemaNullable as SchemaNullable, __webpack_exports__SchemaNumber as SchemaNumber, __webpack_exports__SchemaObject as SchemaObject, __webpack_exports__SchemaOptional as SchemaOptional, __webpack_exports__SchemaPersistChanges as SchemaPersistChanges, __webpack_exports__SchemaPersistResult as SchemaPersistResult, __webpack_exports__SchemaReadonly as SchemaReadonly, __webpack_exports__SchemaSearchable as SchemaSearchable, __webpack_exports__SchemaSerialize as SchemaSerialize, __webpack_exports__SchemaString as SchemaString, __webpack_exports__SchemaTag as SchemaTag, __webpack_exports__SchemaTracked as SchemaTracked, __webpack_exports__SchemaTransform as SchemaTransform, __webpack_exports__SchemaTypes as SchemaTypes, __webpack_exports__SchemaVector as SchemaVector, __webpack_exports__SlotBlock as SlotBlock, __webpack_exports__SqlTranslator as SqlTranslator, __webpack_exports__StringBuilder as StringBuilder, __webpack_exports__SyncronousQueue as SyncronousQueue, __webpack_exports__TagCollection as TagCollection, __webpack_exports__TelemetryDbPlugin as TelemetryDbPlugin, __webpack_exports__TrampolinePipeline as TrampolinePipeline, __webpack_exports__TranslatedArrayValue as TranslatedArrayValue, __webpack_exports__TranslatedGroupValue as TranslatedGroupValue, __webpack_exports__TranslatedSingleValue as TranslatedSingleValue, __webpack_exports__TupleTranslator as TupleTranslator, __webpack_exports__UNRESOLVED as UNRESOLVED, __webpack_exports__ValueExpression as ValueExpression, __webpack_exports__VariableBuilder as VariableBuilder, __webpack_exports__WorkPipeline as WorkPipeline, __webpack_exports__applyInnerOptions as applyInnerOptions, __webpack_exports__assertDate as assertDate, __webpack_exports__assertInstanceOf as assertInstanceOf, __webpack_exports__assertIsArray as assertIsArray, __webpack_exports__assertIsNotNull as assertIsNotNull, __webpack_exports__assertIsNumber as assertIsNumber, __webpack_exports__assertString as assertString, __webpack_exports__cast as cast, __webpack_exports__childrenOf as childrenOf, __webpack_exports__clone as clone, __webpack_exports__collectingSink as collectingSink, __webpack_exports__combineExpressions as combineExpressions, __webpack_exports__combineQueryOptionsCollections as combineQueryOptionsCollections, __webpack_exports__compiledSchemaToJsonSchema as compiledSchemaToJsonSchema, __webpack_exports__cosineDistance as cosineDistance, __webpack_exports__createRequestHandler as createRequestHandler, __webpack_exports__createStandardJsonSchemaProps as createStandardJsonSchemaProps, __webpack_exports__describeFilterAsJs as describeFilterAsJs, __webpack_exports__describeFilters as describeFilters, __webpack_exports__describeUnparsableFilter as describeUnparsableFilter, __webpack_exports__deserializeBulkPersist as deserializeBulkPersist, __webpack_exports__deserializePersistResult as deserializePersistResult, __webpack_exports__deserializeQueryOptions as deserializeQueryOptions, __webpack_exports__distinctJoinKeys as distinctJoinKeys, __webpack_exports__evaluate as evaluate, __webpack_exports__executeJoin as executeJoin, __webpack_exports__executedQueriesOf as executedQueriesOf, __webpack_exports__explainQuery as explainQuery, __webpack_exports__extractTypeInfo as extractTypeInfo, __webpack_exports__fastHash as fastHash, __webpack_exports__foldConstantCalls as foldConstantCalls, __webpack_exports__foldedOperandValue as foldedOperandValue, __webpack_exports__forEach as forEach, __webpack_exports__formatExplanation as formatExplanation, __webpack_exports__getLogLevel as getLogLevel, __webpack_exports__getProperties as getProperties, __webpack_exports__getStorageDateReviver as getStorageDateReviver, __webpack_exports__hasPrimitiveElements as hasPrimitiveElements, __webpack_exports__hash as hash, __webpack_exports__hashJoin as hashJoin, __webpack_exports__isArrayValued as isArrayValued, __webpack_exports__isCallExpression as isCallExpression, __webpack_exports__isComparatorExpression as isComparatorExpression, __webpack_exports__isDatabaseStep as isDatabaseStep, __webpack_exports__isDate as isDate, __webpack_exports__isEmptyExpression as isEmptyExpression, __webpack_exports__isExpression as isExpression, __webpack_exports__isLogLevelEnabled as isLogLevelEnabled, __webpack_exports__isNodeRuntime as isNodeRuntime, __webpack_exports__isNotParsableExpression as isNotParsableExpression, __webpack_exports__isOperatorExpression as isOperatorExpression, __webpack_exports__isPropertyExpression as isPropertyExpression, __webpack_exports__isValueExpression as isValueExpression, __webpack_exports__joinInPlugin as joinInPlugin, __webpack_exports__loadJoinInnerSide as loadJoinInnerSide, __webpack_exports__logger as logger, __webpack_exports__loggerSink as loggerSink, __webpack_exports__mappedResultColumns as mappedResultColumns, __webpack_exports__measure as measure, __webpack_exports__nearestBy as nearestBy, __webpack_exports__noop as noop, __webpack_exports__now as now, __webpack_exports__operandValue as operandValue, __webpack_exports__parameter as parameter, __webpack_exports__parameteriseDocument as parameteriseDocument, __webpack_exports__parseFragment as parseFragment, __webpack_exports__parseSelector as parseSelector, __webpack_exports__peelCalls as peelCalls, __webpack_exports__propertyInfoToJsonSchema as propertyInfoToJsonSchema, __webpack_exports__readJoinKey as readJoinKey, __webpack_exports__rehydrateSchemaFromJsonSchema as rehydrateSchemaFromJsonSchema, __webpack_exports__rehydrateSchemaFromJsonString as rehydrateSchemaFromJsonString, __webpack_exports__renderCallAsJs as renderCallAsJs, __webpack_exports__reportRenamedProperties as reportRenamedProperties, __webpack_exports__resetLogLevel as resetLogLevel, __webpack_exports__resolveBulkPersistChanges as resolveBulkPersistChanges, __webpack_exports__s as s, __webpack_exports__semiJoinFilter as semiJoinFilter, __webpack_exports__serializeBulkPersist as serializeBulkPersist, __webpack_exports__serializePersistResult as serializePersistResult, __webpack_exports__serializeQueryOptions as serializeQueryOptions, __webpack_exports__setLogLevel as setLogLevel, __webpack_exports__splitSendableOptions as splitSendableOptions, __webpack_exports__stringifyObject as stringifyObject, __webpack_exports__toEntityShape as toEntityShape, __webpack_exports__toEventArray as toEventArray, __webpack_exports__toExpression as toExpression, __webpack_exports__toMap as toMap, __webpack_exports__toPredicate as toPredicate, __webpack_exports__toPromise as toPromise, __webpack_exports__toStrictPredicate as toStrictPredicate, __webpack_exports__unsafeCast as unsafeCast, __webpack_exports__uuid as uuid, __webpack_exports__uuidv4 as uuidv4, __webpack_exports__withExecutedQueries as withExecutedQueries, __webpack_exports__withInnerSide as withInnerSide };
 
 //# sourceMappingURL=index.js.map