@nlozgachev/pipelined 0.63.0 → 0.64.0

package/dist/{Validation-C5RGZUXy.d.ts → Task-9SJCMtG4.d.ts}

@@ -1,4 +1,4 @@
-import { h as WithKind, o as WithValue, e as WithError, a as NonEmptyArr, T as Thenable, D as Deferred, f as WithErrors } from './InternalTypes-CCXa8Kvr.js';
+import { h as WithKind, o as WithValue, e as WithError, a as NonEmptyArr, f as WithErrors, D as Deferred, T as Thenable } from './InternalTypes-CCXa8Kvr.js';
 import { D as Duration } from './Duration-DeyxG6VQ.js';
 import { RetryPolicy } from './types.js';
 
@@ -891,1667 +891,858 @@ declare const Result: {
     bimap: <E1, E2, A, B>(onErr: (e: E1) => E2, onOk: (a: A) => B) => (data: Result<E1, A>) => Result<E2, B>;
 };
 
+type Passed<A> = WithKind<"Passed"> & WithValue<A>;
+type Failed<E> = WithKind<"Failed"> & WithErrors<E>;
+declare function toResult<E1, E2, A>(combineErrors: (errors: NonEmptyArr<E1>) => E2): (val: Validation<E1, A>) => Result<E2, A>;
+declare function toResult<E, A>(data: Validation<E, A>): Result<NonEmptyArr<E>, A>;
 /**
- * TaskMaybe represents a lazy, infallible async operation that resolves to a `Maybe<A>`.
- * It is a type alias for `Task<Maybe<A>>`.
+ * 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 Task.Maybe for async operations that can result in a missing value (e.g. database lookups).
+ * 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 findUser = (id: string): Task.Maybe<User> =>
- *   Task.Maybe.tryCatch((signal) =>
- *     fetch(`/users/${id}`, { signal }).then(r => r.ok ? r.json() : null)
- *   );
+ * const validateName = (name: string): Validation<string, string> =>
+ *   name.length > 0 ? Validation.make.passed(name) : Validation.make.failed("Name is required");
+ *
+ * const validateAge = (age: number): Validation<string, number> =>
+ *   age >= 0 ? Validation.make.passed(age) : Validation.make.failed("Age must be positive");
+ *
+ * // Accumulates all errors using ap
+ * pipe(
+ *   Validation.make.passed((name: string) => (age: number) => ({ name, age })),
+ *   Validation.ap(validateName("")),
+ *   Validation.ap(validateAge(-1))
+ * );
+ * // Failed(["Name is required", "Age must be positive"])
  * ```
  */
