@oxog/vld 2.0.3 → 2.2.5

package/dist/validators/base.d.ts

@@ -1,3 +1,4 @@
+import type { SchemaRegistry } from '../registry.js';
 /**
  * Base result type for validation
  */
@@ -8,6 +9,108 @@ export type ParseResult<T> = {
     readonly success: false;
     readonly error: Error;
 };
+export interface StandardTypedV1<Input = unknown, Output = Input> {
+    readonly '~standard': StandardTypedV1Props<Input, Output>;
+}
+export interface StandardTypedV1Props<Input = unknown, Output = Input> {
+    readonly version: 1;
+    readonly vendor: string;
+    readonly types?: StandardTypedV1Types<Input, Output> | undefined;
+}
+export interface StandardTypedV1Types<Input = unknown, Output = Input> {
+    readonly input: Input;
+    readonly output: Output;
+}
+export interface StandardSchemaV1<Input = unknown, Output = Input> extends StandardTypedV1<Input, Output> {
+    readonly '~standard': StandardSchemaV1Props<Input, Output>;
+}
+export interface StandardSchemaV1Props<Input = unknown, Output = Input> extends StandardTypedV1Props<Input, Output> {
+    readonly validate: (value: unknown, options?: StandardSchemaV1Options | undefined) => StandardSchemaV1Result<Output> | Promise<StandardSchemaV1Result<Output>>;
+}
+export interface StandardSchemaV1Options {
+    readonly libraryOptions?: Record<string, unknown> | undefined;
+}
+export type StandardSchemaV1Result<Output> = StandardSchemaV1SuccessResult<Output> | StandardSchemaV1FailureResult;
+export interface StandardSchemaV1SuccessResult<Output> {
+    readonly value: Output;
+    readonly issues?: undefined;
+}
+export interface StandardSchemaV1FailureResult {
+    readonly issues: ReadonlyArray<StandardSchemaV1Issue>;
+}
+export interface StandardSchemaV1Issue {
+    readonly message: string;
+    readonly path?: ReadonlyArray<PropertyKey | StandardSchemaV1PathSegment> | undefined;
+}
+export interface StandardSchemaV1PathSegment {
+    readonly key: PropertyKey;
+}
+/**
+ * Validator type constants for O(1) dispatch
+ * Used by VldObject to replace instanceof chains with Map lookups
+ */
+export declare const VLD_VALIDATOR_TYPES: {
+    readonly STRING: "string";
+    readonly STRING_FORMAT: "stringFormat";
+    readonly STRING_BOOL: "stringBool";
+    readonly NUMBER: "number";
+    readonly BOOLEAN: "boolean";
+    readonly DATE: "date";
+    readonly BIGINT: "bigint";
+    readonly UNDEFINED: "undefined";
+    readonly NULL: "null";
+    readonly UNKNOWN: "unknown";
+    readonly ANY: "any";
+    readonly VOID: "void";
+    readonly NEVER: "never";
+    readonly SYMBOL: "symbol";
+    readonly NAN: "nan";
+    readonly HEX: "hex";
+    readonly BASE64: "base64";
+    readonly UINT8_ARRAY: "uint8Array";
+    readonly COERCE_STRING: "coerceString";
+    readonly COERCE_NUMBER: "coerceNumber";
+    readonly COERCE_BOOLEAN: "coerceBoolean";
+    readonly COERCE_DATE: "coerceDate";
+    readonly COERCE_BIGINT: "coerceBigint";
+    readonly OBJECT: "object";
+    readonly ARRAY: "array";
+    readonly TUPLE: "tuple";
+    readonly SET: "set";
+    readonly MAP: "map";
+    readonly RECORD: "record";
+    readonly UNION: "union";
+    readonly DISCRIMINATED_UNION: "discriminatedUnion";
+    readonly INTERSECTION: "intersection";
+    readonly XOR: "xor";
+    readonly ENUM: "enum";
+    readonly LITERAL: "literal";
+    readonly LAZY: "lazy";
+    readonly CUSTOM: "custom";
+    readonly FUNCTION: "function";
+    readonly FILE: "file";
+    readonly JSON: "json";
+    readonly TEMPLATE_LITERAL: "templateLiteral";
+    readonly PROMISE: "promise";
+    readonly OPTIONAL: "optional";
+    readonly NULLABLE: "nullable";
+    readonly NULLISH: "nullish";
+    readonly EXACT_OPTIONAL: "exactOptional";
+    readonly DEFAULT: "default";
+    readonly CATCH: "catch";
+    readonly REFINE: "refine";
+    readonly TRANSFORM: "transform";
+    readonly PIPE: "pipe";
+    readonly PREPROCESS: "preprocess";
+    readonly SUPER_REFINE: "superRefine";
+    readonly BRAND: "brand";
+    readonly READONLY: "readonly";
+    readonly META: "meta";
+    readonly PREFAULT: "prefault";
+    readonly PREFault: "prefault";
+    readonly CODEC: "codec";
+};
+export type ValidatorType = typeof VLD_VALIDATOR_TYPES[keyof typeof VLD_VALIDATOR_TYPES];
 /**
  * Context for superRefine - allows adding multiple issues
  */
@@ -18,11 +121,53 @@ export interface SuperRefineContext {
     }): void;
     path: (string | number)[];
 }
