@oxog/vld 2.0.2 → 2.1.0

package/dist/index.js

@@ -1,17 +1,866 @@
-import { h as VldPreprocess, g as VldNullish, f as VldNullable, e as VldOptional, d as VldBigInt, c as VldDate, b as VldBoolean, a as VldNumber, V as VldString } from './chunks/bigint-DgsCr2dC.js';
-export { i as VldBase, r as getLocale, t as getMessages, s as setLocale } from './chunks/bigint-DgsCr2dC.js';
-import { u as VldJson, t as VldLazy, p as VldNever, s as VldNan, r as VldUndefined, q as VldNull, o as VldVoid, n as VldAny, m as VldEnum, l as VldLiteral, k as VldXor, j as VldDiscriminatedUnion, i as VldIntersection, h as VldUnion, g as VldMap, f as VldSet, e as VldRecord, d as VldTuple, c as VldObject, b as VldArray, a as VldStringBool, V as VldSymbol } from './chunks/json-o20GFhTh.js';
-import { V as VldUnknown } from './chunks/unknown-SLIH1VCf.js';
-import { t as templateLiteral, s as stringFormat, i as iso, h as hash, e as e164, c as cidrv6, a as cidrv4, m as mac, b as ipv6, d as ipv4, u as ulid, f as cuid2, g as cuid, n as nanoid, j as jwt, k as hex, l as base64url, o as base64, p as emoji, q as hostname, r as uuidv4, v as uuid, w as email, x as functionValidator, y as file, z as custom } from './chunks/index-BZqWZvVe.js';
-import { V as VldCodec, a as VldUint8Array, b as VldHex, c as VldBase64 } from './chunks/index-CETyGkrv.js';
-export { D as base64Json, w as base64ToBytes, d as base64ToUint8Array, x as base64UrlToBytes, y as base64urlToBytes, C as bytesToUtf8, p as epochMillisToDate, o as epochSecondsToDate, A as hexLowerToBytes, z as hexToBytes, h as hexToUint8Array, m as isoDatetimeToDate, q as jsonCodec, E as jwtPayload, n as numberToBigInt, k as stringToBigInt, l as stringToBoolean, t as stringToHttpURL, j as stringToInt, i as stringToNumber, r as stringToURL, s as stringToUint8Array, u as uint8ArrayToBase64, e as uint8ArrayToBase64Url, f as uint8ArrayToHex, g as uint8ArrayToString, v as uriComponent, B as utf8ToBytes } from './chunks/index-CETyGkrv.js';
-import { V as VldCoerceDate, a as VldCoerceBoolean, b as VldCoerceNumber, c as VldCoerceString } from './chunks/date-ODue_rtq.js';
-import { VldCoerceBigInt } from './coercion/index.js';
-export { VldError, flattenError, prettifyError, prettifyErrorColored, prettifyErrorPlain, treeifyError } from './errors.js';
-export { Err, Ok, ResultUtils, all, failure, flatMap, fromNullable, isErr, isOk, isResult, map, mapErr, match, success, tryCatch, tryCatchAsync, unwrap, unwrapOr } from './compat/result.js';
+import { VLD_VALIDATOR_TYPES, VldPreprocess, VldBase, VldExactOptional, VldNullish, VldNullable, VldOptional, resolveErrorMessage } from './validators/base.js';
+export { VldMeta, VldBrand as ZodBranded, VldCatch as ZodCatch, VldDefault as ZodDefault, VldMeta as ZodMeta, VldRefine as ZodNonOptional, VldPipe as ZodPipe, VldPrefault as ZodPrefault, VldReadonly as ZodReadonly, VldTransform as ZodTransform } from './validators/base.js';
+import { globalRegistry } from './registry.js';
+export { registry } from './registry.js';
+import { V as VldString } from './chunks/string-BJRQod3t.js';
+import { VldNumber } from './validators/number.js';
+import { VldBoolean } from './validators/boolean.js';
+import { VldDate } from './validators/date.js';
+import { VldStringBool } from './validators/string-bool.js';
+import { VldArray } from './validators/array.js';
+import { VldObject } from './validators/object.js';
+import { VldUnion } from './validators/union.js';
+import { VldLiteral } from './validators/literal.js';
+import { VldBigInt } from './validators/bigint.js';
+import { VldSymbol } from './validators/symbol.js';
+import { VldTuple } from './validators/tuple.js';
+import { VldRecord } from './validators/record.js';
+import { VldSet } from './validators/set.js';
+import { VldMap } from './validators/map.js';
+import { VldEnum } from './validators/enum.js';
+import { VldIntersection } from './validators/intersection.js';
+import { VldAny } from './validators/any.js';
+import { VldUnknown } from './validators/unknown.js';
+import { VldVoid } from './validators/void.js';
+import { VldNever } from './validators/never.js';
+import { VldNull } from './validators/null.js';
+import { VldUndefined } from './validators/undefined.js';
+import { VldNan } from './validators/nan.js';
+import { VldLazy } from './validators/lazy.js';
+import { VldDiscriminatedUnion } from './validators/discriminated-union.js';
+import { VldXor } from './validators/xor.js';
+import { VldJson } from './validators/json.js';
+import { templateLiteral as templateLiteral$1 } from './validators/template-literal.js';
+export { VldTemplateLiteral as ZodTemplateLiteral } from './validators/template-literal.js';
+import { custom as custom$1 } from './validators/custom.js';
+export { VldCustom as ZodCustom, VldCustom as ZodSuccess } from './validators/custom.js';
+import { VldFile, file as file$1 } from './validators/file.js';
+import { functionValidator } from './validators/function.js';
+export { VldFunction as ZodFunction } from './validators/function.js';
+import { VldCodec } from './validators/codec.js';
+import { VldBase64 } from './validators/base64.js';
+import { VldHex } from './validators/hex.js';
+import { VldUint8Array } from './validators/uint8array.js';
+import { promise as promise$1 } from './validators/promise.js';
+export { VldPromise as ZodPromise } from './validators/promise.js';
+import { map as map$1 } from './compat/result.js';
+export { Err, Ok, ResultUtils, all, failure, flatMap, fromNullable, isErr, isOk, isResult, mapErr, match, success, tryCatch, tryCatchAsync, unwrap, unwrapOr } from './compat/result.js';
+import { l as localeNamespace } from './chunks/index-BvH403Yy.js';
+export { s as setLocaleAsync } from './chunks/index-BvH403Yy.js';
+import { VldCoerceBigInt, VldCoerceDate, VldCoerceBoolean, VldCoerceNumber, VldCoerceString } from './coercion/index.js';
+import { flattenError, prettifyError, treeifyError } from './errors.js';
+export { prettifyErrorColored, prettifyErrorPlain } from './errors.js';
+import { uuid as uuid$1, httpUrl as httpUrl$1, email as email$1, regexes as REGEXES, ksuid as ksuid$1, guid as guid$1, xid as xid$1, stringFormat as stringFormat$1, iso as iso$1, hash as hash$1, e164 as e164$1, cidrv6 as cidrv6$1, cidrv4 as cidrv4$1, mac as mac$1, ipv6 as ipv6$1, ipv4 as ipv4$1, ulid as ulid$1, cuid2 as cuid2$1, cuid as cuid$1, nanoid as nanoid$1, jwt as jwt$1, hex as hex$1, base64url as base64url$1, base64 as base64$1, emoji as emoji$1, hostname as hostname$1, uuidv7 as uuidv7$1, uuidv6 as uuidv6$1, uuidv4 as uuidv4$1 } from './validators/string-formats.js';
+export { VldStringFormat as ZodBase64, VldStringFormat as ZodBase64URL, VldStringFormat as ZodCIDRv4, VldStringFormat as ZodCIDRv6, VldStringFormat as ZodCUID, VldStringFormat as ZodCUID2, VldStringFormat as ZodCustomStringFormat, VldStringFormat as ZodE164, VldStringFormat as ZodEmail, VldStringFormat as ZodEmoji, VldStringFormat as ZodGUID, VldStringFormat as ZodIPv4, VldStringFormat as ZodIPv6, VldStringFormat as ZodISODate, VldStringFormat as ZodISODateTime, VldStringFormat as ZodISODuration, VldStringFormat as ZodISOTime, VldStringFormat as ZodJWT, VldStringFormat as ZodKSUID, VldStringFormat as ZodMAC, VldStringFormat as ZodNanoID, VldStringFormat as ZodStringFormat, VldStringFormat as ZodULID, VldStringFormat as ZodURL, VldStringFormat as ZodUUID, VldStringFormat as ZodXID } from './validators/string-formats.js';
+export { b as base64Json, a as base64ToBytes, c as base64ToUint8Array, d as base64UrlToBytes, e as base64urlToBytes, f as bytesToUtf8, g as epochMillisToDate, h as epochSecondsToDate, i as hexLowerToBytes, j as hexToBytes, k as hexToUint8Array, l as invertCodec, m as isoDatetimeToDate, n as jsonCodec, o as jwtPayload, p as numberToBigInt, s as stringToBigInt, q as stringToBoolean, r as stringToHttpURL, t as stringToInt, u as stringToNumber, v as stringToURL, w as stringToUint8Array, x as uint8ArrayToBase64, y as uint8ArrayToBase64Url, z as uint8ArrayToHex, A as uint8ArrayToString, B as uriComponent, C as utf8ToBytes } from './chunks/index-0R2ntSud.js';
 export { createEmitter, createEventBus, withEmitter } from './compat/emitter.js';
 export { createVldKernel, definePlugin, getVldKernel, resetVldKernel, usePlugin } from './kernel.js';