-type TaskMaybe<A> = Task<Maybe<A>>;
-declare const TaskMaybe: {
-    /**
-     * Wraps a value in a Some inside a Task.
-     *
-     * @example
-     * ```ts
-     * const task = Task.Maybe.some(42);
-     * const res = await task(); // Some(42)
-     * ```
-     */
+type Validation<E, A> = Passed<A> | Failed<E>;
+declare const Validation: {
     make: {
         /**
-         * Creates a Task.Maybe that resolves to Some(value).
+         * Wraps a value in a passed Validation.
+         *
+         * @example
+         * ```ts
+         * Validation.make.passed(42); // Passed(42)
+         * ```
+         */
+        passed: <E, A>(value: A) => Validation<E, A>;
+        /**
+         * Creates a failed Validation from a single error.
+         *
+         * @example
+         * ```ts
+         * Validation.make.failed("Invalid input");
+         * ```
+         */
+        failed: <E>(error: E) => Failed<E>;
+        /**
+         * Creates a failed Validation from multiple errors.
+         *
+         * @example
+         * ```ts
+         * Validation.make.failedAll(["Invalid input"]);
+         * ```
+         */
+        failedAll: <E>(errors: NonEmptyArr<E>) => Failed<E>;
+    };
+    is: {
+        /**
+         * Type guard that checks if a Validation is passed.
          *
          * @example
          * ```ts
-         * const task = Task.Maybe.make.some(42);
-         * const res = await task(); // Some(42)
+         * const v = Validation.make.passed(42);
+         * if (Validation.is.passed(v)) {
+         *   console.log(v.value); // 42
+         * }
          * ```
          */
-        some: <A>(value: A) => TaskMaybe<A>;
+        passed: <E, A>(data: Validation<E, A>) => data is Passed<A>;
         /**
-         * Creates a Task.Maybe that resolves to None.
+         * Type guard that checks if a Validation is failed.
          *
          * @example
          * ```ts
-         * const task = Task.Maybe.make.none();
-         * const res = await task(); // None
+         * const v = Validation.make.failed("invalid");
+         * if (Validation.is.failed(v)) {
+         *   console.log(v.errors); // ["invalid"]
+         * }
          * ```
          */
-        none: <A = never>() => TaskMaybe<A>;
+        failed: <E, A>(data: Validation<E, A>) => data is Failed<E>;
     };
-    some: <A>(value: A) => TaskMaybe<A>;
-    none: <A = never>() => TaskMaybe<A>;
+    /**
+     * Creates a Validation from a synchronous thunk that may throw.
+     * Catches any errors and transforms them using the `onError` function into a Failed validation.
+     *
+     * @example
+     * ```ts
+     * const result = Validation.tryCatch(
+     *   () => JSON.parse(rawString),
+     *   { onError: (e) => `Parse error: ${e}` }
+     * );
+     * ```
+     */
+    tryCatch: <E, A>(f: () => A, options: {
+        onError: (e: unknown) => E;
+    }) => Validation<E, A>;
     from: {
         /**
-         * Lifts a Maybe into a Task.Maybe.
+         * Creates a Validation from a predicate applied to a value.
+         * Returns Passed if the predicate passes, Failed from `onFalse` otherwise.
          *
          * @example
          * ```ts
-         * Task.Maybe.from.Maybe(Maybe.make.some(42));
+         * const validateName = Validation.from.Predicate(
+         *   (s: string) => s.length > 0,
+         *   () => "Name is required"
+         * );
+         *
+         * validateName("Alice"); // Passed("Alice")
+         * validateName("");      // Failed(["Name is required"])
          * ```
          */
-        Maybe: <A>(option: Maybe<A>) => TaskMaybe<A>;
+        Predicate: <E, A>(pred: (a: A) => boolean, onFalse: (a: A) => E) => (a: A) => Validation<E, A>;
         /**
-         * Creates a Task.Maybe from a nullable value.
-         * Returns Some if the value is not null or undefined, None otherwise.
+         * 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
-         * Task.Maybe.from.nullable(42);   // resolves to Some(42)
-         * Task.Maybe.from.nullable(null); // resolves to None
+         * pipe(null, Validation.from.nullable(() => "is null")); // Failed(["is null"])
+         * pipe(42, Validation.from.nullable(() => "is null"));   // Passed(42)
          * ```
          */
-        nullable: <A>(value: A | null | undefined) => TaskMaybe<A>;
+        nullable: <E>(onNull: () => E) => <A>(value: A | null | undefined) => Validation<E, A>;
         /**
-         * Creates a Task.Maybe from a Result.
-         * Ok becomes Some, Error becomes None (the error value is discarded).
+         * Creates a Validation from a Maybe.
+         * If the Maybe is None, returns Failed with the error from onNone.
+         * Otherwise, returns Passed.
          *
          * @example
          * ```ts
-         * Task.Maybe.from.Result(Result.make.ok(42)); // resolves to Some(42)
-         * Task.Maybe.from.Result(Result.make.err("e")); // resolves to None
+         * pipe(Maybe.make.none(), Validation.from.Maybe(() => "is none")); // Failed(["is none"])
+         * pipe(Maybe.make.some(42), Validation.from.Maybe(() => "is none")); // Passed(42)
          * ```
          */
-        Result: <E, A>(result: Result<E, A>) => TaskMaybe<A>;
+        Maybe: <E>(onNone: () => E) => <A>(maybe: Maybe<A>) => Validation<E, A>;
         /**
-         * Lifts a Task into a Task.Maybe by wrapping its result in Some.
+         * 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
-         * Task.Maybe.from.Task(Task.resolve(42)); // resolves to Some(42)
+         * Validation.from.Result(Result.make.ok(42));       // Passed(42)
+         * Validation.from.Result(Result.make.err("bad"));   // Failed(["bad"])
          * ```
          */
-        Task: <A>(task: Task<A>) => TaskMaybe<A>;
+        Result: <E, A>(data: Result<E, A>) => Validation<E, 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.
+     * Transforms the success value inside a Validation.
      *
      * @example
      * ```ts
-     * const fetchUser = Task.Maybe.tryCatch((signal) =>
-     *   fetch("/user/1", { signal }).then(r => r.json())
-     * );
+     * pipe(Validation.make.passed(5), Validation.map(n => n * 2)); // Passed(10)
+     * pipe(Validation.make.failed("oops"), Validation.map(n => n * 2)); // Failed(["oops"])
      * ```
      */
-    tryCatch: <A>(f: (signal?: AbortSignal) => Thenable<A>) => TaskMaybe<A>;
+    map: <A, B>(f: (a: A) => B) => <E>(data: Validation<E, A>) => Validation<E, B>;
     /**
-     * Transforms the value inside a Task.Maybe.
+     * Transforms the error list inside a Validation.
+     *
+     * @example
+     * ```ts
+     * pipe(Validation.make.failed("oops"), Validation.mapError(e => e.toUpperCase())); // Failed(["OOPS"])
+     * ```
      */
-    map: <A, B>(f: (a: A) => B) => (data: TaskMaybe<A>) => TaskMaybe<B>;
+    mapError: <E, F, A>(f: (e: E) => F) => (data: Validation<E, A>) => Validation<F, A>;
     /**
-     * Chains Task.Maybe computations. If the first resolves to Some, passes the
-     * value to f. If the first resolves to None, propagates None.
+     * 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.make.passed(add),
+     *   Validation.ap(Validation.make.passed(5)),
+     *   Validation.ap(Validation.make.passed(3))
+     * ); // Passed(8)
+     *
      * pipe(
-     *   findUser("123"),
-     *   Task.Maybe.chain(user => findOrg(user.orgId))
-     * )();
+     *   Validation.make.passed(add),
+     *   Validation.ap(Validation.make.failed<string>("bad a")),
+     *   Validation.ap(Validation.make.failed<string>("bad b"))
+     * ); // Failed(["bad a", "bad b"])
      * ```
      */
-    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.
-     */
-    ap: <A>(arg: TaskMaybe<A>) => <B>(data: TaskMaybe<(a: A) => B>) => TaskMaybe<B>;
+    ap: <E, A>(arg: Validation<E, A>) => <B>(data: Validation<E, (a: A) => B>) => Validation<E, B>;
     /**
-     * Extracts a value from a Task.Maybe by providing handlers for both cases.
+     * Applies a function wrapped in a Validation to a value wrapped in a Validation,
+     * using a custom error concatenator function when both sides fail.
+     *
+     * @example
+     * ```ts
+     * const concat = (e1: NonEmptyArr<string>, e2: NonEmptyArr<string>): NonEmptyArr<string> =>
+     *   [...e1, ...e2];
+     * pipe(fnVal, Validation.apCustom(concat)(argVal));
+     * ```
      */
-    fold: <A, B>(onNone: () => B, onSome: (a: A) => B) => (data: TaskMaybe<A>) => Task<B>;
+    apCustom: <E1, E2, E3>(concat: (e1: NonEmptyArr<E1>, e2: NonEmptyArr<E2>) => NonEmptyArr<E3>) => <A>(arg: Validation<E2, A>) => <B>(data: Validation<E1, (a: A) => B>) => Validation<E3, B>;
     /**
-     * Pattern matches on a Task.Maybe, returning a Task of the result.
+     * Extracts the value from a Validation by providing handlers for both cases.
      *
      * @example
      * ```ts
      * pipe(
-     *   findUser("123"),
-     *   Task.Maybe.match({
-     *     some: user => `Hello, ${user.name}`,
-     *     none: () => "User not found"
-     *   })
-     * )();
+     *   Validation.make.passed(42),
+     *   Validation.fold(
+     *     errors => `Errors: ${errors.join(", ")}`,
+     *     value => `Value: ${value}`
+     *   )
+     * );
      * ```
      */
-    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>`.
-     */
-    getOrElse: <B>(defaultValue: () => B) => <A>(data: TaskMaybe<A>) => Task<A | B>;
-    /**
-     * Executes a side effect on the value without changing the Task.Maybe.
-     * Useful for logging or debugging.
-     */
-    tap: <A>(f: (a: A) => void) => (data: TaskMaybe<A>) => TaskMaybe<A>;
-    /**
-     * Filters the value inside a Task.Maybe. Returns None if the predicate fails.
-     */
-    filter: <A>(predicate: (a: A) => boolean) => (data: TaskMaybe<A>) => TaskMaybe<A>;
-    to: {
-        /**
-         * Converts a Task.Maybe to a Task.Result, using onNone to produce the error value.
-         *
-         * @example
-         * ```ts
-         * pipe(
-         *   findUser("123"),
-         *   Task.Maybe.to.Result(() => "User not found")
-         * );
-         * ```
-         */
-        Result: <E>(onNone: () => E) => <A>(data: TaskMaybe<A>) => Task.Result<E, A>;
-    };
+    fold: <E, A, B>(onFailed: (errors: NonEmptyArr<E>) => B, onPassed: (a: A) => B) => (data: Validation<E, A>) => B;
     /**
-     * Lifts a Task.Maybe value into an accumulator object.
+     * Pattern matches on a Validation, returning the result of the matching case.
      *
      * @example
      * ```ts
-     * pipe(Task.Maybe.some(42), Task.Maybe.bindTo("value")); // Task.Maybe({ value: 42 })
+     * pipe(
+     *   validation,
+     *   Validation.match({
+     *     passed: value => `Got ${value}`,
+     *     failed: errors => `Failed: ${errors.join(", ")}`
+     *   })
+     * );
      * ```
      */
-    bindTo: <K extends string>(key: K) => <A>(data: TaskMaybe<A>) => TaskMaybe<{ [P in K]: A; }>;
+    match: <E, A, B>(cases: {
+        passed: (a: A) => B;
+        failed: (errors: NonEmptyArr<E>) => B;
+    }) => (data: Validation<E, A>) => B;
     /**
-     * Evaluates a new Task.Maybe using the current accumulator and attaches the output to a new key.
+     * 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(
-     *   Task.Maybe.some({ a: 1 }),
-     *   Task.Maybe.bind("b", ({ a }) => Task.Maybe.some(a + 1))
-     * ); // Task.Maybe({ a: 1, b: 2 })
+     * pipe(Validation.make.passed(5), Validation.getOrElse(() => 0)); // 5
+     * pipe(Validation.make.failed("oops"), Validation.getOrElse(() => 0)); // 0
+     * pipe(Validation.make.failed("oops"), Validation.getOrElse(() => null)); // null — typed as number | null
      * ```
      */
-    bind: <K extends string, A, B>(key: K, f: (a: A) => TaskMaybe<B>) => (data: TaskMaybe<A>) => TaskMaybe<A & { [P in K]: B; }>;
+    getOrElse: <B>(defaultValue: () => B) => <E, A>(data: Validation<E, A>) => A | B;
     /**
-     * Recovers from a None state by providing a fallback Task.Maybe.
+     * Executes a side effect on the success value without changing the Validation.
      *
      * @example
      * ```ts
      * pipe(
-     *   Task.Maybe.none(),
-     *   Task.Maybe.recover(() => Task.Maybe.some(42))
-     * ); // Task.Maybe(42)
+     *   Validation.make.passed(5),
+     *   Validation.tap(n => console.log("Value:", n)),
+     *   Validation.map(n => n * 2)
+     * );
      * ```
      */
-    recover: <B>(fallback: () => TaskMaybe<B>) => <A>(data: TaskMaybe<A>) => TaskMaybe<A | B>;
+    tap: <E, A>(f: (a: A) => void) => (data: Validation<E, A>) => Validation<E, A>;
     /**
-     * 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.
+     * Executes a side effect on the accumulated errors without changing the Validation.
+     * Useful for logging or reporting validation failures.
      *
      * @example
      * ```ts
-     * Task.Maybe.struct({
-     *   name: Task.Maybe.some("Alice"),
-     *   age: Task.Maybe.some(30)
-     * }); // Task.Maybe({ name: "Alice", age: 30 })
+     * pipe(
+     *   Validation.make.failed("Name required"),
+     *   Validation.tapError(errors => console.error("validation failed:", errors)),
+     *   Validation.map(toUser)
+     * );
      * ```
      */
-    struct: <R extends Record<string, any>>(fields: { [K in keyof R]: TaskMaybe<R[K]>; }) => TaskMaybe<R>;
+    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>`.
+     */
+    recover: <E, B>(fallback: (errors: NonEmptyArr<E>) => Validation<E, B>) => <A>(data: Validation<E, A>) => Validation<E, A | B>;
     /**
-     * Creates a memoized version of a Task.Maybe. The task is executed at most once on first call,
-     * and its resolved Maybe is cached for all subsequent calls.
+     * 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
-     * const loadUser = Task.Maybe.memoize(fetchUserMaybeTask);
+     * pipe(
+     *   Validation.make.failed("field-error"),
+     *   Validation.recoverUnless(e => e === "fatal", () => Validation.make.passed(0))
+     * ); // Passed(0)
      * ```
      */
-    memoize: <A>(task: TaskMaybe<A>) => TaskMaybe<A>;
-};
-
-/**
- * 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()),
- *     { onError: (e) => new Error(`Failed to fetch user: ${e}`) }
- *   );
- * ```
- */
-type TaskResult<E, A> = Task<Result<E, A>>;
-declare const TaskResult: {
-    make: {
+    recoverUnless: <E, B>(isBlocked: (e: E) => boolean, fallback: () => Validation<E, B>) => <A>(data: Validation<E, A>) => Validation<E, A | B>;
+    to: {
         /**
-         * Wraps a value in a successful Task.Result.
+         * Converts a Validation to a Result.
+         * Passed becomes Ok.
+         * Direct call converts Failed to Err with accumulated error list `NonEmptyArr<E>`.
+         * Curried call converts Failed to Err with combined error `E2` via `combineErrors`.
          *
          * @example
          * ```ts
-         * const task = Task.Result.make.ok(42);
-         * const res = await task(); // Ok(42)
+         * Validation.to.Result(Validation.make.passed(42));        // Ok(42)
+         * Validation.to.Result(Validation.make.failed("oops"));  // Err(["oops"])
+         * pipe(Validation.make.failed("oops"), Validation.to.Result(errors => errors.join(", "))); // Err("oops")
          * ```
          */
-        ok: <E = never, A = unknown>(value: A) => TaskResult<E, A>;
+        Result: typeof toResult;
         /**
-         * Creates a failed Task.Result with the given error.
+         * Converts a Validation to a Maybe. `Passed` becomes `Some`; `Failed` becomes `None`
+         * (errors are discarded).
          *
          * @example
          * ```ts
-         * const task = Task.Result.make.err("failed");
-         * const res = await task(); // Err("failed")
+         * Validation.to.Maybe(Validation.make.passed(42));       // Some(42)
+         * Validation.to.Maybe(Validation.make.failed("bad"));  // None
          * ```
          */
-        err: <E, A = never>(error: E) => TaskResult<E, A>;
-    };
-    ok: <E = never, A = unknown>(value: A) => TaskResult<E, A>;
-    err: <E, A = never>(error: E) => TaskResult<E, A>;
-    from: {
-        /**
-         * Creates a Task.Result from a nullable value.
-         * Returns Ok if the value is not null or undefined, err from onNull otherwise.
-         *
-         * @example
-         * ```ts
-         * Task.Result.from.nullable(() => "missing")(42);   // resolves to Ok(42)
-         * Task.Result.from.nullable(() => "missing")(null); // resolves to Err("missing")
-         * ```
-         */
-        nullable: <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.
-         *
-         * @example
-         * ```ts
-         * Task.Result.from.Maybe(() => "empty")(Maybe.make.some(42)); // resolves to Ok(42)
-         * Task.Result.from.Maybe(() => "empty")(Maybe.make.none());   // resolves to Err("empty")
-         * ```
-         */
-        Maybe: <E>(onNone: () => E) => <A>(maybe: Maybe<A>) => TaskResult<E, A>;
-        /**
-         * Lifts a Result into a Task.Result.
-         *
-         * @example
-         * ```ts
-         * Task.Result.from.Result(Result.make.ok(42)); // resolves to Ok(42)
-         * ```
-         */
-        Result: <E, A>(result: Result<E, A>) => TaskResult<E, A>;
-    };
-    to: {
-        /**
-         * Converts a Task.Result to a Task.Maybe, dropping the error value on Err.
-         *
-         * @example
-         * ```ts
-         * const taskResult = Task.Result.ok(42);
-         * const taskMaybe = pipe(taskResult, Task.Result.to.Maybe);
-         * ```
-         */
-        Maybe: <E, A>(data: TaskResult<E, A>) => TaskMaybe<A>;
+        Maybe: <E, A>(data: Validation<E, A>) => Maybe<A>;
     };
     /**
-     * Creates a Task.Result from a Promise-returning thunk that may throw or reject.
-     * Catches any errors and transforms them using the `onError` function into an `Err`.
-     * The thunk optionally receives an `AbortSignal` forwarded from the call site.
+     * 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
-     * const loadUser = Task.Result.tryCatch(
-     *   (signal) => userStore.get("u_123", { signal }),
-     *   { onError: (e) => new DbError(e) }
-     * );
+     * Validation.product(
+     *   Validation.make.passed("alice"),
+     *   Validation.make.passed(30)
+     * ); // Passed(["alice", 30])
+     *
+     * Validation.product(
+     *   Validation.make.failed("Name required"),
+     *   Validation.make.failed("Age must be >= 0")
+     * ); // Failed(["Name required", "Age must be >= 0"])
      * ```
      */
-    tryCatch: <E, A>(f: (signal?: AbortSignal) => Thenable<A>, options: {
-        onError: (error: unknown) => E;
-    }) => TaskResult<E, A>;
-    /**
-     * Transforms the success value inside a Task.Result.
-     */
-    map: <E, A, B>(f: (a: A) => B) => (data: TaskResult<E, A>) => TaskResult<E, B>;
-    /**
-     * Transforms the error value inside a Task.Result.
-     */
-    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.
-     */
-    chain: <E2, A, B>(f: (a: A) => TaskResult<E2, B>) => <E1 = never>(data: TaskResult<E1, A>) => TaskResult<E1 | E2, B>;
+    product: <E, A, B>(first: Validation<E, A>, second: Validation<E, B>) => Validation<E, readonly [A, B]>;
     /**
-     * Extracts the value from a Task.Result by providing handlers for both cases.
+     * 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])
+     * ```
      */
-    fold: <E, A, B>(onErr: (e: E) => B, onOk: (a: A) => B) => (data: TaskResult<E, A>) => Task<B>;
+    productAll: <E, A>(data: NonEmptyArr<Validation<E, A>>) => Validation<E, readonly A[]>;
     /**
-     * Pattern matches on a Task.Result, returning a Task of the result.
+     * Combines a record of Validations into a single Validation of a record.
+     * Accumulates all failed branches' errors.
+     *
+     * @example
+     * ```ts
+     * Validation.struct({
+     *   name: Validation.make.passed("Alice"),
+     *   age: Validation.make.passed(30)
+     * }); // Passed({ name: "Alice", age: 30 })
+     *
+     * Validation.struct({
+     *   name: Validation.make.failed("Name required"),
+     *   age: Validation.make.failed("Age must be >= 0")
+     * }); // Failed(["Name required", "Age must be >= 0"])
+     * ```
      */
-    match: <E, A, B>(cases: {
-        err: (e: E) => B;
-        ok: (a: A) => B;
-    }) => (data: TaskResult<E, A>) => Task<B>;
+    struct: <E, R extends Record<string, any>>(fields: { [K in keyof R]: Validation<E, R[K]>; }) => Validation<E, R>;
+};
+
+type _CoreMaybe<A> = Maybe<A>;
+type _CoreResult<E, A> = Result<E, A>;
+type _CoreValidation<E, A> = Validation<E, A>;
+/**
+ * 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 `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
+ * operation. Existing tasks that ignore the signal continue to work unchanged.
+ *
+ * Calling a Task returns a `Deferred<A>` — a one-shot async value that supports
+ * `await` but has no `.catch()`, `.finally()`, or chainable `.then()`.
+ *
+ * **Consuming a Task:**
+ *
+ * Use `await task()` to run it and get the value directly:
+ * ```ts
+ * const value: number = await task();
+ * ```
+ *
+ * When you need an explicit `Promise<A>` (e.g. for a third-party API), convert
+ * the `Deferred` with `Deferred.to.Promise`:
+ * ```ts
+ * const p: Promise<number> = Deferred.to.Promise(task());
+ * ```
+ *
+ * @example
+ * ```ts
+ * const getTimestamp: Task<number> = Task.resolve(Date.now());
+ *
+ * // Nothing runs yet — getTimestamp is just a description
+ * const formatted = pipe(
+ *   getTimestamp,
+ *   Task.map(ts => new Date(ts).toISOString())
+ * );
+ *
+ * // Execute when ready
+ * const result = await formatted();
+ * ```
+ */
+type Task<A> = (signal?: AbortSignal) => Deferred<A>;
+declare const Task: {
     /**
-     * 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>`.
+     * Creates a Task that immediately resolves to the given value.
+     *
+     * @example
+     * ```ts
+     * const task = Task.resolve(42);
+     * const value = await task(); // 42
+     * ```
      */
-    recover: <E, B>(fallback: (e: E) => TaskResult<E, B>) => <A>(data: TaskResult<E, A>) => TaskResult<E, A | B>;
+    resolve: <A>(value: A) => Task<A>;
+    from: {
+        /**
+         * Creates a Task from a lazy synchronous thunk.
+         * Unlike `Task.resolve(f())`, `from.sync` does not evaluate `f` until the Task is called.
+         *
+         * @example
+         * ```ts
+         * const t = Task.from.sync(() => Date.now()); // Date.now() not called yet
+         * const ts = await t(); // called here, every time
+         * ```
+         */
+        sync: <A>(f: () => A) => Task<A>;
+    };
     /**
-     * Recovers from an error unless the predicate `isBlocked` returns true for that error.
-     * The fallback can produce a different success type, widening the result to `Task.Result<E, A | B>`.
+     * Wraps a Promise-returning thunk that may throw or reject,
+     * trapping errors with a fallback function and returning a guaranteed `Task<A>`.
      *
      * @example
      * ```ts
-     * pipe(
-     *   fetchTask,
-     *   Task.Result.recoverUnless(
-     *     (e) => e === "fatal",
-     *     () => Task.Result.ok("fallback")
-     *   )
+     * const loadConfig = Task.tryCatch(
+     *   () => configStore.get("default"),
+     *   { onError: () => DEFAULT_CONFIG }
      * );
      * ```
      */
-    recoverUnless: <E, B>(isBlocked: (e: E) => boolean, fallback: (e: E) => TaskResult<E, B>) => <A>(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>`.
-     */
-    getOrElse: <B>(defaultValue: () => B) => <E, A>(data: TaskResult<E, A>) => Task<A | B>;
+    tryCatch: <A>(f: (signal?: AbortSignal) => globalThis.Promise<A>, options: {
+        onError: (error: unknown) => A;
+    }) => Task<A>;
     /**
-     * Executes a side effect on the success value without changing the Task.Result.
-     * Useful for logging or debugging.
+     * Transforms the value inside a Task.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   Task.resolve(5),
+     *   Task.map(n => n * 2)
+     * )(); // Deferred<10>
+     * ```
      */
-    tap: <E, A>(f: (a: A) => void) => (data: TaskResult<E, A>) => TaskResult<E, A>;
+    map: <A, B>(f: (a: A) => B) => (data: Task<A>) => Task<B>;
     /**
-     * Executes a side effect on the error value without changing the Task.Result.
-     * Useful for logging or reporting async errors.
+     * Chains Task computations. Passes the resolved value of the first Task to f.
      *
      * @example
      * ```ts
+     * const readUserId: Task<string> = Task.resolve(session.userId);
+     * const loadPrefs = (id: string): Task<Preferences> =>
+     *   Task.resolve(prefsCache.get(id));
+     *
      * pipe(
-     *   fetchUser(id),
-     *   Task.Result.tapError(e => console.error("fetch failed:", e)),
-     *   Task.Result.chain(saveToCache),
-     * )
+     *   readUserId,
+     *   Task.chain(loadPrefs)
+     * )(); // Deferred<Preferences>
      * ```
      */
-    tapError: <E, A>(f: (e: E) => void) => (data: TaskResult<E, A>) => TaskResult<E, A>;
+    chain: <A, B>(f: (a: A) => Task<B>) => (data: Task<A>) => Task<B>;
     /**
-     * Applies a function wrapped in a Task.Result to a value wrapped in a Task.Result.
+     * Applies a function wrapped in a Task to a value wrapped in a Task.
      * Both Tasks run in parallel.
+     *
+     * @example
+     * ```ts
+     * const add = (a: number) => (b: number) => a + b;
+     * pipe(
+     *   Task.resolve(add),
+     *   Task.ap(Task.resolve(5)),
+     *   Task.ap(Task.resolve(3))
+     * )(); // Deferred<8>
+     * ```
      */
-    ap: <E, A>(arg: TaskResult<E, A>) => <B>(data: TaskResult<E, (a: A) => B>) => TaskResult<E, B>;
+    ap: <A>(arg: Task<A>) => <B>(data: Task<(a: A) => B>) => Task<B>;
     /**
-     * Executes a `Task.Result` with an optional signal, returning `Promise<Result<E, A>>`.
-     * Use as a terminal step in a `pipe` chain.
+     * Executes a side effect on the value without changing the Task.
+     * Useful for logging or debugging.
      *
      * @example
      * ```ts
-     * const controller = new AbortController();
-     * const result = await pipe(
-     *     fetchUser("42"),
-     *     Task.Result.chain(user => fetchPosts(user.id)),
-     *     Task.Result.run(controller.signal),
+     * pipe(
+     *   loadConfig,
+     *   Task.tap(cfg => console.log("Config:", cfg)),
+     *   Task.map(buildReport)
      * );
-     * if (Result.is.ok(result)) render(result.value);
      * ```
      */
-    run: (signal?: AbortSignal) => <E, A>(task: TaskResult<E, A>) => Deferred<Result<E, A>>;
+    tap: <A>(f: (a: A) => void) => (data: Task<A>) => Task<A>;
     /**
-     * Converts a Task.Result value into an object containing a single property.
-     * Initiates the pipeline accumulator record.
+     * Runs multiple Tasks in parallel and collects their results.
      *
      * @example
      * ```ts
-     * pipe(Task.Result.ok(42), Task.Result.bindTo("value")); // Task.Result({ value: 42 })
+     * Task.all([loadConfig, detectLocale, loadTheme])();
+     * // Deferred<[Config, string, Theme]>
      * ```
      */
-    bindTo: <K extends string>(key: K) => <E, A>(data: TaskResult<E, A>) => TaskResult<E, { [P in K]: A; }>;
+    all: <T extends readonly Task<unknown>[]>(tasks: T) => Task<{ [K in keyof T]: T[K] extends Task<infer A> ? A : never; }>;
     /**
-     * Evaluates a new Task.Result using the current accumulator and attaches the output to a new key.
+     * Delays the execution of a Task by the specified duration.
+     * Useful for debouncing or rate limiting.
      *
      * @example
      * ```ts
      * pipe(
-     *   Task.Result.ok({ a: 1 }),
-     *   Task.Result.bind("b", ({ a }) => Task.Result.ok(a + 1))
-     * ); // Task.Result({ a: 1, b: 2 })
+     *   Task.resolve(42),
+     *   Task.delay(Duration.seconds(1))
+     * )(); // Resolves after 1 second
      * ```
      */
-    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; }>;
+    delay: (duration: Duration) => <A>(data: Task<A>) => Task<A>;
     /**
-     * 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.
+     * Runs a Task a fixed number of times sequentially, collecting all results into an array.
+     * An optional delay duration can be inserted between runs.
      *
      * @example
      * ```ts
-     * Task.Result.struct({
-     *   name: Task.Result.ok("Alice"),
-     *   age: Task.Result.ok(30)
-     * }); // Task.Result({ name: "Alice", age: 30 })
+     * pipe(
+     *   pollSensor,
+     *   Task.repeat({ times: 5, delay: Duration.seconds(1) })
+     * )(); // Task<Reading[]> — 5 readings, one per second
      * ```
      */
-    struct: <E, R extends Record<string, any>>(fields: { [K in keyof R]: TaskResult<E, R[K]>; }) => TaskResult<E, R>;
+    repeat: (options: {
+        times: number;
+        delay?: Duration;
+    }) => <A>(task: Task<A>) => Task<readonly A[]>;
     /**
-     * Retries a fallible Task.Result according to a RetryPolicy.
-     * If the task succeeds, returns Ok immediately.
-     * If the task fails, retries up to policy.attempts times with delays generated by policy.
+     * Runs a Task repeatedly until the result satisfies a predicate, returning that result.
+     * An optional delay duration can be inserted between runs.
+     * An optional `maxAttempts` cap stops the loop after N calls — the last value is returned
+     * regardless of whether the predicate was satisfied.
      *
      * @example
      * ```ts
-     * const policy = RetryPolicy.exponential({ attempts: 3, initial: Duration.milliseconds(100) });
-     * const retryableFetch = pipe(fetchData, Task.Result.retry(policy));
+     * pipe(
+     *   checkStatus,
+     *   Task.repeatUntil({ when: (s) => s === "ready", delay: Duration.milliseconds(500) })
+     * )(); // polls every 500ms until status is "ready"
      * ```
      */
-    retry: (policy: RetryPolicy) => <E, A>(task: TaskResult<E, A>) => TaskResult<E, A>;
+    repeatUntil: <A>(options: {
+        when: (a: A) => boolean;
+        delay?: Duration;
+        maxAttempts?: number;
+    }) => (task: Task<A>) => Task<A>;
     /**
-     * Creates a memoized version of a Task.Result. The task is executed at most once on first call,
-     * and its resolved Result is cached for all subsequent calls.
+     * Resolves with the value of the first Task to complete. All Tasks start
+     * immediately. When one resolves, the other tasks are cancelled (aborted)
+     * downstream.
      *
      * @example
      * ```ts
-     * const loadConfig = Task.Result.memoize(fetchConfigTask);
+     * const fast = Task.resolve("fast");
+     * const slow = Task.delay(Duration.milliseconds(200))(Task.resolve("slow"));
+     *
+     * await Task.race([fast, slow])(); // "fast"
      * ```
      */
-    memoize: <E, A>(task: TaskResult<E, A>) => TaskResult<E, A>;
+    race: <A>(tasks: ReadonlyArray<Task<A>>) => Task<A>;
     /**
-     * Times out a fallible task, resolving to `Err(onTimeout())` if the duration elapses
-     * before the task completes.
+     * Runs an array of Tasks concurrently and collects their results in an array.
+     * Forward-propagates the call site's AbortSignal to all subtasks concurrently.
      *
      * @example
      * ```ts
-     * const fetchWithTimeout = pipe(
-     *   fetchTask,
-     *   Task.Result.timeout({ duration: Duration.seconds(5), onTimeout: () => "Request timed out" })
-     * );
+     * Task.sequence([loadConfig, detectLocale, loadTheme])();
+     * // Deferred<[Config, string, Theme]>
      * ```
      */
-    timeout: <E2>(options: {
-        duration: Duration;
-        onTimeout: () => E2;
-    }) => <E1 = never, A = unknown>(task: TaskResult<E1, A>) => TaskResult<E1 | E2, A>;
+    sequence: <A>(tasks: ReadonlyArray<Task<A>>) => Task<ReadonlyArray<A>>;
     /**
-     * Runs a list of fallible tasks in parallel and collects all outcomes (`Ok` and `Err`)
-     * without short-circuiting on failure.
+     * Runs an array of Tasks one at a time in order, collecting all results.
+     * Each Task starts only after the previous one resolves.
      *
      * @example
      * ```ts
-     * const results = await Task.Result.allSettled([task1, task2, task3])();
-     * // [Ok(val1), Err(err2), Ok(val3)]
+     * let log: number[] = [];
+     * const makeTask = (n: number) => Task.resolve(n);
+     *
+     * await Task.sequential([makeTask(1), makeTask(2), makeTask(3)])();
+     * // log = [1, 2, 3] — tasks ran in order
      * ```
      */
-    allSettled: <E, A>(tasks: ReadonlyArray<TaskResult<E, A>>) => Task<ReadonlyArray<Result<E, A>>>;
-};
-
-/**
- * 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 const TaskValidation: {
-    make: {
-        /**
-         * Wraps a value in a passed Task.Validation.
-         *
-         * @example
-         * ```ts
-         * const task = Task.Validation.make.passed(42);
-         * const res = await task(); // Passed(42)
-         * ```
-         */
-        passed: <E = never, A = unknown>(value: A) => TaskValidation<E, A>;
-        /**
-         * Creates a failed Task.Validation with a single error.
-         *
-         * @example
-         * ```ts
-         * const task = Task.Validation.make.failed("invalid");
-         * const res = await task(); // Failed(["invalid"])
-         * ```
-         */
-        failed: <E, A = never>(error: E) => TaskValidation<E, A>;
-        /**
-         * Creates a failed Task.Validation from multiple errors.
-         *
-         * @example
-         * ```ts
-         * const task = Task.Validation.make.failedAll(["err1", "err2"]);
-         * const res = await task(); // Failed(["err1", "err2"])
-         * ```
-         */
-        failedAll: <E, A = never>(errors: NonEmptyArr<E>) => TaskValidation<E, A>;
-    };
-    passed: <E = never, A = unknown>(value: A) => TaskValidation<E, A>;
-    failed: <E, A = never>(error: E) => TaskValidation<E, A>;
-    failedAll: <E, A = never>(errors: NonEmptyArr<E>) => TaskValidation<E, A>;
-    from: {
-        /**
-         * Lifts a Validation into a Task.Validation.
-         *
-         * @example
-         * ```ts
-         * Task.Validation.from.Validation(Validation.make.passed(42));
-         * ```
-         */
-        Validation: <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.
-         *
-         * @example
-         * ```ts
-         * Task.Validation.from.nullable(() => "missing")(42);   // resolves to Passed(42)
-         * Task.Validation.from.nullable(() => "missing")(null); // resolves to Failed(["missing"])
-         * ```
-         */
-        nullable: <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.
-         *
-         * @example
-         * ```ts
-         * Task.Validation.from.Maybe(() => "empty")(Maybe.make.some(42)); // resolves to Passed(42)
-         * Task.Validation.from.Maybe(() => "empty")(Maybe.make.none());   // resolves to Failed(["empty"])
-         * ```
-         */
-        Maybe: <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]).
-         *
-         * @example
-         * ```ts
-         * Task.Validation.from.Result(Result.make.ok(42));     // resolves to Passed(42)
-         * Task.Validation.from.Result(Result.make.err("bad")); // resolves to Failed(["bad"])
-         * ```
-         */
-        Result: <E, A>(result: Result<E, A>) => TaskValidation<E, A>;
-    };
-    to: {
-        /**
-         * Converts a `Task.Validation` to a `Task.Result`, combining accumulated errors using `combineErrors`.
-         * `Passed(a)` becomes `Ok(a)`; `Failed(errors)` becomes `Err(combineErrors(errors))`.
-         *
-         * @example
-         * ```ts
-         * Task.Validation.to.Result((errors) => errors.join(", "))(validationTask);
-         * ```
-         */
-        Result: <E1, E2, A>(combineErrors: (errors: NonEmptyArr<E1>) => E2) => (data: TaskValidation<E1, A>) => TaskResult<E2, A>;
-        /**
-         * Converts a `Task.Validation` to a `Task.Maybe`.
-         * `Passed(a)` becomes `Some(a)`; `Failed(errors)` becomes `None` (errors are discarded).
-         *
-         * @example
-         * ```ts
-         * Task.Validation.to.Maybe(validationTask);
-         * ```
-         */
-        Maybe: <E, A>(data: TaskValidation<E, A>) => TaskMaybe<A>;
-    };
-    /**
-     * Creates a Task.Validation from a Promise-returning thunk that may throw or reject.
-     * Catches any errors and transforms them using the `onError` function into a Failed validation.
-     * The thunk optionally receives an `AbortSignal` forwarded from the call site.
-     *
-     * @example
-     * ```ts
-     * const loadConfig = Task.Validation.tryCatch(
-     *   (signal) => configStore.get("default", { signal }),
-     *   { onError: (e) => `Failed to load config: ${e}` }
-     * );
-     * ```
-     */
-    tryCatch: <E, A>(f: (signal?: AbortSignal) => Thenable<A>, options: {
-        onError: (error: unknown) => E;
-    }) => TaskValidation<E, A>;
-    /**
-     * Transforms the success value inside a Task.Validation.
-     */
-    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))
-     * )();
-     * ```
-     */
-    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.
-     */
-    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)
-     *   })
-     * )();
-     * ```
-     */
-    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>`.
-     */
-    getOrElse: <B>(defaultValue: () => B) => <E, A>(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.
-     */
-    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>`.
-     */
-    recover: <E, B>(fallback: (errors: NonEmptyArr<E>) => TaskValidation<E, B>) => <A>(data: TaskValidation<E, A>) => TaskValidation<E, A | B>;
-    /**
-     * Recovers from a Failed state unless the predicate `isBlocked` returns true for the accumulated errors.
-     * The fallback receives the accumulated errors and can produce a different success type, widening the result to `Task.Validation<E, A | B>`.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   validationTask,
-     *   Task.Validation.recoverUnless(
-     *     (errors) => errors.includes("fatal"),
-     *     (errors) => Task.Validation.passed("fallback")
-     *   )
-     * );
-     * ```
-     */
-    recoverUnless: <E, B>(isBlocked: (errors: NonEmptyArr<E>) => boolean, fallback: (errors: NonEmptyArr<E>) => TaskValidation<E, B>) => <A>(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])
-     * ```
-     */
-    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])
-     * ```
-     */
-    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"]))
-     * ```
-     */
-    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))
-     * );
-     * ```
-     */
-    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 })
-     * ```
-     */
-    struct: <E, R extends Record<string, any>>(fields: { [K in keyof R]: TaskValidation<E, R[K]>; }) => TaskValidation<E, R>;
-    /**
-     * Creates a memoized version of a Task.Validation. The task is executed at most once on first call,
-     * and its resolved Validation is cached for all subsequent calls.
-     *
-     * @example
-     * ```ts
-     * const validate = Task.Validation.memoize(validateFormTask);
-     * ```
-     */
-    memoize: <E, A>(task: TaskValidation<E, A>) => TaskValidation<E, A>;
-};
-
-/**
- * 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 `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
- * operation. Existing tasks that ignore the signal continue to work unchanged.
- *
- * Calling a Task returns a `Deferred<A>` — a one-shot async value that supports
- * `await` but has no `.catch()`, `.finally()`, or chainable `.then()`.
- *
- * **Consuming a Task:**
- *
- * Use `await task()` to run it and get the value directly:
- * ```ts
- * const value: number = await task();
- * ```
- *
- * When you need an explicit `Promise<A>` (e.g. for a third-party API), convert
- * the `Deferred` with `Deferred.to.Promise`:
- * ```ts
- * const p: Promise<number> = Deferred.to.Promise(task());
- * ```
- *
- * @example
- * ```ts
- * const getTimestamp: Task<number> = Task.resolve(Date.now());
- *
- * // Nothing runs yet — getTimestamp is just a description
- * const formatted = pipe(
- *   getTimestamp,
- *   Task.map(ts => new Date(ts).toISOString())
- * );
- *
- * // Execute when ready
- * const result = await formatted();
- * ```
- */
-type Task<A> = (signal?: AbortSignal) => Deferred<A>;
-declare const Task: {
-    /**
-     * Creates a Task that immediately resolves to the given value.
-     *
-     * @example
-     * ```ts
-     * const task = Task.resolve(42);
-     * const value = await task(); // 42
-     * ```
-     */
-    resolve: <A>(value: A) => Task<A>;
-    from: {
-        /**
-         * Creates a Task from a lazy synchronous thunk.
-         * Unlike `Task.resolve(f())`, `from.sync` does not evaluate `f` until the Task is called.
-         *
-         * @example
-         * ```ts
-         * const t = Task.from.sync(() => Date.now()); // Date.now() not called yet
-         * const ts = await t(); // called here, every time
-         * ```
-         */
-        sync: <A>(f: () => A) => Task<A>;
-    };
-    /**
-     * Wraps a Promise-returning thunk that may throw or reject,
-     * trapping errors with a fallback function and returning a guaranteed `Task<A>`.
-     *
-     * @example
-     * ```ts
-     * const loadConfig = Task.tryCatch(
-     *   () => configStore.get("default"),
-     *   { onError: () => DEFAULT_CONFIG }
-     * );
-     * ```
-     */
-    tryCatch: <A>(f: (signal?: AbortSignal) => globalThis.Promise<A>, options: {
-        onError: (error: unknown) => A;
-    }) => Task<A>;
-    /**
-     * Transforms the value inside a Task.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   Task.resolve(5),
-     *   Task.map(n => n * 2)
-     * )(); // Deferred<10>
-     * ```
-     */
-    map: <A, B>(f: (a: A) => B) => (data: Task<A>) => Task<B>;
-    /**
-     * Chains Task computations. Passes the resolved value of the first Task to f.
-     *
-     * @example
-     * ```ts
-     * const readUserId: Task<string> = Task.resolve(session.userId);
-     * const loadPrefs = (id: string): Task<Preferences> =>
-     *   Task.resolve(prefsCache.get(id));
-     *
-     * pipe(
-     *   readUserId,
-     *   Task.chain(loadPrefs)
-     * )(); // Deferred<Preferences>
-     * ```
-     */
-    chain: <A, B>(f: (a: A) => Task<B>) => (data: Task<A>) => Task<B>;
-    /**
-     * Applies a function wrapped in a Task to a value wrapped in a Task.
-     * Both Tasks run in parallel.
-     *
-     * @example
-     * ```ts
-     * const add = (a: number) => (b: number) => a + b;
-     * pipe(
-     *   Task.resolve(add),
-     *   Task.ap(Task.resolve(5)),
-     *   Task.ap(Task.resolve(3))
-     * )(); // Deferred<8>
-     * ```
-     */
-    ap: <A>(arg: Task<A>) => <B>(data: Task<(a: A) => B>) => Task<B>;
-    /**
-     * Executes a side effect on the value without changing the Task.
-     * Useful for logging or debugging.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   loadConfig,
-     *   Task.tap(cfg => console.log("Config:", cfg)),
-     *   Task.map(buildReport)
-     * );
-     * ```
-     */
-    tap: <A>(f: (a: A) => void) => (data: Task<A>) => Task<A>;
-    /**
-     * Runs multiple Tasks in parallel and collects their results.
-     *
-     * @example
-     * ```ts
-     * Task.all([loadConfig, detectLocale, loadTheme])();
-     * // Deferred<[Config, string, Theme]>
-     * ```
-     */
-    all: <T extends readonly Task<unknown>[]>(tasks: T) => Task<{ [K in keyof T]: T[K] extends Task<infer A> ? A : never; }>;
-    /**
-     * Delays the execution of a Task by the specified duration.
-     * Useful for debouncing or rate limiting.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   Task.resolve(42),
-     *   Task.delay(Duration.seconds(1))
-     * )(); // Resolves after 1 second
-     * ```
-     */
-    delay: (duration: Duration) => <A>(data: Task<A>) => Task<A>;
-    /**
-     * Runs a Task a fixed number of times sequentially, collecting all results into an array.
-     * An optional delay duration can be inserted between runs.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   pollSensor,
-     *   Task.repeat({ times: 5, delay: Duration.seconds(1) })
-     * )(); // Task<Reading[]> — 5 readings, one per second
-     * ```
-     */
-    repeat: (options: {
-        times: number;
-        delay?: Duration;
-    }) => <A>(task: Task<A>) => Task<readonly A[]>;
-    /**
-     * Runs a Task repeatedly until the result satisfies a predicate, returning that result.
-     * An optional delay duration can be inserted between runs.
-     * An optional `maxAttempts` cap stops the loop after N calls — the last value is returned
-     * regardless of whether the predicate was satisfied.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   checkStatus,
-     *   Task.repeatUntil({ when: (s) => s === "ready", delay: Duration.milliseconds(500) })
-     * )(); // polls every 500ms until status is "ready"
-     * ```
-     */
-    repeatUntil: <A>(options: {
-        when: (a: A) => boolean;
-        delay?: Duration;
-        maxAttempts?: number;
-    }) => (task: Task<A>) => Task<A>;
-    /**
-     * Resolves with the value of the first Task to complete. All Tasks start
-     * immediately. When one resolves, the other tasks are cancelled (aborted)
-     * downstream.
-     *
-     * @example
-     * ```ts
-     * const fast = Task.resolve("fast");
-     * const slow = Task.delay(Duration.milliseconds(200))(Task.resolve("slow"));
-     *
-     * await Task.race([fast, slow])(); // "fast"
-     * ```
-     */
-    race: <A>(tasks: ReadonlyArray<Task<A>>) => Task<A>;
-    /**
-     * Runs an array of Tasks concurrently and collects their results in an array.
-     * Forward-propagates the call site's AbortSignal to all subtasks concurrently.
-     *
-     * @example
-     * ```ts
-     * Task.sequence([loadConfig, detectLocale, loadTheme])();
-     * // Deferred<[Config, string, Theme]>
-     * ```
-     */
-    sequence: <A>(tasks: ReadonlyArray<Task<A>>) => Task<ReadonlyArray<A>>;
-    /**
-     * Runs an array of Tasks one at a time in order, collecting all results.
-     * Each Task starts only after the previous one resolves.
-     *
-     * @example
-     * ```ts
-     * let log: number[] = [];
-     * const makeTask = (n: number) => Task.resolve(n);
-     *
-     * await Task.sequential([makeTask(1), makeTask(2), makeTask(3)])();
-     * // log = [1, 2, 3] — tasks ran in order
-     * ```
-     */
-    sequential: <A>(tasks: ReadonlyArray<Task<A>>) => Task<ReadonlyArray<A>>;
-    /**
-     * Converts a `Task<A>` into a `Task<Result<E, A>>`, resolving to `Err` if the
-     * Task does not complete within the given duration. The inner Task receives an
-     * `AbortSignal` that fires when the deadline passes, so asynchronous operations
-     * that accept a signal are cancelled rather than left dangling.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   heavyComputation,
-     *   Task.timeout({ duration: Duration.seconds(5), onTimeout: () => "timed out" }),
-     *   Task.Result.chain(processResult)
-     * );
-     * ```
-     */
-    timeout: <E>(options: {
-        duration: Duration;
-        onTimeout: () => E;
-    }) => <A>(task: Task<A>) => Task<Result<E, A>>;
-    /**
-     * Creates a Task paired with an `abort` handle. Calling `abort()` cancels the
-     * current in-flight call immediately. Unlike a one-shot abort, calling `task()`
-     * again after `abort()` starts a fresh call with a new signal.
-     *
-     * Each invocation of `task()` automatically cancels the previous in-flight call,
-     * making it safe to call repeatedly (e.g. on user input) without leaking promises.
-     *
-     * If an outer signal is also present (passed at the call site), aborting it
-     * propagates into the internal controller.
-     *
-     * @example
-     * ```ts
-     * const { task: poll, abort } = Task.abortable(
-     *   (signal) => waitForEvent(bus, "ready", { signal }),
-     * );
-     *
-     * onUnmount(abort);
-     * await poll();
-     * ```
-     */
-    abortable: <A>(factory: (signal: AbortSignal) => Thenable<A>) => {
-        task: Task<A>;
-        abort: () => void;
-    };
-    /**
-     * Executes a task with an optional signal. Use as a terminal step in a `pipe` chain.
-     *
-     * @example
-     * ```ts
-     * const name = await pipe(
-     *     loadConfig,
-     *     Task.map(config => config.name),
-     *     Task.run(),
-     * );
-     * ```
-     */
-    run: (signal?: AbortSignal) => <A>(task: Task<A>) => Deferred<A>;
-    /**
-     * Converts a Task value into an object containing a single property.
-     * Initiates the pipeline accumulator record.
-     *
-     * @example
-     * ```ts
-     * pipe(Task.resolve(42), Task.bindTo("value")); // Task({ value: 42 })
-     * ```
-     */
-    bindTo: <K extends string>(key: K) => <A>(data: Task<A>) => Task<{ [P in K]: A; }>;
-    /**
-     * Evaluates a new Task using the current accumulator and attaches the output to a new key.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   Task.resolve({ a: 1 }),
-     *   Task.bind("b", ({ a }) => Task.resolve(a + 1))
-     * ); // Task({ a: 1, b: 2 })
-     * ```
-     */
-    bind: <K extends string, A, B>(key: K, f: (a: A) => Task<B>) => (data: Task<A>) => Task<A & { [P in K]: B; }>;
-    /**
-     * Creates a memoized version of a Task. The task is executed at most once on first call,
-     * and its resolved value is cached for all subsequent calls.
-     *
-     * @example
-     * ```ts
-     * const loadToken = Task.memoize(loadAuthToken);
-     * const token1 = await loadToken(); // loads token
-     * const token2 = await loadToken(); // returns cached token immediately
-     * ```
-     */
-    memoize: <A>(task: Task<A>) => Task<A>;
-    /**
-     * Monitors progress of a Task by calling `onProgress(0)` before execution and `onProgress(1)` upon completion.
-     *
-     * @example
-     * ```ts
-     * const taskWithProgress = pipe(
-     *   readTask,
-     *   Task.withProgress((ratio) => console.log(`Progress: ${ratio * 100}%`))
-     * );
-     * ```
-     */
-    withProgress: <A>(onProgress: (ratio: number) => void) => (task: Task<A>) => Task<A>;
-    /**
-     * Attaches a read-only `.label` property to a Task, preserving the literal string generic type for IDE tooltips.
-     *
-     * @example
-     * ```ts
-     * const labeledTask = pipe(readTask, Task.withLabel("readUser"));
-     * console.log(labeledTask.label); // "readUser"
-     * ```
-     */
-    withLabel: <L extends string>(label: L) => <A>(task: Task<A>) => Task.LabeledTask<L, A>;
-    Maybe: {
-        make: {
-            some: <A>(value: A) => TaskMaybe<A>;
-            none: <A = never>() => TaskMaybe<A>;
-        };
-        some: <A>(value: A) => TaskMaybe<A>;
-        none: <A = never>() => TaskMaybe<A>;
-        from: {
-            Maybe: <A>(option: Maybe<A>) => TaskMaybe<A>;
-            nullable: <A>(value: A | null | undefined) => TaskMaybe<A>;
-            Result: <E, A>(result: Result<E, A>) => TaskMaybe<A>;
-            Task: <A>(task: Task<A>) => TaskMaybe<A>;
-        };
-        tryCatch: <A>(f: (signal?: AbortSignal) => Thenable<A>) => TaskMaybe<A>;
-        map: <A, B>(f: (a: A) => B) => (data: TaskMaybe<A>) => TaskMaybe<B>;
-        chain: <A, B>(f: (a: A) => TaskMaybe<B>) => (data: TaskMaybe<A>) => TaskMaybe<B>;
-        ap: <A>(arg: TaskMaybe<A>) => <// Deferred<10>
-        B>(data: TaskMaybe<(a: A) => B>) => TaskMaybe<B>;
-        fold: <A, B>(onNone: () => B, onSome: (a: A) => B) => (data: TaskMaybe<A>) => Task<B>;
-        match: <A, B>(cases: {
-            none: () => B;
-            some: (a: A) => B;
-        }) => (data: TaskMaybe<A>) => Task<B>;
-        getOrElse: <B>(defaultValue: () => B) => <A>(data: TaskMaybe<A>) => Task<A | B>;
-        tap: <A>(f: (a: A) => void) => (data: TaskMaybe<A>) => TaskMaybe<A>;
-        filter: <A>(predicate: (a: A) => boolean) => (data: TaskMaybe<A>) => TaskMaybe<A>;
-        to: {
-            Result: <E>(onNone: () => E) => <A>(data: TaskMaybe<A>) => Task.Result<E, A>;
-        };
-        bindTo: <K extends string>(key: K) => <A>(data: TaskMaybe<A>) => TaskMaybe<{ [P in K]: A; }>;
-        bind: <K extends string, A, B>(key: K, f: (a: A) => TaskMaybe<B>) => (data: TaskMaybe<A>) => TaskMaybe<A & { [P in K]: B; }>;
-        recover: <B>(fallback: () => TaskMaybe<B>) => <A>(data: TaskMaybe<A>) => TaskMaybe<A | B>;
-        struct: <R extends Record<string, any>>(fields: { [K in keyof R]: TaskMaybe<R[K]>; }) => TaskMaybe<R>;
-        memoize: <A>(task: TaskMaybe<A>) => TaskMaybe<A>;
-    };
-    Result: {
-        make: {
-            ok: <E = never, A = unknown>(value: A) => TaskResult<E, A>;
-            err: <E, A = never>(error: E) => TaskResult<E, A>;
-        };
-        ok: <E = never, A = unknown>(value: A) => TaskResult<E, A>;
-        err: <E, A = never>(error: E) => TaskResult<E, A>;
-        from: {
-            nullable: <E>(onNull: () => E) => <A>(value: A | null | undefined) => TaskResult<E, A>;
-            Maybe: <E>(onNone: () => E) => <A>(maybe: Maybe<A>) => TaskResult<E, A>;
-            Result: <E, A>(result: Result<E, A>) => TaskResult<E, A>;
-        };
-        to: {
-            Maybe: <E, A>(data: TaskResult<E, A>) => TaskMaybe<A>;
-        };
-        tryCatch: <E, A>(f: (signal?: AbortSignal) => Thenable<A>, options: {
-            onError: (error: unknown) => E;
-        }) => TaskResult<E, A>;
-        map: <E, A, B>(f: (a: A) => B) => (data: TaskResult<E, A>) => TaskResult<E, B>;
-        mapError: <E, F, A>(f: (e: E) => F) => (data: TaskResult<E, A>) => TaskResult<F, A>;
-        chain: <E2, A, B>(f: (a: A) => TaskResult<E2, B>) => <E1 = never>(data: TaskResult<E1, A>) => TaskResult<E1 | E2, B>;
-        fold: <E, A, B>(onErr: (e: E) => B, onOk: (a: A) => B) => (data: TaskResult<E, A>) => Task<B>;
-        match: <E, A, B>(cases: {
-            err: (e: E) => B;
-            ok: (a: A) => B;
-        }) => (data: TaskResult<E, A>) => Task<B>;
-        recover: <E, B>(fallback: (e: E) => TaskResult<E, B>) => <A>(data: TaskResult<E, A>) => TaskResult<E, A | B>;
-        recoverUnless: <E, B>(isBlocked: (e: E) => boolean, fallback: (e: E) => TaskResult<E, B>) => <A>(data: TaskResult<E, A>) => TaskResult<E, A | B>;
-        getOrElse: <B>(defaultValue: () => B) => <E, A>(// oxlint-disable-next-line prefer-const
-        data: TaskResult<E, A>) => Task<A | B>;
-        tap: <E, A>(f: (a: A) => void) => (data: TaskResult<E, A>) => TaskResult<E, A>;
-        tapError: <E, A>(f: (e: E) => void) => (data: TaskResult<E, A>) => TaskResult<E, A>;
-        ap: <E, A>(arg: TaskResult<E, A>) => <B>(data: TaskResult<E, (a: A) => B>) => TaskResult<E, B>;
-        run: (signal?: AbortSignal) => <E, A>(task: TaskResult<E, A>) => Deferred<Result<E, A>>;
-        bindTo: <K extends string>(key: K) => <E, A>(data: TaskResult<E, A>) => TaskResult<E, { [P in K]: A; }>;
-        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; }>;
-        struct: <E, R extends Record<string, any>>(fields: { [K in keyof R]: TaskResult<E, R[K]>; }) => TaskResult<E, R>;
-        retry: (policy: RetryPolicy) => <E, A>(task: TaskResult<E, A>) => TaskResult<E, A>;
-        memoize: <E, A>(task: TaskResult<E, A>) => TaskResult<E, A>;
-        timeout: <E2>(options: {
-            duration: Duration;
-            onTimeout: () => E2;
-        }) => <E1 = never, A = unknown>(task: TaskResult<E1, A>) => TaskResult<E1 | E2, A>;
-        allSettled: <E, A>(tasks: ReadonlyArray<TaskResult<E, A>>) => Task<ReadonlyArray<Result<E, A>>>;
-    };
-    Validation: {
-        make: {
-            passed: <E = never, A = unknown>(value: A) => TaskValidation<E, A>;
-            failed: <E, A = never>(error: E) => TaskValidation<E, A>;
-            failedAll: <E, A = never>(errors: NonEmptyArr<E>) => TaskValidation<E, A>;
-        };
-        passed: <E = never, A = unknown>(value: A) => TaskValidation<E, A>;
-        failed: <E, A = never>(error: E) => TaskValidation<E, A>;
-        failedAll: <E, A = never>(errors: NonEmptyArr<E>) => TaskValidation<E, A>;
-        from: {
-            Validation: <E, A>(validation: Validation<E, A>) => TaskValidation<E, A>;
-            nullable: <E>(onNull: () => E) => <A>(value: A | null | undefined) => TaskValidation<E, A>;
-            Maybe: <E>(onNone: () => E) => <A>(maybe: Maybe<A>) => TaskValidation<E, A>;
-            Result: <E, A>(result: Result<E, A>) => TaskValidation<E, A>;
-        };
-        to: {
-            Result: <E1, E2, A>(combineErrors: (errors: NonEmptyArr<E1>) => E2) => (data: TaskValidation<E1, A>) => TaskResult<E2, A>;
-            Maybe: <E, A>(data: TaskValidation<E, A>) => TaskMaybe<A>;
-        };
-        tryCatch: <E, A>(f: (signal?: AbortSignal) => Thenable<A>, options: {
-            onError: (error: unknown) => E;
-        }) => TaskValidation<E, A>;
-        map: <E, A, B>(f: (a: A) => B) => (data: TaskValidation<E, A>) => TaskValidation<E, B>;
-        ap: <E, A>(arg: TaskValidation<E, A>) => <B>(data: TaskValidation<E, (a: A) => B>) => TaskValidation<E, B>;
-        fold: <E, A, B>(onFailed: (errors: NonEmptyArr<E>) => B, onPassed: (a: A) => B) => (data: TaskValidation<E, A>) => Task<B>;
-        match: <E, A, B>(cases: {
-            passed: (a: A) => B;
-            failed: (errors: NonEmptyArr<E>) => B;
-        }) => (data: TaskValidation<E, A>) => Task<B>;
-        getOrElse: <B>(defaultValue: () => B) => <E, A>(data: TaskValidation<E, A>) => Task<A | B>;
-        tap: <E, A>(f: (a: A) => void) => (data: TaskValidation<E, A>) => TaskValidation<E, A>;
-        recover: <E, B>(fallback: (errors: NonEmptyArr<E>) => TaskValidation<E, B>) => <A>(data: TaskValidation<E, A>) => TaskValidation<E, A | B>;
-        recoverUnless: <E, B>(isBlocked: (errors: NonEmptyArr<E>) => boolean, fallback: (errors: NonEmptyArr<E>) => TaskValidation<E, B>) => <A>(data: TaskValidation<E, A>) => TaskValidation<E, A | B>;
-        product: <E, A, B>(first: TaskValidation<E, A>, second: TaskValidation<E, B>) => TaskValidation<E, readonly [A, B]>;
-        productAll: <E, A>(data: NonEmptyArr<TaskValidation<E, A>>) => TaskValidation<E, readonly A[]>;
-        mapError: <E, F, A>(f: (e: E) => F) => (data: TaskValidation<E, A>) => TaskValidation<F, A>;
-        tapError: <E, A>(f: (errors: NonEmptyArr<E>) => void) => (data: TaskValidation<E, A>) => TaskValidation<E, A>;
-        struct: <E, R extends Record<string, any>>(fields: { [K in keyof R]: TaskValidation<E, R[K]>; }) => TaskValidation<E, R>;
-        memoize: <E, A>(task: TaskValidation<E, A>) => TaskValidation<E, A>;
-    };
-};
-declare namespace Task {
-    type LabeledTask<L extends string, A> = Task<A> & {
-        readonly label: L;
-    };
-    type Maybe<A> = TaskMaybe<A>;
-    type Result<E, A> = TaskResult<E, A>;
-    type Validation<E, A> = TaskValidation<E, A>;
-}
-
-type Passed<A> = WithKind<"Passed"> & WithValue<A>;
-type Failed<E> = WithKind<"Failed"> & WithErrors<E>;
-declare function toResult<E1, E2, A>(combineErrors: (errors: NonEmptyArr<E1>) => E2): (val: Validation<E1, A>) => Result<E2, A>;
-declare function toResult<E, A>(data: Validation<E, A>): Result<NonEmptyArr<E>, A>;
-/**
- * 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.make.passed(name) : Validation.make.failed("Name is required");
- *
- * const validateAge = (age: number): Validation<string, number> =>
- *   age >= 0 ? Validation.make.passed(age) : Validation.make.failed("Age must be positive");
- *
- * // Accumulates all errors using ap
- * pipe(
- *   Validation.make.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 const Validation: {
-    make: {
-        /**
-         * Wraps a value in a passed Validation.
-         *
-         * @example
-         * ```ts
-         * Validation.make.passed(42); // Passed(42)
-         * ```
-         */
-        passed: <E, A>(value: A) => Validation<E, A>;
-        /**
-         * Creates a failed Validation from a single error.
-         *
-         * @example
-         * ```ts
-         * Validation.make.failed("Invalid input");
-         * ```
-         */
-        failed: <E>(error: E) => Failed<E>;
-        /**
-         * Creates a failed Validation from multiple errors.
-         *
-         * @example
-         * ```ts
-         * Validation.make.failedAll(["Invalid input"]);
-         * ```
-         */
-        failedAll: <E>(errors: NonEmptyArr<E>) => Failed<E>;
-    };
-    is: {
-        /**
-         * Type guard that checks if a Validation is passed.
-         *
-         * @example
-         * ```ts
-         * const v = Validation.make.passed(42);
-         * if (Validation.is.passed(v)) {
-         *   console.log(v.value); // 42
-         * }
-         * ```
-         */
-        passed: <E, A>(data: Validation<E, A>) => data is Passed<A>;
-        /**
-         * Type guard that checks if a Validation is failed.
-         *
-         * @example
-         * ```ts
-         * const v = Validation.make.failed("invalid");
-         * if (Validation.is.failed(v)) {
-         *   console.log(v.errors); // ["invalid"]
-         * }
-         * ```
-         */
-        failed: <E, A>(data: Validation<E, A>) => data is Failed<E>;
-    };
-    /**
-     * Creates a Validation from a synchronous thunk that may throw.
-     * Catches any errors and transforms them using the `onError` function into a Failed validation.
-     *
-     * @example
-     * ```ts
-     * const result = Validation.tryCatch(
-     *   () => JSON.parse(rawString),
-     *   { onError: (e) => `Parse error: ${e}` }
-     * );
-     * ```
-     */
-    tryCatch: <E, A>(f: () => A, options: {
-        onError: (e: unknown) => E;
-    }) => Validation<E, A>;
-    from: {
-        /**
-         * 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.from.Predicate(
-         *   (s: string) => s.length > 0,
-         *   () => "Name is required"
-         * );
-         *
-         * validateName("Alice"); // Passed("Alice")
-         * validateName("");      // Failed(["Name is required"])
-         * ```
-         */
-        Predicate: <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.from.nullable(() => "is null")); // Failed(["is null"])
-         * pipe(42, Validation.from.nullable(() => "is null"));   // Passed(42)
-         * ```
-         */
-        nullable: <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.make.none(), Validation.from.Maybe(() => "is none")); // Failed(["is none"])
-         * pipe(Maybe.make.some(42), Validation.from.Maybe(() => "is none")); // Passed(42)
-         * ```
-         */
-        Maybe: <E>(onNone: () => E) => <A>(maybe: Maybe<A>) => Validation<E, 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.from.Result(Result.make.ok(42));       // Passed(42)
-         * Validation.from.Result(Result.make.err("bad"));   // Failed(["bad"])
-         * ```
-         */
-        Result: <E, A>(data: Result<E, A>) => Validation<E, A>;
-    };
-    /**
-     * Transforms the success value inside a Validation.
-     *
-     * @example
-     * ```ts
-     * pipe(Validation.make.passed(5), Validation.map(n => n * 2)); // Passed(10)
-     * pipe(Validation.make.failed("oops"), Validation.map(n => n * 2)); // Failed(["oops"])
-     * ```
-     */
-    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.make.failed("oops"), Validation.mapError(e => e.toUpperCase())); // Failed(["OOPS"])
-     * ```
-     */
-    mapError: <E, F, A>(f: (e: E) => F) => (data: Validation<E, A>) => Validation<F, A>;
+    sequential: <A>(tasks: ReadonlyArray<Task<A>>) => Task<ReadonlyArray<A>>;
     /**
-     * Applies a function wrapped in a Validation to a value wrapped in a Validation.
-     * Accumulates errors from both sides.
+     * Converts a `Task<A>` into a `Task<Result<E, A>>`, resolving to `Err` if the
+     * Task does not complete within the given duration. The inner Task receives an
+     * `AbortSignal` that fires when the deadline passes, so asynchronous operations
+     * that accept a signal are cancelled rather than left dangling.
      *
      * @example
      * ```ts
-     * const add = (a: number) => (b: number) => a + b;
-     * pipe(
-     *   Validation.make.passed(add),
-     *   Validation.ap(Validation.make.passed(5)),
-     *   Validation.ap(Validation.make.passed(3))
-     * ); // Passed(8)
-     *
      * pipe(
-     *   Validation.make.passed(add),
-     *   Validation.ap(Validation.make.failed<string>("bad a")),
-     *   Validation.ap(Validation.make.failed<string>("bad b"))
-     * ); // Failed(["bad a", "bad b"])
+     *   heavyComputation,
+     *   Task.timeout({ duration: Duration.seconds(5), onTimeout: () => "timed out" }),
+     *   Task.Result.chain(processResult)
+     * );
      * ```
      */
