@nlozgachev/pipelined 0.42.0 → 0.44.0

package/dist/{Task-BprUabHP.d.mts → Validation-DM2eh6wj.d.ts}

@@ -1,57 +1,5 @@
-import { D as Duration } from './Duration-BTeT9D-q.mjs';
-import { NonEmptyList } from './types.mjs';
-
-declare const _deferred: unique symbol;
-/**
- * A nominally typed, one-shot async value that supports `await` but enforces infallibility.
- *
- * Two design choices work together to make the guarantee structural rather than documentary:
- *
- * - The phantom `[_deferred]` symbol makes the type **nominal**: only values produced by
- *   `Deferred.fromPromise` satisfy it. A plain object `{ then: ... }` does not.
- * - The single-parameter `.then()` **excludes rejection handlers** by construction. There is
- *   no second argument to pass, so chaining and `.catch()` are impossible.
- *
- * This makes `Deferred<A>` the natural return type for `Task<A>`, which is guaranteed to
- * never reject.
- *
- * @example
- * ```ts
- * const value = await Deferred.fromPromise(Promise.resolve(42));
- * // value === 42
- * ```
- */
-type Deferred<A> = {
-    readonly [_deferred]: A;
-    readonly then: (onfulfilled: (value: A) => unknown) => void;
-};
-declare namespace Deferred {
-    /**
-     * Wraps a `Promise` into a `Deferred`, structurally excluding rejection handlers,
-     * `.catch()`, `.finally()`, and chainable `.then()`.
-     *
-     * **Precondition**: `p` must never reject. If `p` rejects, the returned `Deferred` will
-     * never resolve — `await`-ing it will hang indefinitely. Use `TaskResult.tryCatch` to
-     * handle operations that may fail before converting to a `Deferred`.
-     *
-     * @example
-     * ```ts
-     * const d = Deferred.fromPromise(Promise.resolve("hello"));
-     * const value = await d; // "hello"
-     * ```
-     */
-    const fromPromise: <A>(p: Promise<A>) => Deferred<A>;
-    /**
-     * Converts a `Deferred` back into a `Promise`.
-     *
-     * @example
-     * ```ts
-     * const p = Deferred.toPromise(Deferred.fromPromise(Promise.resolve(42)));
-     * // p is Promise<42>
-     * ```
-     */
-    const toPromise: <A>(d: Deferred<A>) => Promise<A>;
-}
+import { g as WithKind, n as WithValue, d as WithError, T as Thenable, D as Deferred, N as NonEmptyArr, e as WithErrors } from './InternalTypes-7o9-yrHq.js';
+import { Duration } from './types.js';
 
 /**
  * A function that checks whether two values of type `A` are equal.
@@ -140,60 +88,6 @@ declare namespace Equality {
     const and: <A>(eq2: Equality<A>) => (eq1: Equality<A>) => Equality<A>;
 }
 
-type WithKind<K extends string> = {
-    readonly kind: K;
-};
-type WithValue<T> = {
-    readonly value: T;
-};
-type WithError<T> = {
-    readonly error: T;
-};
-type WithErrors<T> = {
-    readonly errors: NonEmptyList<T>;
-};
-type WithFirst<T> = {
-    readonly first: T;
-};
-type WithSecond<T> = {
-    readonly second: T;
-};
-type WithLog<T> = {
-    readonly log: ReadonlyArray<T>;
-};
-/** Retry policy for `Op.interpret`. */
-type RetryOptions<E> = {
-    readonly attempts: number;
-    readonly backoff?: Duration | ((attempt: number) => Duration);
-    readonly when?: (error: E) => boolean;
-};
-/** Timeout policy for `Op.interpret`. Wraps the entire retry sequence. */
-type TimeoutOptions<E> = {
-    readonly duration: Duration;
-    readonly onTimeout: () => E;
-};
-type WithTimeout<E> = {
-    readonly timeout?: TimeoutOptions<E>;
-};
-type WithDuration = {
-    readonly duration: Duration;
-};
-type WithN = {
-    readonly n: number;
-};
-type WithConcurrency = {
-    readonly concurrency?: number;
-};
-type WithSize = {
-    readonly size?: number;
-};
-type WithCooldown = {
-    readonly cooldown?: Duration;
-};
-type WithMinInterval = {
-    readonly minInterval?: Duration;
-};
-
 type Some<A> = WithKind<"Some"> & WithValue<A>;
 type None = WithKind<"None">;
 /**
@@ -809,13 +703,552 @@ declare namespace Result {
     const struct: <E, R extends Record<string, any>>(fields: { [K in keyof R]: Result<E, R[K]>; }) => Result<E, R>;
 }
 
+/**
+ * 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): Task.Maybe<User> =>
+ *   Task.Maybe.tryCatch(() => db.users.findById(id));
+ *
+ * pipe(
+ *   findUser("123"),
+ *   Task.Maybe.map(user => user.name),
+ *   Task.Maybe.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 Task.Maybe that resolves to None.
+     */
+    const none: <A = never>() => TaskMaybe<A>;
+    /**
+     * Lifts an Option into a Task.Maybe.
+     */
+    const fromMaybe: <A>(option: Maybe<A>) => TaskMaybe<A>;
+    /**
+     * Creates a Task.Maybe 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 Task.Maybe 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 Task.Maybe by wrapping its result in Some.
+     */
+    const fromTask: <A>(task: Task<A>) => TaskMaybe<A>;
+    /**
+     * Creates a Task.Maybe 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 = Task.Maybe.tryCatch((signal) =>
+     *   fetch("/user/1", { signal }).then(r => r.json())
+     * );
+     * ```
+     */
+    const tryCatch: <A>(f: (signal?: AbortSignal) => Thenable<A>) => TaskMaybe<A>;
+    /**
+     * Transforms the value inside a Task.Maybe.
+     */
+    const map: <A, B>(f: (a: A) => B) => (data: TaskMaybe<A>) => TaskMaybe<B>;
+    /**
+     * Chains Task.Maybe 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"),
+     *   Task.Maybe.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 Task.Maybe to a value wrapped in a Task.Maybe.
+     * Both Tasks run in parallel.
+     */
+    const ap: <A>(arg: TaskMaybe<A>) => <B>(data: TaskMaybe<(a: A) => B>) => TaskMaybe<B>;
+    /**
+     * Extracts a value from a Task.Maybe 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 Task.Maybe, returning a Task of the result.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   findUser("123"),
+     *   Task.Maybe.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 Task.Maybe 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 Task.Maybe.
+     * Useful for logging or debugging.
+     */
+    const tap: <A>(f: (a: A) => void) => (data: TaskMaybe<A>) => TaskMaybe<A>;
+    /**
+     * Filters the value inside a Task.Maybe. Returns None if the predicate fails.
+     */
+    const filter: <A>(predicate: (a: A) => boolean) => (data: TaskMaybe<A>) => TaskMaybe<A>;
+    /**
+     * Converts a Task.Maybe to a Task.Result, using onNone to produce the error value.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   findUser("123"),
+     *   Task.Maybe.toResult(() => "User not found")
+     * );
+     * ```
+     */
+    const toResult: <E>(onNone: () => E) => <A>(data: TaskMaybe<A>) => Task.Result<E, A>;
+    /**
+     * Lifts a Task.Maybe value into an accumulator object.
+     *
+     * @example
+     * ```ts
+     * pipe(Task.Maybe.some(42), Task.Maybe.bindTo("value")); // Task.Maybe({ value: 42 })
+     * ```
+     */
+    const bindTo: <K extends string>(key: K) => <A>(data: TaskMaybe<A>) => TaskMaybe<{ [P in K]: A; }>;
+    /**
+     * Evaluates a new Task.Maybe using the current accumulator and attaches the output to a new key.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   Task.Maybe.some({ a: 1 }),
+     *   Task.Maybe.bind("b", ({ a }) => Task.Maybe.some(a + 1))
+     * ); // Task.Maybe({ 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; }>;
+    /**
+     * Recovers from a None state by providing a fallback Task.Maybe.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   Task.Maybe.none(),
+     *   Task.Maybe.recover(() => Task.Maybe.some(42))
+     * ); // Task.Maybe(42)
+     * ```
+     */
+    const recover: <A, B>(fallback: () => TaskMaybe<B>) => (data: TaskMaybe<A>) => TaskMaybe<A | B>;
+    /**
+     * Combines a record of Task.Maybes into a single Task.Maybe of a record.
+     * Evaluates fields in parallel and returns None if any task resolves to None.
+     *
+     * @example
+     * ```ts
+     * Task.Maybe.struct({
+     *   name: Task.Maybe.some("Alice"),
+     *   age: Task.Maybe.some(30)
+     * }); // Task.Maybe({ name: "Alice", age: 30 })
+     * ```
+     */
+    const struct: <R extends Record<string, any>>(fields: { [K in keyof R]: TaskMaybe<R[K]>; }) => TaskMaybe<R>;
+}
+
+/**
+ * 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): Task.Result<Error, User> =>
+ *   Task.Result.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 Task.Result.
+     */
+    const ok: <E, A>(value: A) => TaskResult<E, A>;
+    /**
+     * Creates a failed Task.Result with the given error.
+     */
+    const err: <E, A>(error: E) => TaskResult<E, A>;
+    /**
+     * Creates a Task.Result 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 Task.Result 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 Task.Result.
+     */
+    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 Task.Result.
+     */
+    const fromThrowable: <Args extends readonly unknown[], A, E>(f: (...args: Args) => Promise<A>, onError: (e: unknown) => E) => (...args: Args) => TaskResult<E, A>;
+    /**
+     * Creates a Task.Result 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): Task.Result<string, User> =>
+     *   Task.Result.tryCatch(
+     *     (signal) => fetch(`/users/${id}`, { signal }).then(r => r.json()),
+     *     String
+     *   );
+     * ```
+     */
+    const tryCatch: <E, A>(f: (signal?: AbortSignal) => Thenable<A>, onError: (e: unknown) => E) => TaskResult<E, A>;
+    /**
+     * Transforms the success value inside a Task.Result.
+     */
+    const map: <E, A, B>(f: (a: A) => B) => (data: TaskResult<E, A>) => TaskResult<E, B>;
+    /**
+     * Transforms the error value inside a Task.Result.
+     */
+    const mapError: <E, F, A>(f: (e: E) => F) => (data: TaskResult<E, A>) => TaskResult<F, A>;
+    /**
+     * Chains Task.Result 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 Task.Result 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 Task.Result, 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 Task.Result.
+     * The fallback can produce a different success type, widening the result to `Task.Result<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 Task.Result 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 Task.Result.
+     * 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 Task.Result.
+     * Useful for logging or reporting async errors.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   fetchUser(id),
+     *   Task.Result.tapError(e => console.error("fetch failed:", e)),
+     *   Task.Result.chain(saveToCache),
+     * )
+     * ```
+     */
+    const tapError: <E, A>(f: (e: E) => void) => (data: TaskResult<E, A>) => TaskResult<E, A>;
+    /**
+     * Applies a function wrapped in a Task.Result to a value wrapped in a Task.Result.
+     * 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 `Task.Result` 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"),
+     *     Task.Result.chain(user => fetchPosts(user.id)),
+     *     Task.Result.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 Task.Result value into an object containing a single property.
+     * Initiates the pipeline accumulator record.
+     *
+     * @example
+     * ```ts
+     * pipe(Task.Result.ok(42), Task.Result.bindTo("value")); // Task.Result({ value: 42 })
+     * ```
+     */
+    const bindTo: <K extends string>(key: K) => <E, A>(data: TaskResult<E, A>) => TaskResult<E, { [P in K]: A; }>;
+    /**
+     * Evaluates a new Task.Result using the current accumulator and attaches the output to a new key.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   Task.Result.ok({ a: 1 }),
+     *   Task.Result.bind("b", ({ a }) => Task.Result.ok(a + 1))
+     * ); // Task.Result({ 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 Task.Results into a single Task.Result 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
+     * Task.Result.struct({
+     *   name: Task.Result.ok("Alice"),
+     *   age: Task.Result.ok(30)
+     * }); // Task.Result({ 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 Task.Result, multiple failures are collected
+ * rather than short-circuiting on the first error.
+ *
+ * @example
+ * ```ts
+ * const validateName = (name: string): Task.Validation<string, string> =>
+ *   name.length > 0
+ *     ? Task.Validation.passed(name)
+ *     : Task.Validation.failed("Name is required");
+ *
+ * // Accumulate errors from multiple async validations using ap
+ * pipe(
+ *   Task.Validation.passed((name: string) => (age: number) => ({ name, age })),
+ *   Task.Validation.ap(validateName("")),
+ *   Task.Validation.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 Task.Validation.
+     */
+    const passed: <E, A>(value: A) => TaskValidation<E, A>;
+    /**
+     * Creates a failed Task.Validation with a single error.
+     */
+    const failed: <E, A>(error: E) => TaskValidation<E, A>;
+    /**
+     * Creates a failed Task.Validation from multiple errors.
+     */
+    const failedAll: <E, A>(errors: NonEmptyArr<E>) => TaskValidation<E, A>;
+    /**
+     * Lifts a Validation into a Task.Validation.
+     */
+    const fromValidation: <E, A>(validation: Validation<E, A>) => TaskValidation<E, A>;
+    /**
+     * Creates a Task.Validation 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 Task.Validation 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 Task.Validation from a Result.
+     * Ok becomes Passed, Err(e) becomes Failed([e]).
+     */
+    const fromResult: <E, A>(result: Result<E, A>) => TaskValidation<E, A>;
+    /**
+     * Creates a Task.Validation 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): Task.Validation<string, User> =>
+     *   Task.Validation.tryCatch(
+     *     (signal) => fetch(`/users/${id}`, { signal }).then(r => r.json()),
+     *     e => `Failed to fetch user: ${e}`
+     *   );
+     * ```
+     */
+    const tryCatch: <E, A>(f: (signal?: AbortSignal) => Thenable<A>, onError: (e: unknown) => E) => TaskValidation<E, A>;
+    /**
+     * Transforms the success value inside a Task.Validation.
+     */
+    const map: <E, A, B>(f: (a: A) => B) => (data: TaskValidation<E, A>) => TaskValidation<E, B>;
+    /**
+     * Applies a function wrapped in a Task.Validation to a value wrapped in a
+     * Task.Validation. Both Tasks run in parallel and errors from both sides
+     * are accumulated.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   Task.Validation.passed((name: string) => (age: number) => ({ name, age })),
+     *   Task.Validation.ap(validateName(name)),
+     *   Task.Validation.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 Task.Validation by providing handlers for both cases.
+     */
+    const fold: <E, A, B>(onFailed: (errors: NonEmptyArr<E>) => B, onPassed: (a: A) => B) => (data: TaskValidation<E, A>) => Task<B>;
+    /**
+     * Pattern matches on a Task.Validation, returning a Task of the result.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   validateForm(input),
+     *   Task.Validation.match({
+     *     passed: data => save(data),
+     *     failed: errors => showErrors(errors)
+     *   })
+     * )();
+     * ```
+     */
+    const match: <E, A, B>(cases: {
+        passed: (a: A) => B;
+        failed: (errors: NonEmptyArr<E>) => B;
+    }) => (data: TaskValidation<E, A>) => Task<B>;
+    /**
+     * Returns the success value or a default value if the Task.Validation 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 Task.Validation.
+     * 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 Task.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 `Task.Validation<E, A | B>`.
+     */
+    const recover: <E, A, B>(fallback: (errors: NonEmptyArr<E>) => TaskValidation<E, B>) => (data: TaskValidation<E, A>) => TaskValidation<E, A | B>;
+    /**
+     * Runs two Task.Validations 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 Task.Validation.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 Task.Validations 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 Task.Validation.productAll([
+     *   validateName(form.name),
+     *   validateEmail(form.email),
+     *   validateAge(form.age),
+     * ])(); // Passed([name, email, age]) or Failed([...all errors])
+     * ```
+     */
+    const productAll: <E, A>(data: NonEmptyArr<TaskValidation<E, A>>) => TaskValidation<E, readonly A[]>;
+    /**
+     * Transforms all accumulated errors inside a Task.Validation.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   Task.Validation.failed("oops"),
+     *   Task.Validation.mapError(e => e.toUpperCase())
+     * ); // Task.Validation(Failed(["OOPS"]))
+     * ```
+     */
+    const mapError: <E, F, A>(f: (e: E) => F) => (data: TaskValidation<E, A>) => TaskValidation<F, A>;
+    /**
+     * Executes a side effect on the accumulated errors without changing the Task.Validation.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   Task.Validation.failed("invalid name"),
+     *   Task.Validation.tapError(errs => logger.error(errs))
+     * );
+     * ```
+     */
+    const tapError: <E, A>(f: (errors: NonEmptyArr<E>) => void) => (data: TaskValidation<E, A>) => TaskValidation<E, A>;
+    /**
+     * Combines a record of Task.Validations into a single Task.Validation of a record.
+     * Evaluates fields in parallel and accumulates all validation errors.
+     *
+     * @example
+     * ```ts
+     * Task.Validation.struct({
+     *   name: Task.Validation.passed("Alice"),
+     *   age: Task.Validation.passed(30)
+     * }); // Task.Validation({ name: "Alice", age: 30 })
+     * ```
+     */
+    const struct: <E, R extends Record<string, any>>(fields: { [K in keyof R]: TaskValidation<E, R[K]>; }) => TaskValidation<E, R>;
+}
+
 /**
  * A lazy async computation that always resolves.
  *
  * Two guarantees:
  * - **Lazy** — nothing starts until you call it.
  * - **Infallible** — it never rejects. If failure is possible, encode it in the
- *   return type using `TaskResult<E, A>` instead.
+ *   return type using `Task.Result<E, A>` instead.
  *
  * An optional `AbortSignal` can be passed at the call site. Combinators like
  * `retry`, `pollUntil`, and `timeout` thread it automatically to every inner
@@ -872,7 +1305,7 @@ declare namespace Task {
      * const getTimestamp = Task.from(() => Promise.resolve(Date.now()));
      * ```
      */