-export { blue, bold, createTheme, cyan, dim, gray, green, grey, italic, magenta, pigment, red, strip, supportsColor, underline, vldTheme, white, yellow } from './pigment.js';
+export { blue, bold, createTheme, cyan, dim, gray, green, grey, italic, magenta, default as pigment, red, strip, supportsColor, underline, vldTheme, white, yellow } from './pigment.js';
+import { V as VldError } from './chunks/errors-core-BeiFUtZM.js';
+export { getLocale, getMessages, getSupportedLocales, isLocaleLoaded, isLocaleSupported, registerLocale, setLocale } from './locales/runtime.js';
+
+/**
+ * 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 = {}) {
+    const normalizedOptions = normalizeOptions(options);
+    const result = normalizeForTarget(schemaToJSONSchema(schema, normalizedOptions), normalizedOptions);
+    const target = normalizedOptions.target || 'draft-07';
+    if (target === 'draft-04') {
+        result.$schema ?? (result.$schema = 'http://json-schema.org/draft-04/schema#');
+    }
+    else if (target === 'draft-07') {
+        result.$schema ?? (result.$schema = 'http://json-schema.org/draft-07/schema#');
+    }
+    else if (target === 'draft-2019-09') {
+        result.$schema ?? (result.$schema = 'https://json-schema.org/draft/2019-09/schema');
+    }
+    else if (target === 'draft-2020-12') {
+        result.$schema ?? (result.$schema = 'https://json-schema.org/draft/2020-12/schema');
+    }
+    return result;
+}
+/**
+ * Convert a JSON Schema to a VLD schema
+ * @param json The JSON Schema definition
+ * @returns A VLD schema
+ */
+function fromJSONSchema(json) {
+    return jsonSchemaToVLD(json);
+}
+function normalizeOptions(options) {
+    const target = options.target;
+    if (target === 'draft-4') {
+        return { ...options, target: 'draft-04' };
+    }
+    if (target === 'draft-7') {
+        return { ...options, target: 'draft-07' };
+    }
+    return options;
+}
+function normalizeForTarget(definition, options) {
+    const target = options.target || 'draft-07';
+    const result = { ...definition };
+    if (Array.isArray(result.items)) {
+        const tupleItems = result.items.map((item) => normalizeForTarget(item, options));
+        if (target === 'draft-2020-12' || target === 'draft-2019-09') {
+            result.prefixItems = tupleItems;
+            result.items = false;
+        }
+        else {
+            result.items = tupleItems;
+        }
+    }
+    else if (result.items && typeof result.items === 'object') {
+        result.items = normalizeForTarget(result.items, options);
+    }
+    if (result.prefixItems) {
+        result.prefixItems = result.prefixItems.map((item) => normalizeForTarget(item, options));
+    }
+    if (result.properties) {
+        result.properties = Object.fromEntries(Object.entries(result.properties).map(([key, value]) => [key, normalizeForTarget(value, options)]));
+    }
+    if (result.additionalProperties && typeof result.additionalProperties === 'object') {
+        result.additionalProperties = normalizeForTarget(result.additionalProperties, options);
+    }
+    for (const key of ['anyOf', 'allOf', 'oneOf']) {
+        if (result[key]) {
+            result[key] = result[key].map((item) => normalizeForTarget(item, options));
+        }
+    }
+    if (result.not && typeof result.not === 'object') {
+        result.not = normalizeForTarget(result.not, options);
+    }
+    if (target === 'openapi-3.0') {
+        normalizeOpenAPI30(result);
+    }
+    return result;
+}
+function normalizeOpenAPI30(definition) {
+    if (Array.isArray(definition.type) && definition.type.includes('null')) {
+        const nonNullTypes = definition.type.filter((type) => type !== 'null');
+        definition.nullable = true;
+        if (nonNullTypes.length === 1) {
+            const nonNullType = nonNullTypes[0];
+            if (nonNullType !== undefined) {
+                definition.type = nonNullType;
+            }
+            else {
+                delete definition.type;
+            }
+        }
+        else if (nonNullTypes.length > 1) {
+            definition.type = nonNullTypes;
+        }
+        else {
+            delete definition.type;
+        }
+    }
+    if (typeof definition.exclusiveMinimum === 'number') {
+        definition.minimum ?? (definition.minimum = definition.exclusiveMinimum);
+        definition.exclusiveMinimum = true;
+    }
+    if (typeof definition.exclusiveMaximum === 'number') {
+        definition.maximum ?? (definition.maximum = definition.exclusiveMaximum);
+        definition.exclusiveMaximum = true;
+    }
+}
+/**
+ * Internal function to convert VLD schema to JSON Schema
+ */
+function schemaToJSONSchema(schema, options) {
+    const target = options.target || 'draft-07';
+    const schemaAny = schema;
+    const validatorType = schema.validatorType;
+    // Handle primitives
+    if (schema.constructor.name === 'VldString' || validatorType === VLD_VALIDATOR_TYPES.STRING) {
+        return withMetadata(schema, buildStringSchema(target, schema), options);
+    }
+    if (schema.constructor.name === 'VldNumber' || validatorType === VLD_VALIDATOR_TYPES.NUMBER) {
+        return withMetadata(schema, buildNumberSchema(schema), options);
+    }
+    if (schema.constructor.name === 'VldBoolean' || validatorType === VLD_VALIDATOR_TYPES.BOOLEAN) {
+        return withMetadata(schema, { type: 'boolean' }, options);
+    }
+    if (schema.constructor.name === 'VldBigInt' || validatorType === VLD_VALIDATOR_TYPES.BIGINT) {
+        return withMetadata(schema, buildBigIntSchema(schema), options);
+    }
+    if (schema.constructor.name === 'VldDate' || validatorType === VLD_VALIDATOR_TYPES.DATE) {
+        return withMetadata(schema, buildDateSchema(schema), options);
+    }
+    if (schema.constructor.name === 'VldArray' || validatorType === VLD_VALIDATOR_TYPES.ARRAY) {
+        return withMetadata(schema, buildArraySchema(schema, options), options);
+    }
+    if (schema.constructor.name === 'VldObject' || validatorType === VLD_VALIDATOR_TYPES.OBJECT) {
+        return withMetadata(schema, buildObjectSchema(schema, options), options);
+    }
+    // Handle union types
+    if (schema.constructor.name === 'VldUnion') {
+        return withMetadata(schema, buildUnionSchema(schema, options), options);
+    }
+    // Handle literal types
+    if (schema.constructor.name === 'VldLiteral') {
+        return withMetadata(schema, buildLiteralSchema(schema), options);
+    }
+    if (schema.constructor.name === 'VldEnum') {
+        return withMetadata(schema, buildEnumSchema(schema), options);
+    }
+    if (schema.constructor.name === 'VldSet' || validatorType === VLD_VALIDATOR_TYPES.SET) {
+        return withMetadata(schema, buildSetSchema(schema, options), options);
+    }
+    if (schema.constructor.name === 'VldMap' || validatorType === VLD_VALIDATOR_TYPES.MAP) {
+        return withMetadata(schema, buildMapSchema(schema, options), options);
+    }
+    if (schema.constructor.name === 'VldRecord' || validatorType === VLD_VALIDATOR_TYPES.RECORD) {
+        return withMetadata(schema, buildRecordSchema(schema, options), options);
+    }
+    if (schema.constructor.name === 'VldTuple' || validatorType === VLD_VALIDATOR_TYPES.TUPLE) {
+        return withMetadata(schema, buildTupleSchema(schema, options), options);
+    }
+    if (schema.constructor.name === 'VldIntersection') {
+        return withMetadata(schema, buildIntersectionSchema(schema, options), options);
+    }
+    if (schema.constructor.name === 'VldOptional') {
+        return withMetadata(schema, buildOptionalSchema(schema, options), options);
+    }
+    if (schema.constructor.name === 'VldNullable') {
+        return withMetadata(schema, buildNullableSchema(schema, options), options);
+    }
+    if (schema.constructor.name === 'VldNullish') {
+        return withMetadata(schema, buildNullishSchema(schema, options), options);
+    }
+    if (schema.constructor.name === 'VldExactOptional') {
+        return withMetadata(schema, buildExactOptionalSchema(schema, options), options);
+    }
+    if (schema.constructor.name === 'VldLazy') {
+        return withMetadata(schema, { type: 'object' }, options); // Placeholder for recursive schemas
+    }
+    if (schema.constructor.name === 'VldJson') {
+        return withMetadata(schema, {}, options); // Any JSON
+    }
+    if (schema.constructor.name === 'VldAny') {
+        return withMetadata(schema, {}, options); // JSON Schema true
+    }
+    if (schema.constructor.name === 'VldUnknown') {
+        return withMetadata(schema, {}, options); // JSON Schema true
+    }
+    if (schema.constructor.name === 'VldNever') {
+        return withMetadata(schema, { not: {} }, options); // JSON Schema false
+    }
+    if (schema.constructor.name === 'VldNull') {
+        return withMetadata(schema, { type: 'null' }, options);
+    }
+    if (schema.constructor.name === 'VldUndefined') {
+        return withMetadata(schema, { not: {} }, options); // Undefined can't be represented in JSON Schema
+    }
+    if (schema.constructor.name === 'VldNan') {
+        return withMetadata(schema, { type: 'number', not: {} }, options); // NaN is a number type constraint
+    }
+    if (schema.constructor.name === 'VldVoid') {
+        return withMetadata(schema, { not: {} }, options); // Void/undefined can't be represented
+    }
+    // Handle branded types - unwrap and continue
+    if (schema.constructor.name === 'VldBrand') {
+        return withMetadata(schema, schemaToJSONSchema(schemaAny.baseValidator, options), options);
+    }
+    // Handle readonly types
+    if (schema.constructor.name === 'VldReadonly') {
+        return withMetadata(schema, schemaToJSONSchema(schemaAny.baseValidator, options), 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 result = schemaToJSONSchema(schemaAny.baseValidator, options);
+        return withMetadata(schema, result, options);
+    }
+    // Handle refine/superRefine types
+    if (schema.constructor.name === 'VldRefine' || schema.constructor.name === 'VldSuperRefine') {
+        return withMetadata(schema, schemaToJSONSchema(unwrapInner(schemaAny), options), options);
+    }
+    // Handle pipe types
+    if (schema.constructor.name === 'VldPipe') {
+        return withMetadata(schema, schemaToJSONSchema(schemaAny._next || schemaAny.second, options), options);
+    }
+    // Handle default/catch types
+    if (schema.constructor.name === 'VldDefault' || schema.constructor.name === 'VldCatch') {
+        return withMetadata(schema, schemaToJSONSchema(unwrapInner(schemaAny), options), options);
+    }
+    // Handle preprocess types
+    if (schema.constructor.name === 'VldPreprocess') {
+        return withMetadata(schema, schemaToJSONSchema(schemaAny._schema, options), options);
+    }
+    // Handle string format validators
+    if (schema.constructor.name === 'VldStringFormat') {
+        const formatSchema = schema;
+        return withMetadata(schema, { type: 'string', format: formatSchema._format }, options);
+    }
+    // Fallback for unknown types
+    return withMetadata(schema, {}, options);
+}
+function unwrapInner(schema) {
+    if (typeof schema.unwrap === 'function') {
+        return schema.unwrap();
+    }
+    return schema._inner || schema._baseValidator || schema.baseValidator || schema.valueValidator;
+}
+function getMetadata(schema) {
+    const registered = globalRegistry.get(schema);
+    const schemaAny = schema;
+    const local = typeof schemaAny.getMeta === 'function' ? schemaAny.getMeta() : undefined;
+    return registered || local ? { ...(local || {}), ...(registered || {}) } : undefined;
+}
+function withMetadata(schema, definition, options) {
+    if (options.includeMetadata === false) {
+        return definition;
+    }
+    const metadata = getMetadata(schema);
+    if (!metadata) {
+        return definition;
+    }
+    const result = { ...definition };
+    if (metadata.id)
+        result.$id = metadata.id;
+    if (metadata.title)
+        result.title = metadata.title;
+    if (metadata.description)
+        result.description = metadata.description;
+    if (metadata.examples && options.includeExamples !== false)
+        result.examples = metadata.examples;
+    if (metadata.default !== undefined)
+        result.default = metadata.default;
+    if (metadata.deprecated)
+        result.deprecated = true;
+    if (metadata.readOnly)
+        result.readOnly = true;
+    if (metadata.writeOnly)
+        result.writeOnly = true;
+    return result;
+}
+/**
+ * Build string JSON Schema
+ */
+function buildStringSchema(_target, schema) {
+    const hints = schema?.config?.jsonSchema || {};
+    const result = { type: 'string' };
+    if (hints.exactLength !== undefined) {
+        result.minLength = hints.exactLength;
+        result.maxLength = hints.exactLength;
+    }
+    else {
+        if (hints.minLength !== undefined)
+            result.minLength = hints.minLength;
+        if (hints.maxLength !== undefined)
+            result.maxLength = hints.maxLength;
+    }
+    if (hints.format)
+        result.format = hints.format;
+    if (hints.pattern)
+        result.pattern = hints.pattern;
+    return result;
+}
+/**
+ * Build number JSON Schema from VLD number schema
+ */
+function buildNumberSchema(schema, _target) {
+    const config = schema.config || {};
+    const hints = config.jsonSchema || {};
+    const checks = config.checks || [];
+    const result = { type: hints.type || 'number' };
+    if (hints.minimum !== undefined)
+        result.minimum = hints.minimum;
+    if (hints.maximum !== undefined)
+        result.maximum = hints.maximum;
+    if (hints.exclusiveMinimum !== undefined)
+        result.exclusiveMinimum = hints.exclusiveMinimum;
+    if (hints.exclusiveMaximum !== undefined)
+        result.exclusiveMaximum = hints.exclusiveMaximum;
+    if (hints.multipleOf !== undefined)
+        result.multipleOf = hints.multipleOf;
+    if (Object.keys(hints).length > 0) {
+        return result;
+    }
+    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;
+}
+function bigintToSafeNumber(value) {
+    const asNumber = Number(value);
+    if (!Number.isSafeInteger(asNumber)) {
+        return undefined;
+    }
+    return BigInt(asNumber) === value ? asNumber : undefined;
+}
+function applyBigIntBound(result, numericKey, extensionKey, value) {
+    if (value === undefined) {
+        return;
+    }
+    result[extensionKey] = value.toString();
+    const safeNumber = bigintToSafeNumber(value);
+    if (safeNumber !== undefined) {
+        result[numericKey] = safeNumber;
+    }
+}
+function buildBigIntSchema(schema) {
+    const hints = schema.jsonSchema || schema.config?.jsonSchema || {};
+    const result = { type: 'integer' };
+    applyBigIntBound(result, 'minimum', 'x-vld-minimum', hints.minimum);
+    applyBigIntBound(result, 'maximum', 'x-vld-maximum', hints.maximum);
+    applyBigIntBound(result, 'exclusiveMinimum', 'x-vld-exclusiveMinimum', hints.exclusiveMinimum);
+    applyBigIntBound(result, 'exclusiveMaximum', 'x-vld-exclusiveMaximum', hints.exclusiveMaximum);
+    return result;
+}
+function buildDateSchema(schema) {
+    const hints = schema.jsonSchema || schema.config?.jsonSchema || {};
+    const result = {
+        type: 'string',
+        format: 'date-time'
+    };
+    if (hints.formatMinimum)
+        result.formatMinimum = hints.formatMinimum;
+    if (hints.formatMaximum)
+        result.formatMaximum = hints.formatMaximum;
+    if (hints.formatExclusiveMinimum)
+        result.formatExclusiveMinimum = hints.formatExclusiveMinimum;
+    if (hints.formatExclusiveMaximum)
+        result.formatExclusiveMaximum = hints.formatExclusiveMaximum;
+    return result;
+}
+/**
+ * Build array JSON Schema
+ */
+function buildArraySchema(schema, options) {
+    const inner = schema._item || schema._inner || schema.config?.itemValidator;
+    const result = { type: 'array' };
+    if (inner) {
+        result.items = schemaToJSONSchema(inner, options);
+    }
+    if (schema.config?.exactLength !== undefined) {
+        result.minItems = schema.config.exactLength;
+        result.maxItems = schema.config.exactLength;
+    }
+    else {
+        if (schema.config?.minLength !== undefined)
+            result.minItems = schema.config.minLength;
+        if (schema.config?.maxLength !== undefined)
+            result.maxItems = schema.config.maxLength;
+    }
+    if (schema.config?.unique)
+        result.uniqueItems = true;
+    return result;
+}
+/**
+ * Build object JSON Schema
+ */
+function buildObjectSchema(schema, options) {
+    const shape = schema._shape || schema.shape || schema.config?.shape;
+    if (!shape)
+        return { type: 'object' };
+    const properties = {};
+    const required = [];
+    for (const [key, value] of Object.entries(shape)) {
+        const child = value;
+        properties[key] = schemaToJSONSchema(child, options);
+        // VLD objects require all keys by default
+        if (!isOptionalLike(child)) {
+            required.push(key);
+        }
+    }
+    const result = {
+        type: 'object',
+        properties
+    };
+    if (required.length > 0) {
+        result.required = required;
+    }
+    // Handle passthrough mode
+    if (schema._passthrough || schema._loose || schema.config?.passthrough) {
+        result.additionalProperties = true;
+    }
+    else if (schema._strict || schema.config?.strict) {
+        result.additionalProperties = false;
+    }
+    else if (schema.config?.catchall) {
+        result.additionalProperties = schemaToJSONSchema(schema.config.catchall, options);
+    }
+    return result;
+}
+function isOptionalLike(schema) {
+    const name = schema.constructor.name;
+    return (name === 'VldOptional' ||
+        name === 'VldNullish' ||
+        name === 'VldExactOptional' ||
+        schema.validatorType === VLD_VALIDATOR_TYPES.OPTIONAL ||
+        schema.validatorType === VLD_VALIDATOR_TYPES.NULLISH ||
+        schema.validatorType === VLD_VALIDATOR_TYPES.EXACT_OPTIONAL);
+}
+/**
+ * Build union JSON Schema
+ */
+function buildUnionSchema(schema, options) {
+    const validators = schema._validators || schema._options || schema.validators || [];
+    return {
+        anyOf: validators.map((v) => schemaToJSONSchema(v, options))
+    };
+}
+/**
+ * Build literal JSON Schema
+ */
+function buildLiteralSchema(schema) {
+    const value = schema._literal ?? schema.literal ?? 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.valueSchema || schema._value || schema._inner || schema.valueValidator;
+    if (valueValidator) {
+        return {
+            type: 'object',
+            additionalProperties: schemaToJSONSchema(valueValidator, options)
+        };
+    }
+    return { type: 'object' };
+}
+/**
+ * Build Set JSON Schema as the JSON-compatible array representation.
+ */
+function buildSetSchema(schema, options) {
+    const itemValidator = schema.itemSchema || schema.itemValidator || schema._item || schema._inner;
+    const result = {
+        type: 'array',
+        uniqueItems: true,
+        'x-vld-type': 'set'
+    };
+    if (itemValidator) {
+        result.items = schemaToJSONSchema(itemValidator, options);
+    }
+    return result;
+}
+/**
+ * Build Map JSON Schema as an array of key/value pairs.
+ */
+function buildMapSchema(schema, options) {
+    const keyValidator = schema.keySchema || schema.keyValidator || schema._key;
+    const valueValidator = schema.valueSchema || schema.valueValidator || schema._value;
+    const keySchema = keyValidator ? schemaToJSONSchema(keyValidator, options) : {};
+    const valueSchema = valueValidator ? schemaToJSONSchema(valueValidator, options) : {};
+    return {
+        type: 'array',
+        'x-vld-type': 'map',
+        items: {
+            type: 'array',
+            items: [keySchema, valueSchema],
+            minItems: 2,
+            maxItems: 2
+        }
+    };
+}
+/**
+ * Build tuple JSON Schema
+ */
+function buildTupleSchema(schema, options) {
+    const items = schema.items || schema._items || schema.validators;
+    if (!items || !Array.isArray(items)) {
+        return { type: 'array' };
+    }
+    return {
+        type: 'array',
+        items: items.map((item) => schemaToJSONSchema(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(schemaToJSONSchema(first, options));
+    if (second)
+        schemas.push(schemaToJSONSchema(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 = unwrapInner(schema);
+    if (!inner)
+        return {};
+    const result = schemaToJSONSchema(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 = unwrapInner(schema);
+    if (!inner)
+        return { type: 'null' };
+    const result = schemaToJSONSchema(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 = unwrapInner(schema);
+    if (!inner)
+        return {};
+    const result = schemaToJSONSchema(inner, options);
+    if (typeof result.type === 'string') {
+        return { ...result, type: [result.type, 'null'] };
+    }
+    return result;
+}
+/**
+ * Build exactOptional JSON Schema
+ */
+function buildExactOptionalSchema(schema, options) {
+    const inner = unwrapInner(schema);
+    if (!inner)
+        return {};
+    return schemaToJSONSchema(inner, options);
+}
+/**
+ * Internal function to convert JSON Schema to VLD schema
+ */
+function jsonSchemaToVLD(json) {
+    return applyJSONSchemaMetadata(jsonSchemaToVLDInner(json), json);
+}
+function jsonSchemaToVLDInner(json) {
+    // 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 firstSchema = json.allOf[0];
+        if (firstSchema === undefined) {
+            return VldAny.create();
+        }
+        const first = jsonSchemaToVLD(firstSchema);
+        if (json.allOf.length > 1) {
+            const second = jsonSchemaToVLD({ allOf: json.allOf.slice(1) });
+            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.nullable && typeof json.type === 'string'
+        ? [json.type, 'null']
+        : json.type;
+    if (type === 'string' || type === undefined) {
+        let s = VldString.create();
+        if (json.minLength !== undefined)
+            s = s.min(json.minLength);
+        if (json.maxLength !== undefined)
+            s = s.max(json.maxLength);
+        if (json.pattern)
+            s = s.regex(new RegExp(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':
+                    return email$1();
+                case 'uri':
+                case 'uri-reference':
+                    return httpUrl$1();
+                case 'uuid':
+                    return uuid$1();
+            }
+        }
+        return s;
+    }
+    if (type === 'number' || type === 'integer') {
+        let n = VldNumber.create();
+        if (type === 'integer')
+            n = n.int();
+        if (json.minimum !== undefined)
+            n = n.min(json.minimum);
+        if (json.maximum !== undefined)
+            n = n.max(json.maximum);
+        if (typeof json.exclusiveMinimum === 'number')
+            n = n.gt(json.exclusiveMinimum);
+        if (typeof json.exclusiveMaximum === 'number')
+            n = n.lt(json.exclusiveMaximum);
+        if (json.exclusiveMinimum === true && json.minimum !== undefined)
+            n = n.gt(json.minimum);
+        if (json.exclusiveMaximum === true && json.maximum !== undefined)
+            n = n.lt(json.maximum);
+        if (json.multipleOf !== undefined)
+            n = n.multipleOf(json.multipleOf);
+        return n;
+    }
+    if (type === 'boolean') {
+        return VldBoolean.create();
+    }
+    if (type === 'array') {
+        if (json.prefixItems && json.prefixItems.length > 0) {
+            const validators = json.prefixItems.map((item) => jsonSchemaToVLD(item));
+            return VldTuple.create(...validators);
+        }
+        if (Array.isArray(json.items)) {
+            const validators = json.items.map((item) => jsonSchemaToVLD(item));
+            return VldTuple.create(...validators);
+        }
+        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 = new Set(json.required || []);
+            for (const [key, propSchema] of Object.entries(json.properties)) {
+                const fieldSchema = jsonSchemaToVLD(propSchema);
+                shape[key] = required.has(key) ? fieldSchema : fieldSchema.optional();
+            }
+            let obj = VldObject.create(shape);
+            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);
+                return 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, nullable: false });
+        });
+        if (options.length > 0) {
+            return VldUnion.create(...options);
+        }
+    }
+    // Fallback to any
+    return VldAny.create();
+}
+function applyJSONSchemaMetadata(schema, json) {
+    const metadata = {};
+    if (json.$id)
+        metadata.id = json.$id;
+    if (json.title)
+        metadata.title = json.title;
+    if (json.description)
+        metadata.description = json.description;
+    if (json.examples)
+        metadata.examples = json.examples;
+    if (json.default !== undefined)
+        metadata.default = json.default;
+    if (json.deprecated)
+        metadata.deprecated = true;
+    if (json.readOnly)
+        metadata.readOnly = true;
+    if (json.writeOnly)
+        metadata.writeOnly = true;
+    return Object.keys(metadata).length > 0
+        ? schema.meta(metadata)
+        : schema;
+}
 
 /**
  * VLD Logger
@@ -206,7 +1055,192 @@ function createNoOpLogger() {
  * - Colored console output for better debugging
  * - Debug logging system
  */
-// Import validators
+// Import base class
+let globalConfig = {};
+let globalErrorMap;
+function configure(config) {
+    if (config === undefined) {
+        return { ...globalConfig };
+    }
+    globalConfig = { ...globalConfig, ...config };
+    if ('customError' in config) {
+        globalErrorMap = config.customError;
+    }
+    else if ('errorMap' in config) {
+        globalErrorMap = config.errorMap;
+    }
+    return { ...globalConfig };
+}
+function setGlobalErrorMap(errorMap) {
+    globalErrorMap = errorMap;
+    globalConfig = { ...globalConfig, errorMap };
+}
+function getGlobalErrorMap() {
+    return globalErrorMap;
+}
+function enumValuesFromNativeEnum(enumObject) {
+    const values = Object.keys(enumObject)
+        .filter(key => !/^\d+$/.test(key))
+        .map(key => enumObject[key])
+        .filter((value) => typeof value === 'string' || typeof value === 'number');
+    const uniqueValues = Array.from(new Set(values));
+    if (uniqueValues.length === 0) {
+        throw new Error('nativeEnum requires at least one string or number value');
+    }
+    return uniqueValues;
+}
+function toErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function addFormattedIssue(root, path, message) {
+    let current = root;
+    for (const segment of path) {
+        const key = String(segment);
+        const next = current[key];
+        if (!next || Array.isArray(next)) {
+            current[key] = { _errors: [] };
+        }
+        current = current[key];
+    }
+    current._errors.push(message);
+}
+function isCodec(schema) {
+    return schema instanceof VldCodec;
+}
+function messageFromRefinementParam(param) {
+    return param === undefined ? undefined : resolveErrorMessage(param, 'Refinement check failed');
+}
+function cloneSchema(schema) {
+    return schema;
+}
+function createTransform(transformer) {
+    return custom$1({
+        parse: (value) => {
+            const transformed = transformer(value, { addIssue: () => undefined, path: [] });
+            if (transformed !== null && typeof transformed === 'object' && typeof transformed.then === 'function') {
+                throw new Error('Use parseAsync for async transforms');
+            }
+            return transformed;
+        },
+        parseAsync: async (value) => {
+            const transformed = await Promise.resolve(transformer(value, { addIssue: () => undefined, path: [] }));
+            return transformed;
+        }
+    });
+}
+function createRefinement(predicate, message) {
+    return custom$1({
+        parse: (value) => {
+            const passed = predicate(value);
+            if (passed !== null && typeof passed === 'object' && typeof passed.then === 'function') {
+                throw new Error('Use parseAsync for async refinements');
+            }
+            if (!passed) {
+                throw new Error(messageFromRefinementParam(message) || 'Refinement check failed');
+            }
+            return value;
+        },
+        parseAsync: async (value) => {
+            if (!await predicate(value)) {
+                throw new Error(messageFromRefinementParam(message) || 'Refinement check failed');
+            }
+            return value;
+        }
+    });
+}
+function createSuperRefinement(refinement) {
+    return VldUnknown.create().superRefine(refinement);
+}
+function propertyCheck(property, schema, message) {
+    return custom$1({
+        parse: (value) => {
+            if (typeof value !== 'object' || value === null || !(property in value)) {
+                throw new Error(messageFromRefinementParam(message) || `Expected object with property "${property}"`);
+            }
+            const result = schema.safeParse(value[property]);
+            if (!result.success) {
+                throw new Error(messageFromRefinementParam(message) || result.error.message);
+            }
+            return value;
+        }
+    });
+}
+function getParsedType(value) {
+    if (value === null)
+        return 'null';
+    if (Array.isArray(value))
+        return 'array';
+    if (Number.isNaN(value))
+        return 'nan';
+    return typeof value;
+}
+const TimePrecision = {
+    Any: null,
+    Minute: -1,
+    Second: 0,
+    Millisecond: 3,
+    Microsecond: 6
+};
+const ZodFirstPartyTypeKind = {};
+const $brand = Symbol.for('vld_brand');
+const $input = Symbol.for('VldInput');
+const $output = Symbol.for('VldOutput');
+const ZodIssueCode = {
+    invalid_type: 'invalid_type',
+    too_big: 'too_big',
+    too_small: 'too_small',
+    invalid_format: 'invalid_format',
+    not_multiple_of: 'not_multiple_of',
+    unrecognized_keys: 'unrecognized_keys',
+    invalid_union: 'invalid_union',
+    invalid_key: 'invalid_key',
+    invalid_element: 'invalid_element',
+    invalid_value: 'invalid_value',
+    custom: 'custom'
+};
+const util = {
+    getParsedType,
+    propertyKeyTypes: new Set(['string', 'number', 'symbol']),
+    primitiveTypes: new Set(['string', 'number', 'bigint', 'boolean', 'symbol', 'undefined', 'null']),
+    assert: (condition, message = 'Assertion failed') => {
+        if (!condition) {
+            throw new Error(message);
+        }
+    },
+    assertNever: (value) => {
+        throw new Error(`Unexpected value: ${String(value)}`);
+    },
+    joinValues: (values, separator = ' | ') => values.map(value => JSON.stringify(value)).join(separator),
+    jsonStringifyReplacer: (_key, value) => typeof value === 'bigint' ? value.toString() : value,
+    nullish: (value) => value === null || value === undefined,
+    cached: (getter) => {
+        let initialized = false;
+        let value;
+        return () => {
+            if (!initialized) {
+                value = getter();
+                initialized = true;
+            }
+            return value;
+        };
+    }
+};
+const core = {
+    util,
+    regexes: REGEXES,
+    locales: localeNamespace,
+    NEVER: VldNever.create(),
+    TimePrecision,
+    ZodIssueCode,
+    globalRegistry,
+    config: configure,
+    getErrorMap: getGlobalErrorMap,
+    setErrorMap: setGlobalErrorMap,
+    parse: (schema, value) => schema.parse(value),
+    safeParse: (schema, value) => schema.safeParse(value),
+    parseAsync: (schema, value) => schema.parseAsync(value),
+    safeParseAsync: (schema, value) => schema.safeParseAsync(value)
+};
 /**
  * Main API object with factory methods for all validators
  */
@@ -216,6 +1250,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(),
@@ -237,9 +1276,11 @@ const v = {
     intersection: (first, second) => VldIntersection.create(first, second),
     discriminatedUnion: (discriminator, ...options) => VldDiscriminatedUnion.create(discriminator, [...options]),
     xor: (...options) => VldXor.create([...options]),
+    keyof: (schema) => schema.keyof(),
     // Literal and enum
     literal: (value) => VldLiteral.create(value),
     enum: (...values) => VldEnum.create(values),
+    nativeEnum: (enumObject) => VldEnum.create(enumValuesFromNativeEnum(enumObject)),
     // Special validators
     any: () => VldAny.create(),
     unknown: () => VldUnknown.create(),
@@ -250,18 +1291,62 @@ const v = {
     nan: () => VldNan.create(),
     // NEVER constant - Zod 4 API parity for use in transforms
     NEVER: VldNever.create(),
+    TimePrecision,
+    ZodIssueCode,
+    ZodFirstPartyTypeKind,
     // Utility validators
     optional: (validator) => VldOptional.create(validator),
     nullable: (validator) => VldNullable.create(validator),
     nullish: (validator) => VldNullish.create(validator),
+    exactOptional: (validator) => VldExactOptional.create(validator),
+    nonoptional: (validator, message) => validator.refine((value) => value !== undefined, messageFromRefinementParam(message)),
+    catch: (validator, fallbackValue) => validator.catch(fallbackValue),
+    prefault: (validator, defaultValue) => validator.default(typeof defaultValue === 'function' ? defaultValue() : defaultValue).prefault(),
+    readonly: (validator) => validator.readonly(),
+    pipe: (first, second) => first.pipe(second),
+    clone: (schema) => cloneSchema(schema),
+    describe: (schemaOrDescription, description) => schemaOrDescription instanceof VldBase
+        ? schemaOrDescription.describe(description || '')
+        : VldUnknown.create().describe(schemaOrDescription),
+    meta: (schemaOrMetadata, metadata) => schemaOrMetadata instanceof VldBase
+        ? schemaOrMetadata.meta(metadata || {})
+        : VldUnknown.create().meta(schemaOrMetadata),
+    transform: (schemaOrTransformer, transformer) => schemaOrTransformer instanceof VldBase
+        ? schemaOrTransformer.transform(transformer || ((value) => value))
+        : createTransform(schemaOrTransformer),
+    overwrite: (transformer) => createTransform(transformer),
+    refine: (schemaOrPredicate, predicateOrMessage, message) => schemaOrPredicate instanceof VldBase
+        ? schemaOrPredicate.refine(predicateOrMessage, messageFromRefinementParam(message))
+        : createRefinement(schemaOrPredicate, predicateOrMessage),
+    check: (schemaOrPredicate, predicateOrMessage, message) => schemaOrPredicate instanceof VldBase
+        ? schemaOrPredicate.check(predicateOrMessage, messageFromRefinementParam(message))
+        : createRefinement(schemaOrPredicate, predicateOrMessage),
+    superRefine: (schemaOrRefinement, refinement) => schemaOrRefinement instanceof VldBase
+        ? schemaOrRefinement.superRefine(refinement || (() => undefined))
+        : createSuperRefinement(schemaOrRefinement),
+    property: propertyCheck,
+    instanceof: (constructor, message) => custom$1({
+        parse: (value) => {
+            if (!(value instanceof constructor)) {
+                throw new Error(messageFromRefinementParam(message) || `Expected instance of ${constructor.name || 'provided constructor'}`);
+            }
+            return value;
+        }
+    }),
+    config: configure,
+    setErrorMap: setGlobalErrorMap,
+    getErrorMap: getGlobalErrorMap,
+    core,
+    util,
+    locales: localeNamespace,
     // Recursive schemas
     lazy: (schemaGetter) => VldLazy.create(schemaGetter),
     // JSON validator
     json: (schema) => VldJson.create(schema),
     // Custom validator for type-safe user-defined schemas
-    custom: (options) => custom(options),
+    custom: (options) => custom$1(options),
     // File validator for file uploads
-    file: () => file(),
+    file: () => file$1(),
     // Function validator for function validation
     function: () => functionValidator(),
     // Preprocessing
@@ -275,42 +1360,175 @@ const v = {
         bigint: () => VldCoerceBigInt.create(),
     },
     // String format validators (Zod 4 parity)
-    email: (options) => email(options),
-    uuid: (options) => uuid(options),
-    uuidv4: () => uuidv4(),
-    hostname: () => hostname(),
-    emoji: () => emoji(),
-    base64: () => base64(),
-    base64url: () => base64url(),
-    hex: () => hex(),
-    jwt: () => jwt(),
-    nanoid: () => nanoid(),
-    cuid: () => cuid(),
-    cuid2: () => cuid2(),
-    ulid: () => ulid(),
-    ipv4: () => ipv4(),
-    ipv6: () => ipv6(),
-    mac: () => mac(),
-    cidrv4: () => cidrv4(),
-    cidrv6: () => cidrv6(),
-    e164: () => e164(),
-    hash: (algorithm) => hash(algorithm),
+    email: (options) => email$1(options),
+    url: () => VldString.create().url(),
+    uuid: (options) => uuid$1(options),
+    uuidv4: () => uuidv4$1(),
+    uuidv6: () => uuidv6$1(),
+    uuidv7: () => uuidv7$1(),
+    hostname: () => hostname$1(),
+    emoji: () => emoji$1(),
+    base64: () => base64$1(),
+    base64url: () => base64url$1(),
+    hex: () => hex$1(),
+    jwt: () => jwt$1(),
+    nanoid: () => nanoid$1(),
+    cuid: () => cuid$1(),
+    cuid2: () => cuid2$1(),
+    ulid: () => ulid$1(),
+    ipv4: () => ipv4$1(),
+    ipv6: () => ipv6$1(),
+    mac: () => mac$1(),
+    cidrv4: () => cidrv4$1(),
+    cidrv6: () => cidrv6$1(),
+    e164: () => e164$1(),
+    hash: (algorithm) => hash$1(algorithm),
     iso: {
-        date: () => iso.date(),
-        time: () => iso.time(),
-        dateTime: () => iso.dateTime(),
-        duration: () => iso.duration(),
+        date: () => iso$1.date(),
+        time: () => iso$1.time(),
+        dateTime: () => iso$1.dateTime(),
+        duration: () => iso$1.duration(),
     },
-    stringFormat: (name, validator) => stringFormat(name, validator),
+    stringFormat: (name, validator) => stringFormat$1(name, validator),
+    minLength: (value, message) => VldString.create().min(value, message),
+    maxLength: (value, message) => VldString.create().max(value, message),
+    length: (value, message) => VldString.create().length(value, message),
+    regex: (pattern, message) => VldString.create().regex(pattern, message),
+    startsWith: (value, message) => VldString.create().startsWith(value, message),
+    endsWith: (value, message) => VldString.create().endsWith(value, message),
+    includes: (value, message) => VldString.create().includes(value, message),
+    trim: () => VldString.create().trim(),
+    toLowerCase: () => VldString.create().toLowerCase(),
+    lowercase: () => VldString.create().toLowerCase(),
+    toUpperCase: () => VldString.create().toUpperCase(),
+    uppercase: () => VldString.create().toUpperCase(),
+    gt: (value, message) => VldNumber.create().gt(value, message),
+    gte: (value, message) => VldNumber.create().gte(value, message),
+    lt: (value, message) => VldNumber.create().lt(value, message),
+    lte: (value, message) => VldNumber.create().lte(value, message),
+    positive: (message) => VldNumber.create().positive(message),
+    negative: (message) => VldNumber.create().negative(message),
+    nonnegative: (message) => VldNumber.create().nonnegative(message),
+    nonpositive: (message) => VldNumber.create().nonpositive(message),
+    multipleOf: (value, message) => VldNumber.create().multipleOf(value, message),
+    minSize: (value, message) => VldString.create().min(value, message),
+    maxSize: (value, message) => VldString.create().max(value, message),
+    size: (value, message) => VldString.create().length(value, message),
+    normalize: (form) => VldString.create().transform(value => value.normalize(form)),
+    slugify: () => VldString.create().transform(value => value
+        .normalize('NFKD')
+        .replace(/[\u0300-\u036f]/g, '')
+        .toLowerCase()
+        .trim()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '')),
+    mime: (types, message) => VldFile.create().mime(types, message),
+    // Zod v4 parity string formats
+    xid: () => xid$1(),
+    guid: () => guid$1(),
+    httpUrl: () => httpUrl$1(),
+    ksuid: () => ksuid$1(),
+    regexes: REGEXES,
     // Template literal validator
-    templateLiteral: (...components) => templateLiteral(...components),
+    templateLiteral: (...components) => templateLiteral$1(...components),
     // Codec validators (binary data validators)
     base64Bytes: () => VldBase64.create(),
     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),
+    invertCodec: (codec) => codec.invert(),
+    // Promise validator (Zod v4 parity)
+    promise: (inner) => promise$1(inner),
+    // Root parse helpers (Zod v4 parity)
+    parse: (schema, value) => schema.parse(value),
+    safeParse: (schema, value) => schema.safeParse(value),
+    parseAsync: (schema, value) => schema.parseAsync(value),
+    safeParseAsync: (schema, value) => schema.safeParseAsync(value),
+    decode: (schema, value) => schema.parse(value),
+    safeDecode: (schema, value) => schema.safeParse(value),
+    decodeAsync: (schema, value) => schema.parseAsync(value),
+    safeDecodeAsync: (schema, value) => schema.safeParseAsync(value),
+    encode: (schema, value) => isCodec(schema)
+        ? schema.encode(value)
+        : schema.parse(value),
+    safeEncode: (schema, value) => isCodec(schema)
+        ? schema.safeEncode(value)
+        : schema.safeParse(value),
+    encodeAsync: async (schema, value) => isCodec(schema)
+        ? schema.encodeAsync(value)
+        : schema.parseAsync(value),
+    safeEncodeAsync: async (schema, value) => isCodec(schema)
+        ? schema.safeEncodeAsync(value)
+        : schema.safeParseAsync(value),
+    formatError: (error) => {
+        const formatted = { _errors: [] };
+        if (error instanceof VldError) {
+            for (const issue of error.issues) {
+                addFormattedIssue(formatted, issue.path, issue.message);
+            }
+            return formatted;
+        }
+        formatted._errors.push(toErrorMessage(error));
+        return formatted;
+    },
+    treeifyError: treeifyError,
+    prettifyError: prettifyError,
+    flattenError: flattenError,
+    toJSONSchema: toJSONSchema
 };
+/**
+ * Zod-compatible namespace alias.
+ */
+const z = v;
+/**
+ * Zod-compatible root-level factory aliases.
+ *
+ * VLD's primary API remains `v.*`, but Zod exposes most factories directly
+ * from the package root. Re-exporting these aliases makes migration less
+ * intrusive without changing existing behavior.
+ */
+const { string, number, int, int32, uint32, uint64, int64, float32, float64, boolean, date, bigint, symbol, stringbool, array, object, strictObject, looseObject, tuple, record, partialRecord, looseRecord, set, union, intersection, discriminatedUnion, xor, keyof, literal, nativeEnum, any, unknown, nan, optional, nullable, nullish, exactOptional, nonoptional, readonly, pipe, clone, describe, meta, transform, overwrite, refine, check, superRefine, property, config, setErrorMap, getErrorMap, locales, lazy, json, custom, file, preprocess, coerce, email, url, uuid, uuidv4, uuidv6, uuidv7, hostname, emoji, base64, base64url, hex, jwt, nanoid, cuid, cuid2, ulid, ipv4, ipv6, mac, cidrv4, cidrv6, e164, hash, iso, stringFormat, normalize, slugify, mime, xid, guid, httpUrl, ksuid, regexes, templateLiteral, base64Bytes, hexBytes, uint8Array, codec, promise, prefault, parse, safeParse, parseAsync, safeParseAsync, decode, safeDecode, decodeAsync, safeDecodeAsync, encode, safeEncode, encodeAsync, safeEncodeAsync, formatError, NEVER } = v;
+const catchFactory = v.catch;
+const enumFactory = v.enum;
+const functionFactory = v.function;
+const instanceOfFactory = v.instanceof;
+const mapFactory = v.map;
+const neverFactory = v.never;
+const nullFactory = v.null;
+const undefinedFactory = v.undefined;
+const voidFactory = v.void;
+const defaultFactory = v;
+const zodStringFactory = VldString;
+function map(first, second) {
+    if (first instanceof VldBase && second instanceof VldBase) {
+        return v.map(first, second);
+    }
+    return map$1(first, second);
+}
+const minLength = (value, message) => v.string().min(value, message);
+const maxLength = (value, message) => v.string().max(value, message);
+const length = (value, message) => v.string().length(value, message);
+const regex = (pattern, message) => v.string().regex(pattern, message);
+const startsWith = (value, message) => v.string().startsWith(value, message);
+const endsWith = (value, message) => v.string().endsWith(value, message);
+const includes = (value, message) => v.string().includes(value, message);
+const trim = () => v.string().trim();
+const toLowerCase = () => v.string().toLowerCase();
+const lowercase = toLowerCase;
+const toUpperCase = () => v.string().toUpperCase();
+const uppercase = toUpperCase;
+const gt = (value, message) => v.number().gt(value, message);
+const gte = (value, message) => v.number().gte(value, message);
+const lt = (value, message) => v.number().lt(value, message);
+const lte = (value, message) => v.number().lte(value, message);
+const positive = (message) => v.number().positive(message);
+const negative = (message) => v.number().negative(message);
+const nonnegative = (message) => v.number().nonnegative(message);
+const nonpositive = (message) => v.number().nonpositive(message);
+const multipleOf = (value, message) => v.number().multipleOf(value, message);
+const minSize = minLength;
+const maxSize = maxLength;
+const size = length;
 
-export { VldIntersection, createLogger, createNoOpLogger, v as default, disableLogging, enableDebug, getLogger, initLogger, setLogLevel, v };
-//# sourceMappingURL=index.js.map
+export { $brand, $input, $output, NEVER, TimePrecision, VldBase, VldError, VldIntersection, VldAny as ZodAny, VldArray as ZodArray, VldBigInt as ZodBigInt, VldBigInt as ZodBigIntFormat, VldBoolean as ZodBoolean, VldCodec as ZodCodec, VldDate as ZodDate, VldDiscriminatedUnion as ZodDiscriminatedUnion, VldEnum as ZodEnum, VldError as ZodError, VldExactOptional as ZodExactOptional, VldFile as ZodFile, ZodFirstPartyTypeKind, VldIntersection as ZodIntersection, ZodIssueCode, VldJson as ZodJSON, VldLazy as ZodLazy, VldLiteral as ZodLiteral, VldMap as ZodMap, VldNan as ZodNaN, VldNever as ZodNever, VldNull as ZodNull, VldNullable as ZodNullable, VldNumber as ZodNumber, VldNumber as ZodNumberFormat, VldObject as ZodObject, VldOptional as ZodOptional, VldPreprocess as ZodPreprocess, VldError as ZodRealError, VldRecord as ZodRecord, VldSet as ZodSet, VldString as ZodString, VldSymbol as ZodSymbol, VldTuple as ZodTuple, VldBase as ZodType, VldUndefined as ZodUndefined, VldUnion as ZodUnion, VldUnknown as ZodUnknown, VldVoid as ZodVoid, VldXor as ZodXor, zodStringFactory as _ZodString, defaultFactory as _default, functionFactory as _function, any, array, base64, base64Bytes, base64url, bigint, boolean, catchFactory as catch, check, cidrv4, cidrv6, clone, codec, coerce, config, core, createLogger, createNoOpLogger, cuid, cuid2, custom, date, decode, decodeAsync, v as default, describe, disableLogging, discriminatedUnion, e164, email, emoji, enableDebug, encode, encodeAsync, endsWith, enumFactory as enum, exactOptional, file, flattenError, float32, float64, formatError, fromJSONSchema, functionFactory as function, getErrorMap, getLogger, globalRegistry, gt, gte, guid, hash, hex, hexBytes, hostname, httpUrl, includes, initLogger, instanceOfFactory as instanceof, int, int32, int64, intersection, ipv4, ipv6, iso, json, jwt, keyof, ksuid, lazy, length, literal, locales, looseObject, looseRecord, lowercase, lt, lte, mac, map, mapFactory as mapSchema, maxLength, maxSize, meta, mime, minLength, minSize, multipleOf, nan, nanoid, nativeEnum, negative, neverFactory as never, nonnegative, nonoptional, nonpositive, normalize, nullFactory as null, nullable, nullish, number, object, optional, overwrite, parse, parseAsync, partialRecord, pipe, positive, prefault, preprocess, prettifyError, promise, property, readonly, record, refine, regex, regexes, safeDecode, safeDecodeAsync, safeEncode, safeEncodeAsync, safeParse, safeParseAsync, set, setErrorMap, setLogLevel, size, slugify, startsWith, strictObject, string, stringFormat, stringbool, superRefine, symbol, templateLiteral, toJSONSchema, toLowerCase, toUpperCase, transform, treeifyError, trim, tuple, uint32, uint64, uint8Array, ulid, undefinedFactory as undefined, union, unknown, uppercase, url, util, uuid, uuidv4, uuidv6, uuidv7, v, voidFactory as void, xid, xor, z };