-    ap: <E, A>(arg: Validation<E, A>) => <B>(data: Validation<E, (a: A) => B>) => Validation<E, B>;
+    timeout: <E>(options: {
+        duration: Duration;
+        onTimeout: () => E;
+    }) => <A>(task: Task<A>) => Task<Result<E, A>>;
     /**
-     * Applies a function wrapped in a Validation to a value wrapped in a Validation,
-     * using a custom error concatenator function when both sides fail.
+     * Creates a Task paired with an `abort` handle. Calling `abort()` cancels the
+     * current in-flight call immediately. Unlike a one-shot abort, calling `task()`
+     * again after `abort()` starts a fresh call with a new signal.
      *
-     * @example
-     * ```ts
-     * const concat = (e1: NonEmptyArr<string>, e2: NonEmptyArr<string>): NonEmptyArr<string> =>
-     *   [...e1, ...e2];
-     * pipe(fnVal, Validation.apCustom(concat)(argVal));
-     * ```
-     */
-    apCustom: <E1, E2, E3>(concat: (e1: NonEmptyArr<E1>, e2: NonEmptyArr<E2>) => NonEmptyArr<E3>) => <A>(arg: Validation<E2, A>) => <B>(data: Validation<E1, (a: A) => B>) => Validation<E3, B>;
-    /**
-     * Extracts the value from a Validation by providing handlers for both cases.
+     * Each invocation of `task()` automatically cancels the previous in-flight call,
+     * making it safe to call repeatedly (e.g. on user input) without leaking promises.
      *
-     * @example
-     * ```ts
-     * pipe(
-     *   Validation.make.passed(42),
-     *   Validation.fold(
-     *     errors => `Errors: ${errors.join(", ")}`,
-     *     value => `Value: ${value}`
-     *   )
-     * );
-     * ```
-     */
-    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.
+     * If an outer signal is also present (passed at the call site), aborting it
+     * propagates into the internal controller.
      *
      * @example
      * ```ts
-     * pipe(
-     *   validation,
-     *   Validation.match({
-     *     passed: value => `Got ${value}`,
-     *     failed: errors => `Failed: ${errors.join(", ")}`
-     *   })
+     * const { task: poll, abort } = Task.abortable(
+     *   (signal) => waitForEvent(bus, "ready", { signal }),
      * );
-     * ```
-     */
-    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.make.passed(5), Validation.getOrElse(() => 0)); // 5
-     * pipe(Validation.make.failed("oops"), Validation.getOrElse(() => 0)); // 0
-     * pipe(Validation.make.failed("oops"), Validation.getOrElse(() => null)); // null — typed as number | null
+     * onUnmount(abort);
+     * await poll();
      * ```
      */
-    getOrElse: <B>(defaultValue: () => B) => <E, A>(data: Validation<E, A>) => A | B;
+    abortable: <A>(factory: (signal: AbortSignal) => Thenable<A>) => {
+        task: Task<A>;
+        abort: () => void;
+    };
     /**
-     * Executes a side effect on the success value without changing the Validation.
+     * Executes a task with an optional signal. Use as a terminal step in a `pipe` chain.
      *
      * @example
      * ```ts
