@oxog/vld 2.0.1 → 2.0.2

package/dist/cjs/mini.cjs

@@ -3461,6 +3461,7 @@ const REGEX_PATTERNS = {
     ipv4: /^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/};
 /**
  * Immutable string validator with chainable methods
+ * Features pre-compiled validation functions for maximum performance
  */
 class VldString extends VldBase {
     /**
@@ -3468,12 +3469,100 @@ class VldString extends VldBase {
      */
     constructor(config) {
         super();
+        // Cache for pre-compiled validation function
+        this._compiledValidator = null;
         this.config = {
             checks: config?.checks || [],
             transforms: config?.transforms || [],
             errorMessage: config?.errorMessage
         };
     }
+    /**
+     * Compile all transforms and checks into a single optimized function
+     * This eliminates loop overhead and enables better JIT optimization
+     */
+    _compileValidator() {
+        const transforms = this.config.transforms;
+        const checks = this.config.checks;
+        const errorMessage = this.config.errorMessage || getMessages().invalidString;
+        // Fast path: no transforms or checks
+        if (transforms.length === 0 && checks.length === 0) {
+            return (value) => ({ success: true, value });
+        }
+        // Fast path: only transforms, no checks
+        if (checks.length === 0) {
+            switch (transforms.length) {
+                case 1:
+                    return (value) => ({ success: true, value: transforms[0](value) });
+                case 2:
+                    return (value) => ({ success: true, value: transforms[1](transforms[0](value)) });
+                case 3:
+                    return (value) => ({ success: true, value: transforms[2](transforms[1](transforms[0](value))) });
+                default:
+                    return (value) => {
+                        let result = value;
+                        for (let i = 0; i < transforms.length; i++) {
+                            result = transforms[i](result);
+                        }
+                        return { success: true, value: result };
+                    };
+            }
+        }
+        // Fast path: only checks, no transforms
+        if (transforms.length === 0) {
+            switch (checks.length) {
+                case 1:
+                    return (value) => {
+                        if (!checks[0](value))
+                            return { success: false, error: errorMessage };
+                        return { success: true, value };
+                    };
+                case 2:
+                    return (value) => {
+                        if (!checks[0](value) || !checks[1](value))
+                            return { success: false, error: errorMessage };
+                        return { success: true, value };
+                    };
+                case 3:
+                    return (value) => {
+                        if (!checks[0](value) || !checks[1](value) || !checks[2](value))
+                            return { success: false, error: errorMessage };
+                        return { success: true, value };
+                    };
+                default:
+                    return (value) => {
+                        for (let i = 0; i < checks.length; i++) {
+                            if (!checks[i](value))
+                                return { success: false, error: errorMessage };
+                        }
+                        return { success: true, value };
+                    };
+            }
+        }
+        // General case: both transforms and checks
+        return (value) => {
+            let result = value;
+            // Apply transforms
+            for (let i = 0; i < transforms.length; i++) {
+                result = transforms[i](result);
+            }
+            // Apply checks
+            for (let i = 0; i < checks.length; i++) {
+                if (!checks[i](result))
+                    return { success: false, error: errorMessage };
+            }
+            return { success: true, value: result };
+        };
+    }
+    /**
+     * Get the cached compiled validator, creating it if necessary
+     */
+    _getCompiledValidator() {
+        if (!this._compiledValidator) {
+            this._compiledValidator = this._compileValidator();
+        }
+        return this._compiledValidator;
+    }
     /**
      * Create a new string validator
      */
@@ -3481,26 +3570,18 @@ class VldString extends VldBase {
         return new VldString();
     }
     /**
-     * Parse and validate a string value - ultra-optimized
+     * Parse and validate a string value - ultra-optimized with pre-compiled validator
      */
     parse(value) {
         if (typeof value !== 'string') {
             throw new Error(this.config.errorMessage || getMessages().invalidString);
         }
-        let result = value;
-        // Apply transformations with optimized loop
-        const transformsLength = this.config.transforms.length;
-        for (let i = 0; i < transformsLength; i++) {
-            result = this.config.transforms[i](result);
-        }
-        // Apply checks with optimized loop and early termination
-        const checksLength = this.config.checks.length;
-        for (let i = 0; i < checksLength; i++) {
-            if (!this.config.checks[i](result)) {
-                throw new Error(this.config.errorMessage || getMessages().invalidString);
-            }
+        // Use pre-compiled validator for maximum performance
+        const result = this._getCompiledValidator()(value);
+        if (!result.success) {
+            throw new Error(result.error);
         }
-        return result;
+        return result.value;
     }
     /**
      * Safely parse and validate a string value
@@ -4602,16 +4683,9 @@ class VldArray extends VldBase {
             }
             result[i] = parseResult.data; // Direct assignment is faster than push
         }
-        // Check uniqueness if required
+        // Check uniqueness if required - optimized with Map-based approach
         if (this.config.unique) {
-            const seen = new Set();
-            for (const item of result) {
-                const key = typeof item === 'object' ? this.stableStringify(item) : item;
-                if (seen.has(key)) {
-                    throw new Error('Array must contain unique items');
-                }
-                seen.add(key);
-            }
+            this.checkUnique(result);
         }
         return result;
     }
@@ -4626,6 +4700,38 @@ class VldArray extends VldBase {
             return { success: false, error: error };
         }
     }
+    /**
+     * Optimized uniqueness check using Map-based approach
+     * Avoids repeated stableStringify calls by caching serialized values
+     */
+    checkUnique(items) {
+        const seen = new Set(); // Set of seen keys
+        const objectKeys = new WeakMap(); // Cache for object->string mappings
+        for (const item of items) {
+            let key;
+            if (typeof item === 'object' && item !== null) {
+                // Check if we've already serialized this object reference
+                const cached = objectKeys.get(item);
+                if (cached !== undefined) {
+                    key = cached;
+                }
+                else {
+                    // Serialize and cache
+                    const serialized = this.stableStringify(item);
+                    key = serialized;
+                    objectKeys.set(item, serialized);
+                }
+            }
+            else {
+                // Primitives can be used directly as keys
+                key = item;
+            }
+            if (seen.has(key)) {
+                throw new Error('Array must contain unique items');
+            }
+            seen.add(key);
+        }
+    }
     /**
      * Create a stable string representation of an object for hashing
      * Handles circular references and deep nesting gracefully
@@ -4753,11 +4859,17 @@ class VldEnum extends VldBase {
     /**
      * Private constructor to enforce immutability
      */
-    constructor(values, errorMessage) {
+    constructor(_values, errorMessage) {
         super();
-        this.values = values;
+        this._values = _values;
         this.errorMessage = errorMessage;
     }
+    /**
+     * Get the enum values
+     */
+    get values() {
+        return this._values;
+    }
     /**
      * Create a new enum validator
      */
@@ -4771,11 +4883,11 @@ class VldEnum extends VldBase {
         // BUG-002 FIX: Add type check before includes() to prevent type confusion
         if (typeof value !== 'string') {
             throw new Error(this.errorMessage ||
-                getMessages().enumExpected([...this.values], JSON.stringify(value)));
+                getMessages().enumExpected([...this._values], JSON.stringify(value)));
         }
-        if (!this.values.includes(value)) {
+        if (!this._values.includes(value)) {
             throw new Error(this.errorMessage ||
-                getMessages().enumExpected([...this.values], JSON.stringify(value)));
+                getMessages().enumExpected([...this._values], JSON.stringify(value)));
         }
         return value;
     }
@@ -4788,16 +4900,16 @@ class VldEnum extends VldBase {
             return {
                 success: false,
                 error: new Error(this.errorMessage ||
-                    getMessages().enumExpected([...this.values], JSON.stringify(value)))
+                    getMessages().enumExpected([...this._values], JSON.stringify(value)))
             };
         }
-        if (this.values.includes(value)) {
+        if (this._values.includes(value)) {
             return { success: true, data: value };
         }
         return {
             success: false,
             error: new Error(this.errorMessage ||
-                getMessages().enumExpected([...this.values], JSON.stringify(value)))
+                getMessages().enumExpected([...this._values], JSON.stringify(value)))
         };
     }
     /**
@@ -4805,7 +4917,7 @@ class VldEnum extends VldBase {
      * Creates a new enum validator without the specified values
      */
     exclude(...excludeValues) {
-        const filtered = this.values.filter(v => !excludeValues.includes(v));
+        const filtered = this._values.filter(v => !excludeValues.includes(v));
         if (filtered.length === 0) {
             throw new Error('Cannot exclude all enum values');
         }
@@ -4817,7 +4929,7 @@ class VldEnum extends VldBase {
      * Creates a new enum validator with only the specified values
      */
     extract(...extractValues) {
-        const extracted = this.values.filter(v => extractValues.includes(v));
+        const extracted = this._values.filter(v => extractValues.includes(v));
         if (extracted.length === 0) {
             throw new Error('Cannot extract non-existent enum values');
         }
@@ -5338,10 +5450,30 @@ class VldObject extends VldBase {
      */
     constructor(config) {
         super();
-        this.config = config;
+        this._config = config;
         // Pre-compute shape keys for faster access
-        this.shapeKeys = Object.keys(config.shape);
-        this.shapeKeysSet = new Set(this.shapeKeys);
+        this._shapeKeys = Object.keys(config.shape);
+        this._shapeKeysSet = new Set(this._shapeKeys);
+    }
+    /**
+     * Get the validator configuration
+     * @internal Used by discriminated union validator
+     */
+    get config() {
+        return this._config;
+    }
+    /**
+     * Get the shape keys array
+     */
+    get shapeKeys() {
+        return this._shapeKeys;
+    }
+    /**
+     * Get the shape keys set for O(1) lookups
+     * @internal Used by discriminated union validator
+     */
+    get shapeKeysSet() {
+        return this._shapeKeysSet;
     }
     /**
      * Create a new object validator
@@ -5356,14 +5488,14 @@ class VldObject extends VldBase {
     parse(value) {
         // Fast type check
         if (typeof value !== 'object' || value === null || Array.isArray(value)) {
-            throw new Error(this.config.errorMessage || getMessages().invalidObject);
+            throw new Error(this._config.errorMessage || getMessages().invalidObject);
         }
         const obj = value;
         const result = {};
         // Ultra-optimized field validation with inline fast paths
-        for (let i = 0; i < this.shapeKeys.length; i++) {
-            const key = this.shapeKeys[i];
-            const validator = this.config.shape[key];
+        for (let i = 0; i < this._shapeKeys.length; i++) {
+            const key = this._shapeKeys[i];
+            const validator = this._config.shape[key];
             const fieldValue = obj[key];
             // BUG-NEW-002 FIX: Use instanceof instead of constructor.name
             // constructor.name breaks in minified builds where class names become 'a', 'b', etc.
@@ -5420,38 +5552,39 @@ class VldObject extends VldBase {
                 result[key] = parseResult.data;
             }
         }
-        // Handle strict mode - optimized with Set
-        if (this.config.strict) {
+        // Handle strict/passthrough/catchall modes - optimized single Object.keys() call
+        if (this._config.strict || this._config.passthrough || this._config.catchall) {
             const objKeys = Object.keys(obj);
-            const extraKeys = [];
-            for (let i = 0; i < objKeys.length; i++) {
-                if (!this.shapeKeysSet.has(objKeys[i])) {
-                    extraKeys.push(objKeys[i]);
+            // Handle strict mode - optimized with Set
+            if (this._config.strict) {
+                const extraKeys = [];
+                for (let i = 0; i < objKeys.length; i++) {
+                    if (!this._shapeKeysSet.has(objKeys[i])) {
+                        extraKeys.push(objKeys[i]);
+                    }
+                }
+                if (extraKeys.length > 0) {
+                    throw new Error(getMessages().unexpectedKeys(extraKeys));
                 }
             }
-            if (extraKeys.length > 0) {
-                throw new Error(getMessages().unexpectedKeys(extraKeys));
-            }
-        }
-        // Handle passthrough mode - optimized with comprehensive prototype pollution protection
-        if (this.config.passthrough) {
-            const objKeys = Object.keys(obj);
-            for (let i = 0; i < objKeys.length; i++) {
-                const key = objKeys[i];
-                // Skip dangerous keys to prevent prototype pollution
-                if (!this.shapeKeysSet.has(key) && !this.isDangerousKey(key)) {
-                    result[key] = obj[key];
+            // Handle passthrough mode - optimized with comprehensive prototype pollution protection
+            if (this._config.passthrough) {
+                for (let i = 0; i < objKeys.length; i++) {
+                    const key = objKeys[i];
+                    // Skip dangerous keys to prevent prototype pollution
+                    if (!this._shapeKeysSet.has(key) && !this.isDangerousKey(key)) {
+                        result[key] = obj[key];
+                    }
                 }
             }
-        }
-        // Handle catchall - validate extra keys with catchall validator
-        if (this.config.catchall) {
-            const objKeys = Object.keys(obj);
-            for (let i = 0; i < objKeys.length; i++) {
-                const key = objKeys[i];
-                // Skip keys already in shape and dangerous keys
-                if (!this.shapeKeysSet.has(key) && !this.isDangerousKey(key)) {
-                    result[key] = this.config.catchall.parse(obj[key]);
+            // Handle catchall - validate extra keys with catchall validator
+            if (this._config.catchall) {
+                for (let i = 0; i < objKeys.length; i++) {
+                    const key = objKeys[i];
+                    // Skip keys already in shape and dangerous keys
+                    if (!this._shapeKeysSet.has(key) && !this.isDangerousKey(key)) {
+                        result[key] = this._config.catchall.parse(obj[key]);
+                    }
                 }
             }
         }
@@ -5466,15 +5599,15 @@ class VldObject extends VldBase {
         if (typeof value !== 'object' || value === null || Array.isArray(value)) {
             return {
                 success: false,
-                error: new Error(this.config.errorMessage || getMessages().invalidObject)
+                error: new Error(this._config.errorMessage || getMessages().invalidObject)
             };
         }
         const obj = value;
         const result = {};
         // Validate all fields
-        for (let i = 0; i < this.shapeKeys.length; i++) {
-            const key = this.shapeKeys[i];
-            const validator = this.config.shape[key];
+        for (let i = 0; i < this._shapeKeys.length; i++) {
+            const key = this._shapeKeys[i];
+            const validator = this._config.shape[key];
             const fieldValue = obj[key];
             const parseResult = validator.safeParse(fieldValue);
             if (parseResult.success) {
@@ -5487,48 +5620,49 @@ class VldObject extends VldBase {
                 };
             }
         }
-        // Handle strict mode
-        if (this.config.strict) {
+        // Handle strict/passthrough/catchall modes - optimized single Object.keys() call
+        if (this._config.strict || this._config.passthrough || this._config.catchall) {
             const objKeys = Object.keys(obj);
-            const extraKeys = [];
-            for (let i = 0; i < objKeys.length; i++) {
-                if (!this.shapeKeysSet.has(objKeys[i])) {
-                    extraKeys.push(objKeys[i]);
+            // Handle strict mode
+            if (this._config.strict) {
+                const extraKeys = [];
+                for (let i = 0; i < objKeys.length; i++) {
+                    if (!this._shapeKeysSet.has(objKeys[i])) {
+                        extraKeys.push(objKeys[i]);
+                    }
+                }
+                if (extraKeys.length > 0) {
+                    return {
+                        success: false,
+                        error: new Error(getMessages().unexpectedKeys(extraKeys))
+                    };
                 }
             }
-            if (extraKeys.length > 0) {
-                return {
-                    success: false,
-                    error: new Error(getMessages().unexpectedKeys(extraKeys))
-                };
-            }
-        }
-        // Handle passthrough mode with comprehensive prototype pollution protection
-        if (this.config.passthrough) {
-            const objKeys = Object.keys(obj);
-            for (let i = 0; i < objKeys.length; i++) {
-                const key = objKeys[i];
-                // Skip dangerous keys to prevent prototype pollution
-                if (!this.shapeKeysSet.has(key) && !this.isDangerousKey(key)) {
-                    result[key] = obj[key];
+            // Handle passthrough mode with comprehensive prototype pollution protection
+            if (this._config.passthrough) {
+                for (let i = 0; i < objKeys.length; i++) {
+                    const key = objKeys[i];
+                    // Skip dangerous keys to prevent prototype pollution
+                    if (!this._shapeKeysSet.has(key) && !this.isDangerousKey(key)) {
+                        result[key] = obj[key];
+                    }
                 }
             }
-        }
-        // Handle catchall - validate extra keys with catchall validator
-        if (this.config.catchall) {
-            const objKeys = Object.keys(obj);
-            for (let i = 0; i < objKeys.length; i++) {
-                const key = objKeys[i];
-                // Skip keys already in shape and dangerous keys
-                if (!this.shapeKeysSet.has(key) && !this.isDangerousKey(key)) {
-                    const catchallResult = this.config.catchall.safeParse(obj[key]);
-                    if (!catchallResult.success) {
-                        return {
-                            success: false,
-                            error: new Error(getMessages().objectField(key, catchallResult.error.message))
-                        };
+            // Handle catchall - validate extra keys with catchall validator
+            if (this._config.catchall) {
+                for (let i = 0; i < objKeys.length; i++) {
+                    const key = objKeys[i];
+                    // Skip keys already in shape and dangerous keys
+                    if (!this._shapeKeysSet.has(key) && !this.isDangerousKey(key)) {
+                        const catchallResult = this._config.catchall.safeParse(obj[key]);
+                        if (!catchallResult.success) {
+                            return {
+                                success: false,
+                                error: new Error(getMessages().objectField(key, catchallResult.error.message))
+                            };
+                        }
+                        result[key] = catchallResult.data;
                     }
-                    result[key] = catchallResult.data;
                 }
             }
         }
@@ -5593,7 +5727,7 @@ class VldObject extends VldBase {
      */
     strict(message) {
         return new VldObject({
-            ...this.config,
+            ...this._config,
             strict: true,
             passthrough: false,
             errorMessage: message
@@ -5604,7 +5738,7 @@ class VldObject extends VldBase {
      */
     passthrough() {
         return new VldObject({
-            ...this.config,
+            ...this._config,
             strict: false,
             passthrough: true
         });
@@ -5614,11 +5748,11 @@ class VldObject extends VldBase {
      */
     partial() {
         const partialShape = {};
-        for (const key in this.config.shape) {
-            partialShape[key] = new VldOptional(this.config.shape[key]);
+        for (const key in this._config.shape) {
+            partialShape[key] = new VldOptional(this._config.shape[key]);
         }
         return new VldObject({
-            ...this.config,
+            ...this._config,
             shape: partialShape
         });
     }
@@ -5627,8 +5761,8 @@ class VldObject extends VldBase {
      */
     deepPartial() {
         const deepPartialShape = {};
-        for (const key in this.config.shape) {
-            const validator = this.config.shape[key];
+        for (const key in this._config.shape) {
+            const validator = this._config.shape[key];
             if (validator instanceof VldObject) {
                 deepPartialShape[key] = new VldOptional(validator.deepPartial());
             }
@@ -5637,7 +5771,7 @@ class VldObject extends VldBase {
             }
         }
         return new VldObject({
-            ...this.config,
+            ...this._config,
             shape: deepPartialShape
         });
     }
@@ -5647,12 +5781,12 @@ class VldObject extends VldBase {
     pick(...keys) {
         const pickedShape = {};
         for (const key of keys) {
-            if (key in this.config.shape) {
-                pickedShape[key] = this.config.shape[key];
+            if (key in this._config.shape) {
+                pickedShape[key] = this._config.shape[key];
             }
         }
         return new VldObject({
-            ...this.config,
+            ...this._config,
             shape: pickedShape
         });
     }
@@ -5662,13 +5796,13 @@ class VldObject extends VldBase {
     omit(...keys) {
         const omittedShape = {};
         const keysToOmit = new Set(keys);
-        for (const key in this.config.shape) {
+        for (const key in this._config.shape) {
             if (!keysToOmit.has(key)) {
-                omittedShape[key] = this.config.shape[key];
+                omittedShape[key] = this._config.shape[key];
             }
         }
         return new VldObject({
-            ...this.config,
+            ...this._config,
             shape: omittedShape
         });
     }
@@ -5677,8 +5811,8 @@ class VldObject extends VldBase {
      */
     extend(extension) {
         return new VldObject({
-            ...this.config,
-            shape: { ...this.config.shape, ...extension }
+            ...this._config,
+            shape: { ...this._config.shape, ...extension }
         });
     }
     /**
@@ -5686,8 +5820,8 @@ class VldObject extends VldBase {
      */
     merge(other) {
         return new VldObject({
-            ...this.config,
-            shape: { ...this.config.shape, ...other.config.shape }
+            ...this._config,
+            shape: { ...this._config.shape, ...other.config.shape }
         });
     }
     /**
@@ -5695,8 +5829,8 @@ class VldObject extends VldBase {
      */
     required() {
         const requiredShape = {};
-        for (const key in this.config.shape) {
-            const validator = this.config.shape[key];
+        for (const key in this._config.shape) {
+            const validator = this._config.shape[key];
             // If it's optional, unwrap it
             if (validator instanceof VldOptional) {
                 // BUG-001 FIX: Add defensive check for baseValidator property
@@ -5711,7 +5845,7 @@ class VldObject extends VldBase {
             }
         }
         return new VldObject({
-            ...this.config,
+            ...this._config,
             shape: requiredShape
         });
     }
@@ -5721,7 +5855,7 @@ class VldObject extends VldBase {
      */
     catchall(schema) {
         return new VldObject({
-            ...this.config,
+            ...this._config,
             catchall: schema,
             passthrough: false // catchall overrides passthrough
         });
@@ -5731,14 +5865,14 @@ class VldObject extends VldBase {
      * Zod 4 API parity - returns the shape object
      */
     get shape() {
-        return this.config.shape;
+        return this._config.shape;
     }
     /**
      * Create an enum validator from object keys
      * Zod 4 API parity - creates literal union of keys
      */
     keyof() {
-        const keys = Object.keys(this.config.shape);
+        const keys = Object.keys(this._config.shape);
         if (keys.length === 0) {
             throw new Error('Cannot create keyof enum from empty object');
         }
@@ -5757,7 +5891,7 @@ class VldObject extends VldBase {
      */
     safeExtend(extension) {
         // Check for overlapping keys
-        const existingKeys = new Set(Object.keys(this.config.shape));
+        const existingKeys = new Set(Object.keys(this._config.shape));
         const extensionKeys = Object.keys(extension);
         const overlappingKeys = [];
         for (const key of extensionKeys) {
@@ -5769,8 +5903,8 @@ class VldObject extends VldBase {
             throw new Error(`safeExtend: ${getMessages().safeExtendOverlap(overlappingKeys)}`);
         }
         return new VldObject({
-            ...this.config,
-            shape: { ...this.config.shape, ...extension }
+            ...this._config,
+            shape: { ...this._config.shape, ...extension }
         });
     }
 }
@@ -6353,11 +6487,17 @@ class VldLiteral extends VldBase {
     /**
      * Private constructor to enforce immutability
      */
-    constructor(literal, errorMessage) {
+    constructor(_literal, errorMessage) {
         super();
-        this.literal = literal;
+        this._literal = _literal;
         this.errorMessage = errorMessage;
     }
+    /**
+     * Get the literal value
+     */
+    get literal() {
+        return this._literal;
+    }
     /**
      * Create a new literal validator
      */
@@ -6368,23 +6508,23 @@ class VldLiteral extends VldBase {
      * Parse and validate a literal value
      */
     parse(value) {
-        if (value !== this.literal) {
+        if (value !== this._literal) {
             throw new Error(this.errorMessage ||
-                getMessages().literalExpected(JSON.stringify(this.literal), JSON.stringify(value)));
+                getMessages().literalExpected(JSON.stringify(this._literal), JSON.stringify(value)));
         }
-        return this.literal;
+        return this._literal;
     }
     /**
      * Safely parse and validate a literal value
      */
     safeParse(value) {
-        if (value === this.literal) {
-            return { success: true, data: this.literal };
+        if (value === this._literal) {
+            return { success: true, data: this._literal };
         }
         return {
             success: false,
             error: new Error(this.errorMessage ||
-                getMessages().literalExpected(JSON.stringify(this.literal), JSON.stringify(value)))
+                getMessages().literalExpected(JSON.stringify(this._literal), JSON.stringify(value)))
         };
     }
 }
@@ -6596,27 +6736,56 @@ class VldNan extends VldBase {
 /**
  * Lazy validator - defers schema evaluation until runtime
  * Essential for recursive and self-referencing types
+ *
+ * MEMORY OPTIMIZATION: Uses WeakRef for the cached schema to allow garbage collection
+ * when the validator is no longer in use. This prevents memory leaks in long-running
+ * applications with dynamically created schemas.
  */
 class VldLazy extends VldBase {
     constructor(_schemaGetter) {
         super();
         this._schemaGetter = _schemaGetter;
-        this._cachedSchema = null;
+        // Use WeakRef to allow garbage collection of the cached schema
+        this._cachedSchemaRef = null;
+        // Keep a strong reference flag to prevent GC during active use
+        this._strongRef = null;
     }
     static create(schemaGetter) {
         return new VldLazy(schemaGetter);
     }
     /**
      * Get the actual schema, caching it after first retrieval
+     * Uses WeakRef to allow garbage collection when validator is not in use
      */
     _getSchema() {
-        if (!this._cachedSchema) {
-            this._cachedSchema = this._schemaGetter();
+        // Check if we have a strong reference first (active use)
+        if (this._strongRef) {
+            return this._strongRef;
+        }
+        // Try to get from WeakRef
+        if (this._cachedSchemaRef) {
+            const cached = this._cachedSchemaRef.deref();
+            if (cached) {
+                // Restore strong reference for active use
+                this._strongRef = cached;
+                return cached;
+            }
         }
-        return this._cachedSchema;
+        // Create new schema
+        const schema = this._schemaGetter();
+        this._cachedSchemaRef = new WeakRef(schema);
+        this._strongRef = schema;
+        // Clear strong reference after a tick to allow GC
+        // This keeps the schema alive during synchronous operations
+        // but allows it to be collected if the validator is discarded
+        Promise.resolve().then(() => {
+            this._strongRef = null;
+        });
+        return schema;
     }
     /**
      * Get the inner schema (unwrap)
+     * Returns a strong reference that will keep the schema alive
      */
     unwrap() {
         return this._getSchema();
@@ -6639,11 +6808,10 @@ class VldLazy extends VldBase {
  */
 function extractLiteralValues(schema) {
     if (schema instanceof VldLiteral) {
-        const value = schema.literal;
-        return [value];
+        return [schema.literal];
     }
     if (schema instanceof VldEnum) {
-        return schema.values;
+        return [...schema.values];
     }
     throw new Error('Discriminator must be a literal or enum schema');
 }