@oxog/vld 2.0.1 → 2.0.3

package/dist/cjs/index.cjs

@@ -90,6 +90,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
@@ -134,6 +144,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
@@ -349,6 +402,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
  */
@@ -3478,6 +3563,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 {
     /**
@@ -3485,12 +3571,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
      */
@@ -3498,26 +3672,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
@@ -3931,6 +4097,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'
+        });
+    }
 }
 
 /**
@@ -4439,16 +4665,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;
     }
@@ -4463,6 +4682,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
@@ -4590,11 +4841,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
      */
@@ -4608,11 +4865,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;
     }
@@ -4625,16 +4882,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)))
         };
     }
     /**
@@ -4642,7 +4899,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');
         }
@@ -4654,7 +4911,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');
         }
@@ -5175,10 +5432,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
@@ -5193,14 +5470,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.
@@ -5257,38 +5534,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]);
+                    }
                 }
             }
         }
@@ -5303,15 +5581,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) {
@@ -5324,48 +5602,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;
                 }
             }
         }
@@ -5430,7 +5709,7 @@ class VldObject extends VldBase {
      */
     strict(message) {
         return new VldObject({
-            ...this.config,
+            ...this._config,
             strict: true,
             passthrough: false,
             errorMessage: message
@@ -5441,7 +5720,7 @@ class VldObject extends VldBase {
      */
     passthrough() {
         return new VldObject({
-            ...this.config,
+            ...this._config,
             strict: false,
             passthrough: true
         });
@@ -5451,11 +5730,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
         });
     }
@@ -5464,8 +5743,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());
             }
@@ -5474,7 +5753,7 @@ class VldObject extends VldBase {
             }
         }
         return new VldObject({
-            ...this.config,
+            ...this._config,
             shape: deepPartialShape
         });
     }
@@ -5484,12 +5763,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
         });
     }
@@ -5499,13 +5778,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
         });
     }
@@ -5514,8 +5793,8 @@ class VldObject extends VldBase {
      */
     extend(extension) {
         return new VldObject({
-            ...this.config,
-            shape: { ...this.config.shape, ...extension }
+            ...this._config,
+            shape: { ...this._config.shape, ...extension }
         });
     }
     /**
@@ -5523,8 +5802,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 }
         });
     }
     /**
@@ -5532,8 +5811,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
@@ -5548,7 +5827,7 @@ class VldObject extends VldBase {
             }
         }
         return new VldObject({
-            ...this.config,
+            ...this._config,
             shape: requiredShape
         });
     }
@@ -5558,7 +5837,7 @@ class VldObject extends VldBase {
      */
     catchall(schema) {
         return new VldObject({
-            ...this.config,
+            ...this._config,
             catchall: schema,
             passthrough: false // catchall overrides passthrough
         });
@@ -5568,14 +5847,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');
         }
@@ -5594,7 +5873,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) {
@@ -5606,8 +5885,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 }
         });
     }
 }
@@ -5743,11 +6022,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
      */
@@ -5758,23 +6043,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)))
         };
     }
 }
@@ -6613,27 +6898,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();
-        }
-        return this._cachedSchema;
+        // 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;
+            }
+        }
+        // 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();
@@ -6656,11 +6970,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');
 }
@@ -7957,6 +8270,87 @@ class VldUint8Array extends VldBase {
     }
 }
 
