@oxog/vld 2.0.1 → 2.0.3

package/dist/cjs/mini.cjs

@@ -88,6 +88,16 @@ class VldBase {
     nullish() {
         return new VldNullish(this);
     }
+    /**
+     * Make this validator exactly optional - allows undefined but not missing
+     * Unlike .optional() which treats missing as undefined, exactOptional()
+     * requires the key to be present but allows undefined as a value
+     * Zod 4 API parity
+     * @returns A new exact optional validator
+     */
+    exactOptional() {
+        return new VldExactOptional(this);
+    }
     /**
      * Pipe the output of this validator into another validator
      * @param next The next validator to pipe into
@@ -132,6 +142,49 @@ class VldBase {
     apply(fn) {
         return fn(this);
     }
+    check(predicate, message) {
+        return new VldRefine(this, predicate, message);
+    }
+    /**
+     * Get or set metadata for this schema
+     */
+    meta(data) {
+        if (data === undefined) {
+            return undefined;
+        }
+        return new VldMeta(this, data);
+    }
+    /**
+     * Add a description to this schema
+     * Zod 4 API parity - convenience method for .meta({ description: ... })
+     * @param description The description to add
+     * @returns A new validator with the description
+     */
+    describe(description) {
+        return new VldMeta(this, { description });
+    }
+}
+/**
+ * Metadata validator - wraps a schema with metadata
+ */
+class VldMeta extends VldBase {
+    constructor(baseValidator, metadata) {
+        super();
+        this.baseValidator = baseValidator;
+        this.metadata = metadata;
+    }
+    parse(value) {
+        return this.baseValidator.parse(value);
+    }
+    safeParse(value) {
+        return this.baseValidator.safeParse(value);
+    }
+    /**
+     * Get the metadata
+     */
+    getMeta() {
+        return this.metadata;
+    }
 }
 /**
  * Readonly validator - marks output as readonly
@@ -347,6 +400,38 @@ class VldOptional extends VldBase {
         return this.baseValidator;
     }
 }
+/**
+ * Exact optional validator - allows undefined but requires key presence
+ * Unlike Optional which treats missing as undefined, ExactOptional
+ * requires the key to be present (not missing from object) but allows undefined
+ * Zod 4 API parity
+ */
+class VldExactOptional extends VldBase {
+    constructor(baseValidator) {
+        super();
+        this.baseValidator = baseValidator;
+    }
+    static create(baseValidator) {
+        return new VldExactOptional(baseValidator);
+    }
+    parse(value) {
+        if (value === undefined) {
+            return undefined;
+        }
+        return this.baseValidator.parse(value);
+    }
+    safeParse(value) {
+        // Unlike regular optional, undefined is explicitly valid
+        // but we still validate through the base validator
+        if (value === undefined) {
+            return { success: true, data: undefined };
+        }
+        return this.baseValidator.safeParse(value);
+    }
+    unwrap() {
+        return this.baseValidator;
+    }
+}
 /**
  * Nullable validator - allows null
  */
@@ -3461,6 +3546,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 +3554,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 +3655,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
@@ -3914,6 +4080,66 @@ class VldNumber extends VldBase {
     lte(value, message) {
         return this.max(value, message);
     }
+    /**
+     * Create a validator for unsigned 32-bit integers
+     * Range: 0 to 4,294,967,295
+     */
+    uint32(message) {
+        return new VldNumber({
+            checks: [...this.config.checks, (v) => Number.isSafeInteger(v) && v >= 0 && v <= 4294967295],
+            errorMessage: message || 'Expected an unsigned 32-bit integer'
+        });
+    }
+    /**
+     * Create a validator for unsigned 64-bit integers
+     * Range: 0 to 2^53-1 (safe integer limit)
+     */
+    uint64(message) {
+        return new VldNumber({
+            checks: [...this.config.checks, (v) => Number.isSafeInteger(v) && v >= 0],
+            errorMessage: message || 'Expected an unsigned 64-bit integer'
+        });
+    }
+    /**
+     * Create a validator for signed 32-bit integers
+     * Range: -2,147,483,648 to 2,147,483,647
+     */
+    int32(message) {
+        return new VldNumber({
+            checks: [...this.config.checks, (v) => Number.isSafeInteger(v) && v >= -2147483648 && v <= 2147483647],
+            errorMessage: message || 'Expected a signed 32-bit integer'
+        });
+    }
+    /**
+     * Create a validator for signed 64-bit integers
+     * Range: -(2^53-1) to 2^53-1 (safe integer limit)
+     */
+    int64(message) {
+        return new VldNumber({
+            checks: [...this.config.checks, (v) => Number.isSafeInteger(v)],
+            errorMessage: message || 'Expected a signed 64-bit integer'
+        });
+    }
+    /**
+     * Create a validator for 32-bit floats (IEEE 754 single precision)
+     * Range: -3.4e38 to 3.4e38, precision ~7 decimal digits
+     */
+    float32(message) {
+        return new VldNumber({
+            checks: [...this.config.checks, (v) => Number.isFinite(v) && Math.abs(v) <= 3.4e38],
+            errorMessage: message || 'Expected a 32-bit float'
+        });
+    }
+    /**
+     * Create a validator for 64-bit floats (IEEE 754 double precision)
+     * Alias for standard number validation
+     */
+    float64(message) {
+        return new VldNumber({
+            checks: [...this.config.checks, (v) => Number.isFinite(v)],
+            errorMessage: message || 'Expected a 64-bit float'
+        });
+    }
 }
 
 /**
@@ -4602,16 +4828,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 +4845,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 +5004,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 +5028,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 +5045,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 +5062,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 +5074,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 +5595,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 +5633,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 +5697,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 +5744,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 +5765,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 +5872,7 @@ class VldObject extends VldBase {
      */
     strict(message) {
         return new VldObject({
-            ...this.config,
+            ...this._config,
             strict: true,
             passthrough: false,
             errorMessage: message
@@ -5604,7 +5883,7 @@ class VldObject extends VldBase {
      */
     passthrough() {
         return new VldObject({
-            ...this.config,
+            ...this._config,
             strict: false,
             passthrough: true
         });
@@ -5614,11 +5893,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 +5906,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 +5916,7 @@ class VldObject extends VldBase {
             }
         }
         return new VldObject({
-            ...this.config,
+            ...this._config,
             shape: deepPartialShape
         });
     }
@@ -5647,12 +5926,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 +5941,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 +5956,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 +5965,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 +5974,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 +5990,7 @@ class VldObject extends VldBase {
             }
         }
         return new VldObject({
-            ...this.config,
+            ...this._config,
             shape: requiredShape
         });
     }
@@ -5721,7 +6000,7 @@ class VldObject extends VldBase {
      */
     catchall(schema) {
         return new VldObject({
-            ...this.config,
+            ...this._config,
             catchall: schema,
             passthrough: false // catchall overrides passthrough
         });
@@ -5731,14 +6010,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 +6036,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 +6048,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 +6632,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 +6653,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 +6881,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 +6953,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');
 }