@oxog/vld 2.0.2 → 2.1.0

package/dist/cjs/validators/string-formats.cjs

@@ -0,0 +1,168 @@
+'use strict';
+
+var validators_base = require('./base.cjs');
+var locales_runtime = require('../locales/runtime.cjs');
+require('../registry.cjs');
+require('../locales/en.cjs');
+
+/**
+ * Top-level string format validators
+ * Part of Zod 4 API parity implementation
+ * Provides convenient validators for common string formats
+ */
+/**
+ * Pre-compiled regex patterns for performance
+ */
+const REGEXES = {
+    email: /^[^\s@]+@[^\s@]+\.[^\s@]+$/,
+    uuid: /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i,
+    uuidv4: /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,
+    uuidv6: /^[0-9a-f]{8}-[0-9a-f]{4}-6[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,
+    uuidv7: /^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,
+    hostname: /^(?=.{1,253}$)(?:(?!-)[a-zA-Z0-9-]{1,63}(?<!-)\.)+[a-zA-Z]{2,63}$/,
+    emoji: /^(?:\p{Emoji_Presentation}|\p{Emoji}\uFE0F)(?:\u200D(?:\p{Emoji_Presentation}|\p{Emoji}\uFE0F))*$/u,
+    base64: /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/,
+    base64url: /^[A-Za-z0-9_-]*$/,
+    hex: /^[0-9a-fA-F]*$/,
+    jwt: /^[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]*$/,
+    nanoid: /^[A-Za-z0-9_-]{21}$/,
+    cuid: /^c[^\s-]{8,}$/i,
+    cuid2: /^[0-9a-z]+$/,
+    ulid: /^[0-9A-HJKMNP-TV-Z]{26}$/,
+    ipv4: /^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/,
+    ipv6: /^(?:[0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$/,
+    mac: /^([0-9A-Fa-f]{2}:){5}[0-9A-Fa-f]{2}$/,
+    cidrv4: /^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\/(?:3[0-2]|[12]?[0-9])$/,
+    cidrv6: /^(?:[0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}\/(?:12[0-8]|1[01][0-9]|[1-9]?[0-9])$|^::(?:[0-9a-fA-F]{1,4}:){0,6}[0-9a-fA-F]{1,4}\/(?:12[0-8]|1[01][0-9]|[1-9]?[0-9])$|^(?:[0-9a-fA-F]{1,4}:){1,7}:\/(?:12[0-8]|1[01][0-9]|[1-9]?[0-9])$/,
+    e164: /^\+[1-9]\d{1,14}$/,
+    isoDate: /^\d{4}-(?:0[1-9]|1[0-2])-(?:0[1-9]|[12]\d|3[01])$/,
+    isoTime: /^(?:[01]\d|2[0-3]):[0-5]\d(?::[0-5]\d(?:\.\d+)?)?$/,
+    isoDateTime: /^\d{4}-(?:0[1-9]|1[0-2])-(?:0[1-9]|[12]\d|3[01])T(?:[01]\d|2[0-3]):[0-5]\d:[0-5]\d(?:\.\d+)?Z?$/,
+    md5: /^[a-f0-9]{32}$/i,
+    sha1: /^[a-f0-9]{40}$/i,
+    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
+    ksuid: /^[0-9A-Za-z]{27}$/,
+};
+/**
+ * Generic string format validator
+ */
+class VldStringFormat extends validators_base.VldBase {
+    constructor(_format, _validator, _errorMessage) {
+        super(validators_base.VLD_VALIDATOR_TYPES.STRING_FORMAT);
+        this._format = _format;
+        this._validator = _validator;
+        this._errorMessage = _errorMessage;
+    }
+    static create(format, validator, errorMessage) {
+        return new VldStringFormat(format, validator, errorMessage);
+    }
+    parse(value) {
+        if (typeof value !== 'string') {
+            throw new Error(locales_runtime.getMessages().invalidString);
+        }
+        if (!this._validator(value)) {
+            throw new Error(this._errorMessage || `Invalid ${this._format} format`);
+        }
+        return value;
+    }
+    safeParse(value) {
+        if (typeof value !== 'string') {
+            return {
+                success: false,
+                error: new Error(locales_runtime.getMessages().invalidString)
+            };
+        }
+        if (!this._validator(value)) {
+            return {
+                success: false,
+                error: new Error(this._errorMessage || `Invalid ${this._format} format`)
+            };
+        }
+        return { success: true, data: value };
+    }
+}
+/**
+ * Top-level string format validators
+ */
+const email = (options) => VldStringFormat.create('email', (val) => (options?.pattern ?? REGEXES.email).test(val));
+const uuid = (options) => {
+    const pattern = options?.version ? REGEXES[`uuid${options.version}`] : REGEXES.uuid;
+    return VldStringFormat.create('uuid', (val) => pattern.test(val));
+};
+const uuidv4 = () => VldStringFormat.create('uuid', (val) => REGEXES.uuidv4.test(val));
+const uuidv6 = () => VldStringFormat.create('uuid', (val) => REGEXES.uuidv6.test(val));
+const uuidv7 = () => VldStringFormat.create('uuid', (val) => REGEXES.uuidv7.test(val));
+const hostname = () => VldStringFormat.create('hostname', (val) => REGEXES.hostname.test(val));
+const emoji = () => VldStringFormat.create('emoji', (val) => REGEXES.emoji.test(val));
+const base64 = () => VldStringFormat.create('base64', (val) => REGEXES.base64.test(val));
+const base64url = () => VldStringFormat.create('base64url', (val) => REGEXES.base64url.test(val));
+const hex = () => VldStringFormat.create('hex', (val) => REGEXES.hex.test(val));
+const jwt = () => VldStringFormat.create('jwt', (val) => REGEXES.jwt.test(val));
+const nanoid = () => VldStringFormat.create('nanoid', (val) => REGEXES.nanoid.test(val));
+const cuid = () => VldStringFormat.create('cuid', (val) => REGEXES.cuid.test(val));
+const cuid2 = () => VldStringFormat.create('cuid2', (val) => REGEXES.cuid2.test(val));
+const ulid = () => VldStringFormat.create('ulid', (val) => REGEXES.ulid.test(val));
+const ipv4 = () => VldStringFormat.create('ipv4', (val) => REGEXES.ipv4.test(val));
+const ipv6 = () => VldStringFormat.create('ipv6', (val) => REGEXES.ipv6.test(val));
+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 ksuid = () => VldStringFormat.create('ksuid', (val) => REGEXES.ksuid.test(val));
+const hash = (algorithm) => VldStringFormat.create('hash', (val) => REGEXES[algorithm]?.test(val) ?? false, `Invalid ${algorithm} hash`);
+/**
+ * ISO date/time validators
+ */
+const iso = {
+    date: () => VldStringFormat.create('date', (val) => REGEXES.isoDate.test(val)),
+    time: () => VldStringFormat.create('time', (val) => REGEXES.isoTime.test(val)),
+    dateTime: (_options) => VldStringFormat.create('datetime', (val) => REGEXES.isoDateTime.test(val)),
+    duration: () => VldStringFormat.create('duration', (val) => /^-?P(?!$)(?:\d+(?:\.\d+)?Y)?(?:\d+(?:\.\d+)?M)?(?:\d+(?:\.\d+)?W)?(?:\d+(?:\.\d+)?D)?(?:T(?=\d)(?:\d+(?:\.\d+)?H)?(?:\d+(?:\.\d+)?M)?(?:\d+(?:\.\d+)?S)?)?$/.test(val)),
+};
+/**
+ * Custom format validator
+ */
+const stringFormat = (name, validator) => {
+    const fn = validator instanceof RegExp ? (val) => validator.test(val) : validator;
+    return VldStringFormat.create(name, fn);
+};
+
+exports.VldStringFormat = VldStringFormat;
+exports.base64 = base64;
+exports.base64url = base64url;
+exports.cidrv4 = cidrv4;
+exports.cidrv6 = cidrv6;
+exports.cuid = cuid;
+exports.cuid2 = cuid2;
+exports.e164 = e164;
+exports.email = email;
+exports.emoji = emoji;
+exports.guid = guid;
+exports.hash = hash;
+exports.hex = hex;
+exports.hostname = hostname;
+exports.httpUrl = httpUrl;
+exports.ipv4 = ipv4;
+exports.ipv6 = ipv6;
+exports.iso = iso;
+exports.jwt = jwt;
+exports.ksuid = ksuid;
+exports.mac = mac;
+exports.nanoid = nanoid;
+exports.regexes = REGEXES;
+exports.stringFormat = stringFormat;
+exports.ulid = ulid;
+exports.uuid = uuid;
+exports.uuidv4 = uuidv4;
+exports.uuidv6 = uuidv6;
+exports.uuidv7 = uuidv7;
+exports.xid = xid;

package/dist/cjs/validators/string.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+require('./base.cjs');
+require('../locales/runtime.cjs');
+var validators_string = require('../chunks/string-BKZrc4hs.cjs');
+require('../chunks/errors-core-DWxLFs2f.cjs');
+require('../registry.cjs');
+require('../locales/en.cjs');
+
+
+
+exports.VldString = validators_string.VldString;

package/dist/cjs/validators/symbol.cjs

@@ -0,0 +1,62 @@
+'use strict';
+
+var validators_base = require('./base.cjs');
+var locales_runtime = require('../locales/runtime.cjs');
+var errorsCore = require('../chunks/errors-core-DWxLFs2f.cjs');
+require('../registry.cjs');
+require('../locales/en.cjs');
+
+function createSymbolError(message) {
+    return new errorsCore.VldError([{ code: 'invalid_type', path: [], message }]);
+}
+/**
+ * Immutable symbol validator
+ */
+class VldSymbol extends validators_base.VldBase {
+    /**
+     * Private constructor to enforce immutability
+     */
+    constructor(errorMessage) {
+        super(validators_base.VLD_VALIDATOR_TYPES.SYMBOL);
+        this.errorMessage = errorMessage;
+    }
+    /**
+     * Create a new symbol validator
+     */
+    static create() {
+        return new VldSymbol();
+    }
+    get isSimple() {
+        return true;
+    }
+    /**
+     * Parse and validate a symbol value
+     */
+    parse(value) {
+        if (typeof value !== 'symbol') {
+            throw new Error(this.errorMessage || locales_runtime.getMessages().invalidSymbol);
+        }
+        return value;
+    }
+    /**
+     * Parse a value that has already passed the symbol type guard.
+     * @internal Used by object validators to avoid duplicate hot-path checks.
+     */
+    parseKnownSymbol(value) {
+        return value;
+    }
+    /**
+     * Safely parse and validate a symbol value
+     */
+    safeParse(value) {
+        if (typeof value === 'symbol') {
+            return { success: true, data: value };
+        }
+        return {
+            success: false,
+            error: createSymbolError(this.errorMessage || locales_runtime.getMessages().invalidSymbol)
+        };
+    }
+}
+
+exports.VldSymbol = VldSymbol;

package/dist/cjs/validators/template-literal.cjs

@@ -0,0 +1,108 @@
+'use strict';
+
+var validators_base = require('./base.cjs');
+var locales_runtime = require('../locales/runtime.cjs');
+require('../registry.cjs');
+require('../locales/en.cjs');
+
+/**
+ * Immutable template literal validator
+ * Validates strings matching a template pattern
+ */
+class VldTemplateLiteral extends validators_base.VldBase {
+    constructor(pattern) {
+        super(validators_base.VLD_VALIDATOR_TYPES.TEMPLATE_LITERAL);
+        this.pattern = pattern;
+    }
+    /**
+     * Create a template literal validator from components
+     */
+    static create(...components) {
+        // Build regex pattern from components
+        let pattern = '^';
+        for (const comp of components) {
+            if (typeof comp === 'string') {
+                // Escape special regex characters
+                pattern += comp.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+            }
+            else {
+                // Add appropriate pattern based on validator type
+                pattern += getPatternForValidator(comp);
+            }
+        }
+        pattern += '$';
+        return new VldTemplateLiteral(new RegExp(pattern));
+    }
+    /**
+     * Parse and validate a template literal string
+     */
+    parse(value) {
+        if (typeof value !== 'string') {
+            throw new Error(locales_runtime.getMessages().invalidString);
+        }
+        if (!this.pattern.test(value)) {
+            throw new Error(locales_runtime.getMessages().stringPatternInvalid);
+        }
+        return value;
+    }
+    /**
+     * Safely parse and validate a template literal string
+     */
+    safeParse(value) {
+        try {
+            return { success: true, data: this.parse(value) };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error
+            };
+        }
+    }
+}
+/**
+ * Get regex pattern for a validator type
+ */
+function getPatternForValidator(validator) {
+    // For template literals, we need to identify the validator type
+    // and return an appropriate capture group pattern
+    switch (validator.validatorType) {
+        case validators_base.VLD_VALIDATOR_TYPES.STRING:
+        case validators_base.VLD_VALIDATOR_TYPES.STRING_FORMAT:
+            return '(.+)';
+        case validators_base.VLD_VALIDATOR_TYPES.NUMBER:
+        case validators_base.VLD_VALIDATOR_TYPES.COERCE_NUMBER:
+            return '(-?\\d+(?:\\.\\d+)?)';
+        case validators_base.VLD_VALIDATOR_TYPES.BIGINT:
+        case validators_base.VLD_VALIDATOR_TYPES.COERCE_BIGINT:
+            return '(-?\\d+)';
+        case validators_base.VLD_VALIDATOR_TYPES.BOOLEAN:
+        case validators_base.VLD_VALIDATOR_TYPES.COERCE_BOOLEAN:
+            return '(true|false)';
+        case validators_base.VLD_VALIDATOR_TYPES.NULL:
+            return '(null)';
+        case validators_base.VLD_VALIDATOR_TYPES.UNDEFINED:
+        case validators_base.VLD_VALIDATOR_TYPES.VOID:
+            return '(undefined)';
+        case validators_base.VLD_VALIDATOR_TYPES.LITERAL: {
+            const literalValidator = validator;
+            if (literalValidator.literal !== undefined) {
+                const valueStr = String(literalValidator.literal);
+                return '(' + valueStr.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') + ')';
+            }
+            break;
+        }
+    }
+    // Default: match any string
+    return '(.+)';
+}
+/**
+ * Helper function to create template literal validators
+ * Usage: v.templateLiteral(v.string(), '-', v.number())
+ */
+function templateLiteral(...components) {
+    return VldTemplateLiteral.create(...components);
+}
+
+exports.VldTemplateLiteral = VldTemplateLiteral;
+exports.templateLiteral = templateLiteral;

package/dist/cjs/validators/tuple.cjs

@@ -0,0 +1,187 @@
+'use strict';
+
+var validators_base = require('./base.cjs');
+var locales_runtime = require('../locales/runtime.cjs');
+var errorsCore = require('../chunks/errors-core-DWxLFs2f.cjs');
+require('../registry.cjs');
+require('../locales/en.cjs');
+
+function createTupleError(message) {
+    return new errorsCore.VldError([{ code: 'invalid_array', path: [], message }]);
+}
+/**
+ * Immutable tuple validator for fixed-length arrays
+ */
+class VldTuple extends validators_base.VldBase {
+    constructor(validators, errorMessage) {
+        super(validators_base.VLD_VALIDATOR_TYPES.TUPLE);
+        this.validators = validators;
+        this.errorMessage = errorMessage;
+        this._length = validators.length;
+        this._validatorTypes = validators.map(validator => validator.validatorType);
+        this._simpleItemModes = validators.map((validator, index) => this.getSimpleItemMode(validator, this._validatorTypes[index]));
+        this._simpleItemValues = validators.map((validator, index) => this._simpleItemModes[index] === 'literal' ? validator.literal : undefined);
+    }
+    get items() {
+        return this.validators;
+    }
+    getSimpleItemMode(validator, type) {
+        if (validator.isSimple !== true) {
+            return undefined;
+        }
+        switch (type) {
+            case validators_base.VLD_VALIDATOR_TYPES.STRING:
+                return 'string';
+            case validators_base.VLD_VALIDATOR_TYPES.NUMBER:
+                return 'number';
+            case validators_base.VLD_VALIDATOR_TYPES.BOOLEAN:
+                return 'boolean';
+            case validators_base.VLD_VALIDATOR_TYPES.BIGINT:
+                return 'bigint';
+            case validators_base.VLD_VALIDATOR_TYPES.SYMBOL:
+                return 'symbol';
+            case validators_base.VLD_VALIDATOR_TYPES.NULL:
+                return 'null';
+            case validators_base.VLD_VALIDATOR_TYPES.UNDEFINED:
+            case validators_base.VLD_VALIDATOR_TYPES.VOID:
+                return 'undefinedValue';
+            case validators_base.VLD_VALIDATOR_TYPES.LITERAL:
+                return 'literal';
+            case validators_base.VLD_VALIDATOR_TYPES.ANY:
+            case validators_base.VLD_VALIDATOR_TYPES.UNKNOWN:
+                return 'passthrough';
+            default:
+                return undefined;
+        }
+    }
+    getSimpleItemError(mode, expected, received) {
+        switch (mode) {
+            case 'string':
+                return locales_runtime.getMessages().invalidString;
+            case 'number':
+                return locales_runtime.getMessages().invalidNumber;
+            case 'boolean':
+                return locales_runtime.getMessages().invalidBoolean;
+            case 'bigint':
+                return locales_runtime.getMessages().invalidBigint;
+            case 'symbol':
+                return locales_runtime.getMessages().invalidSymbol;
+            case 'null':
+                return `Expected null, received ${typeof received}`;
+            case 'undefinedValue':
+                return locales_runtime.getMessages().expectedUndefined;
+            case 'literal':
+                return locales_runtime.getMessages().literalExpected(JSON.stringify(expected), JSON.stringify(received));
+            default:
+                return locales_runtime.getMessages().invalidTuple;
+        }
+    }
+    /**
+     * Create a new tuple validator
+     */
+    static create(...validators) {
+        return new VldTuple(validators);
+    }
+    /**
+     * Parse and validate a tuple value
+     */
+    parse(value) {
+        if (!Array.isArray(value)) {
+            throw new Error(this.errorMessage || locales_runtime.getMessages().invalidTuple);
+        }
+        return this.parseKnownTuple(value);
+    }
+    /**
+     * Parse a value that has already passed the tuple array type guard.
+     * @internal Used by object validators to avoid duplicate hot-path checks.
+     */
+    parseKnownTuple(value) {
+        if (value.length !== this._length) {
+            throw new Error(this.errorMessage ||
+                locales_runtime.getMessages().tupleLength(this._length, value.length));
+        }
+        const result = new Array(this._length);
+        for (let i = 0; i < this._length; i++) {
+            const simpleMode = this._simpleItemModes[i];
+            const item = value[i];
+            if (simpleMode !== undefined) {
+                switch (simpleMode) {
+                    case 'string':
+                        if (typeof item !== 'string') {
+                            throw new Error(locales_runtime.getMessages().arrayItem(i, locales_runtime.getMessages().invalidString));
+                        }
+                        result[i] = item;
+                        continue;
+                    case 'number':
+                        if (typeof item !== 'number' || isNaN(item)) {
+                            throw new Error(locales_runtime.getMessages().arrayItem(i, locales_runtime.getMessages().invalidNumber));
+                        }
+                        result[i] = item;
+                        continue;
+                    case 'boolean':
+                        if (typeof item !== 'boolean') {
+                            throw new Error(locales_runtime.getMessages().arrayItem(i, locales_runtime.getMessages().invalidBoolean));
+                        }
+                        result[i] = item;
+                        continue;
+                    case 'bigint':
+                        if (typeof item !== 'bigint') {
+                            throw new Error(locales_runtime.getMessages().arrayItem(i, locales_runtime.getMessages().invalidBigint));
+                        }
+                        result[i] = item;
+                        continue;
+                    case 'symbol':
+                        if (typeof item !== 'symbol') {
+                            throw new Error(locales_runtime.getMessages().arrayItem(i, locales_runtime.getMessages().invalidSymbol));
+                        }
+                        result[i] = item;
+                        continue;
+                    case 'null':
+                        if (item !== null) {
+                            throw new Error(locales_runtime.getMessages().arrayItem(i, this.getSimpleItemError(simpleMode, undefined, item)));
+                        }
+                        result[i] = null;
+                        continue;
+                    case 'undefinedValue':
+                        if (item !== undefined) {
+                            throw new Error(locales_runtime.getMessages().arrayItem(i, locales_runtime.getMessages().expectedUndefined));
+                        }
+                        result[i] = undefined;
+                        continue;
+                    case 'literal': {
+                        const literal = this._simpleItemValues[i];
+                        if (item !== literal) {
+                            throw new Error(locales_runtime.getMessages().arrayItem(i, this.getSimpleItemError(simpleMode, literal, item)));
+                        }
+                        result[i] = literal;
+                        continue;
+                    }
+                    case 'passthrough':
+                        result[i] = item;
+                        continue;
+                }
+            }
+            try {
+                const validator = this.validators[i];
+                result[i] = validator.parse(item);
+            }
+            catch (error) {
+                throw new Error(locales_runtime.getMessages().arrayItem(i, error.message));
+            }
+        }
+        return result;
+    }
+    /**
+     * Safely parse and validate a tuple value
+     */
+    safeParse(value) {
+        try {
+            return { success: true, data: this.parse(value) };
+        }
+        catch (error) {
+            return { success: false, error: createTupleError(error.message) };
+        }
+    }
+}
+
+exports.VldTuple = VldTuple;

package/dist/cjs/validators/uint8array.cjs

@@ -0,0 +1,106 @@
+'use strict';
+
+var validators_base = require('./base.cjs');
+var errors = require('../errors.cjs');
+var locales_runtime = require('../locales/runtime.cjs');
+var errorsCore = require('../chunks/errors-core-DWxLFs2f.cjs');
+require('../registry.cjs');
+require('../pigment.cjs');
+require('../locales/en.cjs');
+
+/**
+ * Uint8Array validator with immutable configuration
+ * BUG-NEW-010 FIX: Refactored to follow immutability pattern
+ */
+class VldUint8Array extends validators_base.VldBase {
+    /**
+     * Protected constructor to maintain immutability
+     */
+    constructor(config) {
+        super(validators_base.VLD_VALIDATOR_TYPES.UINT8_ARRAY);
+        this.config = config || {};
+    }
+    parse(value) {
+        const result = this.safeParse(value);
+        if (!result.success) {
+            throw result.error;
+        }
+        return result.data;
+    }
+    safeParse(value) {
+        if (!(value instanceof Uint8Array)) {
+            return {
+                success: false,
+                error: new errorsCore.VldError([
+                    errors.createIssue('invalid_type', [], locales_runtime.getMessages().expectedUint8Array)
+                ])
+            };
+        }
+        // Check exact length if specified
+        if (this.config.exactLength !== undefined && value.length !== this.config.exactLength) {
+            return {
+                success: false,
+                error: new errorsCore.VldError([
+                    errors.createIssue('custom', [], locales_runtime.getMessages().uint8ArrayExactLength(this.config.exactLength))
+                ])
+            };
+        }
+        // Check minimum length
+        if (this.config.minLength !== undefined && value.length < this.config.minLength) {
+            return {
+                success: false,
+                error: new errorsCore.VldError([
+                    errors.createIssue('custom', [], locales_runtime.getMessages().uint8ArrayMinLength(this.config.minLength))
+                ])
+            };
+        }
+        // Check maximum length
+        if (this.config.maxLength !== undefined && value.length > this.config.maxLength) {
+            return {
+                success: false,
+                error: new errorsCore.VldError([
+                    errors.createIssue('custom', [], locales_runtime.getMessages().uint8ArrayMaxLength(this.config.maxLength))
+                ])
+            };
+        }
+        return { success: true, data: value };
+    }
+    /**
+     * Set minimum byte length
+     * Returns new immutable validator instance
+     */
+    min(length) {
+        return new VldUint8Array({
+            ...this.config,
+            minLength: length
+        });
+    }
+    /**
+     * Set maximum byte length
+     * Returns new immutable validator instance
+     */
+    max(length) {
+        return new VldUint8Array({
+            ...this.config,
+            maxLength: length
+        });
+    }
+    /**
+     * Set exact byte length
+     * Returns new immutable validator instance
+     * Clears min/max when setting exact length
+     */
+    length(length) {
+        return new VldUint8Array({
+            exactLength: length,
+            // Clear min/max when exact length is set
+            minLength: undefined,
+            maxLength: undefined
+        });
+    }
+    static create() {
+        return new VldUint8Array();
+    }
+}
+
+exports.VldUint8Array = VldUint8Array;

package/dist/cjs/validators/undefined.cjs

@@ -0,0 +1,43 @@
+'use strict';
+
+var validators_base = require('./base.cjs');
+var errorsCore = require('../chunks/errors-core-DWxLFs2f.cjs');
+require('../registry.cjs');
+
+/**
+ * VldUndefined - Validates that a value is exactly undefined
+ * Part of Zod 4 API parity implementation
+ */
+function createUndefinedError(message) {
+    return new errorsCore.VldError([{ code: 'invalid_type', path: [], message }]);
+}
+/**
+ * Undefined validator - validates that a value is exactly undefined
+ */
+class VldUndefined extends validators_base.VldBase {
+    constructor() {
+        super(validators_base.VLD_VALIDATOR_TYPES.UNDEFINED);
+    }
+    static create() {
+        return new VldUndefined();
+    }
+    get isSimple() {
+        return true;
+    }
+    parse(value) {
+        if (value !== undefined) {
+            throw new Error(`Expected undefined, received ${typeof value}`);
+        }
+        return undefined;
+    }
+    safeParse(value) {
+        try {
+            return { success: true, data: this.parse(value) };
+        }
+        catch (error) {
+            return { success: false, error: createUndefinedError(error.message) };
+        }
+    }
+}
+
+exports.VldUndefined = VldUndefined;