@nlozgachev/pipelined 0.42.0 → 0.44.0

package/dist/core.d.ts

@@ -1,7 +1,7 @@
-import { M as Maybe, q as WithValue, k as WithLog, D as Deferred, R as Result, j as WithKind, g as WithError, c as RetryOptions, d as TimeoutOptions, p as WithTimeout, l as WithMinInterval, e as WithCooldown, W as WithConcurrency, o as WithSize, f as WithDuration, m as WithN, T as Task, i as WithFirst, n as WithSecond, h as WithErrors } from './Task-Dt3ZMen6.js';
-export { E as Equality, a as Err, N as None, O as Ok, b as Ordering, S as Some } from './Task-Dt3ZMen6.js';
-import { D as Duration } from './Duration-BTeT9D-q.js';
-import { NonEmptyList } from './types.js';
+import { M as Maybe, R as Result, T as Task } from './Validation-DM2eh6wj.js';
+export { E as Equality, a as Err, F as Failed, N as None, O as Ok, b as Ordering, P as Passed, S as Some, c as TaskMaybe, d as TaskResult, e as TaskValidation, V as Validation } from './Validation-DM2eh6wj.js';
+import { n as WithValue, h as WithLog, D as Deferred, g as WithKind, d as WithError, R as RetryOptions, a as TimeoutOptions, m as WithTimeout, i as WithMinInterval, b as WithCooldown, W as WithConcurrency, l as WithSize, c as WithDuration, j as WithN, f as WithFirst, k as WithSecond } from './InternalTypes-7o9-yrHq.js';
+import { Duration } from './types.js';
 
 /**
  * A type that can combine two values of type `A` into one, with a neutral starting value.
@@ -1972,7 +1972,7 @@ declare namespace RemoteData {
      *
      * @example
      * ```ts
-     * const result = await TaskResult.tryCatch(fetchUser, String)();
+     * const result = await Task.Result.tryCatch(fetchUser, String)();
      * setState(RemoteData.fromResult(result)); // Success(user) or Failure(msg)
      * ```
      */
