@nlozgachev/pipelined 0.43.0 → 0.44.0

package/dist/{Validation-BOPLiDqa.d.ts → Validation-DM2eh6wj.d.ts}

@@ -1,4 +1,4 @@
-import { g as WithKind, n as WithValue, d as WithError, T as Thenable, D as Deferred, N as NonEmptyArr, e as WithErrors } from './InternalTypes-DuzMFAfJ.js';
+import { g as WithKind, n as WithValue, d as WithError, T as Thenable, D as Deferred, N as NonEmptyArr, e as WithErrors } from './InternalTypes-7o9-yrHq.js';
 import { Duration } from './types.js';
 
 /**
@@ -709,13 +709,13 @@ declare namespace Result {
  *
  * @example
  * ```ts
- * const findUser = (id: string): TaskMaybe<User> =>
- *   TaskMaybe.tryCatch(() => db.users.findById(id));
+ * const findUser = (id: string): Task.Maybe<User> =>
+ *   Task.Maybe.tryCatch(() => db.users.findById(id));
  *
  * pipe(
  *   findUser("123"),
- *   TaskMaybe.map(user => user.name),
- *   TaskMaybe.getOrElse(() => "Unknown")
+ *   Task.Maybe.map(user => user.name),
+ *   Task.Maybe.getOrElse(() => "Unknown")
  * )();
  * ```
  */
