valrs 0.1.0

package/dist/schema.js

@@ -0,0 +1,1179 @@
+/**
+ * Base schema class providing the fluent API wrapper around Standard Schema.
+ *
+ * This module provides the `ValSchema` base class that all schema types extend.
+ * It wraps the internal Standard Schema implementation and exposes Zod-like methods.
+ */
+import { isValidationSuccess } from './types';
+import { ValError } from './error';
+import { VENDOR, VERSION, success } from './factory';
+import { compileSchema } from './compiler';
+/**
+ * Type guard to check if a SafeParseResult is successful.
+ */
+export function isSafeParseSuccess(result) {
+    return result.success === true;
+}
+/**
+ * Type guard to check if a SafeParseResult is a failure.
+ */
+export function isSafeParseError(result) {
+    return result.success === false;
+}
+/**
+ * Base schema class that provides the Zod-compatible API.
+ *
+ * All schema types extend this class, inheriting methods like `parse()`,
+ * `safeParse()`, and maintaining Standard Schema compliance via `~standard`.
+ *
+ * @template Input - The expected input type
+ * @template Output - The validated output type (defaults to Input)
+ *
+ * @example
+ * ```typescript
+ * const schema = v.string();
+ *
+ * // Throws ValError on failure
+ * const value = schema.parse('hello');
+ *
+ * // Returns { success, data } or { success, error }
+ * const result = schema.safeParse('hello');
+ * if (result.success) {
+ *   console.log(result.data);
+ * }
+ * ```
+ */
+export class ValSchema {
+    /**
+     * Standard Schema interface for interoperability.
+     *
+     * This property makes ValSchema compatible with any library that
+     * supports the Standard Schema specification.
+     */
+    '~standard';
+    /**
+     * Compiled validator for fast boolean checks.
+     * Lazily initialized on first check() call.
+     */
+    _compiledCheck;
+    /**
+     * Whether this schema or any of its children contain transforms.
+     * When true, validation must go through WASM to apply transforms.
+     */
+    _hasTransforms = false;
+    /**
+     * Returns whether this schema contains transforms.
+     * Used internally to determine validation path.
+     */
+    hasTransforms() {
+        return this._hasTransforms;
+    }
+    /**
+     * Creates a new ValSchema wrapping a validation function.
+     *
+     * @param validateFn - Function that validates input values
+     * @param inputJsonSchemaFn - Function that generates JSON Schema for input type
+     * @param outputJsonSchemaFn - Function that generates JSON Schema for output type
+     */
+    constructor(validateFn, inputJsonSchemaFn, outputJsonSchemaFn) {
+        const outputFn = outputJsonSchemaFn ?? inputJsonSchemaFn;
+        this['~standard'] = {
+            version: VERSION,
+            vendor: VENDOR,
+            validate: validateFn,
+            jsonSchema: {
+                input: (options) => inputJsonSchemaFn(options.target),
+                output: (options) => outputFn(options.target),
+            },
+        };
+    }
+    /**
+     * Parses the input and returns the validated value.
+     *
+     * Throws a `ValError` if validation fails.
+     *
+     * @param data - The value to validate
+     * @returns The validated value with the correct type
+     * @throws {ValError} If validation fails
+     *
+     * @example
+     * ```typescript
+     * const name = v.string().parse('Alice'); // 'Alice'
+     * const age = v.number().parse('42');     // throws ValError
+     * ```
+     */
+    parse(data) {
+        const result = this['~standard'].validate(data);
+        if (isValidationSuccess(result)) {
+            return result.value;
+        }
+        throw new ValError(result.issues);
+    }
+    /**
+     * Parses the input and returns a result object.
+     *
+     * Never throws. Returns `{ success: true, data }` on success,
+     * or `{ success: false, error }` on failure.
+     *
+     * @param data - The value to validate
+     * @returns A result object indicating success or failure
+     *
+     * @example
+     * ```typescript
+     * const result = v.string().safeParse(input);
+     *
+     * if (result.success) {
+     *   console.log(result.data); // The validated string
+     * } else {
+     *   console.log(result.error.issues); // Array of validation issues
+     * }
+     * ```
+     */
+    safeParse(data) {
+        // Fast path: use JS-compiled check for non-transform schemas
+        if (!this._hasTransforms && this.check(data)) {
+            return {
+                success: true,
+                data: data,
+            };
+        }
+        // Full validation path (WASM) for transforms or when check fails
+        const result = this['~standard'].validate(data);
+        if (isValidationSuccess(result)) {
+            return {
+                success: true,
+                data: result.value,
+            };
+        }
+        return {
+            success: false,
+            error: new ValError(result.issues),
+        };
+    }
+    /**
+     * Alias for `safeParse()` that matches Standard Schema naming.
+     */
+    validate(data) {
+        return this.safeParse(data);
+    }
+    /**
+     * Returns the JSON Schema for this schema's input type.
+     *
+     * @param target - The JSON Schema version (e.g., 'draft-2020-12', 'draft-07', 'openapi-3.0')
+     * @returns A JSON Schema object
+     *
+     * @example
+     * ```typescript
+     * const schema = v.string();
+     * const jsonSchema = schema.toJsonSchema('draft-2020-12');
+     * // { type: 'string' }
+     * ```
+     */
+    toJsonSchema(target = 'draft-2020-12') {
+        return this['~standard'].jsonSchema.input({ target });
+    }
+    /**
+     * Fast boolean check using JS-compiled validator.
+     *
+     * Returns true if the data passes validation, false otherwise.
+     * Does NOT apply transforms - use safeParse() for that.
+     *
+     * @param data - The value to check
+     * @returns true if valid, false otherwise
+     *
+     * @example
+     * ```typescript
+     * const schema = v.string();
+     * schema.check('hello'); // true
+     * schema.check(42);      // false
+     * ```
+     */
+    check(data) {
+        if (!this._compiledCheck) {
+            try {
+                const jsonSchema = this.toJsonSchema();
+                this._compiledCheck = compileSchema(jsonSchema);
+            }
+            catch {
+                // Fallback: always return true if compilation fails
+                this._compiledCheck = () => true;
+            }
+        }
+        return this._compiledCheck(data);
+    }
+    /**
+     * Checks if the schema is optional.
+     *
+     * Override in subclasses that support optionality.
+     */
+    isOptional() {
+        return false;
+    }
+    /**
+     * Checks if the schema is nullable.
+     *
+     * Override in subclasses that support nullability.
+     */
+    isNullable() {
+        return false;
+    }
+    /**
+     * Makes the schema accept undefined values.
+     *
+     * @returns A new schema that accepts T | undefined
+     *
+     * @example
+     * ```typescript
+     * const schema = v.string().optional();
+     * schema.parse(undefined); // undefined
+     * schema.parse('hello');   // 'hello'
+     * ```
+     */
+    optional() {
+        return new ValOptional(this);
+    }
+    /**
+     * Makes the schema accept null values.
+     *
+     * @returns A new schema that accepts T | null
+     *
+     * @example
+     * ```typescript
+     * const schema = v.string().nullable();
+     * schema.parse(null);    // null
+     * schema.parse('hello'); // 'hello'
+     * ```
+     */
+    nullable() {
+        return new ValNullable(this);
+    }
+    /**
+     * Makes the schema accept null or undefined values.
+     *
+     * @returns A new schema that accepts T | null | undefined
+     *
+     * @example
+     * ```typescript
+     * const schema = v.string().nullish();
+     * schema.parse(null);      // null
+     * schema.parse(undefined); // undefined
+     * schema.parse('hello');   // 'hello'
+     * ```
+     */
+    nullish() {
+        return new ValNullish(this);
+    }
+    /**
+     * Provides a default value when the input is undefined.
+     *
+     * @param defaultValue - The default value or a function that returns it
+     * @returns A new schema that uses the default when input is undefined
+     *
+     * @example
+     * ```typescript
+     * const schema = v.string().default('anonymous');
+     * schema.parse(undefined); // 'anonymous'
+     * schema.parse('hello');   // 'hello'
+     * ```
+     */
+    default(defaultValue) {
+        return new ValDefault(this, defaultValue);
+    }
+    /**
+     * Provides a fallback value when parsing fails.
+     *
+     * @param catchValue - The fallback value or a function that returns it
+     * @returns A new schema that uses the fallback on parse error
+     *
+     * @example
+     * ```typescript
+     * const schema = v.number().catch(0);
+     * schema.parse('not a number'); // 0
+     * schema.parse(42);             // 42
+     * ```
+     */
+    catch(catchValue) {
+        return new ValCatch(this, catchValue);
+    }
+    /**
+     * Creates an array schema with this schema as the element type.
+     *
+     * This is an alternative syntax for `v.array(schema)`.
+     *
+     * @returns A new array schema
+     *
+     * @example
+     * ```typescript
+     * const schema = v.string().array();
+     * schema.parse(['a', 'b', 'c']); // ['a', 'b', 'c']
+     *
+     * type Arr = v.infer<typeof schema>; // string[]
+     * ```
+     */
+    array() {
+        return new ValArray(this);
+    }
+    /**
+     * Creates a union of this schema with another schema.
+     *
+     * @param other - The other schema to union with
+     * @returns A new union schema
+     *
+     * @example
+     * ```typescript
+     * const schema = v.string().or(v.number());
+     * schema.parse('hello'); // 'hello'
+     * schema.parse(42);      // 42
+     *
+     * type T = v.infer<typeof schema>; // string | number
+     * ```
+     */
+    or(other) {
+        return new ValUnion([this, other]);
+    }
+    /**
+     * Creates an intersection of this schema with another schema.
+     *
+     * @param other - The other schema to intersect with
+     * @returns A new intersection schema
+     *
+     * @example
+     * ```typescript
+     * const A = v.object({ a: v.string() });
+     * const B = v.object({ b: v.number() });
+     * const AB = A.and(B);
+     *
+     * type AB = v.infer<typeof AB>; // { a: string } & { b: number }
+     * ```
+     */
+    and(other) {
+        return new ValIntersection(this, other);
+    }
+    // ============================================================================
+    // Transform and Refinement Methods
+    // ============================================================================
+    /**
+     * Transforms the output value after validation.
+     *
+     * Changes the output type of the schema.
+     *
+     * @param fn - Transform function that receives validated value
+     * @returns A new schema with transformed output type
+     *
+     * @example
+     * ```typescript
+     * const schema = v.string().transform(s => parseInt(s, 10));
+     * schema.parse('42'); // 42 (number)
+     *
+     * type Input = v.input<typeof schema>;   // string
+     * type Output = v.output<typeof schema>; // number
+     * ```
+     */
+    transform(fn) {
+        return new ValTransformed(this, fn);
+    }
+    /**
+     * Adds a custom validation refinement.
+     *
+     * Does not change the output type.
+     *
+     * @param predicate - Function that returns true if valid, false otherwise
+     * @param messageOrOptions - Error message or options object
+     * @returns A new schema with the refinement
+     *
+     * @example
+     * ```typescript
+     * const schema = v.string().refine(
+     *   s => s.length > 0,
+     *   'Required'
+     * );
+     *
+     * const schemaWithPath = v.string().refine(
+     *   s => s.includes('@'),
+     *   { message: 'Must contain @', path: ['email'] }
+     * );
+     * ```
+     */
+    refine(predicate, messageOrOptions = 'Invalid value') {
+        const options = typeof messageOrOptions === 'string'
+            ? { message: messageOrOptions }
+            : messageOrOptions;
+        return new ValRefined(this, predicate, options);
+    }
+    /**
+     * Adds advanced refinement that can add multiple issues.
+     *
+     * Provides a context object for adding validation issues.
+     *
+     * @param fn - Refinement function with context
+     * @returns A new schema with the refinement
+     *
+     * @example
+     * ```typescript
+     * const schema = v.string().superRefine((val, ctx) => {
+     *   if (val.length < 5) {
+     *     ctx.addIssue({
+     *       code: 'custom',
+     *       message: 'Too short',
+     *       path: [],
+     *     });
+     *   }
+     *   if (val.length > 100) {
+     *     ctx.addIssue({
+     *       code: 'custom',
+     *       message: 'Too long',
+     *       path: [],
+     *     });
+     *   }
+     * });
+     * ```
+     */
+    superRefine(fn) {
+        return new ValSuperRefined(this, fn);
+    }
+    /**
+     * Pipes the output of this schema into another schema.
+     *
+     * Useful for chaining transforms with additional validation.
+     *
+     * @param schema - The schema to pipe into
+     * @returns A new schema that validates with both schemas
+     *
+     * @example
+     * ```typescript
+     * const schema = v.string()
+     *   .transform(s => parseInt(s, 10))
+     *   .pipe(v.number().positive());
+     *
+     * schema.parse('42');  // 42
+     * schema.parse('-5');  // throws (not positive)
+     * ```
+     */
+    pipe(schema) {
+        return new ValPiped(this, schema);
+    }
+    // ============================================================================
+    // Async Parsing Methods
+    // ============================================================================
+    /**
+     * Asynchronously parses the input value.
+     *
+     * Required when using async transforms or refinements.
+     *
+     * @param data - The value to validate
+     * @returns Promise resolving to the validated value
+     * @throws {ValError} If validation fails
+     *
+     * @example
+     * ```typescript
+     * const schema = v.string().refine(async (s) => {
+     *   return await checkIfExists(s);
+     * }, 'Not found');
+     *
+     * const value = await schema.parseAsync('test');
+     * ```
+     */
+    async parseAsync(data) {
+        const result = await this.safeParseAsync(data);
+        if (result.success) {
+            return result.data;
+        }
+        throw result.error;
+    }
+    /**
+     * Asynchronously parses the input and returns a result object.
+     *
+     * Never throws. Required when using async transforms or refinements.
+     *
+     * @param data - The value to validate
+     * @returns Promise resolving to result object
+     *
+     * @example
+     * ```typescript
+     * const schema = v.string().transform(async (s) => {
+     *   return await lookupValue(s);
+     * });
+     *
+     * const result = await schema.safeParseAsync('key');
+     * if (result.success) {
+     *   console.log(result.data);
+     * }
+     * ```
+     */
+    async safeParseAsync(data) {
+        const result = this['~standard'].validate(data);
+        // Handle both sync and async validation results
+        const resolvedResult = result instanceof Promise ? await result : result;
+        if (isValidationSuccess(resolvedResult)) {
+            return {
+                success: true,
+                data: resolvedResult.value,
+            };
+        }
+        return {
+            success: false,
+            error: new ValError(resolvedResult.issues),
+        };
+    }
+}
+/**
+ * Schema for array values with validation methods.
+ *
+ * Supports chainable methods like `.min()`, `.max()`, `.length()`, `.nonempty()`.
+ * Each method returns a new schema instance (immutable).
+ *
+ * @template S - The element schema type
+ *
+ * @example
+ * ```typescript
+ * const schema = v.array(v.string());
+ * schema.parse(['a', 'b', 'c']); // ['a', 'b', 'c']
+ *
+ * const nonEmpty = v.array(v.number()).nonempty();
+ * nonEmpty.parse([1, 2]); // [1, 2]
+ * nonEmpty.parse([]);     // throws
+ * ```
+ */
+export class ValArray extends ValSchema {
+    element;
+    validators;
+    constructor(elementSchema, validators = []) {
+        const capturedValidators = validators;
+        const validateFn = (value) => {
+            if (!Array.isArray(value)) {
+                return { issues: [{ message: 'Expected array' }] };
+            }
+            const result = [];
+            const issues = [];
+            for (let i = 0; i < value.length; i++) {
+                const elementResult = elementSchema['~standard'].validate(value[i]);
+                if (elementResult.issues !== undefined) {
+                    for (const issue of elementResult.issues) {
+                        issues.push({
+                            message: issue.message,
+                            path: [i, ...(issue.path ?? [])],
+                        });
+                    }
+                }
+                else {
+                    result.push(elementResult.value);
+                }
+            }
+            if (issues.length > 0) {
+                return { issues };
+            }
+            // Run array-level validators
+            for (let i = 0; i < capturedValidators.length; i++) {
+                const validator = capturedValidators[i];
+                if (validator !== undefined) {
+                    const issue = validator(result);
+                    if (issue !== null) {
+                        return issue;
+                    }
+                }
+            }
+            return { value: result };
+        };
+        const inputJsonSchemaFn = (target) => ({
+            type: 'array',
+            items: elementSchema['~standard'].jsonSchema.input({ target }),
+        });
+        const outputJsonSchemaFn = (target) => ({
+            type: 'array',
+            items: elementSchema['~standard'].jsonSchema.output({ target }),
+        });
+        super(validateFn, inputJsonSchemaFn, outputJsonSchemaFn);
+        this.element = elementSchema;
+        this.validators = validators;
+        this._hasTransforms = elementSchema.hasTransforms() || validators.length > 0;
+    }
+    /**
+     * Creates a copy of this schema with additional validators.
+     */
+    clone(additionalValidators) {
+        return new ValArray(this.element, [...this.validators, ...additionalValidators]);
+    }
+    /**
+     * Requires array to have at least `length` elements.
+     */
+    min(length, message) {
+        return this.clone([
+            (arr) => arr.length >= length
+                ? null
+                : { issues: [{ message: message ?? `Array must have at least ${length} element(s)` }] },
+        ]);
+    }
+    /**
+     * Requires array to have at most `length` elements.
+     */
+    max(length, message) {
+        return this.clone([
+            (arr) => arr.length <= length
+                ? null
+                : { issues: [{ message: message ?? `Array must have at most ${length} element(s)` }] },
+        ]);
+    }
+    /**
+     * Requires array to have exactly `len` elements.
+     */
+    length(len, message) {
+        return this.clone([
+            (arr) => arr.length === len
+                ? null
+                : { issues: [{ message: message ?? `Array must have exactly ${len} element(s)` }] },
+        ]);
+    }
+    /**
+     * Requires array to be non-empty (at least 1 element).
+     */
+    nonempty(message) {
+        return this.min(1, message ?? 'Array must not be empty');
+    }
+}
+/**
+ * Schema for union types (one of multiple schemas).
+ *
+ * @template T - Array of member schemas
+ *
+ * @example
+ * ```typescript
+ * const schema = v.union([v.string(), v.number()]);
+ * schema.parse('hello'); // 'hello'
+ * schema.parse(42);      // 42
+ *
+ * type U = v.infer<typeof schema>; // string | number
+ * ```
+ */
+export class ValUnion extends ValSchema {
+    options;
+    constructor(options) {
+        const validateFn = (value) => {
+            for (const option of options) {
+                const result = option['~standard'].validate(value);
+                if (result.issues === undefined) {
+                    return { value: result.value };
+                }
+            }
+            return {
+                issues: [{ message: `Invalid union: none of ${options.length} variants matched` }],
+            };
+        };
+        const inputJsonSchemaFn = (target) => ({
+            oneOf: options.map((o) => o['~standard'].jsonSchema.input({ target })),
+        });
+        const outputJsonSchemaFn = (target) => ({
+            oneOf: options.map((o) => o['~standard'].jsonSchema.output({ target })),
+        });
+        super(validateFn, inputJsonSchemaFn, outputJsonSchemaFn);
+        this.options = options;
+        this._hasTransforms = options.some(s => s.hasTransforms());
+    }
+}
+// ============================================================================
+// ValIntersection Class
+// ============================================================================
+/**
+ * Schema for intersection types (all of multiple schemas).
+ *
+ * @template L - Left schema
+ * @template R - Right schema
+ *
+ * @example
+ * ```typescript
+ * const A = v.object({ a: v.string() });
+ * const B = v.object({ b: v.number() });
+ * const AB = v.intersection(A, B);
+ *
+ * type AB = v.infer<typeof AB>; // { a: string } & { b: number }
+ * ```
+ */
+export class ValIntersection extends ValSchema {
+    left;
+    right;
+    constructor(left, right) {
+        const validateFn = (value) => {
+            const leftResult = left['~standard'].validate(value);
+            if (leftResult.issues !== undefined) {
+                return leftResult;
+            }
+            const rightResult = right['~standard'].validate(value);
+            if (rightResult.issues !== undefined) {
+                return rightResult;
+            }
+            // Merge results for objects
+            if (typeof leftResult.value === 'object' &&
+                leftResult.value !== null &&
+                typeof rightResult.value === 'object' &&
+                rightResult.value !== null) {
+                return { value: { ...leftResult.value, ...rightResult.value } };
+            }
+            // For non-objects, just return the left result (both passed)
+            return { value: leftResult.value };
+        };
+        const inputJsonSchemaFn = (target) => ({
+            allOf: [
+                left['~standard'].jsonSchema.input({ target }),
+                right['~standard'].jsonSchema.input({ target }),
+            ],
+        });
+        const outputJsonSchemaFn = (target) => ({
+            allOf: [
+                left['~standard'].jsonSchema.output({ target }),
+                right['~standard'].jsonSchema.output({ target }),
+            ],
+        });
+        super(validateFn, inputJsonSchemaFn, outputJsonSchemaFn);
+        this.left = left;
+        this.right = right;
+        this._hasTransforms = left.hasTransforms() || right.hasTransforms();
+    }
+}
+/**
+ * Schema wrapper that makes the inner schema optional (accepts undefined).
+ */
+export class ValOptional extends ValSchema {
+    innerSchema;
+    constructor(schema) {
+        const validateFn = (value) => {
+            if (value === undefined) {
+                return { value: undefined };
+            }
+            return schema['~standard'].validate(value);
+        };
+        const inputJsonSchemaFn = (target) => {
+            const innerSchema = schema['~standard'].jsonSchema.input({ target });
+            return { oneOf: [innerSchema, { type: 'null' }] };
+        };
+        const outputJsonSchemaFn = (target) => {
+            const innerSchema = schema['~standard'].jsonSchema.output({ target });
+            return { oneOf: [innerSchema, { type: 'null' }] };
+        };
+        super(validateFn, inputJsonSchemaFn, outputJsonSchemaFn);
+        this.innerSchema = schema;
+    }
+    isOptional() {
+        return true;
+    }
+    /**
+     * Returns the inner schema (unwrapped).
+     */
+    unwrap() {
+        return this.innerSchema;
+    }
+}
+/**
+ * Schema wrapper that makes the inner schema nullable (accepts null).
+ */
+export class ValNullable extends ValSchema {
+    innerSchema;
+    constructor(schema) {
+        const validateFn = (value) => {
+            if (value === null) {
+                return { value: null };
+            }
+            return schema['~standard'].validate(value);
+        };
+        const inputJsonSchemaFn = (target) => {
+            const innerSchema = schema['~standard'].jsonSchema.input({ target });
+            return { oneOf: [innerSchema, { type: 'null' }] };
+        };
+        const outputJsonSchemaFn = (target) => {
+            const innerSchema = schema['~standard'].jsonSchema.output({ target });
+            return { oneOf: [innerSchema, { type: 'null' }] };
+        };
+        super(validateFn, inputJsonSchemaFn, outputJsonSchemaFn);
+        this.innerSchema = schema;
+    }
+    isNullable() {
+        return true;
+    }
+    /**
+     * Returns the inner schema (unwrapped).
+     */
+    unwrap() {
+        return this.innerSchema;
+    }
+}
+/**
+ * Schema wrapper that makes the inner schema nullish (accepts null or undefined).
+ */
+export class ValNullish extends ValSchema {
+    innerSchema;
+    constructor(schema) {
+        const validateFn = (value) => {
+            if (value === null) {
+                return { value: null };
+            }
+            if (value === undefined) {
+                return { value: undefined };
+            }
+            return schema['~standard'].validate(value);
+        };
+        const inputJsonSchemaFn = (target) => {
+            const innerSchema = schema['~standard'].jsonSchema.input({ target });
+            return { oneOf: [innerSchema, { type: 'null' }] };
+        };
+        const outputJsonSchemaFn = (target) => {
+            const innerSchema = schema['~standard'].jsonSchema.output({ target });
+            return { oneOf: [innerSchema, { type: 'null' }] };
+        };
+        super(validateFn, inputJsonSchemaFn, outputJsonSchemaFn);
+        this.innerSchema = schema;
+    }
+    isOptional() {
+        return true;
+    }
+    isNullable() {
+        return true;
+    }
+    /**
+     * Returns the inner schema (unwrapped).
+     */
+    unwrap() {
+        return this.innerSchema;
+    }
+}
+/**
+ * Schema wrapper that provides a default value when input is undefined.
+ */
+export class ValDefault extends ValSchema {
+    innerSchema;
+    constructor(schema, defaultValue) {
+        const capturedDefault = defaultValue;
+        const validateFn = (value) => {
+            if (value === undefined) {
+                const resolved = typeof capturedDefault === 'function'
+                    ? capturedDefault()
+                    : capturedDefault;
+                return { value: resolved };
+            }
+            return schema['~standard'].validate(value);
+        };
+        const inputJsonSchemaFn = (target) => {
+            return schema['~standard'].jsonSchema.input({ target });
+        };
+        const outputJsonSchemaFn = (target) => {
+            return schema['~standard'].jsonSchema.output({ target });
+        };
+        super(validateFn, inputJsonSchemaFn, outputJsonSchemaFn);
+        this.innerSchema = schema;
+        this._hasTransforms = true;
+    }
+    /**
+     * Removes the default wrapper.
+     */
+    removeDefault() {
+        return this.innerSchema;
+    }
+}
+/**
+ * Schema wrapper that provides a catch value when parsing fails.
+ */
+export class ValCatch extends ValSchema {
+    innerSchema;
+    constructor(schema, catchValue) {
+        const capturedCatch = catchValue;
+        const validateFn = (value) => {
+            const result = schema['~standard'].validate(value);
+            if (result.issues !== undefined) {
+                const resolved = typeof capturedCatch === 'function'
+                    ? capturedCatch()
+                    : capturedCatch;
+                return { value: resolved };
+            }
+            return result;
+        };
+        const inputJsonSchemaFn = (target) => {
+            return schema['~standard'].jsonSchema.input({ target });
+        };
+        const outputJsonSchemaFn = (target) => {
+            return schema['~standard'].jsonSchema.output({ target });
+        };
+        super(validateFn, inputJsonSchemaFn, outputJsonSchemaFn);
+        this.innerSchema = schema;
+        this._hasTransforms = true;
+    }
+    /**
+     * Removes the catch wrapper.
+     */
+    removeCatch() {
+        return this.innerSchema;
+    }
+}
+// ============================================================================
+// Transform and Refinement Schema Classes
+// ============================================================================
+/**
+ * Schema that applies a transform function after validation.
+ *
+ * Changes the output type of the schema.
+ *
+ * @template Input - The original input type
+ * @template Middle - The intermediate validated type
+ * @template Output - The final transformed output type
+ */
+export class ValTransformed extends ValSchema {
+    constructor(schema, fn) {
+        const capturedFn = fn;
+        const capturedSchema = schema;
+        const validateFn = (value) => {
+            const result = capturedSchema['~standard'].validate(value);
+            // Handle async inner validation
+            if (result instanceof Promise) {
+                return result.then((resolvedResult) => {
+                    if (resolvedResult.issues !== undefined) {
+                        return resolvedResult;
+                    }
+                    const transformed = capturedFn(resolvedResult.value);
+                    if (transformed instanceof Promise) {
+                        return transformed.then((v) => success(v));
+                    }
+                    return success(transformed);
+                });
+            }
+            if (result.issues !== undefined) {
+                return result;
+            }
+            // Apply transform
+            const transformed = capturedFn(result.value);
+            if (transformed instanceof Promise) {
+                return transformed.then((v) => success(v));
+            }
+            return success(transformed);
+        };
+        const inputJsonSchemaFn = (target) => {
+            return capturedSchema['~standard'].jsonSchema.input({ target });
+        };
+        // Output JSON schema is not available for arbitrary transforms
+        const outputJsonSchemaFn = (_target) => {
+            return {};
+        };
+        // Cast to sync validate function - async is handled by parseAsync/safeParseAsync
+        super(validateFn, inputJsonSchemaFn, outputJsonSchemaFn);
+        this._hasTransforms = true;
+    }
+}
+/**
+ * Schema that adds a refinement predicate.
+ *
+ * Does not change the output type.
+ *
+ * @template Input - The input type
+ * @template Output - The output type
+ */
+export class ValRefined extends ValSchema {
+    constructor(schema, predicate, options) {
+        const capturedPredicate = predicate;
+        const capturedOptions = options;
+        const capturedSchema = schema;
+        const validateFn = (value) => {
+            const result = capturedSchema['~standard'].validate(value);
+            // Handle async inner validation
+            if (result instanceof Promise) {
+                return result.then((resolvedResult) => {
+                    if (resolvedResult.issues !== undefined) {
+                        return resolvedResult;
+                    }
+                    return applyRefinement(resolvedResult.value);
+                });
+            }
+            if (result.issues !== undefined) {
+                return result;
+            }
+            return applyRefinement(result.value);
+            function applyRefinement(validatedValue) {
+                const predicateResult = capturedPredicate(validatedValue);
+                if (predicateResult instanceof Promise) {
+                    return predicateResult.then((isValid) => {
+                        if (!isValid) {
+                            const issue = {
+                                message: capturedOptions.message ?? 'Invalid value',
+                            };
+                            if (capturedOptions.path !== undefined) {
+                                issue.path = capturedOptions.path;
+                            }
+                            return { issues: [issue] };
+                        }
+                        return success(validatedValue);
+                    });
+                }
+                if (!predicateResult) {
+                    const issue = {
+                        message: capturedOptions.message ?? 'Invalid value',
+                    };
+                    if (capturedOptions.path !== undefined) {
+                        issue.path = capturedOptions.path;
+                    }
+                    return { issues: [issue] };
+                }
+                return success(validatedValue);
+            }
+        };
+        const inputJsonSchemaFn = (target) => {
+            return capturedSchema['~standard'].jsonSchema.input({ target });
+        };
+        const outputJsonSchemaFn = (target) => {
+            return capturedSchema['~standard'].jsonSchema.output({ target });
+        };
+        // Cast to sync validate function - async is handled by parseAsync/safeParseAsync
+        super(validateFn, inputJsonSchemaFn, outputJsonSchemaFn);
+        this._hasTransforms = true;
+    }
+}
+/**
+ * Schema that applies a superRefine function for advanced validation.
+ *
+ * Allows adding multiple issues via the context.
+ *
+ * @template Input - The input type
+ * @template Output - The output type
+ */
+export class ValSuperRefined extends ValSchema {
+    constructor(schema, fn) {
+        const capturedFn = fn;
+        const capturedSchema = schema;
+        const validateFn = (value) => {
+            const result = capturedSchema['~standard'].validate(value);
+            // Handle async inner validation
+            if (result instanceof Promise) {
+                return result.then((resolvedResult) => {
+                    if (resolvedResult.issues !== undefined) {
+                        return resolvedResult;
+                    }
+                    return applySuperRefine(resolvedResult.value);
+                });
+            }
+            if (result.issues !== undefined) {
+                return result;
+            }
+            return applySuperRefine(result.value);
+            function applySuperRefine(validatedValue) {
+                const issues = [];
+                const ctx = {
+                    addIssue(issue) {
+                        const newIssue = {
+                            message: issue.message,
+                        };
+                        if (issue.path !== undefined) {
+                            newIssue.path = issue.path;
+                        }
+                        issues.push(newIssue);
+                    },
+                };
+                const fnResult = capturedFn(validatedValue, ctx);
+                if (fnResult instanceof Promise) {
+                    return fnResult.then(() => {
+                        if (issues.length > 0) {
+                            return { issues };
+                        }
+                        return success(validatedValue);
+                    });
+                }
+                if (issues.length > 0) {
+                    return { issues };
+                }
+                return success(validatedValue);
+            }
+        };
+        const inputJsonSchemaFn = (target) => {
+            return capturedSchema['~standard'].jsonSchema.input({ target });
+        };
+        const outputJsonSchemaFn = (target) => {
+            return capturedSchema['~standard'].jsonSchema.output({ target });
+        };
+        // Cast to sync validate function - async is handled by parseAsync/safeParseAsync
+        super(validateFn, inputJsonSchemaFn, outputJsonSchemaFn);
+        this._hasTransforms = true;
+    }
+}
+/**
+ * Schema that pipes the output of one schema into another.
+ *
+ * Useful for chaining transforms with additional validation.
+ *
+ * @template Input - The original input type
+ * @template Middle - The intermediate validated type
+ * @template Output - The final output type from the second schema
+ */
+export class ValPiped extends ValSchema {
+    constructor(first, second) {
+        const capturedFirst = first;
+        const capturedSecond = second;
+        const validateFn = (value) => {
+            const firstResult = capturedFirst['~standard'].validate(value);
+            // Handle async first validation
+            if (firstResult instanceof Promise) {
+                return firstResult.then((resolvedFirst) => {
+                    if (resolvedFirst.issues !== undefined) {
+                        return resolvedFirst;
+                    }
+                    return capturedSecond['~standard'].validate(resolvedFirst.value);
+                });
+            }
+            if (firstResult.issues !== undefined) {
+                return firstResult;
+            }
+            return capturedSecond['~standard'].validate(firstResult.value);
+        };
+        const inputJsonSchemaFn = (target) => {
+            return capturedFirst['~standard'].jsonSchema.input({ target });
+        };
+        const outputJsonSchemaFn = (target) => {
+            return capturedSecond['~standard'].jsonSchema.output({ target });
+        };
+        // Cast to sync validate function - async is handled by parseAsync/safeParseAsync
+        super(validateFn, inputJsonSchemaFn, outputJsonSchemaFn);
+        this._hasTransforms = first.hasTransforms() || second.hasTransforms();
+    }
+}
+/**
+ * Schema that preprocesses input before validation.
+ *
+ * Useful for coercing input types before validation.
+ *
+ * @template Input - The preprocessed input type
+ * @template Output - The validated output type
+ */
+export class ValPreprocessed extends ValSchema {
+    constructor(preprocessFn, schema) {
+        const capturedPreprocess = preprocessFn;
+        const capturedSchema = schema;
+        const validateFn = (value) => {
+            const preprocessed = capturedPreprocess(value);
+            return capturedSchema['~standard'].validate(preprocessed);
+        };
+        // Input schema is unknown since preprocessing accepts any input
+        const inputJsonSchemaFn = (_target) => {
+            return {};
+        };
+        const outputJsonSchemaFn = (target) => {
+            return capturedSchema['~standard'].jsonSchema.output({ target });
+        };
+        // Cast to sync validate function - async is handled by parseAsync/safeParseAsync
+        super(validateFn, inputJsonSchemaFn, outputJsonSchemaFn);
+        this._hasTransforms = true;
+    }
+}
+/**
+ * Creates a ValSchema from an existing Standard Schema object.
+ *
+ * Useful for wrapping schemas created with the factory functions.
+ *
+ * @param standardSchema - A Standard Schema compliant object
+ * @returns A ValSchema instance
+ */
+export function fromStandardSchema(standardSchema) {
+    const std = standardSchema['~standard'];
+    return new ValSchema(std.validate, (target) => std.jsonSchema.input({ target }), (target) => std.jsonSchema.output({ target }));
+}
+/**
+ * Creates a ValSchema from a simple Standard Schema (without JSON Schema support).
+ *
+ * @param standardSchema - A Standard Schema compliant object
+ * @param jsonSchemaFn - Function to generate JSON Schema
+ * @returns A ValSchema instance
+ */
+export function fromSimpleStandardSchema(standardSchema, jsonSchemaFn) {
+    return new ValSchema(standardSchema['~standard'].validate, jsonSchemaFn);
+}
+//# sourceMappingURL=schema.js.map