@@ -2021,7 +2021,7 @@ declare namespace RemoteData {
  * @example
  * ```ts
  * const dbResource = Resource.make(
- *   TaskResult.tryCatch(() => openConnection(config), (e) => new DbError(e)),
+ *   Task.Result.tryCatch(() => openConnection(config), (e) => new DbError(e)),
  *   (conn) => Task.from(() => conn.close())
  * );
  *
@@ -2033,7 +2033,7 @@ declare namespace RemoteData {
  * ```
  */
 type Resource<E, A> = {
-    readonly acquire: TaskResult<E, A>;
+    readonly acquire: Task.Result<E, A>;
     readonly release: (a: A) => Task<void>;
 };
 declare namespace Resource {
@@ -2043,12 +2043,12 @@ declare namespace Resource {
      * @example
      * ```ts
      * const fileResource = Resource.make(
-     *   TaskResult.tryCatch(() => fs.promises.open("data.csv", "r"), toFileError),
+     *   Task.Result.tryCatch(() => fs.promises.open("data.csv", "r"), toFileError),
      *   (handle) => Task.from(() => handle.close())
      * );
      * ```
      */
-    const make: <E, A>(acquire: TaskResult<E, A>, release: (a: A) => Task<void>) => Resource<E, A>;
+    const make: <E, A>(acquire: Task.Result<E, A>, release: (a: A) => Task<void>) => Resource<E, A>;
     /**
      * Creates a Resource from an acquire operation that cannot fail.
      * Use this when opening the resource is guaranteed to succeed, such as
@@ -2078,7 +2078,7 @@ declare namespace Resource {
      * // conn is closed whether the query succeeds or fails
      * ```
      */
-    const use: <E, A, B>(f: (a: A) => TaskResult<E, B>) => (resource: Resource<E, A>) => TaskResult<E, B>;
+    const use: <E, A, B>(f: (a: A) => Task.Result<E, B>) => (resource: Resource<E, A>) => Task.Result<E, B>;
     /**
      * Acquires two resources in sequence and presents them as a tuple.
      * Resources are released in reverse order: the second is released before the first.
@@ -2312,483 +2312,6 @@ declare namespace State {
     const bind: <K extends string, S, A, B>(key: K, f: (a: A) => State<S, B>) => (data: State<S, A>) => State<S, A & { [P in K]: B; }>;
 }
 
-/**
- * A Task that resolves to an optional value.
- * Combines async operations with the Maybe type for values that may not exist.
- *
- * @example
- * ```ts
- * const findUser = (id: string): TaskMaybe<User> =>
- *   TaskMaybe.tryCatch(() => db.users.findById(id));
- *
- * pipe(
- *   findUser("123"),
- *   TaskMaybe.map(user => user.name),
- *   TaskMaybe.getOrElse(() => "Unknown")
- * )();
- * ```
- */
-type TaskMaybe<A> = Task<Maybe<A>>;
-declare namespace TaskMaybe {
-    /**
-     * Wraps a value in a Some inside a Task.
-     */
-    const some: <A>(value: A) => TaskMaybe<A>;
-    /**
-     * Creates a TaskMaybe that resolves to None.
-     */
-    const none: <A = never>() => TaskMaybe<A>;
-    /**
-     * Lifts an Option into a TaskMaybe.
-     */
-    const fromMaybe: <A>(option: Maybe<A>) => TaskMaybe<A>;
-    /**
-     * Creates a TaskMaybe from a nullable value.
-     * Returns Some if the value is not null or undefined, None otherwise.
-     */
-    const fromNullable: <A>(value: A | null | undefined) => TaskMaybe<A>;
-    /**
-     * Creates a TaskMaybe from a Result.
-     * Ok becomes Some, Error becomes None (the error value is discarded).
-     */
-    const fromResult: <E, A>(result: Result<E, A>) => TaskMaybe<A>;
-    /**
-     * Lifts a Task into a TaskMaybe by wrapping its result in Some.
-     */
-    const fromTask: <A>(task: Task<A>) => TaskMaybe<A>;
-    /**
-     * Creates a TaskMaybe from a Promise-returning function.
-     * Returns Some if the promise resolves, None if it rejects.
-     * The factory optionally receives an `AbortSignal` forwarded from the call site.
-     *
-     * @example
-     * ```ts
-     * const fetchUser = TaskMaybe.tryCatch((signal) =>
-     *   fetch("/user/1", { signal }).then(r => r.json())
-     * );
-     * ```
-     */
-    const tryCatch: <A>(f: (signal?: AbortSignal) => Promise<A>) => TaskMaybe<A>;
-    /**
-     * Transforms the value inside a TaskMaybe.
-     */
-    const map: <A, B>(f: (a: A) => B) => (data: TaskMaybe<A>) => TaskMaybe<B>;
-    /**
-     * Chains TaskMaybe computations. If the first resolves to Some, passes the
-     * value to f. If the first resolves to None, propagates None.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   findUser("123"),
-     *   TaskMaybe.chain(user => findOrg(user.orgId))
-     * )();
-     * ```
-     */
-    const chain: <A, B>(f: (a: A) => TaskMaybe<B>) => (data: TaskMaybe<A>) => TaskMaybe<B>;
-    /**
-     * Applies a function wrapped in a TaskMaybe to a value wrapped in a TaskMaybe.
-     * Both Tasks run in parallel.
-     */
-    const ap: <A>(arg: TaskMaybe<A>) => <B>(data: TaskMaybe<(a: A) => B>) => TaskMaybe<B>;
-    /**
-     * Extracts a value from a TaskMaybe by providing handlers for both cases.
-     */
-    const fold: <A, B>(onNone: () => B, onSome: (a: A) => B) => (data: TaskMaybe<A>) => Task<B>;
-    /**
-     * Pattern matches on a TaskMaybe, returning a Task of the result.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   findUser("123"),
-     *   TaskMaybe.match({
-     *     some: user => `Hello, ${user.name}`,
-     *     none: () => "User not found"
-     *   })
-     * )();
-     * ```
-     */
-    const match: <A, B>(cases: {
-        none: () => B;
-        some: (a: A) => B;
-    }) => (data: TaskMaybe<A>) => Task<B>;
-    /**
-     * Returns the value or a default if the TaskMaybe resolves to None.
-     * The default can be a different type, widening the result to `Task<A | B>`.
-     */
-    const getOrElse: <A, B>(defaultValue: () => B) => (data: TaskMaybe<A>) => Task<A | B>;
-    /**
-     * Executes a side effect on the value without changing the TaskMaybe.
-     * Useful for logging or debugging.
-     */
-    const tap: <A>(f: (a: A) => void) => (data: TaskMaybe<A>) => TaskMaybe<A>;
-    /**
-     * Filters the value inside a TaskMaybe. Returns None if the predicate fails.
-     */
-    const filter: <A>(predicate: (a: A) => boolean) => (data: TaskMaybe<A>) => TaskMaybe<A>;
-    /**
-     * Converts a TaskMaybe to a TaskResult, using onNone to produce the error value.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   findUser("123"),
-     *   TaskMaybe.toTaskResult(() => "User not found")
-     * );
-     * ```
-     */
-    const toTaskResult: <E>(onNone: () => E) => <A>(data: TaskMaybe<A>) => TaskResult<E, A>;
-    /**
-     * Lifts a TaskMaybe value into an accumulator object.
-     *
-     * @example
-     * ```ts
-     * pipe(TaskMaybe.some(42), TaskMaybe.bindTo("value")); // TaskMaybe({ value: 42 })
-     * ```
-     */
-    const bindTo: <K extends string>(key: K) => <A>(data: TaskMaybe<A>) => TaskMaybe<{ [P in K]: A; }>;
-    /**
-     * Evaluates a new TaskMaybe using the current accumulator and attaches the output to a new key.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   TaskMaybe.some({ a: 1 }),
-     *   TaskMaybe.bind("b", ({ a }) => TaskMaybe.some(a + 1))
-     * ); // TaskMaybe({ a: 1, b: 2 })
-     * ```
-     */
-    const bind: <K extends string, A, B>(key: K, f: (a: A) => TaskMaybe<B>) => (data: TaskMaybe<A>) => TaskMaybe<A & { [P in K]: B; }>;
-}
-
-/**
- * A Task that can fail with an error of type E or succeed with a value of type A.
- * Combines async operations with typed error handling.
- *
- * @example
- * ```ts
- * const fetchUser = (id: string): TaskResult<Error, User> =>
- *   TaskResult.tryCatch(
- *     (signal) => fetch(`/users/${id}`, { signal }).then(r => r.json()),
- *     (e) => new Error(`Failed to fetch user: ${e}`)
- *   );
- * ```
- */
-type TaskResult<E, A> = Task<Result<E, A>>;
-declare namespace TaskResult {
-    /**
-     * Wraps a value in a successful TaskResult.
-     */
-    const ok: <E, A>(value: A) => TaskResult<E, A>;
-    /**
-     * Creates a failed TaskResult with the given error.
-     */
-    const err: <E, A>(error: E) => TaskResult<E, A>;
-    /**
-     * Creates a TaskResult from a nullable value.
-     * Returns Ok if the value is not null or undefined, err from onNull otherwise.
-     */
-    const fromNullable: <E>(onNull: () => E) => <A>(value: A | null | undefined) => TaskResult<E, A>;
-    /**
-     * Creates a TaskResult from a Maybe.
-     * Some becomes Ok, None becomes err from onNone.
-     */
-    const fromMaybe: <E>(onNone: () => E) => <A>(maybe: Maybe<A>) => TaskResult<E, A>;
-    /**
-     * Lifts a Result into a TaskResult.
-     */
-    const fromResult: <E, A>(result: Result<E, A>) => TaskResult<E, A>;
-    /**
-     * Wraps a Promise-returning function of any arguments, returning a new function
-     * that catches rejections and returns a TaskResult.
-     */
-    const fromThrowable: <Args extends readonly unknown[], A, E>(f: (...args: Args) => Promise<A>, onError: (e: unknown) => E) => (...args: Args) => TaskResult<E, A>;
-    /**
-     * Creates a TaskResult from a function that may throw.
-     * Catches any errors and transforms them using the onError function.
-     * The factory optionally receives an `AbortSignal` forwarded from the call site.
-     *
-     * @example
-     * ```ts
-     * const fetchUser = (id: string): TaskResult<string, User> =>
-     *   TaskResult.tryCatch(
-     *     (signal) => fetch(`/users/${id}`, { signal }).then(r => r.json()),
-     *     String
-     *   );
-     * ```
-     */
-    const tryCatch: <E, A>(f: (signal?: AbortSignal) => Promise<A>, onError: (e: unknown) => E) => TaskResult<E, A>;
-    /**
-     * Transforms the success value inside a TaskResult.
-     */
-    const map: <E, A, B>(f: (a: A) => B) => (data: TaskResult<E, A>) => TaskResult<E, B>;
-    /**
-     * Transforms the error value inside a TaskResult.
-     */
-    const mapError: <E, F, A>(f: (e: E) => F) => (data: TaskResult<E, A>) => TaskResult<F, A>;
-    /**
-     * Chains TaskResult computations. If the first succeeds, passes the value to f.
-     * If the first fails, propagates the error.
-     */
-    const chain: <E, A, B>(f: (a: A) => TaskResult<E, B>) => (data: TaskResult<E, A>) => TaskResult<E, B>;
-    /**
-     * Extracts the value from a TaskResult by providing handlers for both cases.
-     */
-    const fold: <E, A, B>(onErr: (e: E) => B, onOk: (a: A) => B) => (data: TaskResult<E, A>) => Task<B>;
-    /**
-     * Pattern matches on a TaskResult, returning a Task of the result.
-     */
-    const match: <E, A, B>(cases: {
-        err: (e: E) => B;
-        ok: (a: A) => B;
-    }) => (data: TaskResult<E, A>) => Task<B>;
-    /**
-     * Recovers from an error by providing a fallback TaskResult.
-     * The fallback can produce a different success type, widening the result to `TaskResult<E, A | B>`.
-     */
-    const recover: <E, A, B>(fallback: (e: E) => TaskResult<E, B>) => (data: TaskResult<E, A>) => TaskResult<E, A | B>;
-    /**
-     * Returns the success value or a default value if the TaskResult is an error.
-     * The default can be a different type, widening the result to `Task<A | B>`.
-     */
-    const getOrElse: <E, A, B>(defaultValue: () => B) => (data: TaskResult<E, A>) => Task<A | B>;
-    /**
-     * Executes a side effect on the success value without changing the TaskResult.
-     * Useful for logging or debugging.
-     */
-    const tap: <E, A>(f: (a: A) => void) => (data: TaskResult<E, A>) => TaskResult<E, A>;
-    /**
-     * Executes a side effect on the error value without changing the TaskResult.
-     * Useful for logging or reporting async errors.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   fetchUser(id),
-     *   TaskResult.tapError(e => console.error("fetch failed:", e)),
-     *   TaskResult.chain(saveToCache),
-     * )
-     * ```
-     */
-    const tapError: <E, A>(f: (e: E) => void) => (data: TaskResult<E, A>) => TaskResult<E, A>;
-    /**
-     * Applies a function wrapped in a TaskResult to a value wrapped in a TaskResult.
-     * Both Tasks run in parallel.
-     */
-    const ap: <E, A>(arg: TaskResult<E, A>) => <B>(data: TaskResult<E, (a: A) => B>) => TaskResult<E, B>;
-    /**
-     * Executes a `TaskResult` with an optional signal, returning `Promise<Result<E, A>>`.
-     * Use as a terminal step in a `pipe` chain.
-     *
-     * @example
-     * ```ts
-     * const controller = new AbortController();
-     * const result = await pipe(
-     *     fetchUser("42"),
-     *     TaskResult.chain(user => fetchPosts(user.id)),
-     *     TaskResult.run(controller.signal),
-     * );
-     * if (Result.isOk(result)) render(result.value);
-     * ```
-     */
-    const run: (signal?: AbortSignal) => <E, A>(task: TaskResult<E, A>) => Deferred<Result<E, A>>;
-    /**
-     * Converts a TaskResult value into an object containing a single property.
-     * Initiates the pipeline accumulator record.
-     *
-     * @example
-     * ```ts
-     * pipe(TaskResult.ok(42), TaskResult.bindTo("value")); // TaskResult({ value: 42 })
-     * ```
-     */
-    const bindTo: <K extends string>(key: K) => <E, A>(data: TaskResult<E, A>) => TaskResult<E, { [P in K]: A; }>;
-    /**
-     * Evaluates a new TaskResult using the current accumulator and attaches the output to a new key.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   TaskResult.ok({ a: 1 }),
-     *   TaskResult.bind("b", ({ a }) => TaskResult.ok(a + 1))
-     * ); // TaskResult({ a: 1, b: 2 })
-     * ```
-     */
-    const bind: <K extends string, E, A, B>(key: K, f: (a: A) => TaskResult<E, B>) => (data: TaskResult<E, A>) => TaskResult<E, A & { [P in K]: B; }>;
-    /**
-     * Combines a record of TaskResults into a single TaskResult of a record.
-     * Evaluates all tasks in parallel, forwarding the AbortSignal down to each sub-task.
-     * Returns the first Err encountered in key order.
-     *
-     * @example
-     * ```ts
-     * TaskResult.struct({
-     *   name: TaskResult.ok("Alice"),
-     *   age: TaskResult.ok(30)
-     * }); // TaskResult({ name: "Alice", age: 30 })
-     * ```
-     */
-    const struct: <E, R extends Record<string, any>>(fields: { [K in keyof R]: TaskResult<E, R[K]>; }) => TaskResult<E, R>;
-}
-
-/**
- * A Task that resolves to a Validation — combining async operations with
- * error accumulation. Unlike TaskResult, multiple failures are collected
- * rather than short-circuiting on the first error.
- *
- * @example
- * ```ts
- * const validateName = (name: string): TaskValidation<string, string> =>
- *   name.length > 0
- *     ? TaskValidation.passed(name)
- *     : TaskValidation.failed("Name is required");
- *
- * // Accumulate errors from multiple async validations using ap
- * pipe(
- *   TaskValidation.passed((name: string) => (age: number) => ({ name, age })),
- *   TaskValidation.ap(validateName("")),
- *   TaskValidation.ap(validateAge(-1))
- * )();
- * // Failed(["Name is required", "Age must be positive"])
- * ```
- */
-type TaskValidation<E, A> = Task<Validation<E, A>>;
-declare namespace TaskValidation {
-    /**
-     * Wraps a value in a passed TaskValidation.
-     */
-    const passed: <E, A>(value: A) => TaskValidation<E, A>;
-    /**
-     * Creates a failed TaskValidation with a single error.
-     */
-    const failed: <E, A>(error: E) => TaskValidation<E, A>;
-    /**
-     * Creates a failed TaskValidation from multiple errors.
-     */
-    const failedAll: <E, A>(errors: NonEmptyList<E>) => TaskValidation<E, A>;
-    /**
-     * Lifts a Validation into a TaskValidation.
-     */
-    const fromValidation: <E, A>(validation: Validation<E, A>) => TaskValidation<E, A>;
-    /**
-     * Creates a TaskValidation from a nullable value.
-     * If the value is null or undefined, returns Failed with the error from onNull.
-     * Otherwise, returns Passed.
-     */
-    const fromNullable: <E>(onNull: () => E) => <A>(value: A | null | undefined) => TaskValidation<E, A>;
-    /**
-     * Creates a TaskValidation from a Maybe.
-     * Some becomes Passed, None becomes Failed with the error from onNone.
-     */
-    const fromMaybe: <E>(onNone: () => E) => <A>(maybe: Maybe<A>) => TaskValidation<E, A>;
-    /**
-     * Creates a TaskValidation from a Result.
-     * Ok becomes Passed, Err(e) becomes Failed([e]).
-     */
-    const fromResult: <E, A>(result: Result<E, A>) => TaskValidation<E, A>;
-    /**
-     * Creates a TaskValidation from a Promise-returning function.
-     * Catches any errors and transforms them using the onError function.
-     * The factory optionally receives an `AbortSignal` forwarded from the call site.
-     *
-     * @example
-     * ```ts
-     * const fetchUser = (id: string): TaskValidation<string, User> =>
-     *   TaskValidation.tryCatch(
-     *     (signal) => fetch(`/users/${id}`, { signal }).then(r => r.json()),
-     *     e => `Failed to fetch user: ${e}`
-     *   );
-     * ```
-     */
-    const tryCatch: <E, A>(f: (signal?: AbortSignal) => Promise<A>, onError: (e: unknown) => E) => TaskValidation<E, A>;
-    /**
-     * Transforms the success value inside a TaskValidation.
-     */
-    const map: <E, A, B>(f: (a: A) => B) => (data: TaskValidation<E, A>) => TaskValidation<E, B>;
-    /**
-     * Applies a function wrapped in a TaskValidation to a value wrapped in a
-     * TaskValidation. Both Tasks run in parallel and errors from both sides
-     * are accumulated.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   TaskValidation.passed((name: string) => (age: number) => ({ name, age })),
-     *   TaskValidation.ap(validateName(name)),
-     *   TaskValidation.ap(validateAge(age))
-     * )();
-     * ```
-     */
-    const ap: <E, A>(arg: TaskValidation<E, A>) => <B>(data: TaskValidation<E, (a: A) => B>) => TaskValidation<E, B>;
-    /**
-     * Extracts a value from a TaskValidation by providing handlers for both cases.
-     */
-    const fold: <E, A, B>(onFailed: (errors: NonEmptyList<E>) => B, onPassed: (a: A) => B) => (data: TaskValidation<E, A>) => Task<B>;
-    /**
-     * Pattern matches on a TaskValidation, returning a Task of the result.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   validateForm(input),
-     *   TaskValidation.match({
-     *     passed: data => save(data),
-     *     failed: errors => showErrors(errors)
-     *   })
-     * )();
-     * ```
-     */
-    const match: <E, A, B>(cases: {
-        passed: (a: A) => B;
-        failed: (errors: NonEmptyList<E>) => B;
-    }) => (data: TaskValidation<E, A>) => Task<B>;
-    /**
-     * Returns the success value or a default value if the TaskValidation is failed.
-     * The default can be a different type, widening the result to `Task<A | B>`.
-     */
-    const getOrElse: <E, A, B>(defaultValue: () => B) => (data: TaskValidation<E, A>) => Task<A | B>;
-    /**
-     * Executes a side effect on the success value without changing the TaskValidation.
-     * Useful for logging or debugging.
-     */
-    const tap: <E, A>(f: (a: A) => void) => (data: TaskValidation<E, A>) => TaskValidation<E, A>;
-    /**
-     * Recovers from a Failed state by providing a fallback TaskValidation.
-     * The fallback receives the accumulated error list so callers can inspect which errors occurred.
-     * The fallback can produce a different success type, widening the result to `TaskValidation<E, A | B>`.
-     */
-    const recover: <E, A, B>(fallback: (errors: NonEmptyList<E>) => TaskValidation<E, B>) => (data: TaskValidation<E, A>) => TaskValidation<E, A | B>;
-    /**
-     * Runs two TaskValidations concurrently and combines their results into a tuple.
-     * If both are Passed, returns Passed with both values. If either fails, accumulates
-     * errors from both sides.
-     *
-     * @example
-     * ```ts
-     * await TaskValidation.product(
-     *   validateName(form.name),
-     *   validateAge(form.age),
-     * )(); // Passed(["Alice", 30]) or Failed([...errors])
-     * ```
-     */
-    const product: <E, A, B>(first: TaskValidation<E, A>, second: TaskValidation<E, B>) => TaskValidation<E, readonly [A, B]>;
-    /**
-     * Runs all TaskValidations concurrently and collects results.
-     * If all are Passed, returns Passed with all values as an array.
-     * If any fail, returns Failed with all accumulated errors.
-     *
-     * @example
-     * ```ts
-     * await TaskValidation.productAll([
-     *   validateName(form.name),
-     *   validateEmail(form.email),
-     *   validateAge(form.age),
-     * ])(); // Passed([name, email, age]) or Failed([...all errors])
-     * ```
-     */
-    const productAll: <E, A>(data: NonEmptyList<TaskValidation<E, A>>) => TaskValidation<E, readonly A[]>;
-}
-
 type TheseFirst<T> = WithKind<"First"> & WithFirst<T>;
 type TheseSecond<T> = WithKind<"Second"> & WithSecond<T>;
 type TheseBoth<First, Second> = WithKind<"Both"> & WithFirst<First> & WithSecond<Second>;
@@ -3142,329 +2665,4 @@ declare namespace Tuple {
     const tap: <A, B>(f: (a: A, b: B) => void) => (tuple: Tuple<A, B>) => Tuple<A, B>;
 }
 
-type Passed<A> = WithKind<"Passed"> & WithValue<A>;
-type Failed<E> = WithKind<"Failed"> & WithErrors<E>;
-/**
- * Validation represents a value that is either passed with a success value,
- * or failed with accumulated errors.
- * Unlike Result, Validation can accumulate multiple errors instead of short-circuiting.
- *
- * Use Validation when you need to collect all errors (e.g., form validation).
- * Use Result when you want to fail fast on the first error.
- *
- * @example
- * ```ts
- * const validateName = (name: string): Validation<string, string> =>
- *   name.length > 0 ? Validation.passed(name) : Validation.failed("Name is required");
- *
- * const validateAge = (age: number): Validation<string, number> =>
- *   age >= 0 ? Validation.passed(age) : Validation.failed("Age must be positive");
- *
- * // Accumulates all errors using ap
- * pipe(
- *   Validation.passed((name: string) => (age: number) => ({ name, age })),
- *   Validation.ap(validateName("")),
- *   Validation.ap(validateAge(-1))
- * );
- * // Failed(["Name is required", "Age must be positive"])
- * ```
- */
-type Validation<E, A> = Passed<A> | Failed<E>;
-declare namespace Validation {
-    /**
-     * Wraps a value in a passed Validation.
-     *
-     * @example
-     * ```ts
-     * Validation.passed(42); // Passed(42)
-     * ```
-     */
-    const passed: <E, A>(value: A) => Validation<E, A>;
-    /**
-     * Creates a failed Validation from a single error.
-     *
-     * @example
-     * ```ts
-     * Validation.failed("Invalid input");
-     * ```
-     */
-    const failed: <E>(error: E) => Failed<E>;
-    /**
-     * Creates a failed Validation from multiple errors.
-     *
-     * @example
-     * ```ts
-     * Validation.failedAll(["Invalid input"]);
-     * ```
-     */
-    const failedAll: <E>(errors: NonEmptyList<E>) => Failed<E>;
-    /**
-     * Type guard that checks if a Validation is passed.
-     */
-    const isPassed: <E, A>(data: Validation<E, A>) => data is Passed<A>;
-    /**
-     * Type guard that checks if a Validation is failed.
-     */
-    const isFailed: <E, A>(data: Validation<E, A>) => data is Failed<E>;
-    /**
-     * Creates a Validation from a predicate applied to a value.
-     * Returns Passed if the predicate passes, Failed from `onFalse` otherwise.
-     *
-     * @example
-     * ```ts
-     * const validateName = Validation.fromPredicate(
-     *   (s: string) => s.length > 0,
-     *   () => "Name is required"
-     * );
-     *
-     * validateName("Alice"); // Passed("Alice")
-     * validateName("");      // Failed(["Name is required"])
-     * ```
-     */
-    const fromPredicate: <E, A>(pred: (a: A) => boolean, onFalse: (a: A) => E) => (a: A) => Validation<E, A>;
-    /**
-     * Creates a Validation from a nullable value.
-     * If the value is null or undefined, returns Failed with the error from onNull.
-     * Otherwise, returns Passed.
-     *
-     * @example
-     * ```ts
-     * pipe(null, Validation.fromNullable(() => "is null")); // Failed(["is null"])
-     * pipe(42, Validation.fromNullable(() => "is null"));   // Passed(42)
-     * ```
-     */
-    const fromNullable: <E>(onNull: () => E) => <A>(value: A | null | undefined) => Validation<E, A>;
-    /**
-     * Creates a Validation from a Maybe.
-     * If the Maybe is None, returns Failed with the error from onNone.
-     * Otherwise, returns Passed.
-     *
-     * @example
-     * ```ts
-     * pipe(Maybe.none(), Validation.fromMaybe(() => "is none")); // Failed(["is none"])
-     * pipe(Maybe.some(42), Validation.fromMaybe(() => "is none")); // Passed(42)
-     * ```
-     */
-    const fromMaybe: <E>(onNone: () => E) => <A>(maybe: Maybe<A>) => Validation<E, A>;
-    /**
-     * Transforms the success value inside a Validation.
-     *
-     * @example
-     * ```ts
-     * pipe(Validation.passed(5), Validation.map(n => n * 2)); // Passed(10)
-     * pipe(Validation.failed("oops"), Validation.map(n => n * 2)); // Failed(["oops"])
-     * ```
-     */
-    const map: <A, B>(f: (a: A) => B) => <E>(data: Validation<E, A>) => Validation<E, B>;
-    /**
-     * Transforms the error list inside a Validation.
-     *
-     * @example
-     * ```ts
-     * pipe(Validation.failed("oops"), Validation.mapError(e => e.toUpperCase())); // Failed(["OOPS"])
-     * ```
-     */
-    const mapError: <E, F, A>(f: (e: E) => F) => (data: Validation<E, A>) => Validation<F, A>;
-    /**
-     * Applies a function wrapped in a Validation to a value wrapped in a Validation.
-     * Accumulates errors from both sides.
-     *
-     * @example
-     * ```ts
-     * const add = (a: number) => (b: number) => a + b;
-     * pipe(
-     *   Validation.passed(add),
-     *   Validation.ap(Validation.passed(5)),
-     *   Validation.ap(Validation.passed(3))
-     * ); // Passed(8)
-     *
-     * pipe(
-     *   Validation.passed(add),
-     *   Validation.ap(Validation.failed<string, number>("bad a")),
-     *   Validation.ap(Validation.failed<string, number>("bad b"))
-     * ); // Failed(["bad a", "bad b"])
-     * ```
-     */
-    const ap: <E, A>(arg: Validation<E, A>) => <B>(data: Validation<E, (a: A) => B>) => Validation<E, B>;
-    /**
-     * Extracts the value from a Validation by providing handlers for both cases.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   Validation.passed(42),
-     *   Validation.fold(
-     *     errors => `Errors: ${errors.join(", ")}`,
-     *     value => `Value: ${value}`
-     *   )
-     * );
-     * ```
-     */
-    const fold: <E, A, B>(onFailed: (errors: NonEmptyList<E>) => B, onPassed: (a: A) => B) => (data: Validation<E, A>) => B;
-    /**
-     * Pattern matches on a Validation, returning the result of the matching case.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   validation,
-     *   Validation.match({
-     *     passed: value => `Got ${value}`,
-     *     failed: errors => `Failed: ${errors.join(", ")}`
-     *   })
-     * );
-     * ```
-     */
-    const match: <E, A, B>(cases: {
-        passed: (a: A) => B;
-        failed: (errors: NonEmptyList<E>) => B;
-    }) => (data: Validation<E, A>) => B;
-    /**
-     * Returns the success value or a default value if the Validation is failed.
-     * The default can be a different type, widening the result to `A | B`.
-     *
-     * @example
-     * ```ts
-     * pipe(Validation.passed(5), Validation.getOrElse(() => 0)); // 5
-     * pipe(Validation.failed("oops"), Validation.getOrElse(() => 0)); // 0
-     * pipe(Validation.failed("oops"), Validation.getOrElse(() => null)); // null — typed as number | null
-     * ```
-     */
-    const getOrElse: <E, A, B>(defaultValue: () => B) => (data: Validation<E, A>) => A | B;
-    /**
-     * Executes a side effect on the success value without changing the Validation.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   Validation.passed(5),
-     *   Validation.tap(n => console.log("Value:", n)),
-     *   Validation.map(n => n * 2)
-     * );
-     * ```
-     */
-    const tap: <E, A>(f: (a: A) => void) => (data: Validation<E, A>) => Validation<E, A>;
-    /**
-     * Executes a side effect on the accumulated errors without changing the Validation.
-     * Useful for logging or reporting validation failures.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   Validation.failed("Name required"),
-     *   Validation.tapError(errors => console.error("validation failed:", errors)),
-     *   Validation.map(toUser)
-     * );
-     * ```
-     */
-    const tapError: <E, A>(f: (errors: NonEmptyList<E>) => void) => (data: Validation<E, A>) => Validation<E, A>;
-    /**
-     * Recovers from a Failed state by providing a fallback Validation.
-     * The fallback receives the accumulated error list so callers can inspect which errors occurred.
-     * The fallback can produce a different success type, widening the result to `Validation<E, A | B>`.
-     */
-    const recover: <E, A, B>(fallback: (errors: NonEmptyList<E>) => Validation<E, B>) => (data: Validation<E, A>) => Validation<E, A | B>;
-    /**
-     * Recovers from a Failed state unless `isBlocked` returns true for any of the accumulated errors.
-     * The fallback can produce a different success type, widening the result to `Validation<E, A | B>`.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   Validation.failed("field-error"),
-     *   Validation.recoverUnless(e => e === "fatal", () => Validation.passed(0))
-     * ); // Passed(0)
-     * ```
-     */
-    const recoverUnless: <E, A, B>(isBlocked: (e: E) => boolean, fallback: () => Validation<E, B>) => (data: Validation<E, A>) => Validation<E, A | B>;
-    /**
-     * Converts a Validation to a Result.
-     * Passed becomes Ok, Failed becomes Err with the accumulated error list.
-     *
-     * @example
-     * ```ts
-     * Validation.toResult(Validation.passed(42));        // Ok(42)
-     * Validation.toResult(Validation.failed("oops"));  // Err(["oops"])
-     * ```
-     */
-    const toResult: <E, A>(data: Validation<E, A>) => Result<NonEmptyList<E>, A>;
-    /**
-     * Converts a Validation to a Maybe. `Passed` becomes `Some`; `Failed` becomes `None`
-     * (errors are discarded).
-     *
-     * @example
-     * ```ts
-     * Validation.toMaybe(Validation.passed(42));       // Some(42)
-     * Validation.toMaybe(Validation.failed("bad"));  // None
-     * ```
-     */
-    const toMaybe: <E, A>(data: Validation<E, A>) => Maybe<A>;
-    /**
-     * Converts a `Result` to a `Validation`. `Ok` becomes `Passed`; `Err(e)` becomes `Failed([e])`.
-     *
-     * Useful when bridging from error-short-circuiting `Result` pipelines into
-     * error-accumulating `Validation` pipelines.
-     *
-     * @example
-     * ```ts
-     * Validation.fromResult(Result.ok(42));       // Passed(42)
-     * Validation.fromResult(Result.err("bad"));   // Failed(["bad"])
-     * ```
-     */
-    const fromResult: <E, A>(data: Result<E, A>) => Validation<E, A>;
-    /**
-     * Combines two independent Validation instances into a tuple.
-     * If both are Passed, returns Passed with both values as a tuple.
-     * If either is Failed, accumulates errors from both sides.
-     *
-     * @example
-     * ```ts
-     * Validation.product(
-     *   Validation.passed("alice"),
-     *   Validation.passed(30)
-     * ); // Passed(["alice", 30])
-     *
-     * Validation.product(
-     *   Validation.failed("Name required"),
-     *   Validation.failed("Age must be >= 0")
-     * ); // Failed(["Name required", "Age must be >= 0"])
-     * ```
-     */
-    const product: <E, A, B>(first: Validation<E, A>, second: Validation<E, B>) => Validation<E, readonly [A, B]>;
-    /**
-     * Combines a non-empty list of Validation instances, accumulating all errors.
-     * If all are Passed, returns Passed with all values collected into an array.
-     * If any are Failed, returns Failed with all accumulated errors.
-     *
-     * @example
-     * ```ts
-     * Validation.productAll([
-     *   validateName(name),
-     *   validateEmail(email),
-     *   validateAge(age)
-     * ]);
-     * // Passed([name, email, age]) or Failed([...all errors])
-     * ```
-     */
-    const productAll: <E, A>(data: NonEmptyList<Validation<E, A>>) => Validation<E, readonly A[]>;
-    /**
-     * Combines a record of Validations into a single Validation of a record.
-     * Accumulates all failed branches' errors.
-     *
-     * @example
-     * ```ts
-     * Validation.struct({
-     *   name: Validation.passed("Alice"),
-     *   age: Validation.passed(30)
-     * }); // Passed({ name: "Alice", age: 30 })
-     *
-     * Validation.struct({
-     *   name: Validation.failed("Name required"),
-     *   age: Validation.failed("Age must be >= 0")
-     * }); // Failed(["Name required", "Age must be >= 0"])
-     * ```
-     */
-    const struct: <E, R extends Record<string, any>>(fields: { [K in keyof R]: Validation<E, R[K]>; }) => Validation<E, R>;
-}
-
-export { Combinable, Deferred, type Failed, type Failure, Lazy, Lens, type Loading, Logged, Maybe, type NotAsked, Op, Optional, type Passed, Predicate, Reader, Refinement, RemoteData, Resource, Result, State, type Success, Task, TaskMaybe, TaskResult, TaskValidation, These, type TheseBoth, type TheseFirst, type TheseSecond, Tuple, Validation };
+export { Combinable, Deferred, type Failure, Lazy, Lens, type Loading, Logged, Maybe, type NotAsked, Op, Optional, Predicate, Reader, Refinement, RemoteData, Resource, Result, State, type Success, Task, These, type TheseBoth, type TheseFirst, type TheseSecond, Tuple };