+/**
+ * Promise validator - validates Promise values
+ * Validates that the resolved value matches the inner schema
+ */
+/**
+ * Promise validator - validates Promise<T> where T matches inner schema
+ * Zod 4 API parity - allows async validation with proper type inference
+ *
+ * Validates that the input is a Promise, and validates the resolved value
+ * against the inner schema when parsed.
+ *
+ * Use parseAsync() or safeParseAsync() for proper async handling.
+ */
+class VldPromise {
+    constructor(inner) {
+        this.inner = inner;
+    }
+    /**
+     * Check if value is thenable (Promise-like)
+     * Must be called BEFORE wrapping in Promise.resolve
+     */
+    _isThenable(value) {
+        return value !== null && typeof value.then === 'function';
+    }
+    /**
+     * Parse and validate a Promise value asynchronously
+     * @param value The Promise to validate
+     * @returns The validated value
+     * @throws {Error} If validation fails when Promise resolves
+     */
+    async parse(value) {
+        // Check if value is thenable BEFORE wrapping in Promise.resolve
+        if (!this._isThenable(value)) {
+            throw new Error('Expected a Promise value');
+        }
+        // Now we can safely await it
+        const resolved = await Promise.resolve(value);
+        return this.inner.parse(resolved);
+    }
+    /**
+     * Safely parse and validate a Promise value asynchronously
+     * @param value The Promise to validate
+     * @returns A Promise resolving to ParseResult containing the validated value
+     */
+    async safeParse(value) {
+        // Check if value is thenable BEFORE wrapping in Promise.resolve
+        if (!this._isThenable(value)) {
+            return {
+                success: false,
+                error: new Error('Expected a Promise value')
+            };
+        }
+        try {
+            const resolved = await Promise.resolve(value);
+            const validated = this.inner.parse(resolved);
+            return {
+                success: true,
+                data: validated
+            };
+        }
+        catch (err) {
+            return {
+                success: false,
+                error: err instanceof Error ? err : new Error(String(err))
+            };
+        }
+    }
+}
+/**
+ * Create a Promise validator
+ * @param inner The schema to validate the resolved value against
+ * @returns A new Promise validator
+ * @example
+ * const promiseSchema = v.promise(v.string());
+ * const result = await promiseSchema.parse(Promise.resolve("hello"));
+ * // result is string
+ */
+function promise(inner) {
+    return new VldPromise(inner);
+}
+
 /**
  * BigInt coercion validator that attempts to convert values to bigint
  */