-    const from: <A>(f: (signal?: AbortSignal) => Promise<A>) => Task<A>;
+    const from: <A>(f: (signal?: AbortSignal) => Thenable<A>) => Task<A>;
     /**
      * Creates a Task from a lazy synchronous thunk.
      * Unlike `Task.resolve(f())`, `fromSync` does not evaluate `f` until the Task is called.
@@ -1052,7 +1485,7 @@ declare namespace Task {
      * pipe(
      *   heavyComputation,
      *   Task.timeout(Duration.seconds(5), () => "timed out"),
-     *   TaskResult.chain(processResult)
+     *   Task.Result.chain(processResult)
      * );
      * ```
      */
@@ -1078,7 +1511,7 @@ declare namespace Task {
      * await poll();
      * ```
      */
-    const abortable: <A>(factory: (signal: AbortSignal) => Promise<A>) => {
+    const abortable: <A>(factory: (signal: AbortSignal) => Thenable<A>) => {
         task: Task<A>;
         abort: () => void;
     };
@@ -1117,6 +1550,337 @@ declare namespace Task {
      * ```
      */
     const bind: <K extends string, A, B>(key: K, f: (a: A) => Task<B>) => (data: Task<A>) => Task<A & { [P in K]: B; }>;
+    type Maybe<A> = TaskMaybe<A>;
+    const Maybe: typeof TaskMaybe;
+    type Result<E, A> = TaskResult<E, A>;
+    const Result: typeof TaskResult;
+    type Validation<E, A> = TaskValidation<E, A>;
+    const Validation: typeof TaskValidation;
+}
+
+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: NonEmptyArr<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: NonEmptyArr<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: NonEmptyArr<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: NonEmptyArr<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: NonEmptyArr<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<NonEmptyArr<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: NonEmptyArr<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 { Deferred as D, Equality as E, Maybe as M, type None as N, type Ok as O, Result as R, type Some as S, Task as T, type WithConcurrency as W, type Err as a, Ordering as b, type RetryOptions as c, type TimeoutOptions as d, type WithCooldown as e, type WithDuration as f, type WithError as g, type WithErrors as h, type WithFirst as i, type WithKind as j, type WithLog as k, type WithMinInterval as l, type WithN as m, type WithSecond as n, type WithSize as o, type WithTimeout as p, type WithValue as q };
+export { Equality as E, type Failed as F, Maybe as M, type None as N, type Ok as O, type Passed as P, Result as R, type Some as S, Task as T, Validation as V, type Err as a, Ordering as b, TaskMaybe as c, TaskResult as d, TaskValidation as e };