@oxog/vld 2.0.3 → 2.2.5

package/dist/mini.js

@@ -1,132 +1 @@
-import { V as VldBigInt, a as VldBoolean, b as VldDate, c as VldNumber, d as VldNullable, e as VldNullish, f as VldOptional, g as VldPreprocess, h as VldString } from './chunks/bigint-CRS0QVsy.js';
-export { i as VldBase, j as VldBrand, k as VldCatch, l as VldDefault, m as VldPipe, n as VldReadonly, o as VldRefine, p as VldSuperRefine, q as VldTransform } from './chunks/bigint-CRS0QVsy.js';
-import { V as VldNever, a as VldAny, b as VldArray, c as VldDiscriminatedUnion, d as VldEnum, e as VldIntersection, f as VldJson, g as VldLazy, h as VldLiteral, i as VldObject, j as VldRecord, k as VldMap, l as VldNan, m as VldNull, n as VldSet, o as VldStringBool, p as VldSymbol, q as VldTuple, r as VldUndefined, s as VldUnion, t as VldVoid, u as VldXor } from './chunks/json-Cp4WO0M9.js';
-import { V as VldUnknown } from './chunks/unknown-Dhzri_T-.js';
-import { V as VldCoerceDate, a as VldCoerceBoolean, b as VldCoerceNumber, c as VldCoerceString } from './chunks/date-50JV_Mfj.js';
-import { VldCoerceBigInt } from './coercion/index.js';
-
-/**
- * VLD Mini - Tree-Shakable Functional API
- *
- * This module provides a functional, tree-shakable alternative to the main `v` object.
- * Use this when bundle size is critical.
- *
- * @example
- * ```typescript
- * import { string, number, object, optional } from '@oxog/vld/mini';
- *
- * const schema = object({
- *   name: string().min(1),
- *   age: optional(number().int())
- * });
- * ```
- */
-// ============================================
-// Base Types & Classes
-// ============================================
-// --- Primitive Validators ---
-/** Create a string validator */
-const string = () => VldString.create();
-/** Create a number validator */
-const number = () => VldNumber.create();
-/** Create an integer validator */
-const int = () => VldNumber.create().int();
-/** Create an int32 validator (-2147483648 to 2147483647) */
-const int32 = () => VldNumber.create().int().min(-2147483648).max(2147483647);
-/** Create a boolean validator */
-const boolean = () => VldBoolean.create();
-/** Create a date validator */
-const date = () => VldDate.create();
-/** Create a bigint validator */
-const bigint = () => VldBigInt.create();
-/** Create a symbol validator */
-const symbol = () => VldSymbol.create();
-/** Create a string-to-boolean validator */
-const stringbool = (options) => VldStringBool.create(options);
-// --- Complex Validators ---
-/** Create an array validator */
-const array = (item) => VldArray.create(item);
-/** Create an object validator */
-const object = (shape) => VldObject.create(shape);
-/** Create a strict object validator (no extra keys allowed) */
-const strictObject = (shape) => VldObject.create(shape).strict();
-/** Create a loose object validator (extra keys passed through) */
-const looseObject = (shape) => VldObject.create(shape).passthrough();
-/** Create a tuple validator */
-const tuple = (...items) => VldTuple.create(...items);
-/** Create a record validator */
-const record = (value) => VldRecord.create(value);
-/** Create a partial record validator */
-const partialRecord = (value) => VldRecord.create(value).partial();
-/** Create a loose record validator */
-const looseRecord = (value) => VldRecord.create(value).loose();
-/** Create a set validator */
-const set = (item) => VldSet.create(item);
-/** Create a map validator */
-const map = (key, value) => VldMap.create(key, value);
-// --- Union & Intersection ---
-/** Create a union validator (value must match one of the validators) */
-const union = (...validators) => VldUnion.create(...validators);
-/** Create an intersection validator (value must match both validators) */
-const intersection = (first, second) => VldIntersection.create(first, second);
-/** Create a discriminated union validator */
-const discriminatedUnion = (discriminator, ...options) => VldDiscriminatedUnion.create(discriminator, [...options]);
-/** Create an XOR validator (value must match exactly one of the validators) */
-const xor = (...options) => VldXor.create([...options]);
-// --- Literal & Enum ---
-/** Create a literal validator */
-const literal = (value) => VldLiteral.create(value);
-/** Create an enum validator */
-const enumValidator = (...values) => VldEnum.create(values);
-// --- Special Validators ---
-/** Create a validator that accepts any value */
-const any = () => VldAny.create();
-/** Create a validator that accepts unknown values */
-const unknown = () => VldUnknown.create();
-/** Create a void validator */
-const voidValidator = () => VldVoid.create();
-/** Create a never validator (always fails) */
-const never = () => VldNever.create();
-/** Create a null validator */
-const nullValidator = () => VldNull.create();
-/** Create an undefined validator */
-const undefinedValidator = () => VldUndefined.create();
-/** Create a NaN validator */
-const nan = () => VldNan.create();
-// --- Utility Validators ---
-/** Create a lazy validator for recursive schemas */
-const lazy = (schemaGetter) => VldLazy.create(schemaGetter);
-/** Create a JSON validator */
-const json = (schema) => VldJson.create(schema);
-// ============================================
-// Utility Functions (Wrappers)
-// ============================================
-/** Make a validator optional (allows undefined) */
-const optional = (validator) => VldOptional.create(validator);
-/** Make a validator nullable (allows null) */
-const nullable = (validator) => VldNullable.create(validator);
-/** Make a validator nullish (allows null or undefined) */
-const nullish = (validator) => VldNullish.create(validator);
-/** Preprocess input before validation */
-const preprocess = (preprocessor, schema) => VldPreprocess.create(preprocessor, schema);
-/** Coercion validators - convert values to target type before validation */
-const coerce = {
-    /** Coerce to string */
-    string: () => VldCoerceString.create(),
-    /** Coerce to number */
-    number: () => VldCoerceNumber.create(),
-    /** Coerce to boolean */
-    boolean: () => VldCoerceBoolean.create(),
-    /** Coerce to date */
-    date: () => VldCoerceDate.create(),
-    /** Coerce to bigint */
-    bigint: () => VldCoerceBigInt.create(),
-};
-// ============================================
-// NEVER Constant (for transforms)
-// ============================================
-/** NEVER constant for use in transforms - Zod 4 API parity */
-const NEVER = VldNever.create();
-
-export { NEVER, VldAny, VldArray, VldBigInt, VldBoolean, VldDate, VldDiscriminatedUnion, VldEnum, VldIntersection, VldJson, VldLazy, VldLiteral, VldMap, VldNan, VldNever, VldNull, VldNullable, VldNullish, VldNumber, VldObject, VldOptional, VldPreprocess, VldRecord, VldSet, VldString, VldStringBool, VldSymbol, VldTuple, VldUndefined, VldUnion, VldUnknown, VldVoid, VldXor, any, array, bigint, boolean, coerce, date, discriminatedUnion, enumValidator, int, int32, intersection, json, lazy, literal, looseObject, looseRecord, map, nan, never, nullValidator, nullable, nullish, number, object, optional, partialRecord, preprocess, record, set, strictObject, string, stringbool, symbol, tuple, undefinedValidator, union, unknown, voidValidator, xor };
-//# sourceMappingURL=mini.js.map
+import{VldNullable as r,VldNullish as t,VldOptional as a,VldPreprocess as e}from"./validators/base.js";export{VldBase,VldBrand,VldCatch,VldDefault,VldPipe,VldReadonly,VldRefine,VldSuperRefine,VldTransform}from"./validators/base.js";import{VldString as o}from"./validators/string.js";import{VldNumber as i}from"./validators/number.js";import{VldBoolean as s}from"./validators/boolean.js";import{VldDate as m}from"./validators/date.js";import{VldBigInt as c}from"./validators/bigint.js";import{VldSymbol as l}from"./validators/symbol.js";import{VldStringBool as d}from"./validators/string-bool.js";import{VldArray as n}from"./validators/array.js";import{VldObject as p}from"./validators/object.js";import{VldTuple as f}from"./validators/tuple.js";import{VldRecord as j}from"./validators/record.js";import{VldSet as v}from"./validators/set.js";import{VldMap as u}from"./validators/map.js";import{VldUnion as b}from"./validators/union.js";import{VldIntersection as V}from"./validators/intersection.js";import{VldLiteral as g}from"./validators/literal.js";import{VldEnum as x}from"./validators/enum.js";import{VldAny as y}from"./validators/any.js";import{VldUnknown as h}from"./validators/unknown.js";import{VldVoid as R}from"./validators/void.js";import{VldNever as B}from"./validators/never.js";import{VldNull as k}from"./validators/null.js";import{VldUndefined as w}from"./validators/undefined.js";import{VldNan as z}from"./validators/nan.js";import{VldLazy as C}from"./validators/lazy.js";import{VldDiscriminatedUnion as D}from"./validators/discriminated-union.js";import{VldXor as P}from"./validators/xor.js";import{VldJson as S}from"./validators/json.js";import{VldCoerceBigInt as T,VldCoerceDate as q,VldCoerceBoolean as A,VldCoerceNumber as E,VldCoerceString as F}from"./coercion/index.js";const G=()=>o.create(),H=()=>i.create(),I=()=>i.create().int(),J=()=>i.create().int().min(-2147483648).max(2147483647),K=()=>s.create(),L=()=>m.create(),M=()=>c.create(),N=()=>l.create(),O=r=>d.create(r),Q=r=>n.create(r),U=r=>p.create(r),W=r=>p.create(r).strict(),X=r=>p.create(r).passthrough(),Y=(...r)=>f.create(...r),Z=r=>j.create(r),$=r=>j.create(r).partial(),_=r=>j.create(r).loose(),rr=r=>v.create(r),tr=(r,t)=>u.create(r,t),ar=(...r)=>b.create(...r),er=(r,t)=>V.create(r,t),or=(r,...t)=>D.create(r,[...t]),ir=(...r)=>P.create([...r]),sr=r=>g.create(r),mr=(...r)=>x.create(r),cr=()=>y.create(),lr=()=>h.create(),dr=()=>R.create(),nr=()=>B.create(),pr=()=>k.create(),fr=()=>w.create(),jr=()=>z.create(),vr=r=>C.create(r),ur=r=>S.create(r),br=r=>a.create(r),Vr=t=>r.create(t),gr=r=>t.create(r),xr=(r,t)=>e.create(r,t),yr={string:()=>F.create(),number:()=>E.create(),boolean:()=>A.create(),date:()=>q.create(),bigint:()=>T.create()},hr=B.create();export{hr as NEVER,y as VldAny,n as VldArray,c as VldBigInt,s as VldBoolean,m as VldDate,D as VldDiscriminatedUnion,x as VldEnum,V as VldIntersection,S as VldJson,C as VldLazy,g as VldLiteral,u as VldMap,z as VldNan,B as VldNever,k as VldNull,r as VldNullable,t as VldNullish,i as VldNumber,p as VldObject,a as VldOptional,e as VldPreprocess,j as VldRecord,v as VldSet,o as VldString,d as VldStringBool,l as VldSymbol,f as VldTuple,w as VldUndefined,b as VldUnion,h as VldUnknown,R as VldVoid,P as VldXor,cr as any,Q as array,M as bigint,K as boolean,yr as coerce,L as date,or as discriminatedUnion,mr as enumValidator,I as int,J as int32,er as intersection,ur as json,vr as lazy,sr as literal,X as looseObject,_ as looseRecord,tr as map,jr as nan,nr as never,pr as nullValidator,Vr as nullable,gr as nullish,H as number,U as object,br as optional,$ as partialRecord,xr as preprocess,Z as record,rr as set,W as strictObject,G as string,O as stringbool,N as symbol,Y as tuple,fr as undefinedValidator,ar as union,lr as unknown,dr as voidValidator,ir as xor};