@@ -8101,6 +8495,10 @@ const REGEXES = {
     sha256: /^[a-f0-9]{64}$/i,
     sha384: /^[a-f0-9]{96}$/i,
     sha512: /^[a-f0-9]{128}$/i,
+    // Additional formats (Zod v4 parity)
+    xid: /^[A-HJKMNP-TV-Z0-9]{20}$/, // ksort's XID format
+    guid: /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/i, // Alias for UUID
+    httpUrl: /^https?:\/\/[^\s/$.?#].[^\s]*$/, // HTTP/HTTPS URL
 };
 /**
  * Generic string format validator
@@ -8161,6 +8559,9 @@ const mac = () => VldStringFormat.create('mac', (val) => REGEXES.mac.test(val));
 const cidrv4 = () => VldStringFormat.create('cidrv4', (val) => REGEXES.cidrv4.test(val));
 const cidrv6 = () => VldStringFormat.create('cidrv6', (val) => REGEXES.cidrv6.test(val));
 const e164 = () => VldStringFormat.create('e164', (val) => REGEXES.e164.test(val));
+const xid = () => VldStringFormat.create('xid', (val) => REGEXES.xid.test(val));
+const guid = () => VldStringFormat.create('guid', (val) => REGEXES.guid.test(val));
+const httpUrl = () => VldStringFormat.create('httpUrl', (val) => REGEXES.httpUrl.test(val));
 const hash = (algorithm) => VldStringFormat.create('hash', (val) => REGEXES[algorithm]?.test(val) ?? false, `Invalid ${algorithm} hash`);
 /**
  * ISO date/time validators
@@ -9599,6 +10000,534 @@ function createNoOpLogger() {
     return createLogger({ level: 'silent' });
 }
 
+/**
+ * JSON Schema support for VLD validators
+ * Provides conversion between VLD schemas and JSON Schema
+ */
+/**
+ * Convert a VLD schema to JSON Schema
+ * @param schema The VLD schema to convert
+ * @param options Conversion options
+ * @returns JSON Schema definition
+ */
+function toJSONSchema(schema, options = {}) {
+    return schemaToJSONSchema(schema, options);
+}
+/**
+ * Convert a JSON Schema to a VLD schema
+ * @param json The JSON Schema definition
+ * @returns A VLD schema
+ */
+function fromJSONSchema(json) {
+    return jsonSchemaToVLD(json);
+}
+/**
+ * Internal function to convert VLD schema to JSON Schema
+ */
+function schemaToJSONSchema(schema, options) {
+    options.target || 'draft-07';
+    // Handle primitives
+    if (schema.constructor.name === 'VldString') {
+        return buildStringSchema();
+    }
+    if (schema.constructor.name === 'VldNumber') {
+        return buildNumberSchema(schema);
+    }
+    if (schema.constructor.name === 'VldBoolean') {
+        return { type: 'boolean' };
+    }
+    if (schema.constructor.name === 'VldBigInt') {
+        return { type: 'integer' };
+    }
+    if (schema.constructor.name === 'VldDate') {
+        return { type: 'string', format: 'date-time' };
+    }
+    if (schema.constructor.name === 'VldArray') {
+        return buildArraySchema(schema, options);
+    }
+    if (schema.constructor.name === 'VldObject') {
+        return buildObjectSchema(schema, options);
+    }
+    // Handle union types
+    if (schema.constructor.name === 'VldUnion') {
+        return buildUnionSchema(schema, options);
+    }
+    // Handle literal types
+    if (schema.constructor.name === 'VldLiteral') {
+        return buildLiteralSchema(schema);
+    }
+    if (schema.constructor.name === 'VldEnum') {
+        return buildEnumSchema(schema);
+    }
+    if (schema.constructor.name === 'VldRecord') {
+        return buildRecordSchema(schema, options);
+    }
+    if (schema.constructor.name === 'VldTuple') {
+        return buildTupleSchema(schema, options);
+    }
+    if (schema.constructor.name === 'VldIntersection') {
+        return buildIntersectionSchema(schema, options);
+    }
+    if (schema.constructor.name === 'VldOptional') {
+        return buildOptionalSchema(schema, options);
+    }
+    if (schema.constructor.name === 'VldNullable') {
+        return buildNullableSchema(schema, options);
+    }
+    if (schema.constructor.name === 'VldNullish') {
+        return buildNullishSchema(schema, options);
+    }
+    if (schema.constructor.name === 'VldExactOptional') {
+        return buildExactOptionalSchema(schema, options);
+    }
+    if (schema.constructor.name === 'VldLazy') {
+        return { type: 'object' }; // Placeholder for recursive schemas
+    }
+    if (schema.constructor.name === 'VldJson') {
+        return {}; // Any JSON
+    }
+    if (schema.constructor.name === 'VldAny') {
+        return {}; // JSON Schema true
+    }
+    if (schema.constructor.name === 'VldUnknown') {
+        return {}; // JSON Schema true
+    }
+    if (schema.constructor.name === 'VldNever') {
+        return { not: {} }; // JSON Schema false
+    }
+    if (schema.constructor.name === 'VldNull') {
+        return { type: 'null' };
+    }
+    if (schema.constructor.name === 'VldUndefined') {
+        return { not: {} }; // Undefined can't be represented in JSON Schema
+    }
+    if (schema.constructor.name === 'VldNan') {
+        return { type: 'number', not: {} }; // NaN is a number type constraint
+    }
+    if (schema.constructor.name === 'VldVoid') {
+        return { not: {} }; // Void/undefined can't be represented
+    }
+    // Handle branded types - unwrap and continue
+    if (schema.constructor.name === 'VldBrand') {
+        return schemaToJSONSchema(schema.baseValidator, options);
+    }
+    // Handle readonly types
+    if (schema.constructor.name === 'VldReadonly') {
+        return schemaToJSONSchema(schema.baseValidator, options);
+    }
+    // Handle transform types
+    if (schema.constructor.name === 'VldTransform') {
+        return schemaToJSONSchema(schema._inner, options);
+    }
+    // Handle meta types - unwrap metadata
+    if (schema.constructor.name === 'VldMeta') {
+        const metaSchema = schema;
+        const result = schemaToJSONSchema(metaSchema.baseValidator, options);
+        if (options.includeMetadata !== false && metaSchema.metadata) {
+            const meta = metaSchema.metadata;
+            if (meta.title)
+                result.title = meta.title;
+            if (meta.description)
+                result.description = meta.description;
+            if (meta.examples && options.includeExamples)
+                result.examples = meta.examples;
+            if (meta.default !== undefined)
+                result.default = meta.default;
+            if (meta.deprecated)
+                result.deprecated = true;
+            if (meta.readOnly)
+                result.readOnly = true;
+            if (meta.writeOnly)
+                result.writeOnly = true;
+        }
+        return result;
+    }
+    // Handle refine/superRefine types
+    if (schema.constructor.name === 'VldRefine' || schema.constructor.name === 'VldSuperRefine') {
+        return schemaToJSONSchema(schema._inner || schema._baseValidator, options);
+    }
+    // Handle pipe types
+    if (schema.constructor.name === 'VldPipe') {
+        return schemaToJSONSchema(schema._next || schema.second, options);
+    }
+    // Handle default/catch types
+    if (schema.constructor.name === 'VldDefault' || schema.constructor.name === 'VldCatch') {
+        return schemaToJSONSchema(schema._inner || schema._baseValidator, options);
+    }
+    // Handle preprocess types
+    if (schema.constructor.name === 'VldPreprocess') {
+        return schemaToJSONSchema(schema._schema, options);
+    }
+    // Handle string format validators
+    if (schema.constructor.name === 'VldStringFormat') {
+        const formatSchema = schema;
+        return { type: 'string', format: formatSchema._format };
+    }
+    // Fallback for unknown types
+    return {};
+}
+/**
+ * Build string JSON Schema
+ */
+function buildStringSchema(_target) {
+    return { type: 'string' };
+}
+/**
+ * Build number JSON Schema from VLD number schema
+ */
+function buildNumberSchema(schema, _target) {
+    const config = schema.config || {};
+    const checks = config.checks || [];
+    const result = { type: 'number' };
+    for (const check of checks) {
+        // Try to extract constraints from closures
+        const checkStr = check.toString();
+        if (checkStr.includes('>=') || checkStr.includes('min')) {
+            result.minimum = 0; // Default, actual value is in closure
+        }
+        if (checkStr.includes('<=') || checkStr.includes('max')) {
+            result.maximum = 0; // Default, actual value is in closure
+        }
+        if (checkStr.includes('isInteger') || checkStr.includes('int')) {
+            result.type = 'integer';
+        }
+        if (checkStr.includes('isSafeInteger')) {
+            result.type = 'integer';
+        }
+        if (checkStr.includes('Number.isFinite')) ;
+    }
+    return result;
+}
+/**
+ * Build array JSON Schema
+ */
+function buildArraySchema(schema, options) {
+    const inner = schema._item || schema._inner;
+    if (inner) {
+        return {
+            type: 'array',
+            items: toJSONSchema(inner, options)
+        };
+    }
+    return { type: 'array' };
+}
+/**
+ * Build object JSON Schema
+ */
+function buildObjectSchema(schema, options) {
+    const shape = schema._shape || schema.shape;
+    if (!shape)
+        return { type: 'object' };
+    const properties = {};
+    const required = [];
+    for (const [key, value] of Object.entries(shape)) {
+        properties[key] = toJSONSchema(value, options);
+        // VLD objects require all keys by default
+        if (schema._strict !== false) {
+            required.push(key);
+        }
+    }
+    const result = {
+        type: 'object',
+        properties
+    };
+    if (required.length > 0) {
+        result.required = required;
+    }
+    // Handle passthrough mode
+    if (schema._passthrough || schema._loose) {
+        result.additionalProperties = true;
+    }
+    else if (schema._strict) {
+        result.additionalProperties = false;
+    }
+    return result;
+}
+/**
+ * Build union JSON Schema
+ */
+function buildUnionSchema(schema, options) {
+    const validators = schema._validators || schema._options || [];
+    return {
+        anyOf: validators.map((v) => toJSONSchema(v, options))
+    };
+}
+/**
+ * Build literal JSON Schema
+ */
+function buildLiteralSchema(schema) {
+    const value = schema._value || schema.value;
+    if (value === null)
+        return { type: 'null' };
+    if (typeof value === 'string')
+        return { type: 'string', const: value };
+    if (typeof value === 'number')
+        return { type: 'number', const: value };
+    if (typeof value === 'boolean')
+        return { type: 'boolean', const: value };
+    return { const: value };
+}
+/**
+ * Build enum JSON Schema
+ */
+function buildEnumSchema(schema) {
+    const values = schema._values || schema.values;
+    if (Array.isArray(values)) {
+        return { enum: [...values] };
+    }
+    return {};
+}
+/**
+ * Build record JSON Schema
+ */
+function buildRecordSchema(schema, options) {
+    const valueValidator = schema._value || schema._inner;
+    if (valueValidator) {
+        return {
+            type: 'object',
+            additionalProperties: toJSONSchema(valueValidator, options)
+        };
+    }
+    return { type: 'object' };
+}
+/**
+ * Build tuple JSON Schema
+ */
+function buildTupleSchema(schema, options) {
+    const items = schema._items || schema.items;
+    if (!items || !Array.isArray(items)) {
+        return { type: 'array' };
+    }
+    return {
+        type: 'array',
+        items: items.map((item) => toJSONSchema(item, options)),
+        minItems: items.length,
+        maxItems: items.length
+    };
+}
+/**
+ * Build intersection JSON Schema
+ */
+function buildIntersectionSchema(schema, options) {
+    const first = schema._first || schema.first;
+    const second = schema._second || schema.second;
+    const schemas = [];
+    if (first)
+        schemas.push(toJSONSchema(first, options));
+    if (second)
+        schemas.push(toJSONSchema(second, options));
+    if (schemas.length === 0)
+        return {};
+    if (schemas.length === 1)
+        return schemas[0];
+    return { allOf: schemas };
+}
+/**
+ * Build optional JSON Schema
+ */
+function buildOptionalSchema(schema, options) {
+    const inner = schema._inner || schema._baseValidator;
+    if (!inner)
+        return {};
+    const result = toJSONSchema(inner, options);
+    // Remove from required array - but we don't track required here
+    return result;
+}
+/**
+ * Build nullable JSON Schema
+ */
+function buildNullableSchema(schema, options) {
+    const inner = schema._inner || schema._baseValidator;
+    if (!inner)
+        return { type: 'null' };
+    const result = toJSONSchema(inner, options);
+    if (typeof result.type === 'string') {
+        return { type: [result.type, 'null'] };
+    }
+    else if (Array.isArray(result.type)) {
+        result.type.push('null');
+        return result;
+    }
+    return {
+        anyOf: [result, { type: 'null' }]
+    };
+}
+/**
+ * Build nullish JSON Schema
+ */
+function buildNullishSchema(schema, options) {
+    const inner = schema._inner || schema._baseValidator;
+    if (!inner)
+        return {};
+    return toJSONSchema(inner, options);
+}
+/**
+ * Build exactOptional JSON Schema
+ */
+function buildExactOptionalSchema(schema, options) {
+    const inner = schema._inner || schema._baseValidator;
+    if (!inner)
+        return {};
+    return toJSONSchema(inner, options);
+}
+/**
+ * Internal function to convert JSON Schema to VLD schema
+ */
+function jsonSchemaToVLD(json) {
+    // This is a simplified implementation
+    // Full implementation would recursively handle all JSON Schema types
+    const VldString = require('../validators/string').VldString;
+    const VldNumber = require('../validators/number').VldNumber;
+    const VldBoolean = require('../validators/boolean').VldBoolean;
+    const VldObject = require('../validators/object').VldObject;
+    const VldArray = require('../validators/array').VldArray;
+    const VldUnion = require('../validators/union').VldUnion;
+    const VldLiteral = require('../validators/literal').VldLiteral;
+    const VldEnum = require('../validators/enum').VldEnum;
+    const VldNull = require('../validators/null').VldNull;
+    const VldAny = require('../validators/any').VldAny;
+    const VldRecord = require('../validators/record').VldRecord;
+    // Handle $ref
+    if (json.$ref) {
+        // For now, return any - full $ref handling requires registry
+        return VldAny.create();
+    }
+    // Handle anyOf/oneOf (union)
+    if (json.anyOf || json.oneOf) {
+        const options = (json.anyOf || json.oneOf)
+            .map((s) => jsonSchemaToVLD(s))
+            .filter(Boolean);
+        if (options.length > 0) {
+            return VldUnion.create(...options);
+        }
+    }
+    // Handle allOf (intersection)
+    if (json.allOf) {
+        // For intersection, we'd need VldIntersection
+        const first = jsonSchemaToVLD(json.allOf[0]);
+        if (json.allOf.length > 1) {
+            const second = jsonSchemaToVLD({ allOf: json.allOf.slice(1) });
+            const VldIntersection = require('../validators/intersection').VldIntersection;
+            return VldIntersection.create(first, second);
+        }
+        return first;
+    }
+    // Handle not
+    if (json.not) {
+        // For negation, we need special handling
+        return VldAny.create();
+    }
+    // Handle const
+    if (json.const !== undefined) {
+        return VldLiteral.create(json.const);
+    }
+    // Handle enum
+    if (json.enum) {
+        return VldEnum.create(json.enum);
+    }
+    // Handle type
+    const type = json.type;
+    if (type === 'string' || type === undefined) {
+        const s = VldString.create();
+        if (json.minLength)
+            s.minLength = json.minLength;
+        if (json.maxLength)
+            s.maxLength = json.maxLength;
+        if (json.pattern)
+            s.pattern = json.pattern;
+        if (json.format) {
+            // Map JSON Schema formats to VLD validators
+            switch (json.format) {
+                case 'date-time':
+                case 'date':
+                case 'time':
+                    // Would need DateTime validator
+                    break;
+                case 'email':
+                    const email = require('../validators/string-formats').email;
+                    return email();
+                case 'uri':
+                case 'uri-reference':
+                    const httpUrl = require('../validators/string-formats').httpUrl;
+                    return httpUrl();
+                case 'uuid':
+                    const uuid = require('../validators/string-formats').uuid;
+                    return uuid();
+            }
+        }
+        return s;
+    }
+    if (type === 'number' || type === 'integer') {
+        const n = VldNumber.create();
+        if (type === 'integer')
+            n.int();
+        if (json.minimum !== undefined)
+            n.min(json.minimum);
+        if (json.maximum !== undefined)
+            n.max(json.maximum);
+        if (json.exclusiveMinimum !== undefined)
+            n.gt(json.exclusiveMinimum);
+        if (json.exclusiveMaximum !== undefined)
+            n.lt(json.exclusiveMaximum);
+        if (json.multipleOf !== undefined)
+            n.multipleOf(json.multipleOf);
+        return n;
+    }
+    if (type === 'boolean') {
+        return VldBoolean.create();
+    }
+    if (type === 'array') {
+        if (json.items && !Array.isArray(json.items)) {
+            return VldArray.create(jsonSchemaToVLD(json.items));
+        }
+        return VldArray.create(VldAny.create());
+    }
+    if (type === 'object') {
+        if (json.properties) {
+            const shape = {};
+            const required = json.required || [];
+            for (const [key, propSchema] of Object.entries(json.properties)) {
+                shape[key] = jsonSchemaToVLD(propSchema);
+            }
+            let obj = VldObject.create(shape);
+            if (!required.length) {
+                // If no required fields, make all optional
+                for (const key of Object.keys(shape)) {
+                    if (!required.includes(key)) ;
+                }
+            }
+            if (json.additionalProperties === false) {
+                obj = obj.strict();
+            }
+            else if (json.additionalProperties === true) {
+                obj = obj.passthrough();
+            }
+            else if (json.additionalProperties) {
+                // additionalProperties is a schema
+                const valueSchema = jsonSchemaToVLD(json.additionalProperties);
+                obj = VldRecord.create(valueSchema);
+            }
+            return obj;
+        }
+        // Empty object schema
+        return VldObject.create({});
+    }
+    if (type === 'null') {
+        return VldNull.create();
+    }
+    if (Array.isArray(type)) {
+        // Union of types
+        const options = type.map((t) => {
+            return jsonSchemaToVLD({ ...json, type: t });
+        });
+        if (options.length > 0) {
+            return VldUnion.create(...options);
+        }
+    }
+    // Fallback to any
+    return VldAny.create();
+}
+
 /**
  * VLD - Fast, Type-Safe Validation Library
  * Zero dependencies, blazing fast performance
@@ -9624,6 +10553,11 @@ const v = {
     number: () => VldNumber.create(),
     int: () => VldNumber.create().int(),
     int32: () => VldNumber.create().int().min(-2147483648).max(2147483647),
+    uint32: () => VldNumber.create().uint32(),
+    uint64: () => VldNumber.create().uint64(),
+    int64: () => VldNumber.create().int64(),
+    float32: () => VldNumber.create().float32(),
+    float64: () => VldNumber.create().float64(),
     boolean: () => VldBoolean.create(),
     date: () => VldDate.create(),
     bigint: () => VldBigInt.create(),
@@ -9662,6 +10596,7 @@ const v = {
     optional: (validator) => VldOptional.create(validator),
     nullable: (validator) => VldNullable.create(validator),
     nullish: (validator) => VldNullish.create(validator),
+    exactOptional: (validator) => VldExactOptional.create(validator),
     // Recursive schemas
     lazy: (schemaGetter) => VldLazy.create(schemaGetter),
     // JSON validator
@@ -9710,6 +10645,10 @@ const v = {
         duration: () => iso.duration(),
     },
     stringFormat: (name, validator) => stringFormat(name, validator),
+    // Zod v4 parity string formats
+    xid: () => xid(),
+    guid: () => guid(),
+    httpUrl: () => httpUrl(),
     // Template literal validator
     templateLiteral: (...components) => templateLiteral(...components),
     // Codec validators (binary data validators)
@@ -9717,7 +10656,9 @@ const v = {
     hexBytes: () => VldHex.create(),
     uint8Array: () => VldUint8Array.create(),
     // Codec factory
-    codec: (inputValidator, outputValidator, transform) => VldCodec.create(inputValidator, outputValidator, transform)
+    codec: (inputValidator, outputValidator, transform) => VldCodec.create(inputValidator, outputValidator, transform),
+    // Promise validator (Zod v4 parity)
+    promise: (inner) => promise(inner)
 };
 
 exports.Err = Err;
@@ -9726,6 +10667,7 @@ exports.ResultUtils = ResultUtils;
 exports.VldBase = VldBase;
 exports.VldError = VldError;
 exports.VldIntersection = VldIntersection;
+exports.VldMeta = VldMeta;
 exports.all = all;
 exports.base64Json = base64Json;
 exports.base64ToBytes = base64ToBytes;
@@ -9752,6 +10694,7 @@ exports.epochSecondsToDate = epochSecondsToDate;
 exports.failure = failure;
 exports.flatMap = flatMap;
 exports.flattenError = flattenError;
+exports.fromJSONSchema = fromJSONSchema;
 exports.fromNullable = fromNullable;
 exports.getLocale = getLocale;
 exports.getLogger = getLogger;
@@ -9794,6 +10737,7 @@ exports.stringToUint8Array = stringToUint8Array;
 exports.strip = strip;
 exports.success = success;
 exports.supportsColor = supportsColor;
+exports.toJSONSchema = toJSONSchema;
 exports.treeifyError = treeifyError;
 exports.tryCatch = tryCatch;
 exports.tryCatchAsync = tryCatchAsync;