+export interface CheckPayload<T> {
+    value: T;
+    issues: Array<{
+        message?: string;
+        code?: string;
+    }>;
+    aborted?: boolean;
+}
+export type VldCheck<T> = ((payload: CheckPayload<T>) => void | Promise<void>) | {
+    _zod?: {
+        check?: (payload: CheckPayload<T>) => void | Promise<void>;
+    };
+};
+export type ErrorMap = (issue: {
+    code?: string;
+    input?: unknown;
+    path?: (string | number)[];
+}) => string | undefined;
+export type ErrorParam = string | {
+    error?: string | ErrorMap;
+    message?: string;
+};
+export declare function resolveErrorMessage(error: ErrorParam | undefined, fallback: string): string;
+type ValueOrFactory<T> = T | (() => T);
+interface SchemaCompositionFactories {
+    array<TInput, TOutput>(schema: VldBase<TInput, TOutput>): VldBase<unknown[], TOutput[]>;
+    union<TInput, TOutput, TNext>(left: VldBase<TInput, TOutput>, right: VldBase<any, TNext>): VldBase<unknown, TOutput | TNext>;
+    intersection<TInput, TOutput, TNext>(left: VldBase<TInput, TOutput>, right: VldBase<any, TNext>): VldBase<unknown, TOutput & TNext>;
+    toJSONSchema(schema: VldBase<any, any>, options?: unknown): unknown;
+}
+export declare function configureSchemaCompositionFactories(factories: SchemaCompositionFactories): void;
 /**
  * Abstract base class for all validators
  * Implements immutable pattern to prevent memory leaks and race conditions
  */
 export declare abstract class VldBase<TInput, TOutput = TInput> {
+    /**
+     * Runtime type identifier for O(1) dispatch
+     * Used by VldObject instead of instanceof chains
+     */
+    readonly validatorType: ValidatorType;
+    /**
+     * Constructor with runtime type identifier
+     * @param validatorType The runtime type identifier
+     */
+    constructor(validatorType?: ValidatorType);
+    get '~standard'(): StandardSchemaV1Props<unknown, TOutput>;
     /**
      * Parse and validate a value, throwing an error if invalid
      * @param value The value to validate
@@ -36,6 +181,28 @@ export declare abstract class VldBase<TInput, TOutput = TInput> {
      * @returns A result object with either success and data, or failure and error
      */
     abstract safeParse(value: unknown): ParseResult<TOutput>;
+    parseAsync(value: unknown): Promise<TOutput>;
+    safeParseAsync(value: unknown): Promise<ParseResult<TOutput>>;
+    /** Strongly typed forward parse aliases from the Zod 4 codec API. */
+    decode(value: TInput): TOutput;
+    safeDecode(value: TInput): ParseResult<TOutput>;
+    decodeAsync(value: TInput): Promise<TOutput>;
+    safeDecodeAsync(value: TInput): Promise<ParseResult<TOutput>>;
+    /**
+     * Backward parse aliases. Primitive and validation-only schemas are
+     * bidirectional; codecs override these methods with their inverse transform.
+     */
+    encode(value: TOutput): TInput;
+    safeEncode(value: TOutput): ParseResult<TInput>;
+    encodeAsync(value: TOutput): Promise<TInput>;
+    safeEncodeAsync(value: TOutput): Promise<ParseResult<TInput>>;
+    /** Zod's short alias for safeParseAsync. */
+    spa(value: unknown): Promise<ParseResult<TOutput>>;
+    /** Compatibility helpers retained by Zod 4. */
+    isOptional(): boolean;
+    isNullable(): boolean;
+    /** VLD validators are immutable, so cloning can safely share the instance. */
+    clone(): this;
     /**
      * Check if a value is valid according to this validator
      * @param value The value to check
@@ -57,7 +224,7 @@ export declare abstract class VldBase<TInput, TOutput = TInput> {
      * @returns A new refined validator
      */
     refine<TRefined extends TOutput>(predicate: (value: TOutput) => value is TRefined, message?: string): VldRefine<TInput, TOutput, TRefined>;
-    refine(predicate: (value: TOutput) => boolean, message?: string): VldRefine<TInput, TOutput, TOutput>;
+    refine(predicate: (value: TOutput) => boolean | Promise<boolean>, message?: string): VldRefine<TInput, TOutput, TOutput>;
     /**
      * Advanced refinement with context for adding multiple issues
      * @param refinement The refinement function with context
@@ -69,13 +236,22 @@ export declare abstract class VldBase<TInput, TOutput = TInput> {
      * @param transformer The transformation function
      * @returns A new transformed validator
      */
-    transform<TTransformed>(transformer: (value: TOutput) => TTransformed): VldTransform<TInput, TOutput, TTransformed>;
+    transform<TTransformed>(transformer: (value: TOutput) => TTransformed | Promise<TTransformed>): VldTransform<TInput, TOutput, TTransformed>;
     /**
      * Create a new validator with a default value for undefined inputs
      * @param defaultValue The default value
      * @returns A new validator with default
      */
-    default(defaultValue: TOutput): VldDefault<TInput, TOutput>;
+    default(defaultValue: ValueOrFactory<TOutput>): VldDefault<TInput, TOutput>;
+    /** Provide an input value before parsing when the input is undefined. */
+    prefault(defaultValue: ValueOrFactory<TInput>): VldPrefault<TInput, TOutput>;
+    nonoptional(message?: ErrorParam): VldRefine<TInput, TOutput, TOutput>;
+    array(): VldBase<unknown[], TOutput[]>;
+    or<TNext>(option: VldBase<any, TNext>): VldBase<unknown, TOutput | TNext>;
+    and<TNext>(incoming: VldBase<any, TNext>): VldBase<unknown, TOutput & TNext>;
+    overwrite(transformer: (value: TOutput) => TOutput): VldTransform<TInput, TOutput, TOutput>;
+    with(...checks: VldCheck<TOutput>[]): VldSuperRefine<TInput, TOutput>;
+    toJSONSchema(options?: unknown): unknown;
     /**
      * Create a new validator that catches errors and returns a fallback
      * @param fallbackValue The fallback value
@@ -110,7 +286,7 @@ export declare abstract class VldBase<TInput, TOutput = TInput> {
      * @param next The next validator to pipe into
      * @returns A new piped validator
      */
-    pipe<TNextOutput>(next: VldBase<TOutput, TNextOutput>): VldPipe<TInput, TOutput, TNextOutput>;
+    pipe<TNextOutput>(next: VldBase<any, TNextOutput>): VldPipe<TInput, TOutput, TNextOutput>;
     /**
      * Create a new validator that returns readonly output
      * Zod 4 API parity - marks output as readonly for TypeScript
@@ -140,7 +316,7 @@ export declare abstract class VldBase<TInput, TOutput = TInput> {
      * const withLength = (schema: VldBase<unknown, string>) => schema.transform(s => s.length);
      * const lengthSchema = v.string().apply(withLength); // validates string, returns number
      */
-    apply<TNewOutput>(fn: (schema: this) => VldBase<TInput, TNewOutput>): VldBase<TInput, TNewOutput>;
+    apply<TResult>(fn: (schema: this) => TResult): TResult;
     /**
      * Create a new validator that refines this one with a custom predicate
      * Alias for refine() - check() is the Zod 4 API name
@@ -149,7 +325,7 @@ export declare abstract class VldBase<TInput, TOutput = TInput> {
      * @returns A new refined validator
      */
     check<TRefined extends TOutput>(predicate: (value: TOutput) => value is TRefined, message?: string): VldRefine<TInput, TOutput, TRefined>;
-    check(predicate: (value: TOutput) => boolean, message?: string): VldRefine<TInput, TOutput, TOutput>;
+    check(predicate: (value: TOutput) => boolean | Promise<boolean>, message?: string): VldRefine<TInput, TOutput, TOutput>;
     /**
      * Get metadata for this schema
      * Zod 4 API parity - allows attaching OpenAPI/JSON Schema metadata
@@ -163,6 +339,12 @@ export declare abstract class VldBase<TInput, TOutput = TInput> {
      * @returns A new validator with the metadata
      */
     meta(data: Partial<SchemaMetadata>): VldMeta<TInput, TOutput>;
+    /**
+     * Register this schema in a metadata registry and return the same instance.
+     * This mirrors Zod 4's registry convenience API without changing validator
+     * immutability.
+     */
+    register<TMetadata extends Record<string, unknown>>(targetRegistry: SchemaRegistry<TMetadata>, metadata: TMetadata): this;
     /**
      * Add a description to this schema
      * Zod 4 API parity - convenience method for .meta({ description: ... })
@@ -170,6 +352,7 @@ export declare abstract class VldBase<TInput, TOutput = TInput> {
      * @returns A new validator with the description
      */
     describe(description: string): VldMeta<TInput, TOutput>;
+    get description(): string | undefined;
 }
 /**
  * Schema metadata interface for OpenAPI/JSON Schema compatibility
@@ -198,6 +381,9 @@ export declare class VldMeta<TInput, TOutput> extends VldBase<TInput, TOutput> {
      * Get the metadata
      */
     getMeta(): Readonly<Partial<SchemaMetadata>>;