package/dist/pigment.d.ts

@@ -121,4 +121,3 @@ export declare const vldTheme: Theme;
  */
 export declare function createTheme(overrides?: Partial<Theme>): Theme;
 export default pigment;
-//# sourceMappingURL=pigment.d.ts.map

package/dist/pigment.js

@@ -1,178 +1 @@
-/**
- * VLD Pigment - Colored Console Output
- *
- * This module provides ANSI color utilities for terminal output,
- * compatible with @oxog/pigment when available.
- */
-/* eslint-enable @typescript-eslint/no-explicit-any */
-/**
- * Check if colors are supported in the current environment
- */
-function supportsColor() {
-    // Check for NO_COLOR environment variable
-    if (typeof process !== 'undefined' && process.env?.NO_COLOR) {
-        return false;
-    }
-    // Check for FORCE_COLOR environment variable
-    if (typeof process !== 'undefined' && process.env?.FORCE_COLOR) {
-        return true;
-    }
-    // Check for TTY
-    if (typeof process !== 'undefined' && process.stdout?.isTTY) {
-        return true;
-    }
-    // Browser environment - no ANSI colors
-    if (typeof window !== 'undefined') {
-        return false;
-    }
-    return false;
-}
-/**
- * ANSI escape codes
- */
-const ANSI = {
-    // Reset
-    reset: '\x1b[0m',
-    // Styles
-    bold: '\x1b[1m',
-    dim: '\x1b[2m',
-    italic: '\x1b[3m',
-    underline: '\x1b[4m',
-    blink: '\x1b[5m',
-    inverse: '\x1b[7m',
-    hidden: '\x1b[8m',
-    strikethrough: '\x1b[9m',
-    // Foreground colors
-    black: '\x1b[30m',
-    red: '\x1b[31m',
-    green: '\x1b[32m',
-    yellow: '\x1b[33m',
-    blue: '\x1b[34m',
-    magenta: '\x1b[35m',
-    cyan: '\x1b[36m',
-    white: '\x1b[37m',
-    gray: '\x1b[90m',
-    grey: '\x1b[90m',
-    // Bright foreground colors
-    brightRed: '\x1b[91m',
-    brightGreen: '\x1b[92m',
-    brightYellow: '\x1b[93m',
-    brightBlue: '\x1b[94m',
-    brightMagenta: '\x1b[95m',
-    brightCyan: '\x1b[96m',
-    brightWhite: '\x1b[97m',
-    // Background colors
-    bgBlack: '\x1b[40m',
-    bgRed: '\x1b[41m',
-    bgGreen: '\x1b[42m',
-    bgYellow: '\x1b[43m',
-    bgBlue: '\x1b[44m',
-    bgMagenta: '\x1b[45m',
-    bgCyan: '\x1b[46m',
-    bgWhite: '\x1b[47m',
-    // Bright background colors
-    bgBrightRed: '\x1b[101m',
-    bgBrightGreen: '\x1b[102m',
-    bgBrightYellow: '\x1b[103m',
-    bgBrightBlue: '\x1b[104m',
-    bgBrightMagenta: '\x1b[105m',
-    bgBrightCyan: '\x1b[106m',
-    bgBrightWhite: '\x1b[107m'
-};
-/**
- * Create a color function
- */
-function createColorFn(code) {
-    const enabled = supportsColor();
-    return (text) => {
-        if (!enabled || text === '')
-            return text;
-        return `${code}${text}${ANSI.reset}`;
-    };
-}
-/**
- * Pigment - Color utilities for terminal output
- */
-const pigment = {
-    // Check support
-    supportsColor,
-    // Reset
-    reset: (text) => text,
-    // Styles
-    bold: createColorFn(ANSI.bold),
-    dim: createColorFn(ANSI.dim),
-    italic: createColorFn(ANSI.italic),
-    underline: createColorFn(ANSI.underline),
-    inverse: createColorFn(ANSI.inverse),
-    hidden: createColorFn(ANSI.hidden),
-    strikethrough: createColorFn(ANSI.strikethrough),
-    // Foreground colors
-    black: createColorFn(ANSI.black),
-    red: createColorFn(ANSI.red),
-    green: createColorFn(ANSI.green),
-    yellow: createColorFn(ANSI.yellow),
-    blue: createColorFn(ANSI.blue),
-    magenta: createColorFn(ANSI.magenta),
-    cyan: createColorFn(ANSI.cyan),
-    white: createColorFn(ANSI.white),
-    gray: createColorFn(ANSI.gray),
-    grey: createColorFn(ANSI.grey),
-    // Bright colors
-    brightRed: createColorFn(ANSI.brightRed),
-    brightGreen: createColorFn(ANSI.brightGreen),
-    brightYellow: createColorFn(ANSI.brightYellow),
-    brightBlue: createColorFn(ANSI.brightBlue),
-    brightMagenta: createColorFn(ANSI.brightMagenta),
-    brightCyan: createColorFn(ANSI.brightCyan),
-    brightWhite: createColorFn(ANSI.brightWhite),
-    // Background colors
-    bgBlack: createColorFn(ANSI.bgBlack),
-    bgRed: createColorFn(ANSI.bgRed),
-    bgGreen: createColorFn(ANSI.bgGreen),
-    bgYellow: createColorFn(ANSI.bgYellow),
-    bgBlue: createColorFn(ANSI.bgBlue),
-    bgMagenta: createColorFn(ANSI.bgMagenta),
-    bgCyan: createColorFn(ANSI.bgCyan),
-    bgWhite: createColorFn(ANSI.bgWhite),
-    // Semantic colors
-    success: createColorFn(ANSI.green),
-    error: createColorFn(ANSI.red),
-    warning: createColorFn(ANSI.yellow),
-    info: createColorFn(ANSI.blue),
-    muted: createColorFn(ANSI.gray),
-    // Combine multiple styles
-    combine: (...codes) => (text) => {
-        if (!supportsColor())
-            return text;
-        return `${codes.join('')}${text}${ANSI.reset}`;
-    },
-    // Strip ANSI codes from string
-    strip: (text) => text.replace(/[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g, ''),
-    // Get raw ANSI codes
-    codes: ANSI
-};
-// Aliases for convenience
-const { bold, dim, italic, underline, red, green, yellow, blue, magenta, cyan, white, gray, grey, success, error, warning, info, muted, strip } = pigment;
-/**
- * Default VLD theme for error formatting
- */
-const vldTheme = {
-    error: red,
-    success: green,
-    warning: yellow,
-    info: blue,
-    muted: dim,
-    path: cyan,
-    value: yellow,
-    key: bold,
-    symbol: red
-};
-/**
- * Create a custom theme
- */
-function createTheme(overrides = {}) {
-    return { ...vldTheme, ...overrides };
-}
-
-export { blue, bold, createTheme, cyan, pigment as default, dim, error, gray, green, grey, info, italic, magenta, muted, pigment, red, strip, success, supportsColor, underline, vldTheme, warning, white, yellow };
-//# sourceMappingURL=pigment.js.map
+function e(){return("undefined"==typeof process||!process.env?.NO_COLOR)&&(!("undefined"==typeof process||!process.env?.FORCE_COLOR)||!("undefined"==typeof process||!process.stdout?.isTTY))}const r={reset:"",bold:"",dim:"",italic:"",underline:"",blink:"",inverse:"",hidden:"",strikethrough:"",black:"",red:"",green:"",yellow:"",blue:"",magenta:"",cyan:"",white:"",gray:"",grey:"",brightRed:"",brightGreen:"",brightYellow:"",brightBlue:"",brightMagenta:"",brightCyan:"",brightWhite:"",bgBlack:"",bgRed:"",bgGreen:"",bgYellow:"",bgBlue:"",bgMagenta:"",bgCyan:"",bgWhite:"",bgBrightRed:"",bgBrightGreen:"",bgBrightYellow:"",bgBrightBlue:"",bgBrightMagenta:"",bgBrightCyan:"",bgBrightWhite:""},g=new RegExp("[\\u001b\\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]","g");function t(g){const t=e();return e=>t&&""!==e?`${g}${e}${r.reset}`:e}const i={supportsColor:e,reset:e=>e,bold:t(r.bold),dim:t(r.dim),italic:t(r.italic),underline:t(r.underline),inverse:t(r.inverse),hidden:t(r.hidden),strikethrough:t(r.strikethrough),black:t(r.black),red:t(r.red),green:t(r.green),yellow:t(r.yellow),blue:t(r.blue),magenta:t(r.magenta),cyan:t(r.cyan),white:t(r.white),gray:t(r.gray),grey:t(r.grey),brightRed:t(r.brightRed),brightGreen:t(r.brightGreen),brightYellow:t(r.brightYellow),brightBlue:t(r.brightBlue),brightMagenta:t(r.brightMagenta),brightCyan:t(r.brightCyan),brightWhite:t(r.brightWhite),bgBlack:t(r.bgBlack),bgRed:t(r.bgRed),bgGreen:t(r.bgGreen),bgYellow:t(r.bgYellow),bgBlue:t(r.bgBlue),bgMagenta:t(r.bgMagenta),bgCyan:t(r.bgCyan),bgWhite:t(r.bgWhite),success:t(r.green),error:t(r.red),warning:t(r.yellow),info:t(r.blue),muted:t(r.gray),combine:(...g)=>t=>e()?`${g.join("")}${t}${r.reset}`:t,strip:e=>e.replace(g,""),codes:r},{bold:n,dim:b,italic:l,underline:a,red:m,green:h,yellow:o,blue:s,magenta:d,cyan:u,white:c,gray:y,grey:w,success:p,error:B,warning:f,info:R,muted:k,strip:C}=i,Y={error:m,success:h,warning:o,info:s,muted:b,path:u,value:o,key:n,symbol:m};function G(e={}){return{...Y,...e}}export{s as blue,n as bold,G as createTheme,u as cyan,i as default,b as dim,B as error,y as gray,h as green,w as grey,R as info,l as italic,d as magenta,k as muted,i as pigment,m as red,C as strip,p as success,e as supportsColor,a as underline,Y as vldTheme,f as warning,c as white,o as yellow};

package/dist/plugins/index.d.ts

@@ -3,6 +3,5 @@
  *
  * This module exports all plugin-related functionality.
  */
-export type { VldContext, VldPlugin, VldKernelInstance, VldKernelOptions, ValidatorFactory, TransformFactory, CodecFactory, HookContext, PluginBuilder, PluginMeta, PluginHooks } from './types';
-export { createVldKernel, definePlugin, getVldKernel, resetVldKernel, usePlugin } from '../kernel';
-//# sourceMappingURL=index.d.ts.map
+export type { VldContext, VldPlugin, VldKernelInstance, VldKernelOptions, ValidatorFactory, TransformFactory, CodecFactory, HookContext, PluginBuilder, PluginMeta, PluginHooks } from './types.js';
+export { createVldKernel, definePlugin, getVldKernel, resetVldKernel, usePlugin } from '../kernel.js';

package/dist/plugins/index.js

@@ -0,0 +1 @@
+export{createVldKernel,definePlugin,getVldKernel,resetVldKernel,usePlugin}from"../kernel.js";

package/dist/plugins/types.d.ts

@@ -4,10 +4,10 @@
  * This module defines the plugin system interfaces and types
  * for extending VLD with custom validators, transforms, and codecs.
  */
-import type { VldBase } from '../validators/base';
-import type { VldError } from '../errors';
-import type { ParseResult } from '../validators/base';
-import type { Locale } from '../locales';
+import type { VldBase } from '../validators/base.js';
+import type { VldError } from '../errors.js';
+import type { ParseResult } from '../validators/base.js';
+import type { Locale } from '../locales/index.js';
 /**
  * Plugin metadata
  */
@@ -183,4 +183,3 @@ export interface PluginBuilder {
     install(fn: VldPlugin['install']): this;
     build(): VldPlugin;
 }
-//# sourceMappingURL=types.d.ts.map

package/dist/registry.d.ts

@@ -0,0 +1,23 @@
+import type { SchemaMetadata, VldBase } from './validators/base.js';
+/**
+ * Strongly typed schema metadata registry.
+ *
+ * Registries keep metadata outside schema instances, which preserves validator
+ * immutability and mirrors Zod 4's registry model while keeping VLD's existing
+ * .meta() wrapper API backward compatible.
+ */
+export interface SchemaRegistry<TMetadata extends Record<string, unknown> = SchemaMetadata> {
+    add<TSchema extends VldBase<any, any>>(schema: TSchema, metadata: TMetadata): TSchema;
+    get(schema: VldBase<any, any>): TMetadata | undefined;
+    has(schema: VldBase<any, any>): boolean;
+    remove(schema: VldBase<any, any>): boolean;
+    clear(): void;
+}
+/**
+ * Create a schema metadata registry.
+ */
+export declare function registry<TMetadata extends Record<string, unknown> = SchemaMetadata>(): SchemaRegistry<TMetadata>;
+/**
+ * Global JSON Schema/OpenAPI compatible metadata registry.
+ */
+export declare const globalRegistry: SchemaRegistry<SchemaMetadata>;

package/dist/registry.js

@@ -0,0 +1 @@
+class t{constructor(){this.metadata=new WeakMap}add(t,a){return this.metadata.set(t,{...a}),t}get(t){const a=this.metadata.get(t);return a?{...a}:void 0}has(t){return this.metadata.has(t)}remove(t){return this.metadata.delete(t)}clear(){this.metadata=new WeakMap}}function a(){return new t}const e=a();export{e as globalRegistry,a as registry};

package/dist/utils/codec-utils.d.ts

@@ -43,4 +43,3 @@ export declare function safeAtob(encoded: string): string;
  * Polyfill for btoa in Node.js
  */
 export declare function safeBtoa(str: string): string;
-//# sourceMappingURL=codec-utils.d.ts.map

package/dist/utils/deep-merge.d.ts

@@ -18,4 +18,3 @@ export declare function deepMerge<T extends Record<string, any>>(target: T, sour
  * @returns The frozen object
  */
 export declare function deepFreeze<T>(obj: T): Readonly<T>;
-//# sourceMappingURL=deep-merge.d.ts.map

package/dist/utils/ip-validation.d.ts

@@ -8,4 +8,3 @@
  * Uses multiple simple checks instead of one complex regex
  */
 export declare function isValidIPv6(ip: string): boolean;
-//# sourceMappingURL=ip-validation.d.ts.map

package/dist/utils/json-schema.d.ts

@@ -2,7 +2,8 @@
  * JSON Schema support for VLD validators
  * Provides conversion between VLD schemas and JSON Schema
  */
-import { VldBase } from '../validators/base';
+import { VldBase } from '../validators/base.js';
+import { type SchemaRegistry } from '../registry.js';
 /**
  * JSON Schema definition types
  */
@@ -15,18 +16,23 @@ export type JSONSchemaDefinition = {
     enum?: unknown[];
     const?: unknown;
     format?: string;
+    formatMinimum?: string;
+    formatMaximum?: string;
+    formatExclusiveMinimum?: string;
+    formatExclusiveMaximum?: string;
     pattern?: string;
     minLength?: number;
     maxLength?: number;
     minimum?: number;
     maximum?: number;
-    exclusiveMinimum?: number;
-    exclusiveMaximum?: number;
+    exclusiveMinimum?: number | boolean;
+    exclusiveMaximum?: number | boolean;
     multipleOf?: number;
     properties?: Record<string, JSONSchemaDefinition>;
     additionalProperties?: boolean | JSONSchemaDefinition;
     required?: string[];
-    items?: JSONSchemaDefinition | JSONSchemaDefinition[];
+    items?: JSONSchemaDefinition | JSONSchemaDefinition[] | false;
+    prefixItems?: JSONSchemaDefinition[];
     contains?: JSONSchemaDefinition;
     minItems?: number;
     maxItems?: number;
@@ -42,14 +48,28 @@ export type JSONSchemaDefinition = {
     deprecated?: boolean;
     readOnly?: boolean;
     writeOnly?: boolean;
+    nullable?: boolean;
+    'x-vld-type'?: string;
+    'x-vld-minimum'?: string;
+    'x-vld-maximum'?: string;
+    'x-vld-exclusiveMinimum'?: string;
+    'x-vld-exclusiveMaximum'?: string;
 };
 /**
  * Options for JSON Schema conversion
  */
 export interface ToJSONSchemaOptions {
-    target?: 'draft-07' | 'draft-2019-09' | 'draft-2020-12';
+    target?: 'draft-04' | 'draft-4' | 'draft-07' | 'draft-7' | 'draft-2019-09' | 'draft-2020-12' | 'openapi-3.0' | (string & {});
     includeMetadata?: boolean;
     includeExamples?: boolean;
+    /** Match Zod's default throw/any behavior, or opt into VLD extensions. */
+    unrepresentable?: 'throw' | 'any' | 'vld';
+    /** Select the input or output side of codecs and pipes. */
+    io?: 'input' | 'output';
+}
+export interface FromJSONSchemaOptions {
+    defaultTarget?: 'draft-2020-12' | 'draft-7' | 'draft-4' | 'openapi-3.0';
+    registry?: SchemaRegistry<Record<string, unknown>>;
 }
 /**
  * Convert a VLD schema to JSON Schema
@@ -63,5 +83,4 @@ export declare function toJSONSchema<T>(schema: VldBase<unknown, T>, options?: T
  * @param json The JSON Schema definition
  * @returns A VLD schema
  */
-export declare function fromJSONSchema(json: JSONSchemaDefinition): VldBase<unknown, unknown>;
-//# sourceMappingURL=json-schema.d.ts.map
+export declare function fromJSONSchema(json: JSONSchemaDefinition | boolean, options?: FromJSONSchemaOptions): VldBase<unknown, unknown>;

package/dist/utils/security.d.ts

@@ -1,12 +1,8 @@
 /**
  * Security utilities for prototype pollution protection
- * BUG-NEW-018 & BUG-NEW-020 FIX: Centralized comprehensive dangerous key detection
  */
 /**
- * Comprehensive prototype pollution protection
- * Checks for dangerous keys that could modify Object.prototype or built-in prototypes
- * @param key The property key to check
- * @returns true if the key is dangerous, false otherwise
+ * Return true if a property key would, if assigned, mutate the prototype
+ * chain or accessor behavior of the target object.
  */
 export declare function isDangerousKey(key: string): boolean;
-//# sourceMappingURL=security.d.ts.map

package/dist/v3/index.d.ts

@@ -0,0 +1,2 @@
+export * from '../index.js';
+export { default } from '../index.js';

package/dist/v3/index.js

@@ -0,0 +1 @@
+export{$brand,$input,$output,NEVER,TimePrecision,ZodFirstPartyTypeKind,ZodIssueCode,_ZodString,_default,_function,any,array,base64,base64Bytes,base64url,bigint,boolean,catch,check,cidrv4,cidrv6,clone,codec,coerce,config,core,createLogger,createNoOpLogger,creditCard,cuid,cuid2,custom,date,decode,decodeAsync,deepPartial,default,describe,disableLogging,discriminatedUnion,e164,email,emoji,enableDebug,encode,encodeAsync,endsWith,enum,exactOptional,file,float32,float64,formatError,fromJSONSchema,_function as function,getErrorMap,getLogger,gt,gte,guid,hash,hex,hexBytes,hostname,httpUrl,includes,initLogger,input,instanceof,int,int32,int64,intersection,ipv4,ipv6,iso,json,jwt,keyof,ksuid,lazy,length,literal,locales,looseObject,looseRecord,lowercase,lt,lte,mac,map,mapSchema,maxLength,maxSize,meta,mime,minLength,minSize,multipleOf,nan,nanoid,nativeEnum,negative,never,nonnegative,nonoptional,nonpositive,normalize,null,nullable,nullish,number,object,optional,output,overwrite,parse,parseAsync,partialRecord,pipe,positive,prefault,preprocess,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,trim,tuple,uint32,uint64,uint8Array,ulid,undefined,union,unknown,uppercase,url,util,uuid,uuidv4,uuidv6,uuidv7,default as v,void,xid,xor,z}from"../index.js";export{Err,Ok,ResultUtils,all,failure,flatMap,fromNullable,isErr,isOk,isResult,mapErr,match,success,tryCatch,tryCatchAsync,unwrap,unwrapOr}from"../compat/result.js";export{VldBase,VldMeta,VldBrand as ZodBranded,VldCatch as ZodCatch,VldDefault as ZodDefault,VldExactOptional as ZodExactOptional,VldMeta as ZodMeta,VldRefine as ZodNonOptional,VldNullable as ZodNullable,VldOptional as ZodOptional,VldPipe as ZodPipe,VldPrefault as ZodPrefault,VldPreprocess as ZodPreprocess,VldReadonly as ZodReadonly,VldTransform as ZodTransform,VldBase as ZodType}from"../validators/base.js";export{V as VldError,V as ZodError,V as ZodRealError}from"../chunks/errors-core-Cqi4-9ew.js";export{VldIntersection,VldIntersection as ZodIntersection}from"../validators/intersection.js";export{VldAny as ZodAny}from"../validators/any.js";export{VldArray as ZodArray}from"../validators/array.js";export{VldStringFormat as ZodBase64,VldStringFormat as ZodBase64URL,VldStringFormat as ZodCIDRv4,VldStringFormat as ZodCIDRv6,VldStringFormat as ZodCUID,VldStringFormat as ZodCUID2,VldStringFormat as ZodCreditCard,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{VldBigInt as ZodBigInt,VldBigInt as ZodBigIntFormat}from"../validators/bigint.js";export{VldBoolean as ZodBoolean}from"../validators/boolean.js";export{VldCodec as ZodCodec}from"../validators/codec.js";export{VldCustom as ZodCustom,VldCustom as ZodSuccess}from"../validators/custom.js";export{VldDate as ZodDate}from"../validators/date.js";export{VldDiscriminatedUnion as ZodDiscriminatedUnion}from"../validators/discriminated-union.js";export{VldEnum as ZodEnum}from"../validators/enum.js";export{VldFile as ZodFile}from"../validators/file.js";export{VldFunction as ZodFunction}from"../validators/function.js";export{VldJson as ZodJSON}from"../validators/json.js";export{VldLazy as ZodLazy}from"../validators/lazy.js";export{VldLiteral as ZodLiteral}from"../validators/literal.js";export{VldMap as ZodMap}from"../validators/map.js";export{VldNan as ZodNaN}from"../validators/nan.js";export{VldNever as ZodNever}from"../validators/never.js";export{VldNull as ZodNull}from"../validators/null.js";export{VldNumber as ZodNumber,VldNumber as ZodNumberFormat}from"../validators/number.js";export{VldObject as ZodObject}from"../validators/object.js";export{VldPromise as ZodPromise}from"../validators/promise.js";export{VldRecord as ZodRecord}from"../validators/record.js";export{VldSet as ZodSet}from"../validators/set.js";export{VldString as ZodString}from"../validators/string.js";export{VldSymbol as ZodSymbol}from"../validators/symbol.js";export{VldTemplateLiteral as ZodTemplateLiteral}from"../validators/template-literal.js";export{VldTuple as ZodTuple}from"../validators/tuple.js";export{VldUndefined as ZodUndefined}from"../validators/undefined.js";export{VldUnion as ZodUnion}from"../validators/union.js";export{VldUnknown as ZodUnknown}from"../validators/unknown.js";export{VldVoid as ZodVoid}from"../validators/void.js";export{VldXor as ZodXor}from"../validators/xor.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-CkbfQQ4n.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";export{createEmitter,createEventBus,withEmitter}from"../compat/emitter.js";export{createVldKernel,definePlugin,getVldKernel,resetVldKernel,usePlugin}from"../kernel.js";export{flattenError,prettifyError,prettifyErrorColored,prettifyErrorPlain,treeifyError}from"../errors.js";export{getLocale,getMessages,getSupportedLocales,isLocaleLoaded,isLocaleSupported,registerLocale,setLocale}from"../locales/runtime.js";export{globalRegistry,registry}from"../registry.js";export{s as setLocaleAsync}from"../chunks/index-yjpbvFgw.js";