@@ -726,74 +726,74 @@ declare namespace TaskMaybe {
      */
     const some: <A>(value: A) => TaskMaybe<A>;
     /**
-     * Creates a TaskMaybe that resolves to None.
+     * Creates a Task.Maybe that resolves to None.
      */
     const none: <A = never>() => TaskMaybe<A>;
     /**
-     * Lifts an Option into a TaskMaybe.
+     * Lifts an Option into a Task.Maybe.
      */
     const fromMaybe: <A>(option: Maybe<A>) => TaskMaybe<A>;
     /**
-     * Creates a TaskMaybe from a nullable value.
+     * Creates a Task.Maybe from a nullable value.
      * Returns Some if the value is not null or undefined, None otherwise.
      */
     const fromNullable: <A>(value: A | null | undefined) => TaskMaybe<A>;
     /**
-     * Creates a TaskMaybe from a Result.
+     * Creates a Task.Maybe from a Result.
      * Ok becomes Some, Error becomes None (the error value is discarded).
      */
     const fromResult: <E, A>(result: Result<E, A>) => TaskMaybe<A>;
     /**
-     * Lifts a Task into a TaskMaybe by wrapping its result in Some.
+     * Lifts a Task into a Task.Maybe by wrapping its result in Some.
      */
     const fromTask: <A>(task: Task<A>) => TaskMaybe<A>;
     /**
-     * Creates a TaskMaybe from a Promise-returning function.
+     * Creates a Task.Maybe from a Promise-returning function.
      * Returns Some if the promise resolves, None if it rejects.
      * The factory optionally receives an `AbortSignal` forwarded from the call site.
      *
      * @example
      * ```ts
-     * const fetchUser = TaskMaybe.tryCatch((signal) =>
+     * const fetchUser = Task.Maybe.tryCatch((signal) =>
      *   fetch("/user/1", { signal }).then(r => r.json())
      * );
      * ```
      */
     const tryCatch: <A>(f: (signal?: AbortSignal) => Thenable<A>) => TaskMaybe<A>;
     /**
-     * Transforms the value inside a TaskMaybe.
+     * Transforms the value inside a Task.Maybe.
      */
     const map: <A, B>(f: (a: A) => B) => (data: TaskMaybe<A>) => TaskMaybe<B>;
     /**
-     * Chains TaskMaybe computations. If the first resolves to Some, passes the
+     * Chains Task.Maybe computations. If the first resolves to Some, passes the
      * value to f. If the first resolves to None, propagates None.
      *
      * @example
      * ```ts
      * pipe(
      *   findUser("123"),
-     *   TaskMaybe.chain(user => findOrg(user.orgId))
+     *   Task.Maybe.chain(user => findOrg(user.orgId))
      * )();
      * ```
      */
     const chain: <A, B>(f: (a: A) => TaskMaybe<B>) => (data: TaskMaybe<A>) => TaskMaybe<B>;
     /**
-     * Applies a function wrapped in a TaskMaybe to a value wrapped in a TaskMaybe.
+     * Applies a function wrapped in a Task.Maybe to a value wrapped in a Task.Maybe.
      * Both Tasks run in parallel.
      */
     const ap: <A>(arg: TaskMaybe<A>) => <B>(data: TaskMaybe<(a: A) => B>) => TaskMaybe<B>;
     /**
-     * Extracts a value from a TaskMaybe by providing handlers for both cases.
+     * Extracts a value from a Task.Maybe by providing handlers for both cases.
      */
     const fold: <A, B>(onNone: () => B, onSome: (a: A) => B) => (data: TaskMaybe<A>) => Task<B>;
     /**
-     * Pattern matches on a TaskMaybe, returning a Task of the result.
+     * Pattern matches on a Task.Maybe, returning a Task of the result.
      *
      * @example
      * ```ts
      * pipe(
      *   findUser("123"),
-     *   TaskMaybe.match({
+     *   Task.Maybe.match({
      *     some: user => `Hello, ${user.name}`,
      *     none: () => "User not found"
      *   })
@@ -805,74 +805,74 @@ declare namespace TaskMaybe {
         some: (a: A) => B;
     }) => (data: TaskMaybe<A>) => Task<B>;
     /**
-     * Returns the value or a default if the TaskMaybe resolves to None.
+     * Returns the value or a default if the Task.Maybe resolves to None.
      * The default can be a different type, widening the result to `Task<A | B>`.
      */
     const getOrElse: <A, B>(defaultValue: () => B) => (data: TaskMaybe<A>) => Task<A | B>;
     /**
-     * Executes a side effect on the value without changing the TaskMaybe.
+     * Executes a side effect on the value without changing the Task.Maybe.
      * Useful for logging or debugging.
      */
     const tap: <A>(f: (a: A) => void) => (data: TaskMaybe<A>) => TaskMaybe<A>;
     /**
-     * Filters the value inside a TaskMaybe. Returns None if the predicate fails.
+     * Filters the value inside a Task.Maybe. Returns None if the predicate fails.
      */
     const filter: <A>(predicate: (a: A) => boolean) => (data: TaskMaybe<A>) => TaskMaybe<A>;
     /**
-     * Converts a TaskMaybe to a Task.Result, using onNone to produce the error value.
+     * Converts a Task.Maybe to a Task.Result, using onNone to produce the error value.
      *
      * @example
      * ```ts
      * pipe(
      *   findUser("123"),
-     *   TaskMaybe.toResult(() => "User not found")
+     *   Task.Maybe.toResult(() => "User not found")
      * );
      * ```
      */
     const toResult: <E>(onNone: () => E) => <A>(data: TaskMaybe<A>) => Task.Result<E, A>;
     /**
-     * Lifts a TaskMaybe value into an accumulator object.
+     * Lifts a Task.Maybe value into an accumulator object.
      *
      * @example
      * ```ts
-     * pipe(TaskMaybe.some(42), TaskMaybe.bindTo("value")); // TaskMaybe({ value: 42 })
+     * pipe(Task.Maybe.some(42), Task.Maybe.bindTo("value")); // Task.Maybe({ value: 42 })
      * ```
      */
     const bindTo: <K extends string>(key: K) => <A>(data: TaskMaybe<A>) => TaskMaybe<{ [P in K]: A; }>;
     /**
-     * Evaluates a new TaskMaybe using the current accumulator and attaches the output to a new key.
+     * Evaluates a new Task.Maybe using the current accumulator and attaches the output to a new key.
      *
      * @example
      * ```ts
      * pipe(
-     *   TaskMaybe.some({ a: 1 }),
-     *   TaskMaybe.bind("b", ({ a }) => TaskMaybe.some(a + 1))
-     * ); // TaskMaybe({ a: 1, b: 2 })
+     *   Task.Maybe.some({ a: 1 }),
+     *   Task.Maybe.bind("b", ({ a }) => Task.Maybe.some(a + 1))
+     * ); // Task.Maybe({ a: 1, b: 2 })
      * ```
      */
     const bind: <K extends string, A, B>(key: K, f: (a: A) => TaskMaybe<B>) => (data: TaskMaybe<A>) => TaskMaybe<A & { [P in K]: B; }>;
     /**
-     * Recovers from a None state by providing a fallback TaskMaybe.
+     * Recovers from a None state by providing a fallback Task.Maybe.
      *
      * @example
      * ```ts
      * pipe(
-     *   TaskMaybe.none(),
-     *   TaskMaybe.recover(() => TaskMaybe.some(42))
-     * ); // TaskMaybe(42)
+     *   Task.Maybe.none(),
+     *   Task.Maybe.recover(() => Task.Maybe.some(42))
+     * ); // Task.Maybe(42)
      * ```
      */
     const recover: <A, B>(fallback: () => TaskMaybe<B>) => (data: TaskMaybe<A>) => TaskMaybe<A | B>;
     /**
-     * Combines a record of TaskMaybes into a single TaskMaybe of a record.
+     * Combines a record of Task.Maybes into a single Task.Maybe of a record.
      * Evaluates fields in parallel and returns None if any task resolves to None.
      *
      * @example
      * ```ts
-     * TaskMaybe.struct({
-     *   name: TaskMaybe.some("Alice"),
-     *   age: TaskMaybe.some(30)
-     * }); // TaskMaybe({ name: "Alice", age: 30 })
+     * Task.Maybe.struct({
+     *   name: Task.Maybe.some("Alice"),
+     *   age: Task.Maybe.some(30)
+     * }); // Task.Maybe({ name: "Alice", age: 30 })
      * ```
      */
     const struct: <R extends Record<string, any>>(fields: { [K in keyof R]: TaskMaybe<R[K]>; }) => TaskMaybe<R>;
@@ -884,8 +884,8 @@ declare namespace TaskMaybe {
  *
  * @example
  * ```ts
- * const fetchUser = (id: string): TaskResult<Error, User> =>
- *   TaskResult.tryCatch(
+ * const fetchUser = (id: string): Task.Result<Error, User> =>
+ *   Task.Result.tryCatch(
  *     (signal) => fetch(`/users/${id}`, { signal }).then(r => r.json()),
  *     (e) => new Error(`Failed to fetch user: ${e}`)
  *   );
@@ -894,41 +894,41 @@ declare namespace TaskMaybe {
 type TaskResult<E, A> = Task<Result<E, A>>;
 declare namespace TaskResult {
     /**
-     * Wraps a value in a successful TaskResult.
+     * Wraps a value in a successful Task.Result.
      */
     const ok: <E, A>(value: A) => TaskResult<E, A>;
     /**
-     * Creates a failed TaskResult with the given error.
+     * Creates a failed Task.Result with the given error.
      */
     const err: <E, A>(error: E) => TaskResult<E, A>;
     /**
-     * Creates a TaskResult from a nullable value.
+     * Creates a Task.Result from a nullable value.
      * Returns Ok if the value is not null or undefined, err from onNull otherwise.
      */
     const fromNullable: <E>(onNull: () => E) => <A>(value: A | null | undefined) => TaskResult<E, A>;
     /**
-     * Creates a TaskResult from a Maybe.
+     * Creates a Task.Result from a Maybe.
      * Some becomes Ok, None becomes err from onNone.
      */
     const fromMaybe: <E>(onNone: () => E) => <A>(maybe: Maybe<A>) => TaskResult<E, A>;
     /**
-     * Lifts a Result into a TaskResult.
+     * Lifts a Result into a Task.Result.
      */
     const fromResult: <E, A>(result: Result<E, A>) => TaskResult<E, A>;
     /**
      * Wraps a Promise-returning function of any arguments, returning a new function
-     * that catches rejections and returns a TaskResult.
+     * that catches rejections and returns a Task.Result.
      */
     const fromThrowable: <Args extends readonly unknown[], A, E>(f: (...args: Args) => Promise<A>, onError: (e: unknown) => E) => (...args: Args) => TaskResult<E, A>;
     /**
-     * Creates a TaskResult from a function that may throw.
+     * Creates a Task.Result from a function that may throw.
      * Catches any errors and transforms them using the onError function.
      * The factory optionally receives an `AbortSignal` forwarded from the call site.
      *
      * @example
      * ```ts
-     * const fetchUser = (id: string): TaskResult<string, User> =>
-     *   TaskResult.tryCatch(
+     * const fetchUser = (id: string): Task.Result<string, User> =>
+     *   Task.Result.tryCatch(
      *     (signal) => fetch(`/users/${id}`, { signal }).then(r => r.json()),
      *     String
      *   );
@@ -936,65 +936,65 @@ declare namespace TaskResult {
      */
     const tryCatch: <E, A>(f: (signal?: AbortSignal) => Thenable<A>, onError: (e: unknown) => E) => TaskResult<E, A>;
     /**
-     * Transforms the success value inside a TaskResult.
+     * Transforms the success value inside a Task.Result.
      */
     const map: <E, A, B>(f: (a: A) => B) => (data: TaskResult<E, A>) => TaskResult<E, B>;
     /**
-     * Transforms the error value inside a TaskResult.
+     * Transforms the error value inside a Task.Result.
      */
     const mapError: <E, F, A>(f: (e: E) => F) => (data: TaskResult<E, A>) => TaskResult<F, A>;
     /**
-     * Chains TaskResult computations. If the first succeeds, passes the value to f.
+     * Chains Task.Result computations. If the first succeeds, passes the value to f.
      * If the first fails, propagates the error.
      */
     const chain: <E, A, B>(f: (a: A) => TaskResult<E, B>) => (data: TaskResult<E, A>) => TaskResult<E, B>;
     /**
-     * Extracts the value from a TaskResult by providing handlers for both cases.
+     * Extracts the value from a Task.Result by providing handlers for both cases.
      */
     const fold: <E, A, B>(onErr: (e: E) => B, onOk: (a: A) => B) => (data: TaskResult<E, A>) => Task<B>;
     /**
-     * Pattern matches on a TaskResult, returning a Task of the result.
+     * Pattern matches on a Task.Result, returning a Task of the result.
      */
     const match: <E, A, B>(cases: {
         err: (e: E) => B;
         ok: (a: A) => B;
     }) => (data: TaskResult<E, A>) => Task<B>;
     /**
-     * Recovers from an error by providing a fallback TaskResult.
-     * The fallback can produce a different success type, widening the result to `TaskResult<E, A | B>`.
+     * Recovers from an error by providing a fallback Task.Result.
+     * The fallback can produce a different success type, widening the result to `Task.Result<E, A | B>`.
      */
     const recover: <E, A, B>(fallback: (e: E) => TaskResult<E, B>) => (data: TaskResult<E, A>) => TaskResult<E, A | B>;
     /**
-     * Returns the success value or a default value if the TaskResult is an error.
+     * Returns the success value or a default value if the Task.Result is an error.
      * The default can be a different type, widening the result to `Task<A | B>`.
      */
     const getOrElse: <E, A, B>(defaultValue: () => B) => (data: TaskResult<E, A>) => Task<A | B>;
     /**
-     * Executes a side effect on the success value without changing the TaskResult.
+     * Executes a side effect on the success value without changing the Task.Result.
      * Useful for logging or debugging.
      */
     const tap: <E, A>(f: (a: A) => void) => (data: TaskResult<E, A>) => TaskResult<E, A>;
     /**
-     * Executes a side effect on the error value without changing the TaskResult.
+     * Executes a side effect on the error value without changing the Task.Result.
      * Useful for logging or reporting async errors.
      *
      * @example
      * ```ts
      * pipe(
      *   fetchUser(id),
-     *   TaskResult.tapError(e => console.error("fetch failed:", e)),
-     *   TaskResult.chain(saveToCache),
+     *   Task.Result.tapError(e => console.error("fetch failed:", e)),
+     *   Task.Result.chain(saveToCache),
      * )
      * ```
      */
     const tapError: <E, A>(f: (e: E) => void) => (data: TaskResult<E, A>) => TaskResult<E, A>;
     /**
-     * Applies a function wrapped in a TaskResult to a value wrapped in a TaskResult.
+     * Applies a function wrapped in a Task.Result to a value wrapped in a Task.Result.
      * Both Tasks run in parallel.
      */
     const ap: <E, A>(arg: TaskResult<E, A>) => <B>(data: TaskResult<E, (a: A) => B>) => TaskResult<E, B>;
     /**
-     * Executes a `TaskResult` with an optional signal, returning `Promise<Result<E, A>>`.
+     * Executes a `Task.Result` with an optional signal, returning `Promise<Result<E, A>>`.
      * Use as a terminal step in a `pipe` chain.
      *
      * @example
@@ -1002,46 +1002,46 @@ declare namespace TaskResult {
      * const controller = new AbortController();
      * const result = await pipe(
      *     fetchUser("42"),
-     *     TaskResult.chain(user => fetchPosts(user.id)),
-     *     TaskResult.run(controller.signal),
+     *     Task.Result.chain(user => fetchPosts(user.id)),
+     *     Task.Result.run(controller.signal),
      * );
      * if (Result.isOk(result)) render(result.value);
      * ```
      */
     const run: (signal?: AbortSignal) => <E, A>(task: TaskResult<E, A>) => Deferred<Result<E, A>>;
     /**
-     * Converts a TaskResult value into an object containing a single property.
+     * Converts a Task.Result value into an object containing a single property.
      * Initiates the pipeline accumulator record.
      *
      * @example
      * ```ts
-     * pipe(TaskResult.ok(42), TaskResult.bindTo("value")); // TaskResult({ value: 42 })
+     * pipe(Task.Result.ok(42), Task.Result.bindTo("value")); // Task.Result({ value: 42 })
      * ```
      */
     const bindTo: <K extends string>(key: K) => <E, A>(data: TaskResult<E, A>) => TaskResult<E, { [P in K]: A; }>;
     /**
-     * Evaluates a new TaskResult using the current accumulator and attaches the output to a new key.
+     * Evaluates a new Task.Result using the current accumulator and attaches the output to a new key.
      *
      * @example
      * ```ts
      * pipe(
-     *   TaskResult.ok({ a: 1 }),
-     *   TaskResult.bind("b", ({ a }) => TaskResult.ok(a + 1))
-     * ); // TaskResult({ a: 1, b: 2 })
+     *   Task.Result.ok({ a: 1 }),
+     *   Task.Result.bind("b", ({ a }) => Task.Result.ok(a + 1))
+     * ); // Task.Result({ a: 1, b: 2 })
      * ```
      */
     const bind: <K extends string, E, A, B>(key: K, f: (a: A) => TaskResult<E, B>) => (data: TaskResult<E, A>) => TaskResult<E, A & { [P in K]: B; }>;
     /**
-     * Combines a record of TaskResults into a single TaskResult of a record.
+     * Combines a record of Task.Results into a single Task.Result of a record.
      * Evaluates all tasks in parallel, forwarding the AbortSignal down to each sub-task.
      * Returns the first Err encountered in key order.
      *
      * @example
      * ```ts
-     * TaskResult.struct({
-     *   name: TaskResult.ok("Alice"),
-     *   age: TaskResult.ok(30)
-     * }); // TaskResult({ name: "Alice", age: 30 })
+     * Task.Result.struct({
+     *   name: Task.Result.ok("Alice"),
+     *   age: Task.Result.ok(30)
+     * }); // Task.Result({ name: "Alice", age: 30 })
      * ```
      */
     const struct: <E, R extends Record<string, any>>(fields: { [K in keyof R]: TaskResult<E, R[K]>; }) => TaskResult<E, R>;
@@ -1049,21 +1049,21 @@ declare namespace TaskResult {
 
 /**
  * A Task that resolves to a Validation — combining async operations with
- * error accumulation. Unlike TaskResult, multiple failures are collected
+ * error accumulation. Unlike Task.Result, multiple failures are collected
  * rather than short-circuiting on the first error.
  *
  * @example
  * ```ts
- * const validateName = (name: string): TaskValidation<string, string> =>
+ * const validateName = (name: string): Task.Validation<string, string> =>
  *   name.length > 0
- *     ? TaskValidation.passed(name)
- *     : TaskValidation.failed("Name is required");
+ *     ? Task.Validation.passed(name)
+ *     : Task.Validation.failed("Name is required");
  *
  * // Accumulate errors from multiple async validations using ap
  * pipe(
- *   TaskValidation.passed((name: string) => (age: number) => ({ name, age })),
- *   TaskValidation.ap(validateName("")),
- *   TaskValidation.ap(validateAge(-1))
+ *   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"])
  * ```
@@ -1071,46 +1071,46 @@ declare namespace TaskResult {
 type TaskValidation<E, A> = Task<Validation<E, A>>;
 declare namespace TaskValidation {
     /**
-     * Wraps a value in a passed TaskValidation.
+     * Wraps a value in a passed Task.Validation.
      */
     const passed: <E, A>(value: A) => TaskValidation<E, A>;
     /**
-     * Creates a failed TaskValidation with a single error.
+     * Creates a failed Task.Validation with a single error.
      */
     const failed: <E, A>(error: E) => TaskValidation<E, A>;
     /**
-     * Creates a failed TaskValidation from multiple errors.
+     * Creates a failed Task.Validation from multiple errors.
      */
     const failedAll: <E, A>(errors: NonEmptyArr<E>) => TaskValidation<E, A>;
     /**
-     * Lifts a Validation into a TaskValidation.
+     * Lifts a Validation into a Task.Validation.
      */
     const fromValidation: <E, A>(validation: Validation<E, A>) => TaskValidation<E, A>;
     /**
-     * Creates a TaskValidation from a nullable value.
+     * Creates a Task.Validation from a nullable value.
      * If the value is null or undefined, returns Failed with the error from onNull.
      * Otherwise, returns Passed.
      */
     const fromNullable: <E>(onNull: () => E) => <A>(value: A | null | undefined) => TaskValidation<E, A>;
     /**
-     * Creates a TaskValidation from a Maybe.
+     * Creates a Task.Validation from a Maybe.
      * Some becomes Passed, None becomes Failed with the error from onNone.
      */
     const fromMaybe: <E>(onNone: () => E) => <A>(maybe: Maybe<A>) => TaskValidation<E, A>;
     /**
-     * Creates a TaskValidation from a Result.
+     * Creates a Task.Validation from a Result.
      * Ok becomes Passed, Err(e) becomes Failed([e]).
      */
     const fromResult: <E, A>(result: Result<E, A>) => TaskValidation<E, A>;
     /**
-     * Creates a TaskValidation from a Promise-returning function.
+     * Creates a Task.Validation from a Promise-returning function.
      * Catches any errors and transforms them using the onError function.
      * The factory optionally receives an `AbortSignal` forwarded from the call site.
      *
      * @example
      * ```ts
-     * const fetchUser = (id: string): TaskValidation<string, User> =>
-     *   TaskValidation.tryCatch(
+     * const fetchUser = (id: string): Task.Validation<string, User> =>
+     *   Task.Validation.tryCatch(
      *     (signal) => fetch(`/users/${id}`, { signal }).then(r => r.json()),
      *     e => `Failed to fetch user: ${e}`
      *   );
@@ -1118,36 +1118,36 @@ declare namespace TaskValidation {
      */
     const tryCatch: <E, A>(f: (signal?: AbortSignal) => Thenable<A>, onError: (e: unknown) => E) => TaskValidation<E, A>;
     /**
-     * Transforms the success value inside a TaskValidation.
+     * Transforms the success value inside a Task.Validation.
      */
     const map: <E, A, B>(f: (a: A) => B) => (data: TaskValidation<E, A>) => TaskValidation<E, B>;
     /**
-     * Applies a function wrapped in a TaskValidation to a value wrapped in a
-     * TaskValidation. Both Tasks run in parallel and errors from both sides
+     * 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(
-     *   TaskValidation.passed((name: string) => (age: number) => ({ name, age })),
-     *   TaskValidation.ap(validateName(name)),
-     *   TaskValidation.ap(validateAge(age))
+     *   Task.Validation.passed((name: string) => (age: number) => ({ name, age })),
+     *   Task.Validation.ap(validateName(name)),
+     *   Task.Validation.ap(validateAge(age))
      * )();
      * ```
      */
     const ap: <E, A>(arg: TaskValidation<E, A>) => <B>(data: TaskValidation<E, (a: A) => B>) => TaskValidation<E, B>;
     /**
-     * Extracts a value from a TaskValidation by providing handlers for both cases.
+     * Extracts a value from a Task.Validation by providing handlers for both cases.
      */
     const fold: <E, A, B>(onFailed: (errors: NonEmptyArr<E>) => B, onPassed: (a: A) => B) => (data: TaskValidation<E, A>) => Task<B>;
     /**
-     * Pattern matches on a TaskValidation, returning a Task of the result.
+     * Pattern matches on a Task.Validation, returning a Task of the result.
      *
      * @example
      * ```ts
      * pipe(
      *   validateForm(input),
-     *   TaskValidation.match({
+     *   Task.Validation.match({
      *     passed: data => save(data),
      *     failed: errors => showErrors(errors)
      *   })
@@ -1159,29 +1159,29 @@ declare namespace TaskValidation {
         failed: (errors: NonEmptyArr<E>) => B;
     }) => (data: TaskValidation<E, A>) => Task<B>;
     /**
-     * Returns the success value or a default value if the TaskValidation is failed.
+     * Returns the success value or a default value if the Task.Validation is failed.
      * The default can be a different type, widening the result to `Task<A | B>`.
      */
     const getOrElse: <E, A, B>(defaultValue: () => B) => (data: TaskValidation<E, A>) => Task<A | B>;
     /**
-     * Executes a side effect on the success value without changing the TaskValidation.
+     * Executes a side effect on the success value without changing the Task.Validation.
      * Useful for logging or debugging.
      */
     const tap: <E, A>(f: (a: A) => void) => (data: TaskValidation<E, A>) => TaskValidation<E, A>;
     /**
-     * Recovers from a Failed state by providing a fallback TaskValidation.
+     * 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 `TaskValidation<E, A | B>`.
+     * The fallback can produce a different success type, widening the result to `Task.Validation<E, A | B>`.
      */
     const recover: <E, A, B>(fallback: (errors: NonEmptyArr<E>) => TaskValidation<E, B>) => (data: TaskValidation<E, A>) => TaskValidation<E, A | B>;
     /**
-     * Runs two TaskValidations concurrently and combines their results into a tuple.
+     * 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 TaskValidation.product(
+     * await Task.Validation.product(
      *   validateName(form.name),
      *   validateAge(form.age),
      * )(); // Passed(["Alice", 30]) or Failed([...errors])
@@ -1189,13 +1189,13 @@ declare namespace TaskValidation {
      */
     const product: <E, A, B>(first: TaskValidation<E, A>, second: TaskValidation<E, B>) => TaskValidation<E, readonly [A, B]>;
     /**
-     * Runs all TaskValidations concurrently and collects results.
+     * 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 TaskValidation.productAll([
+     * await Task.Validation.productAll([
      *   validateName(form.name),
      *   validateEmail(form.email),
      *   validateAge(form.age),
@@ -1204,39 +1204,39 @@ declare namespace TaskValidation {
      */
     const productAll: <E, A>(data: NonEmptyArr<TaskValidation<E, A>>) => TaskValidation<E, readonly A[]>;
     /**
-     * Transforms all accumulated errors inside a TaskValidation.
+     * Transforms all accumulated errors inside a Task.Validation.
      *
      * @example
      * ```ts
      * pipe(
-     *   TaskValidation.failed("oops"),
-     *   TaskValidation.mapError(e => e.toUpperCase())
-     * ); // TaskValidation(Failed(["OOPS"]))
+     *   Task.Validation.failed("oops"),
+     *   Task.Validation.mapError(e => e.toUpperCase())
+     * ); // Task.Validation(Failed(["OOPS"]))
      * ```
      */
     const mapError: <E, F, A>(f: (e: E) => F) => (data: TaskValidation<E, A>) => TaskValidation<F, A>;
     /**
-     * Executes a side effect on the accumulated errors without changing the TaskValidation.
+     * Executes a side effect on the accumulated errors without changing the Task.Validation.
      *
      * @example
      * ```ts
      * pipe(
-     *   TaskValidation.failed("invalid name"),
-     *   TaskValidation.tapError(errs => logger.error(errs))
+     *   Task.Validation.failed("invalid name"),
+     *   Task.Validation.tapError(errs => logger.error(errs))
      * );
      * ```
      */
     const tapError: <E, A>(f: (errors: NonEmptyArr<E>) => void) => (data: TaskValidation<E, A>) => TaskValidation<E, A>;
     /**
-     * Combines a record of TaskValidations into a single TaskValidation of a record.
+     * 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
-     * TaskValidation.struct({
-     *   name: TaskValidation.passed("Alice"),
-     *   age: TaskValidation.passed(30)
-     * }); // TaskValidation({ name: "Alice", age: 30 })
+     * Task.Validation.struct({
+     *   name: Task.Validation.passed("Alice"),
+     *   age: Task.Validation.passed(30)
+     * }); // Task.Validation({ name: "Alice", age: 30 })
      * ```
      */
     const struct: <E, R extends Record<string, any>>(fields: { [K in keyof R]: TaskValidation<E, R[K]>; }) => TaskValidation<E, R>;
@@ -1248,7 +1248,7 @@ declare namespace TaskValidation {
  * Two guarantees:
  * - **Lazy** — nothing starts until you call it.
  * - **Infallible** — it never rejects. If failure is possible, encode it in the
- *   return type using `TaskResult<E, A>` instead.
+ *   return type using `Task.Result<E, A>` instead.
  *
  * An optional `AbortSignal` can be passed at the call site. Combinators like
  * `retry`, `pollUntil`, and `timeout` thread it automatically to every inner
@@ -1485,7 +1485,7 @@ declare namespace Task {
      * pipe(
      *   heavyComputation,
      *   Task.timeout(Duration.seconds(5), () => "timed out"),
-     *   TaskResult.chain(processResult)
+     *   Task.Result.chain(processResult)
      * );
      * ```
      */
@@ -1883,4 +1883,4 @@ declare namespace Validation {
     const struct: <E, R extends Record<string, any>>(fields: { [K in keyof R]: Validation<E, R[K]>; }) => Validation<E, R>;
 }
 
-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 };
+export { Equality as E, type Failed as F, Maybe as M, type None as N, type Ok as O, type Passed as P, Result as R, type Some as S, Task as T, Validation as V, type Err as a, Ordering as b, TaskMaybe as c, TaskResult as d, TaskValidation as e };