+    meta(): SchemaMetadata | undefined;
+    meta(data: Partial<SchemaMetadata>): VldMeta<TInput, TOutput>;
+    describe(description: string): VldMeta<TInput, TOutput>;
 }
 /**
  * Readonly validator - marks output as readonly
@@ -231,9 +417,10 @@ export declare class VldRefine<TInput, TBase, TOutput extends TBase = TBase> ext
     private readonly baseValidator;
     private readonly predicate;
     private readonly customMessage?;
-    constructor(baseValidator: VldBase<TInput, TBase>, predicate: (value: TBase) => boolean, customMessage?: string | undefined);
+    constructor(baseValidator: VldBase<TInput, TBase>, predicate: (value: TBase) => boolean | Promise<boolean>, customMessage?: string | undefined);
     parse(value: unknown): TOutput;
     safeParse(value: unknown): ParseResult<TOutput>;
+    parseAsync(value: unknown): Promise<TOutput>;
 }
 /**
  * Transform validator - transforms data after validation
@@ -241,9 +428,10 @@ export declare class VldRefine<TInput, TBase, TOutput extends TBase = TBase> ext
 export declare class VldTransform<TInput, TBase, TOutput> extends VldBase<TInput, TOutput> {
     private readonly baseValidator;
     private readonly transformer;
-    constructor(baseValidator: VldBase<TInput, TBase>, transformer: (value: TBase) => TOutput);
+    constructor(baseValidator: VldBase<TInput, TBase>, transformer: (value: TBase) => TOutput | Promise<TOutput>);
     parse(value: unknown): TOutput;
     safeParse(value: unknown): ParseResult<TOutput>;
+    parseAsync(value: unknown): Promise<TOutput>;
 }
 /**
  * Default validator - provides default value for undefined
@@ -253,14 +441,16 @@ export declare class VldTransform<TInput, TBase, TOutput> extends VldBase<TInput
 export declare class VldDefault<TInput, TOutput> extends VldBase<TInput | undefined, TOutput> {
     private readonly baseValidator;
     private readonly defaultValue;
-    constructor(baseValidator: VldBase<TInput, TOutput>, defaultValue: TOutput);
+    constructor(baseValidator: VldBase<TInput, TOutput>, defaultValue: ValueOrFactory<TOutput>);
     parse(value: unknown): TOutput;
     safeParse(value: unknown): ParseResult<TOutput>;
     /**
      * Pre-parse default - validates the default value instead of returning it directly
      * This is useful when the default value needs to be validated against the schema
      */
-    prefault(): VldPrefault<TInput, TOutput>;
+    prefault(defaultValue?: ValueOrFactory<TInput>): VldPrefault<TInput, TOutput>;
+    unwrap(): VldBase<TInput, TOutput>;
+    removeDefault(): VldBase<TInput, TOutput>;
 }
 /**
  * Prefault validator - validates the default value instead of returning it directly
@@ -268,13 +458,14 @@ export declare class VldDefault<TInput, TOutput> extends VldBase<TInput | undefi
 export declare class VldPrefault<TInput, TOutput> extends VldBase<TInput | undefined, TOutput> {
     private readonly baseValidator;
     private readonly defaultValue;
-    constructor(baseValidator: VldBase<TInput, TOutput>, defaultValue: TOutput);
+    constructor(baseValidator: VldBase<TInput, TOutput>, defaultValue: ValueOrFactory<TInput>);
     parse(value: unknown): TOutput;
     safeParse(value: unknown): ParseResult<TOutput>;
     /**
      * Calling prefault multiple times should be safe - return self
      */