-     * pipe(
-     *   Validation.make.passed(5),
-     *   Validation.tap(n => console.log("Value:", n)),
-     *   Validation.map(n => n * 2)
+     * const name = await pipe(
+     *     loadConfig,
+     *     Task.map(config => config.name),
+     *     Task.run(),
      * );
      * ```
      */
-    tap: <E, A>(f: (a: A) => void) => (data: Validation<E, A>) => Validation<E, A>;
+    run: (signal?: AbortSignal) => <A>(task: Task<A>) => Deferred<A>;
     /**
-     * Executes a side effect on the accumulated errors without changing the Validation.
-     * Useful for logging or reporting validation failures.
+     * Converts a Task value into an object containing a single property.
+     * Initiates the pipeline accumulator record.
      *
      * @example
      * ```ts
-     * pipe(
-     *   Validation.make.failed("Name required"),
-     *   Validation.tapError(errors => console.error("validation failed:", errors)),
-     *   Validation.map(toUser)
-     * );
+     * pipe(Task.resolve(42), Task.bindTo("value")); // Task({ value: 42 })
      * ```
      */
-    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>`.
-     */
-    recover: <E, B>(fallback: (errors: NonEmptyArr<E>) => Validation<E, B>) => <A>(data: Validation<E, A>) => Validation<E, A | B>;
+    bindTo: <K extends string>(key: K) => <A>(data: Task<A>) => Task<{ [P in K]: A; }>;
     /**
-     * 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>`.
+     * Evaluates a new Task using the current accumulator and attaches the output to a new key.
      *
      * @example
      * ```ts
      * pipe(
-     *   Validation.make.failed("field-error"),
-     *   Validation.recoverUnless(e => e === "fatal", () => Validation.make.passed(0))
-     * ); // Passed(0)
+     *   Task.resolve({ a: 1 }),
+     *   Task.bind("b", ({ a }) => Task.resolve(a + 1))
+     * ); // Task({ a: 1, b: 2 })
      * ```
      */
-    recoverUnless: <E, B>(isBlocked: (e: E) => boolean, fallback: () => Validation<E, B>) => <A>(data: Validation<E, A>) => Validation<E, A | B>;
-    to: {
-        /**
-         * Converts a Validation to a Result.
-         * Passed becomes Ok.
-         * Direct call converts Failed to Err with accumulated error list `NonEmptyArr<E>`.
-         * Curried call converts Failed to Err with combined error `E2` via `combineErrors`.
-         *
-         * @example
-         * ```ts
-         * Validation.to.Result(Validation.make.passed(42));        // Ok(42)
-         * Validation.to.Result(Validation.make.failed("oops"));  // Err(["oops"])
-         * pipe(Validation.make.failed("oops"), Validation.to.Result(errors => errors.join(", "))); // Err("oops")
-         * ```
-         */
-        Result: typeof toResult;
-        /**
-         * Converts a Validation to a Maybe. `Passed` becomes `Some`; `Failed` becomes `None`
-         * (errors are discarded).
-         *
-         * @example
-         * ```ts
-         * Validation.to.Maybe(Validation.make.passed(42));       // Some(42)
-         * Validation.to.Maybe(Validation.make.failed("bad"));  // None
-         * ```
-         */
-        Maybe: <E, A>(data: Validation<E, A>) => Maybe<A>;
-    };
+    bind: <K extends string, A, B>(key: K, f: (a: A) => Task<B>) => (data: Task<A>) => Task<A & { [P in K]: B; }>;
     /**
-     * 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.
+     * Creates a memoized version of a Task. The task is executed at most once on first call,
+     * and its resolved value is cached for all subsequent calls.
      *
      * @example
      * ```ts
-     * Validation.product(
-     *   Validation.make.passed("alice"),
-     *   Validation.make.passed(30)
-     * ); // Passed(["alice", 30])
-     *
-     * Validation.product(
-     *   Validation.make.failed("Name required"),
-     *   Validation.make.failed("Age must be >= 0")
-     * ); // Failed(["Name required", "Age must be >= 0"])
+     * const loadToken = Task.memoize(loadAuthToken);
+     * const token1 = await loadToken(); // loads token
+     * const token2 = await loadToken(); // returns cached token immediately
      * ```
      */
-    product: <E, A, B>(first: Validation<E, A>, second: Validation<E, B>) => Validation<E, readonly [A, B]>;
+    memoize: <A>(task: Task<A>) => Task<A>;
     /**
-     * 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.
+     * Monitors progress of a Task by calling `onProgress(0)` before execution and `onProgress(1)` upon completion.
      *
      * @example
      * ```ts
-     * Validation.productAll([
-     *   validateName(name),
-     *   validateEmail(email),
-     *   validateAge(age)
-     * ]);
-     * // Passed([name, email, age]) or Failed([...all errors])
+     * const taskWithProgress = pipe(
+     *   readTask,
+     *   Task.withProgress((ratio) => console.log(`Progress: ${ratio * 100}%`))
+     * );
      * ```
      */
-    productAll: <E, A>(data: NonEmptyArr<Validation<E, A>>) => Validation<E, readonly A[]>;
+    withProgress: <A>(onProgress: (ratio: number) => void) => (task: Task<A>) => Task<A>;
     /**
-     * Combines a record of Validations into a single Validation of a record.
-     * Accumulates all failed branches' errors.
+     * Attaches a read-only `.label` property to a Task, preserving the literal string generic type for IDE tooltips.
      *
      * @example
      * ```ts
-     * Validation.struct({
-     *   name: Validation.make.passed("Alice"),
-     *   age: Validation.make.passed(30)
-     * }); // Passed({ name: "Alice", age: 30 })
-     *
-     * Validation.struct({
-     *   name: Validation.make.failed("Name required"),
-     *   age: Validation.make.failed("Age must be >= 0")
-     * }); // Failed(["Name required", "Age must be >= 0"])
+     * const labeledTask = pipe(readTask, Task.withLabel("readUser"));
+     * console.log(labeledTask.label); // "readUser"
      * ```
      */
-    struct: <E, R extends Record<string, any>>(fields: { [K in keyof R]: Validation<E, R[K]>; }) => Validation<E, R>;
+    withLabel: <L extends string>(label: L) => <A>(task: Task<A>) => Task.LabeledTask<L, A>;
+    Maybe: {
+        make: {
+            some: <A>(value: A) => Task.Maybe<A>;
+            none: <A = never>() => Task.Maybe<A>;
+        };
+        from: {
+            Maybe: <A>(option: Maybe<A>) => Task.Maybe<A>;
+            nullable: <A>(value: A | null | undefined) => Task.Maybe<A>;
+            Result: <E, A>(result: Result<E, A>) => Task.Maybe<A>;
+            Task: <A>(task: Task<A>) => Task.Maybe<A>;
+        };
+        tryCatch: <A>(f: (signal?: AbortSignal) => Thenable<A>) => Task.Maybe<A>;
+        map: <A, B>(f: (a: A) => B) => (data: Task.Maybe<A>) => Task.Maybe<B>;
+        chain: <A, B>(f: (a: A) => Task.Maybe<B>) => (data: Task.Maybe<A>) => Task.Maybe<B>;
+        ap: <A>(arg: Task.Maybe<A>) => <B>(data: Task.Maybe<(a: A) => B>) => Task.Maybe<B>;
+        fold: <A, B>(onNone: () => B, onSome: (a: A) => B) => (data: Task.Maybe<A>) => Task<B>;
+        match: <A, B>(cases: {
+            none: () => B;
+            some: (a: A) => B;
+        }) => (data: Task.Maybe<A>) => Task<B>;
+        getOrElse: <B>(defaultValue: () => B) => <A>(data: Task.Maybe<A>) => Task<A | B>;
+        tap: <A>(f: (a: A) => void) => (data: Task.Maybe<A>) => Task.Maybe<A>;
+        filter: <A>(predicate: (a: A) => boolean) => (data: Task.Maybe<A>) => Task.Maybe<A>;
+        to: {
+            Result: <E>(onNone: () => E) => <A>(data: Task.Maybe<A>) => Task.Result<E, A>;
+        };
+        bindTo: <K extends string>(key: K) => <A>(data: Task.Maybe<A>) => Task.Maybe<{ [P in K]: A; }>;
+        bind: <K extends string, A, B>(key: K, f: (a: A) => Task.Maybe<B>) => (data: Task.Maybe<A>) => Task.Maybe<A & { [P in K]: B; }>;
+        recover: <B>(fallback: () => Task.Maybe<B>) => <A>(data: Task.Maybe<A>) => Task.Maybe<A | B>;
+        struct: <R extends Record<string, any>>(fields: { [K in keyof R]: Task.Maybe<R[K]>; }) => Task.Maybe<R>;
+        memoize: <A>(task: Task.Maybe<A>) => Task.Maybe<A>;
+    };
+    Result: {
+        make: {
+            ok: <E = never, A = unknown>(value: A) => Task.Result<E, A>;
+            err: <E, A = never>(error: E) => Task.Result<E, A>;
+        };
+        from: {
+            nullable: <E>(onNull: () => E) => <A>(value: A | null | undefined) => Task.Result<E, A>;
+            Maybe: <E>(onNone: () => E) => <A>(maybe: Maybe<A>) => Task.Result<E, A>;
+            Result: <E, A>(result: Result<E, A>) => Task.Result<E, A>;
+        };
+        to: {
+            Maybe: <E, A>(data: Task.Result<E, A>) => Task.Maybe<A>;
+        };
+        tryCatch: <E, A>(f: (signal?: AbortSignal) => Thenable<A>, options: {
+            onError: (error: unknown) => E;
+        }) => Task.Result<E, A>;
+        map: <E, A, B>(f: (a: A) => B) => (data: Task.Result<E, A>) => Task.Result<E, B>;
+        mapError: <E, F, A>(f: (e: E) => F) => (data: Task.Result<E, A>) => Task.Result<F, A>;
+        chain: <E2, A, B>(f: (a: A) => Task.Result<E2, B>) => <E1 = never>(data: Task.Result<E1, A>) => Task.Result<E1 | E2, B>;
+        fold: <E, A, B>(onErr: (e: E) => B, onOk: (a: A) => B) => (data: Task.Result<E, A>) => Task<B>;
+        match: <E, A, B>(cases: {
+            err: (e: E) => B;
+            ok: (a: A) => B;
+        }) => (data: Task.Result<E, A>) => Task<B>;
+        recover: <E, B>(fallback: (e: E) => Task.Result<E, B>) => <A>(data: Task.Result<E, A>) => Task.Result<E, A | B>;
+        recoverUnless: <E, B>(isBlocked: (e: E) => boolean, fallback: (e: E) => Task.Result<E, B>) => <A>(data: Task.Result<E, A>) => Task.Result<E, A | B>;
+        getOrElse: <B>(defaultValue: () => B) => <E, A>(data: Task.Result<E, A>) => Task<A | B>;
+        tap: <E, A>(f: (a: A) => void) => (data: Task.Result<E, A>) => Task.Result<E, A>;
+        tapError: <E, A>(f: (e: E) => void) => (data: Task.Result<E, A>) => Task.Result<E, A>;
+        ap: <E, A>(arg: Task.Result<E, A>) => <B>(data: Task.Result<E, (a: A) => B>) => Task.Result<E, B>;
+        run: (signal?: AbortSignal) => <E, A>(task: Task.Result<E, A>) => Deferred<Result<E, A>>;
+        bindTo: <K extends string>(key: K) => <E, A>(data: Task.Result<E, A>) => Task.Result<E, { [P in K]: A; }>;
+        bind: <K extends string, E, A, B>(key: K, f: (a: A) => Task.Result<E, B>) => (data: Task.Result<E, A>) => Task.Result<E, A & { [P in K]: B; }>;
+        struct: <E, R extends Record<string, any>>(fields: { [K in keyof R]: Task.Result<E, R[K]>; }) => Task.Result<E, R>;
+        retry: (policy: RetryPolicy) => <E, A>(task: Task.Result<E, A>) => Task.Result<E, A>;
+        memoize: <E, A>(task: Task.Result<E, A>) => Task.Result<E, A>;
+        timeout: <E2>(options: {
+            duration: Duration;
+            onTimeout: () => E2;
+        }) => <E1 = never, A = unknown>(task: Task.Result<E1, A>) => Task.Result<E1 | E2, A>;
+        allSettled: <E, A>(tasks: ReadonlyArray<Task.Result<E, A>>) => Task<ReadonlyArray<Result<E, A>>>;
+    };
+    Validation: {
+        make: {
+            passed: <E = never, A = unknown>(value: A) => Task.Validation<E, A>;
+            failed: <E, A = never>(error: E) => Task.Validation<E, A>;
+            failedAll: <E, A = never>(errors: NonEmptyArr<E>) => Task.Validation<E, A>;
+        };
+        from: {
+            Validation: <E, A>(validation: Validation<E, A>) => Task.Validation<E, A>;
+            nullable: <E>(onNull: () => E) => <A>(value: A | null | undefined) => Task.Validation<E, A>;
+            Maybe: <E>(onNone: () => E) => <A>(maybe: Maybe<A>) => Task.Validation<E, A>;
+            Result: <E, A>(result: Result<E, A>) => Task.Validation<E, A>;
+        };
+        to: {
+            Result: <E1, E2, A>(combineErrors: (errors: NonEmptyArr<E1>) => E2) => (data: Task.Validation<E1, A>) => Task.Result<E2, A>;
+            Maybe: <E, A>(data: Task.Validation<E, A>) => Task.Maybe<A>;
+        };
+        tryCatch: <E, A>(f: (signal?: AbortSignal) => Thenable<A>, options: {
+            onError: (error: unknown) => E;
+        }) => Task.Validation<E, A>;
+        map: <E, A, B>(f: (a: A) => B) => (data: Task.Validation<E, A>) => Task.Validation<E, B>;
+        ap: <E, A>(arg: Task.Validation<E, A>) => <B>(data: Task.Validation<E, (a: A) => B>) => Task.Validation<E, B>;
+        fold: <E, A, B>(onFailed: (errors: NonEmptyArr<E>) => B, onPassed: (a: A) => B) => (data: Task.Validation<E, A>) => Task<B>;
+        match: <E, A, B>(cases: {
+            passed: (a: A) => B;
+            failed: (errors: NonEmptyArr<E>) => B;
+        }) => (data: Task.Validation<E, A>) => Task<B>;
+        getOrElse: <B>(defaultValue: () => B) => <E, A>(data: Task.Validation<E, A>) => Task<A | B>;
+        tap: <E, A>(f: (a: A) => void) => (data: Task.Validation<E, A>) => Task.Validation<E, A>;
+        recover: <E, B>(fallback: (errors: NonEmptyArr<E>) => Task.Validation<E, B>) => <A>(data: Task.Validation<E, A>) => Task.Validation<E, A | B>;
+        recoverUnless: <E, B>(isBlocked: (errors: NonEmptyArr<E>) => boolean, fallback: (errors: NonEmptyArr<E>) => Task.Validation<E, B>) => <A>(data: Task.Validation<E, A>) => Task.Validation<E, A | B>;
+        product: <E, A, B>(first: Task.Validation<E, A>, second: Task.Validation<E, B>) => Task.Validation<E, readonly [A, B]>;
+        productAll: <E, A>(data: NonEmptyArr<Task.Validation<E, A>>) => Task.Validation<E, readonly A[]>;
+        mapError: <E, F, A>(f: (e: E) => F) => (data: Task.Validation<E, A>) => Task.Validation<F, A>;
+        tapError: <E, A>(f: (errors: NonEmptyArr<E>) => void) => (data: Task.Validation<E, A>) => Task.Validation<E, A>;
+        struct: <E, R extends Record<string, any>>(fields: { [K in keyof R]: Task.Validation<E, R[K]>; }) => Task.Validation<E, R>;
+        memoize: <E, A>(task: Task.Validation<E, A>) => Task.Validation<E, A>;
+    };
 };
+declare namespace Task {
+    type LabeledTask<L extends string, A> = Task<A> & {
+        readonly label: L;
+    };
+    type Maybe<A> = Task<_CoreMaybe<A>>;
+    type Result<E, A> = Task<_CoreResult<E, A>>;
+    type Validation<E, A> = Task<_CoreValidation<E, A>>;
+}
 
 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 };