@routier/core 0.6.0 → 0.8.0

package/dist/schema/index.cjs

@@ -346,6 +346,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;
@@ -461,6 +469,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');
     }
@@ -543,6 +571,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;
+};
+
+
 },
 581(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
 __webpack_require__.d(__webpack_exports__, {
@@ -618,12 +769,14 @@ const isLogLevel = (value)=>typeof value === 'string' && LOG_LEVELS.includes(val
         const debug = process.env.DEBUG;
         if (debug === 'routier' || debug === '*') return 'debug';
         const env = "production"?.toLowerCase();
-        // `test` is deliberately absent. It used to be here, which meant no test suite anywhere
-        // could run Routier quietly. Opt in with DEBUG=routier or ROUTIER_LOG_LEVEL when a test
-        // needs the output.
         if (env === 'dev' || env === 'development') return 'debug';
     }
-    return 'silent';
+    // Warnings are on unless something turns them off.
+    //
+    // Routier warns when a query returns correct rows a slower way than it could, or when a filter
+    // compares types that can never match. Both are the caller's to act on, and a default of
+    // `silent` meant the only people who ever saw them were the ones who already knew to look.
+    return 'warn';
 };
 let level = resolveLevel();
 let rank = RANK[level];
@@ -935,6 +1088,7 @@ __webpack_require__.d(__webpack_exports__, {
   SchemaTransform: () => (/* reexport */ SchemaTransform),
   SchemaComputed: () => (/* reexport */ SchemaComputed),
   extractTypeInfo: () => (/* reexport */ extractTypeInfo),
+  getStorageDateReviver: () => (/* reexport */ storageDates/* .getStorageDateReviver */.T),
   SchemaTracked: () => (/* reexport */ SchemaTracked),
   SchemaFile: () => (/* reexport */ SchemaFile),
   SchemaNumber: () => (/* reexport */ SchemaNumber),
@@ -951,12 +1105,12 @@ __webpack_require__.d(__webpack_exports__, {
   SchemaArray: () => (/* reexport */ SchemaArray),
   SchemaKey: () => (/* reexport */ SchemaKey),
   SchemaOptional: () => (/* reexport */ SchemaOptional),
-  hasPrimitiveElements: () => (/* reexport */ hasPrimitiveElements),
+  hasPrimitiveElements: () => (/* reexport */ propertyKind/* .hasPrimitiveElements */.L),
   SchemaDefault: () => (/* reexport */ SchemaDefault),
   SchemaIndex: () => (/* reexport */ SchemaIndex),
   SchemaVector: () => (/* reexport */ SchemaVector),
   HashType: () => (/* reexport */ types/* .HashType */.$),
-  isArrayValued: () => (/* reexport */ isArrayValued),
+  isArrayValued: () => (/* reexport */ propertyKind/* .isArrayValued */.l),
   SchemaBase: () => (/* reexport */ SchemaBase),
   createStandardJsonSchemaProps: () => (/* reexport */ createStandardJsonSchemaProps),
   propertyInfoToJsonSchema: () => (/* reexport */ propertyInfoToJsonSchema),
@@ -1779,12 +1933,6 @@ class SchemaComputed extends SchemaBase {
 ;// CONCATENATED MODULE: ./src/schema/PropertyInfo.ts
 
 
-const SUPPORTED_DESERIALIZATION_TYPES = new Set([
-    types/* .SchemaTypes.Boolean */.L.Boolean,
-    types/* .SchemaTypes.Date */.L.Date,
-    types/* .SchemaTypes.Number */.L.Number,
-    types/* .SchemaTypes.String */.L.String
-]);
 /**
  * Represents metadata and utilities for a property in a schema, including its type, name, parent, children, and serialization details.
  */ class PropertyInfo {
@@ -1904,9 +2052,6 @@ const SUPPORTED_DESERIALIZATION_TYPES = new Set([
     get isRenamed() {
         return !!this.from;
     }
-    get supportsDeserialization() {
-        return this.valueDeserializer != null || SUPPORTED_DESERIALIZATION_TYPES.has(this.type);
-    }
     _getPropertyChain() {
         if (this._propertyChainCache) {
             return this._propertyChainCache;
@@ -2159,7 +2304,7 @@ const SUPPORTED_DESERIALIZATION_TYPES = new Set([
         if (this.type === types/* .SchemaTypes.Boolean */.L.Boolean) {
             return Boolean(value);
         }
-        throw new Error(`Unsupported deserialization for type.  Type: ${this.type}`);
+        return value;
     }
 }
 
@@ -2186,78 +2331,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
@@ -2433,34 +2509,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(", ")})`;
     }
 }
 
@@ -2620,28 +2678,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);
+                args.push(factory.bind(property.injected));
             }
-            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
-                })));
             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);
@@ -2696,34 +2747,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);
@@ -2736,22 +2770,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);
+                args.push(factory.bind(property.injected));
             }
-            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
-                })));
+            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
@@ -2764,44 +2791,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
 
 
@@ -2811,7 +2809,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({
@@ -2853,13 +2851,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, {
@@ -2875,15 +2870,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);
@@ -2924,28 +2913,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);
+                args.push(factory.bind(property.injected));
             }
-            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
-                })));
             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);
@@ -3018,7 +2999,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"
@@ -3355,7 +3336,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
@@ -3381,7 +3362,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); })`;
@@ -3500,7 +3481,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({
@@ -3563,7 +3544,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"
@@ -3858,7 +3839,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",
@@ -3871,18 +3851,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);
@@ -3908,7 +3886,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
@@ -4149,7 +4127,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"
@@ -4314,7 +4292,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"
@@ -4391,7 +4369,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"
@@ -4527,7 +4505,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({
@@ -4537,17 +4514,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);
@@ -4606,7 +4581,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
@@ -5510,8 +5485,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
                         });
@@ -5520,7 +5495,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}"); }`
                         });
@@ -5657,39 +5632,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";
@@ -5788,6 +5740,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;
@@ -5838,10 +5824,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;
@@ -5974,9 +5972,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;');
@@ -6005,9 +6005,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();
@@ -6242,6 +6243,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
@@ -6250,6 +6253,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");
@@ -6891,6 +6898,8 @@ const s = {
 
 
 
+// EXTERNAL MODULE: ./src/schema/utils/storageDates.ts
+var storageDates = __webpack_require__(894);
 ;// CONCATENATED MODULE: ./src/schema/index.ts
 
 
@@ -6903,6 +6912,7 @@ const s = {
 
 
 
+
 })();
 
 module.exports = __webpack_exports__;