-    prefault(): VldPrefault<TInput, TOutput>;
+    prefault(defaultValue?: ValueOrFactory<TInput>): VldPrefault<TInput, TOutput>;
+    unwrap(): VldBase<TInput, TOutput>;
 }
 /**
  * Catch validator - provides fallback value on validation error
@@ -283,6 +474,7 @@ export declare class VldPrefault<TInput, TOutput> extends VldBase<TInput | undef
 export declare class VldCatch<TInput, TOutput> extends VldBase<TInput, TOutput> {
     private readonly baseValidator;
     private readonly fallbackValue;
+    private readonly simpleMode;
     constructor(baseValidator: VldBase<TInput, TOutput>, fallbackValue: TOutput);
     parse(value: unknown): TOutput;
     safeParse(value: unknown): ParseResult<TOutput>;
@@ -292,7 +484,9 @@ export declare class VldCatch<TInput, TOutput> extends VldBase<TInput, TOutput>
  */
 export declare class VldOptional<TInput, TOutput> extends VldBase<TInput | undefined, TOutput | undefined> {
     private readonly baseValidator;
+    private readonly simpleMode;
     constructor(baseValidator: VldBase<TInput, TOutput>);
+    private parseSimpleValue;
     static create<TInput, TOutput>(baseValidator: VldBase<TInput, TOutput>): VldOptional<TInput, TOutput>;
     parse(value: unknown): TOutput | undefined;
     safeParse(value: unknown): ParseResult<TOutput | undefined>;
@@ -306,6 +500,7 @@ export declare class VldOptional<TInput, TOutput> extends VldBase<TInput | undef
  */
 export declare class VldExactOptional<TInput, TOutput> extends VldBase<TInput | undefined, TOutput | undefined> {
     private readonly baseValidator;
+    private readonly simpleMode;
     constructor(baseValidator: VldBase<TInput, TOutput>);
     static create<TInput, TOutput>(baseValidator: VldBase<TInput, TOutput>): VldExactOptional<TInput, TOutput>;
     parse(value: unknown): TOutput | undefined;
@@ -317,6 +512,7 @@ export declare class VldExactOptional<TInput, TOutput> extends VldBase<TInput |
  */
 export declare class VldNullable<TInput, TOutput> extends VldBase<TInput | null, TOutput | null> {
     private readonly baseValidator;
+    private readonly simpleMode;
     constructor(baseValidator: VldBase<TInput, TOutput>);
     static create<TInput, TOutput>(baseValidator: VldBase<TInput, TOutput>): VldNullable<TInput, TOutput>;
     parse(value: unknown): TOutput | null;
@@ -328,6 +524,7 @@ export declare class VldNullable<TInput, TOutput> extends VldBase<TInput | null,
  */
 export declare class VldNullish<TInput, TOutput> extends VldBase<TInput | null | undefined, TOutput | null | undefined> {
     private readonly baseValidator;
+    private readonly simpleMode;
     constructor(baseValidator: VldBase<TInput, TOutput>);
     static create<TInput, TOutput>(baseValidator: VldBase<TInput, TOutput>): VldNullish<TInput, TOutput>;
     parse(value: unknown): TOutput | null | undefined;
@@ -340,7 +537,7 @@ export declare class VldNullish<TInput, TOutput> extends VldBase<TInput | null |
 export declare class VldPipe<TInput, TIntermediate, TOutput> extends VldBase<TInput, TOutput> {
     private readonly first;
     private readonly second;
-    constructor(first: VldBase<TInput, TIntermediate>, second: VldBase<TIntermediate, TOutput>);
+    constructor(first: VldBase<TInput, TIntermediate>, second: VldBase<any, TOutput>);
     parse(value: unknown): TOutput;
     safeParse(value: unknown): ParseResult<TOutput>;
 }
@@ -353,6 +550,8 @@ export declare class VldSuperRefine<TInput, TOutput> extends VldBase<TInput, TOu
     constructor(_inner: VldBase<TInput, TOutput>, _refinement: (value: TOutput, ctx: SuperRefineContext) => void | Promise<void>);
     parse(value: unknown): TOutput;
     safeParse(value: unknown): ParseResult<TOutput>;
+    parseAsync(value: unknown): Promise<TOutput>;
+    safeParseAsync(value: unknown): Promise<ParseResult<TOutput>>;
 }
 /**
  * Preprocess validator - transforms input before validation
@@ -365,4 +564,4 @@ export declare class VldPreprocess<TInput, TOutput> extends VldBase<unknown, TOu
     parse(value: unknown): TOutput;
     safeParse(value: unknown): ParseResult<TOutput>;
 }
-//# sourceMappingURL=base.d.ts.map
+export {};

package/dist/validators/base.js

@@ -0,0 +1 @@
+import{globalRegistry as e}from"../registry.js";const s={STRING:"string",STRING_FORMAT:"stringFormat",STRING_BOOL:"stringBool",NUMBER:"number",BOOLEAN:"boolean",DATE:"date",BIGINT:"bigint",UNDEFINED:"undefined",NULL:"null",UNKNOWN:"unknown",ANY:"any",VOID:"void",NEVER:"never",SYMBOL:"symbol",NAN:"nan",HEX:"hex",BASE64:"base64",UINT8_ARRAY:"uint8Array",COERCE_STRING:"coerceString",COERCE_NUMBER:"coerceNumber",COERCE_BOOLEAN:"coerceBoolean",COERCE_DATE:"coerceDate",COERCE_BIGINT:"coerceBigint",OBJECT:"object",ARRAY:"array",TUPLE:"tuple",SET:"set",MAP:"map",RECORD:"record",UNION:"union",DISCRIMINATED_UNION:"discriminatedUnion",INTERSECTION:"intersection",XOR:"xor",ENUM:"enum",LITERAL:"literal",LAZY:"lazy",CUSTOM:"custom",FUNCTION:"function",FILE:"file",JSON:"json",TEMPLATE_LITERAL:"templateLiteral",PROMISE:"promise",OPTIONAL:"optional",NULLABLE:"nullable",NULLISH:"nullish",EXACT_OPTIONAL:"exactOptional",DEFAULT:"default",CATCH:"catch",REFINE:"refine",TRANSFORM:"transform",PIPE:"pipe",PREPROCESS:"preprocess",SUPER_REFINE:"superRefine",BRAND:"brand",READONLY:"readonly",META:"meta",PREFAULT:"prefault",PREFault:"prefault",CODEC:"codec"};function r(e,s){return"string"==typeof e?e:"string"==typeof e?.error?e.error:"function"==typeof e?.error?e.error({})||s:"string"==typeof e?.message?e.message:s}function t(e){return null!==e&&("object"==typeof e||"function"==typeof e)&&"function"==typeof e.then}let a;function n(e){a=e}function i(e){return"function"==typeof e?e():function(e){if(Array.isArray(e))return[...e];if(e instanceof Map)return new Map(e);if(e instanceof Set)return new Set(e);if(null!==e&&"object"==typeof e){const s=Object.getPrototypeOf(e);if(s===Object.prototype||null===s)return{...e}}return e}(e)}function o(e){if(!0===e.isSimple)switch(e.validatorType){case s.STRING:return"string";case s.NUMBER:return"number";case s.BOOLEAN:return"boolean";case s.BIGINT:return"bigint";case s.SYMBOL:return"symbol";default:return}}function c(e,s){switch(e){case"string":return"string"==typeof s?s:void 0;case"number":return"number"!=typeof s||isNaN(s)?void 0:s;case"boolean":return"boolean"==typeof s?s:void 0;case"bigint":return"bigint"==typeof s?s:void 0;case"symbol":return"symbol"==typeof s?s:void 0;default:return}}class VldBase{constructor(e="unknown"){this.validatorType=e}get"~standard"(){return{version:1,vendor:"vld",validate:e=>{const s=this.safeParse(e);return s.success?{value:s.data}:{issues:[{message:s.error.message}]}},types:void 0}}async parseAsync(e){return this.parse(e)}async safeParseAsync(e){try{return{success:!0,data:await this.parseAsync(e)}}catch(e){return{success:!1,error:e}}}decode(e){return this.parse(e)}safeDecode(e){return this.safeParse(e)}async decodeAsync(e){return this.parseAsync(e)}async safeDecodeAsync(e){return this.safeParseAsync(e)}encode(e){return this.parse(e)}safeEncode(e){const s=this.safeParse(e);return s.success?{success:!0,data:s.data}:s}async encodeAsync(e){return this.parseAsync(e)}async safeEncodeAsync(e){const s=await this.safeParseAsync(e);return s.success?{success:!0,data:s.data}:s}spa(e){return this.safeParseAsync(e)}isOptional(){return this.safeParse(void 0).success}isNullable(){return this.safeParse(null).success}clone(){return this}isValid(e){return this.safeParse(e).success}parseOrDefault(e,s){const r=this.safeParse(e);if(r.success)return r.data;const t=this.safeParse(s);if(!t.success)throw new Error(`Invalid default value provided: ${t.error.message}`);return t.data}refine(e,s){return new VldRefine(this,e,s)}superRefine(e){return new VldSuperRefine(this,e)}transform(e){return new VldTransform(this,e)}default(e){return new VldDefault(this,e)}prefault(e){return new VldPrefault(this,e)}nonoptional(e){return new VldRefine(this,e=>void 0!==e,r(e,"Expected non-optional value"))}array(){return a.array(this)}or(e){return a.union(this,e)}and(e){return a.intersection(this,e)}overwrite(e){return new VldTransform(this,e)}with(...e){return new VldSuperRefine(this,(s,r)=>{const a={value:s,issues:[]},n=[];for(const s of e){const e="function"==typeof s?s:s._zod?.check;if(!e)continue;const r=e(a);t(r)&&n.push(Promise.resolve(r))}const i=()=>{for(const e of a.issues)r.addIssue(void 0===e.code?{message:e.message||"Custom check failed"}:{message:e.message||"Custom check failed",code:e.code})};if(n.length>0)return Promise.all(n).then(i);i()})}toJSONSchema(e){return a.toJSONSchema(this,e)}catch(e){return new VldCatch(this,e)}optional(){return new VldOptional(this)}nullable(){return new VldNullable(this)}nullish(){return new VldNullish(this)}exactOptional(){return new VldExactOptional(this)}pipe(e){return new VldPipe(this,e)}readonly(){return new VldReadonly(this)}brand(){return new VldBrand(this)}apply(e){return e(this)}check(e,s){return new VldRefine(this,e,s)}meta(s){if(void 0===s)return e.get(this);const r=new VldMeta(this,s);return e.add(r,s),r}register(e,s){return e.add(this,s),this}describe(e){return this.meta({description:e})}get description(){return this.meta()?.description}}class VldMeta extends VldBase{constructor(e,r){super(s.META),this.baseValidator=e,this.metadata=r}parse(e){return this.baseValidator.parse(e)}safeParse(e){return this.baseValidator.safeParse(e)}getMeta(){return{...this.metadata}}meta(s){if(void 0===s)return{...this.metadata,...e.get(this)};const r=new VldMeta(this.baseValidator,{...this.metadata,...s});return e.add(r,r.getMeta()),r}describe(e){return this.meta({description:e})}}class VldReadonly extends VldBase{constructor(e){super(s.READONLY),this.baseValidator=e}parse(e){return this.baseValidator.parse(e)}safeParse(e){const s=this.baseValidator.safeParse(e);return s.success?{success:!0,data:s.data}:{success:!1,error:s.error}}}class VldBrand extends VldBase{constructor(e){super(s.BRAND),this.baseValidator=e}parse(e){return this.baseValidator.parse(e)}safeParse(e){const s=this.baseValidator.safeParse(e);return s.success?{success:!0,data:s.data}:{success:!1,error:s.error}}}class VldRefine extends VldBase{constructor(e,r,t){super(s.REFINE),this.baseValidator=e,this.predicate=r,this.customMessage=t}parse(e){const s=this.baseValidator.parse(e),r=this.predicate(s);if(t(r))throw new Error("Use parseAsync for async refinements");if(!r)throw new Error(this.customMessage||"Refinement check failed");return s}safeParse(e){try{return{success:!0,data:this.parse(e)}}catch(e){return{success:!1,error:e}}}async parseAsync(e){const s=await this.baseValidator.parseAsync(e);if(!await this.predicate(s))throw new Error(this.customMessage||"Refinement check failed");return s}}class VldTransform extends VldBase{constructor(e,r){super(s.TRANSFORM),this.baseValidator=e,this.transformer=r}parse(e){const s=this.baseValidator.parse(e);try{const e=this.transformer(s);if(t(e))throw new Error("Use parseAsync for async transforms");return e}catch(e){throw new Error(`Transform failed: ${e.message}`)}}safeParse(e){try{return{success:!0,data:this.parse(e)}}catch(e){return{success:!1,error:e}}}async parseAsync(e){const s=await this.baseValidator.parseAsync(e);try{return await this.transformer(s)}catch(e){throw new Error(`Transform failed: ${e.message}`)}}}class VldDefault extends VldBase{constructor(e,r){super(s.DEFAULT),this.baseValidator=e,this.defaultValue=r}parse(e){return void 0===e?i(this.defaultValue):this.baseValidator.parse(e)}safeParse(e){return void 0===e?{success:!0,data:i(this.defaultValue)}:this.baseValidator.safeParse(e)}prefault(e){return new VldPrefault(this.baseValidator,void 0===e?this.defaultValue:e)}unwrap(){return this.baseValidator}removeDefault(){return this.baseValidator}}class VldPrefault extends VldBase{constructor(e,r){super(s.PREFAULT),this.baseValidator=e,this.defaultValue=r}parse(e){return void 0===e?this.baseValidator.parse(i(this.defaultValue)):this.baseValidator.parse(e)}safeParse(e){return void 0===e?this.baseValidator.safeParse(i(this.defaultValue)):this.baseValidator.safeParse(e)}prefault(e){return void 0===e?this:new VldPrefault(this.baseValidator,e)}unwrap(){return this.baseValidator}}class VldCatch extends VldBase{constructor(e,r){super(s.CATCH),this.baseValidator=e,this.fallbackValue=r,this.simpleMode=o(e);const t=e.safeParse(r);if(!t.success)throw new Error(`Invalid fallback value: ${t.error.message}`)}parse(e){const s=c(this.simpleMode,e);if(void 0!==s)return s;if(void 0!==this.simpleMode)return this.fallbackValue;try{return this.baseValidator.parse(e)}catch{return this.fallbackValue}}safeParse(e){const s=c(this.simpleMode,e);if(void 0!==s)return{success:!0,data:s};if(void 0!==this.simpleMode)return{success:!0,data:this.fallbackValue};const r=this.baseValidator.safeParse(e);return r.success?r:{success:!0,data:this.fallbackValue}}}class VldOptional extends VldBase{constructor(e){super(s.OPTIONAL),this.baseValidator=e,this.simpleMode=o(e)}parseSimpleValue(e){return c(this.simpleMode,e)}static create(e){return new VldOptional(e)}parse(e){if(void 0===e)return;const s=this.parseSimpleValue(e);return void 0!==s?s:this.baseValidator.parse(e)}safeParse(e){if(void 0===e)return{success:!0,data:void 0};const s=this.parseSimpleValue(e);return void 0!==s?{success:!0,data:s}:this.baseValidator.safeParse(e)}unwrap(){return this.baseValidator}}class VldExactOptional extends VldBase{constructor(e){super(s.EXACT_OPTIONAL),this.baseValidator=e,this.simpleMode=o(e)}static create(e){return new VldExactOptional(e)}parse(e){if(void 0===e)return;const s=c(this.simpleMode,e);return void 0!==s?s:this.baseValidator.parse(e)}safeParse(e){if(void 0===e)return{success:!0,data:void 0};const s=c(this.simpleMode,e);return void 0!==s?{success:!0,data:s}:this.baseValidator.safeParse(e)}unwrap(){return this.baseValidator}}class VldNullable extends VldBase{constructor(e){super(s.NULLABLE),this.baseValidator=e,this.simpleMode=o(e)}static create(e){return new VldNullable(e)}parse(e){if(null===e)return null;const s=c(this.simpleMode,e);return void 0!==s?s:this.baseValidator.parse(e)}safeParse(e){if(null===e)return{success:!0,data:null};const s=c(this.simpleMode,e);return void 0!==s?{success:!0,data:s}:this.baseValidator.safeParse(e)}unwrap(){return this.baseValidator}}class VldNullish extends VldBase{constructor(e){super(s.NULLISH),this.baseValidator=e,this.simpleMode=o(e)}static create(e){return new VldNullish(e)}parse(e){if(null==e)return e;const s=c(this.simpleMode,e);return void 0!==s?s:this.baseValidator.parse(e)}safeParse(e){if(null==e)return{success:!0,data:e};const s=c(this.simpleMode,e);return void 0!==s?{success:!0,data:s}:this.baseValidator.safeParse(e)}unwrap(){return this.baseValidator}}class VldPipe extends VldBase{constructor(e,r){super(s.PIPE),this.first=e,this.second=r}parse(e){const s=this.first.parse(e);return this.second.parse(s)}safeParse(e){const s=this.first.safeParse(e);return s.success?this.second.safeParse(s.data):{success:!1,error:s.error}}}class VldSuperRefine extends VldBase{constructor(e,r){super(s.SUPER_REFINE),this._inner=e,this._refinement=r}parse(e){const s=this._inner.parse(e),r=[],t={addIssue:e=>r.push(e),path:[]};if(this._refinement(s,t)instanceof Promise)throw new Error("Use parseAsync for async refinements");if(r.length>0)throw new Error(r.map(e=>e.message).join("; "));return s}safeParse(e){const s=this._inner.safeParse(e);if(!s.success)return{success:!1,error:s.error};const r=[],t={addIssue:e=>r.push(e),path:[]};if(this._refinement(s.data,t)instanceof Promise)throw new Error("Use safeParseAsync for async refinements");return r.length>0?{success:!1,error:new Error(r.map(e=>e.message).join("; "))}:s}async parseAsync(e){const s=await this._inner.parseAsync(e),r=[],t={addIssue:e=>r.push(e),path:[]};if(await this._refinement(s,t),r.length>0)throw new Error(r.map(e=>e.message).join("; "));return s}async safeParseAsync(e){try{return{success:!0,data:await this.parseAsync(e)}}catch(e){return{success:!1,error:e}}}}class VldPreprocess extends VldBase{constructor(e,r){super(s.PREPROCESS),this._preprocessor=e,this._schema=r}static create(e,s){return new VldPreprocess(e,s)}parse(e){const s=this._preprocessor(e);return this._schema.parse(s)}safeParse(e){try{const s=this._preprocessor(e);return this._schema.safeParse(s)}catch(e){return{success:!1,error:e}}}}export{s as VLD_VALIDATOR_TYPES,VldBase,VldBrand,VldCatch,VldDefault,VldExactOptional,VldMeta,VldNullable,VldNullish,VldOptional,VldPipe,VldPrefault,VldPreprocess,VldReadonly,VldRefine,VldSuperRefine,VldTransform,n as configureSchemaCompositionFactories,r as resolveErrorMessage};

package/dist/validators/base64.d.ts

@@ -1,4 +1,4 @@
-import { VldBase, ParseResult } from './base';
+import { VldBase, ParseResult } from './base.js';
 /**
  * Base64 string validator
  */
@@ -15,4 +15,3 @@ export declare class VldBase64 extends VldBase<string, string> {
     urlSafeMode(): VldBase64;
     static create(urlSafe?: boolean): VldBase64;
 }
-//# sourceMappingURL=base64.d.ts.map

package/dist/validators/base64.js

@@ -0,0 +1 @@
+import{VldBase as e,VLD_VALIDATOR_TYPES as s}from"./base.js";import{createIssue as r}from"../errors.js";import{getMessages as t}from"../locales/runtime.js";import{V as a}from"../chunks/errors-core-Cqi4-9ew.js";class VldBase64 extends e{constructor(e=!1){super(s.BASE64),this.urlSafe=e}parse(e){const s=this.safeParse(e);if(!s.success)throw s.error;return s.data}safeParse(e){if("string"!=typeof e)return{success:!1,error:new a([r("invalid_type",[],t().expectedString)])};return(this.urlSafe?VldBase64.BASE64_URL_REGEX:VldBase64.BASE64_REGEX).test(e)?!this.urlSafe&&e.length>0&&e.length%4!=0?{success:!1,error:new a([r("custom",[],t().invalidBase64)])}:{success:!0,data:e}:{success:!1,error:new a([r("custom",[],t().invalidBase64)])}}urlSafeMode(){return new VldBase64(!0)}static create(e=!1){return new VldBase64(e)}}VldBase64.BASE64_REGEX=/^[A-Za-z0-9+/]*={0,2}$/,VldBase64.BASE64_URL_REGEX=/^[A-Za-z0-9_-]*={0,2}$/;export{VldBase64};

package/dist/validators/bigint.d.ts

@@ -1,32 +1,51 @@
-import { VldBase, ParseResult } from './base';
+import { VldBase, ParseResult, ValidatorType } from './base.js';
 /**
  * Type for bigint validation check functions
  */
 type BigIntCheck = (value: bigint) => boolean;
+interface BigIntJSONSchemaHints {
+    readonly minimum?: bigint;
+    readonly maximum?: bigint;
+    readonly exclusiveMinimum?: bigint;
+    readonly exclusiveMaximum?: bigint;
+}
 /**
  * Configuration for bigint validator
  */
 interface BigIntValidatorConfig {
     readonly checks: ReadonlyArray<BigIntCheck>;
-    readonly errorMessage?: string;
+    readonly errorMessage: string | undefined;
+    readonly validatorType?: ValidatorType;
+    readonly jsonSchema: BigIntJSONSchemaHints | undefined;
 }
 /**
  * Immutable bigint validator
  */
 export declare class VldBigInt extends VldBase<bigint, bigint> {
     protected readonly config: BigIntValidatorConfig;
+    private readonly _checks;
+    private readonly _fastCheckMode;
     /**
      * Protected constructor to allow extension while maintaining immutability
      */
     protected constructor(config?: Partial<BigIntValidatorConfig>);
+    get jsonSchema(): BigIntJSONSchemaHints | undefined;
+    get isSimple(): boolean;
     /**
      * Create a new bigint validator
      */
     static create(): VldBigInt;
+    private detectFastCheckMode;
+    private getValidationError;
     /**
      * Parse and validate a bigint value
      */
     parse(value: unknown): bigint;
+    /**
+     * Parse a value that has already passed the bigint type guard.
+     * @internal Used by object validators to avoid duplicate hot-path checks.
+     */
+    parseKnownBigInt(value: bigint): bigint;
     /**
      * Safely parse and validate a bigint value
      */
@@ -77,4 +96,3 @@ export declare class VldBigInt extends VldBase<bigint, bigint> {
     lte(value: bigint | number, message?: string): VldBigInt;
 }
 export {};
-//# sourceMappingURL=bigint.d.ts.map

package/dist/validators/bigint.js

@@ -0,0 +1 @@
+import{VldBase as e,VLD_VALIDATOR_TYPES as i}from"./base.js";import{getMessages as n}from"../locales/runtime.js";import{V as t}from"../chunks/errors-core-Cqi4-9ew.js";function s(e){return new t([{code:"invalid_type",path:[],message:e}])}class VldBigInt extends e{constructor(e){super(e?.validatorType||i.BIGINT),this.config={checks:e?.checks||[],errorMessage:e?.errorMessage,jsonSchema:e?.jsonSchema},this._checks=this.config.checks,this._fastCheckMode=this.detectFastCheckMode()}get jsonSchema(){return this.config.jsonSchema}get isSimple(){return 0===this._checks.length}static create(){return new VldBigInt}detectFastCheckMode(){if(0===this._checks.length)return"none";if(1!==this._checks.length)return;const e=this.config.jsonSchema;return 0n===e?.exclusiveMinimum&&void 0===e.minimum&&void 0===e.maximum?"positive":0n===e?.exclusiveMaximum&&void 0===e.minimum&&void 0===e.maximum?"negative":0n===e?.minimum&&void 0===e.maximum&&void 0===e.exclusiveMaximum?"nonnegative":0n===e?.maximum&&void 0===e.minimum&&void 0===e.exclusiveMinimum?"nonpositive":void 0}getValidationError(){return new Error(this.config.errorMessage||n().invalidBigint)}parse(e){if("bigint"!=typeof e)throw this.getValidationError();return this.parseKnownBigInt(e)}parseKnownBigInt(e){switch(this._fastCheckMode){case"none":return e;case"positive":if(e>0n)return e;throw this.getValidationError();case"negative":if(e<0n)return e;throw this.getValidationError();case"nonnegative":if(e>=0n)return e;throw this.getValidationError();case"nonpositive":if(e<=0n)return e;throw this.getValidationError()}for(const i of this._checks)if(!i(e))throw this.getValidationError();return e}safeParse(e){if("bigint"!=typeof e)return{success:!1,error:s(this.getValidationError().message)};try{return{success:!0,data:this.parseKnownBigInt(e)}}catch(e){return{success:!1,error:s(e.message)}}}min(e,i){return new VldBigInt({...this.config,checks:[...this.config.checks,i=>i>=e],errorMessage:i||`BigInt must be at least ${e}`,jsonSchema:{...this.config.jsonSchema,minimum:e}})}max(e,i){return new VldBigInt({...this.config,checks:[...this.config.checks,i=>i<=e],errorMessage:i||`BigInt must be at most ${e}`,jsonSchema:{...this.config.jsonSchema,maximum:e}})}positive(e){return new VldBigInt({...this.config,checks:[...this.config.checks,e=>e>0n],errorMessage:e||"BigInt must be positive",jsonSchema:{...this.config.jsonSchema,exclusiveMinimum:0n}})}negative(e){return new VldBigInt({...this.config,checks:[...this.config.checks,e=>e<0n],errorMessage:e||"BigInt must be negative",jsonSchema:{...this.config.jsonSchema,exclusiveMaximum:0n}})}nonnegative(e){return new VldBigInt({...this.config,checks:[...this.config.checks,e=>e>=0n],errorMessage:e||"BigInt must be non-negative",jsonSchema:{...this.config.jsonSchema,minimum:0n}})}nonpositive(e){return new VldBigInt({...this.config,checks:[...this.config.checks,e=>e<=0n],errorMessage:e||"BigInt must be non-positive",jsonSchema:{...this.config.jsonSchema,maximum:0n}})}gt(e,i){const n="bigint"==typeof e?e:BigInt(e);return new VldBigInt({...this.config,checks:[...this.config.checks,e=>e>n],errorMessage:i||`BigInt must be greater than ${n}`,jsonSchema:{...this.config.jsonSchema,exclusiveMinimum:n}})}lt(e,i){const n="bigint"==typeof e?e:BigInt(e);return new VldBigInt({...this.config,checks:[...this.config.checks,e=>e<n],errorMessage:i||`BigInt must be less than ${n}`,jsonSchema:{...this.config.jsonSchema,exclusiveMaximum:n}})}gte(e,i){const n="bigint"==typeof e?e:BigInt(e);return this.min(n,i)}lte(e,i){const n="bigint"==typeof e?e:BigInt(e);return this.max(n,i)}}export{VldBigInt};

package/dist/validators/boolean.d.ts

@@ -1,13 +1,18 @@
-import { VldBase, ParseResult } from './base';
+import { VldBase, ParseResult, ValidatorType } from './base.js';
 /**
  * Immutable boolean validator
  */
 export declare class VldBoolean extends VldBase<boolean, boolean> {
-    private readonly errorMessage?;
+    private readonly errorMessage;
     /**
      * Protected constructor to allow extension while maintaining immutability
      */
-    protected constructor(errorMessage?: string);
+    protected constructor(errorMessage?: string, validatorType?: ValidatorType);
+    /**
+     * Returns true if this is a simple boolean validator with no custom checks
+     * Used by VldObject for optimized fast-path dispatch
+     */
+    get isSimple(): boolean;
     /**
      * Create a new boolean validator
      */
@@ -16,6 +21,11 @@ export declare class VldBoolean extends VldBase<boolean, boolean> {
      * Parse and validate a boolean value
      */
     parse(value: unknown): boolean;
+    /**
+     * Parse a value that has already passed the boolean type guard.
+     * @internal Used by object validators to avoid duplicate hot-path checks.
+     */
+    parseKnownBoolean(value: boolean): boolean;
     /**
      * Safely parse and validate a boolean value
      */
@@ -29,4 +39,3 @@ export declare class VldBoolean extends VldBase<boolean, boolean> {
      */
     false(message?: string): VldBoolean;
 }
-//# sourceMappingURL=boolean.d.ts.map

package/dist/validators/boolean.js

@@ -0,0 +1 @@
+import{VldBase as e,VLD_VALIDATOR_TYPES as s}from"./base.js";import{V as r,c as t,g as a}from"../chunks/errors-core-Cqi4-9ew.js";class VldBoolean extends e{constructor(e,r){super(r||s.BOOLEAN),this.errorMessage=e}get isSimple(){return!0}static create(){return new VldBoolean}parse(e){if("boolean"!=typeof e)throw new r([t("boolean",a(e),this.errorMessage)]);return e}parseKnownBoolean(e){return e}safeParse(e){return"boolean"==typeof e?{success:!0,data:e}:{success:!1,error:new r([t("boolean",a(e),this.errorMessage)])}}true(e){return new VldTrue(e||"Value must be true")}false(e){return new VldFalse(e||"Value must be false")}}class VldTrue extends VldBoolean{constructor(e){super(e),this.message=e}get isSimple(){return!1}parse(e){if(!0!==e)throw new r([{code:"custom",path:[],message:this.message}]);return!0}parseKnownBoolean(e){if(!0!==e)throw new r([{code:"custom",path:[],message:this.message}]);return!0}safeParse(e){return!0!==e?{success:!1,error:new r([{code:"custom",path:[],message:this.message}])}:{success:!0,data:!0}}}class VldFalse extends VldBoolean{constructor(e){super(e),this.message=e}get isSimple(){return!1}parse(e){if(!1!==e)throw new r([{code:"custom",path:[],message:this.message}]);return!1}parseKnownBoolean(e){if(!1!==e)throw new r([{code:"custom",path:[],message:this.message}]);return!1}safeParse(e){return!1!==e?{success:!1,error:new r([{code:"custom",path:[],message:this.message}])}:{success:!0,data:!1}}}export{VldBoolean};

package/dist/validators/codec.d.ts

@@ -1,4 +1,4 @@
-import { VldBase, ParseResult } from './base';
+import { VldBase, ParseResult } from './base.js';
 /**
  * Codec transform functions for bidirectional transformations
  */
@@ -23,6 +23,10 @@ export declare class VldCodec<TInput, TOutput> extends VldBase<TInput, TOutput>
      * Safely parse (decode) a value from input to output format
      */
     safeParse(value: unknown): ParseResult<TOutput>;
+    /**
+     * Create a new codec with input and output directions swapped.
+     */
+    invert(): VldCodec<TOutput, TInput>;
     /**
      * Encode a value from output back to input format
      */
@@ -51,5 +55,8 @@ export declare class VldCodec<TInput, TOutput> extends VldBase<TInput, TOutput>
      * Create a codec validator
      */
     static create<TInput, TOutput>(inputValidator: VldBase<unknown, TInput>, outputValidator: VldBase<unknown, TOutput>, codecTransform: CodecTransform<TInput, TOutput>): VldCodec<TInput, TOutput>;
+    /**
+     * Create a codec with input and output directions swapped.
+     */
+    static invert<TInput, TOutput>(codec: VldCodec<TInput, TOutput>): VldCodec<TOutput, TInput>;
 }
-//# sourceMappingURL=codec.d.ts.map

package/dist/validators/codec.js

@@ -0,0 +1 @@
+import{VldBase as r,VLD_VALIDATOR_TYPES as s}from"./base.js";import{createIssue as e}from"../errors.js";import{getMessages as t}from"../locales/runtime.js";import{V as c}from"../chunks/errors-core-Cqi4-9ew.js";class VldCodec extends r{constructor(r,e,t){super(s.CODEC),this.inputValidator=r,this.outputValidator=e,this.codecTransform=t}parse(r){const s=this.safeParse(r);if(!s.success)throw s.error;return s.data}safeParse(r){const s=this.inputValidator.safeParse(r);if(!s.success)return{success:!1,error:s.error};try{const r=this.codecTransform.decode(s.data);if(r instanceof Promise)throw new c([e("custom",[],t().codecAsyncNotSupported)]);return this.outputValidator.safeParse(r)}catch(r){return r instanceof c?{success:!1,error:r}:{success:!1,error:new c([e("custom",[],t().codecDecodeFailed)])}}}invert(){return new VldCodec(this.outputValidator,this.inputValidator,{decode:this.codecTransform.encode,encode:this.codecTransform.decode})}encode(r){const s=this.safeEncode(r);if(!s.success)throw s.error;return s.data}safeEncode(r){const s=this.outputValidator.safeParse(r);if(!s.success)return{success:!1,error:s.error};try{const r=this.codecTransform.encode(s.data);if(r instanceof Promise)throw new c([e("custom",[],t().codecAsyncNotSupported)]);return this.inputValidator.safeParse(r)}catch(r){return r instanceof c?{success:!1,error:r}:{success:!1,error:new c([e("custom",[],t().codecEncodeFailed)])}}}async parseAsync(r){const s=await this.safeParseAsync(r);if(!s.success)throw s.error;return s.data}async safeParseAsync(r){const s=this.inputValidator.safeParse(r);if(!s.success)return{success:!1,error:s.error};try{const r=await this.codecTransform.decode(s.data);return this.outputValidator.safeParse(r)}catch(r){return r instanceof c?{success:!1,error:r}:{success:!1,error:new c([e("custom",[],t().codecDecodeFailed)])}}}async encodeAsync(r){const s=await this.safeEncodeAsync(r);if(!s.success)throw s.error;return s.data}async safeEncodeAsync(r){const s=this.outputValidator.safeParse(r);if(!s.success)return{success:!1,error:s.error};try{const r=await this.codecTransform.encode(s.data);return this.inputValidator.safeParse(r)}catch(r){return r instanceof c?{success:!1,error:r}:{success:!1,error:new c([e("custom",[],t().codecEncodeFailed)])}}}static create(r,s,e){return new VldCodec(r,s,e)}static invert(r){return r.invert()}}export{VldCodec};

package/dist/validators/custom.d.ts

@@ -1,4 +1,4 @@
-import { VldBase, ParseResult } from './base';
+import { VldBase, ParseResult } from './base.js';
 /**
  * Type-safe custom validator options
  */
@@ -7,11 +7,21 @@ export interface CustomValidatorOptions<TOutput> {
      * Parse function that validates and transforms input
      */
     parse: (value: unknown) => TOutput;
+    /**
+     * Optional async parse implementation
+     * If not provided, async parsing delegates to parse()
+     */
+    parseAsync?: (value: unknown) => Promise<TOutput>;
     /**
      * Optional safeParse implementation
      * If not provided, will use try-catch around parse()
      */
     safeParse?: (value: unknown) => ParseResult<TOutput>;
+    /**
+     * Optional async safeParse implementation
+     * If not provided, will use try-catch around parseAsync()
+     */
+    safeParseAsync?: (value: unknown) => Promise<ParseResult<TOutput>>;
 }
 /**
  * Immutable custom validator for user-defined validation logic
@@ -19,7 +29,9 @@ export interface CustomValidatorOptions<TOutput> {
  */
 export declare class VldCustom<TOutput = unknown> extends VldBase<unknown, TOutput> {
     private readonly _parseFn;
+    private readonly _parseAsyncFn;
     private readonly _safeParseFn;
+    private readonly _safeParseAsyncFn;
     private constructor();
     /**
      * Create a new custom validator
@@ -33,6 +45,8 @@ export declare class VldCustom<TOutput = unknown> extends VldBase<unknown, TOutp
      * Safely parse using the custom safeParse function or default implementation
      */
     safeParse(value: unknown): ParseResult<TOutput>;
+    parseAsync(value: unknown): Promise<TOutput>;
+    safeParseAsync(value: unknown): Promise<ParseResult<TOutput>>;
 }
 /**
  * Helper function to create custom validators
@@ -44,4 +58,3 @@ export declare class VldCustom<TOutput = unknown> extends VldBase<unknown, TOutp
  * })
  */
 export declare function custom<TOutput = unknown>(options: CustomValidatorOptions<TOutput>): VldCustom<TOutput>;
-//# sourceMappingURL=custom.d.ts.map

package/dist/validators/custom.js

@@ -0,0 +1 @@
+import{VldBase as s,VLD_VALIDATOR_TYPES as r}from"./base.js";class VldCustom extends s{constructor(s){super(r.CUSTOM),this._parseFn=s.parse,this._parseAsyncFn=s.parseAsync||(s=>Promise.resolve(this._parseFn(s))),this._safeParseFn=s.safeParse||(s=>{try{return{success:!0,data:this._parseFn(s)}}catch(s){return{success:!1,error:s}}}),this._safeParseAsyncFn=s.safeParseAsync||(async s=>{try{return{success:!0,data:await this._parseAsyncFn(s)}}catch(s){return{success:!1,error:s}}})}static create(s){return new VldCustom(s)}parse(s){return this._parseFn(s)}safeParse(s){return this._safeParseFn(s)}async parseAsync(s){return this._parseAsyncFn(s)}async safeParseAsync(s){return this._safeParseAsyncFn(s)}}function e(s){return VldCustom.create(s)}export{VldCustom,e as custom};