@oxog/vld 2.0.2 → 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
  */
@@ -4012,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'
+        });
+    }
 }
 
 /**
@@ -8125,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
  */
@@ -8269,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
@@ -8329,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
@@ -9767,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
@@ -9792,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(),
@@ -9830,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
@@ -9878,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)
@@ -9885,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;
@@ -9894,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;
@@ -9920,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;
@@ -9962,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;