@nlozgachev/pipelined 0.32.0 → 0.34.0

package/dist/core.d.mts

@@ -1,6 +1,6 @@
-import { M as Maybe, W as WithValue, c as WithLog, D as Deferred, R as Result, d as WithKind, e as WithError, f as RetryOptions, g as TimeoutOptions, h as WithTimeout, i as WithMinInterval, j as WithCooldown, k as WithConcurrency, l as WithSize, m as WithMs, n as WithN, T as Task, o as WithErrors, p as WithFirst, q as WithSecond } from './Task-CJZfcOkO.mjs';
-export { E as Equality, a as Error, N as None, O as Ok, b as Ordering, S as Some } from './Task-CJZfcOkO.mjs';
-import { N as NonEmptyList } from './NonEmptyList-BlGFjor5.mjs';
+import { M as Maybe, W as WithValue, c as WithLog, D as Deferred, R as Result, d as WithKind, e as WithError, f as RetryOptions, g as TimeoutOptions, h as WithTimeout, i as WithMinInterval, j as WithCooldown, k as WithConcurrency, l as WithSize, m as WithDuration, n as WithN, T as Task, o as WithErrors, p as WithFirst, q as WithSecond } from './Task-DXsuurnc.mjs';
+export { E as Equality, a as Err, N as None, O as Ok, b as Ordering, S as Some } from './Task-DXsuurnc.mjs';
+import { Duration, NonEmptyList } from './types.mjs';
 
 /**
  * A type that can combine two values of type `A` into one, with a neutral starting value.
@@ -588,12 +588,12 @@ type AllInterpretOptions<I, E> = ({
     strategy: "debounced";
     retry?: RetryOptions<E>;
     leading?: true;
-    maxWait?: number;
-} & WithMs & WithTimeout<E>) | ({
+    maxWait?: Duration;
+} & WithDuration & WithTimeout<E>) | ({
     strategy: "throttled";
     retry?: RetryOptions<E>;
     trailing?: true;
-} & WithMs & WithTimeout<E>) | ({
+} & WithDuration & WithTimeout<E>) | ({
     strategy: "concurrent";
     retry?: RetryOptions<E>;
     overflow?: "queue" | "drop";
@@ -671,7 +671,7 @@ type InterpretResult<I, E, A, O> = [O] extends [{
  * manager.subscribe(state => {
  *   if (Op.isPending(state)) showSpinner();
  *   if (Op.isOk(state))      render(state.value);
- *   if (Op.isError(state))   showError(state.error);
+ *   if (Op.isErr(state))   showError(state.error);
  *   if (Op.isNil(state))     resetUI();
  * });
  * manager.run(userId);
@@ -696,11 +696,11 @@ declare namespace Op {
      *   over a call that was already running; `"evicted"` — a newer `run()` took over
      *   a call that was waiting and had not yet started.
      */
-    type Outcome<E, A> = Ok<A> | Error<E> | Nil;
+    type Outcome<E, A> = Ok<A> | Err<E> | Nil;
     /** A successful outcome with a value. */
     type Ok<A> = WithKind<"OpOk"> & WithValue<A>;
     /** A failed outcome with a typed error. */
-    type Error<E> = WithKind<"OpError"> & WithError<E>;
+    type Err<E> = WithKind<"OpErr"> & WithError<E>;
     /**
      * An outcome that produced nothing. `reason` identifies why:
      * - `"aborted"` — `abort()` was called explicitly.
@@ -759,7 +759,7 @@ declare namespace Op {
      * manager.subscribe(state => {
      *   if (Op.isPending(state)) lockForm();
      *   if (Op.isOk(state))     toast("Saved");
-     *   if (Op.isError(state))  toast(`Error: ${state.error.message}`);
+     *   if (Op.isErr(state))  toast(`Error: ${state.error.message}`);
      * });
      *
      * // Fire and subscribe (subscriber pattern)
@@ -797,7 +797,7 @@ declare namespace Op {
          * Returns a stop handle — call it to cancel future runs.
          */
         poll: (input: I, options: {
-            interval: number;
+            interval: Duration;
         }) => () => void;
     };
     /**
@@ -848,65 +848,65 @@ declare namespace Op {
          * Returns a stop handle — call it to cancel future runs.
          */
         poll: (input: I, options: {
-            interval: number;
+            interval: Duration;
         }) => () => void;
     };
     /** States reachable by a `once` manager (no retry). */
-    type OnceState<E, A> = Idle | Pending | Ok<A> | Error<E> | AbortedNil | DroppedNil;
+    type OnceState<E, A> = Idle | Pending | Ok<A> | Err<E> | AbortedNil | DroppedNil;
     /** States reachable by a `once` manager with retry configured. */
-    type RetryableOnceState<E, A> = Idle | Pending | Retrying<E> | Ok<A> | Error<E> | AbortedNil | DroppedNil;
+    type RetryableOnceState<E, A> = Idle | Pending | Retrying<E> | Ok<A> | Err<E> | AbortedNil | DroppedNil;
     /** States reachable by a `restartable` manager (no retry). */
-    type RestartableState<E, A> = Idle | Pending | Ok<A> | Error<E> | AbortedNil | ReplacedNil;
+    type RestartableState<E, A> = Idle | Pending | Ok<A> | Err<E> | AbortedNil | ReplacedNil;
     /** States reachable by a `restartable` manager with retry configured. */
-    type RetryableRestartableState<E, A> = Idle | Pending | Retrying<E> | Ok<A> | Error<E> | AbortedNil | ReplacedNil;
+    type RetryableRestartableState<E, A> = Idle | Pending | Retrying<E> | Ok<A> | Err<E> | AbortedNil | ReplacedNil;
     /** States reachable by an `exclusive` manager (no retry). */
-    type ExclusiveState<E, A> = Idle | Pending | Ok<A> | Error<E> | AbortedNil | DroppedNil;
+    type ExclusiveState<E, A> = Idle | Pending | Ok<A> | Err<E> | AbortedNil | DroppedNil;
     /** States reachable by an `exclusive` manager with retry configured. */
-    type RetryableExclusiveState<E, A> = Idle | Pending | Retrying<E> | Ok<A> | Error<E> | AbortedNil | DroppedNil;
+    type RetryableExclusiveState<E, A> = Idle | Pending | Retrying<E> | Ok<A> | Err<E> | AbortedNil | DroppedNil;
     /** States reachable by a `queue` manager (no retry, no overflow, no dedupe). */
-    type QueueState<E, A> = Idle | Pending | Queued | Ok<A> | Error<E> | AbortedNil;
+    type QueueState<E, A> = Idle | Pending | Queued | Ok<A> | Err<E> | AbortedNil;
     /** States reachable by a `queue` manager with retry (no overflow, no dedupe). */
-    type RetryableQueueState<E, A> = Idle | Pending | Queued | Retrying<E> | Ok<A> | Error<E> | AbortedNil;
+    type RetryableQueueState<E, A> = Idle | Pending | Queued | Retrying<E> | Ok<A> | Err<E> | AbortedNil;
     /** States reachable by a `queue` manager with `overflow:"drop"` or `dedupe` (no retry). */
-    type QueueDropState<E, A> = Idle | Pending | Queued | Ok<A> | Error<E> | AbortedNil | DroppedNil;
+    type QueueDropState<E, A> = Idle | Pending | Queued | Ok<A> | Err<E> | AbortedNil | DroppedNil;
     /** States reachable by a `queue` manager with `overflow:"drop"` or `dedupe`, with retry. */
-    type RetryableQueueDropState<E, A> = Idle | Pending | Queued | Retrying<E> | Ok<A> | Error<E> | AbortedNil | DroppedNil;
+    type RetryableQueueDropState<E, A> = Idle | Pending | Queued | Retrying<E> | Ok<A> | Err<E> | AbortedNil | DroppedNil;
     /** States reachable by a `queue` manager with `overflow:"replace-last"` and no `dedupe` (no retry). */
-    type QueueReplaceState<E, A> = Idle | Pending | Queued | Ok<A> | Error<E> | AbortedNil | EvictedNil;
+    type QueueReplaceState<E, A> = Idle | Pending | Queued | Ok<A> | Err<E> | AbortedNil | EvictedNil;
     /** States reachable by a `queue` manager with `overflow:"replace-last"` and no `dedupe`, with retry. */
-    type RetryableQueueReplaceState<E, A> = Idle | Pending | Queued | Retrying<E> | Ok<A> | Error<E> | AbortedNil | EvictedNil;
+    type RetryableQueueReplaceState<E, A> = Idle | Pending | Queued | Retrying<E> | Ok<A> | Err<E> | AbortedNil | EvictedNil;
     /** States reachable by a `queue` manager with `overflow:"replace-last"` AND `dedupe` (no retry). */
-    type QueueDropAndReplaceState<E, A> = Idle | Pending | Queued | Ok<A> | Error<E> | AbortedNil | DroppedNil | EvictedNil;
+    type QueueDropAndReplaceState<E, A> = Idle | Pending | Queued | Ok<A> | Err<E> | AbortedNil | DroppedNil | EvictedNil;
     /** States reachable by a `queue` manager with `overflow:"replace-last"` AND `dedupe`, with retry. */
-    type RetryableQueueDropAndReplaceState<E, A> = Idle | Pending | Queued | Retrying<E> | Ok<A> | Error<E> | AbortedNil | DroppedNil | EvictedNil;
+    type RetryableQueueDropAndReplaceState<E, A> = Idle | Pending | Queued | Retrying<E> | Ok<A> | Err<E> | AbortedNil | DroppedNil | EvictedNil;
     /** States reachable by a `buffered` manager (no retry). */
-    type BufferedState<E, A> = Idle | Pending | Queued | Ok<A> | Error<E> | AbortedNil | EvictedNil;
+    type BufferedState<E, A> = Idle | Pending | Queued | Ok<A> | Err<E> | AbortedNil | EvictedNil;
     /** States reachable by a `buffered` manager with retry configured. */
-    type RetryableBufferedState<E, A> = Idle | Pending | Queued | Retrying<E> | Ok<A> | Error<E> | AbortedNil | EvictedNil;
+    type RetryableBufferedState<E, A> = Idle | Pending | Queued | Retrying<E> | Ok<A> | Err<E> | AbortedNil | EvictedNil;
     /** States reachable by a `debounced` manager (no retry). */
-    type DebouncedState<E, A> = Idle | Pending | Ok<A> | Error<E> | AbortedNil | EvictedNil;
+    type DebouncedState<E, A> = Idle | Pending | Ok<A> | Err<E> | AbortedNil | EvictedNil;
     /** States reachable by a `debounced` manager with retry configured. */
-    type RetryableDebouncedState<E, A> = Idle | Pending | Retrying<E> | Ok<A> | Error<E> | AbortedNil | EvictedNil;
+    type RetryableDebouncedState<E, A> = Idle | Pending | Retrying<E> | Ok<A> | Err<E> | AbortedNil | EvictedNil;
     /** States reachable by a `throttled` manager (leading-only, no retry). */
-    type ThrottledState<E, A> = Idle | Pending | Ok<A> | Error<E> | AbortedNil | DroppedNil;
+    type ThrottledState<E, A> = Idle | Pending | Ok<A> | Err<E> | AbortedNil | DroppedNil;
     /** States reachable by a `throttled` manager (leading-only, with retry). */
-    type RetryableThrottledState<E, A> = Idle | Pending | Retrying<E> | Ok<A> | Error<E> | AbortedNil | DroppedNil;
+    type RetryableThrottledState<E, A> = Idle | Pending | Retrying<E> | Ok<A> | Err<E> | AbortedNil | DroppedNil;
     /** States reachable by a `throttled` manager with `trailing: true` (no retry). */
-    type ThrottledTrailingState<E, A> = Idle | Pending | Ok<A> | Error<E> | AbortedNil | EvictedNil;
+    type ThrottledTrailingState<E, A> = Idle | Pending | Ok<A> | Err<E> | AbortedNil | EvictedNil;
     /** States reachable by a `throttled` manager with `trailing: true` and retry. */
-    type RetryableThrottledTrailingState<E, A> = Idle | Pending | Retrying<E> | Ok<A> | Error<E> | AbortedNil | EvictedNil;
+    type RetryableThrottledTrailingState<E, A> = Idle | Pending | Retrying<E> | Ok<A> | Err<E> | AbortedNil | EvictedNil;
     /** States reachable by a `concurrent` manager with `overflow: "queue"` (no retry). */
-    type ConcurrentQueueState<E, A> = Idle | Pending | Queued | Ok<A> | Error<E> | AbortedNil;
+    type ConcurrentQueueState<E, A> = Idle | Pending | Queued | Ok<A> | Err<E> | AbortedNil;
     /** States reachable by a `concurrent` manager with `overflow: "queue"` and retry. */
-    type RetryableConcurrentQueueState<E, A> = Idle | Pending | Queued | Retrying<E> | Ok<A> | Error<E> | AbortedNil;
+    type RetryableConcurrentQueueState<E, A> = Idle | Pending | Queued | Retrying<E> | Ok<A> | Err<E> | AbortedNil;
     /** States reachable by a `concurrent` manager with `overflow: "drop"` (no retry). */
-    type ConcurrentDropState<E, A> = Idle | Pending | Ok<A> | Error<E> | AbortedNil | DroppedNil;
+    type ConcurrentDropState<E, A> = Idle | Pending | Ok<A> | Err<E> | AbortedNil | DroppedNil;
     /** States reachable by a `concurrent` manager with `overflow: "drop"` and retry. */
-    type RetryableConcurrentDropState<E, A> = Idle | Pending | Retrying<E> | Ok<A> | Error<E> | AbortedNil | DroppedNil;
+    type RetryableConcurrentDropState<E, A> = Idle | Pending | Retrying<E> | Ok<A> | Err<E> | AbortedNil | DroppedNil;
     /** Per-key state union for a `keyed` manager with `perKey: "exclusive"`. */
-    type KeyedExclusivePerKey<E, A> = Pending | Ok<A> | Error<E> | AbortedNil | DroppedNil;
+    type KeyedExclusivePerKey<E, A> = Pending | Ok<A> | Err<E> | AbortedNil | DroppedNil;
     /** Per-key state union for a `keyed` manager with `perKey: "restartable"`. */
-    type KeyedRestartablePerKey<E, A> = Pending | Ok<A> | Error<E> | AbortedNil | ReplacedNil;
+    type KeyedRestartablePerKey<E, A> = Pending | Ok<A> | Err<E> | AbortedNil | ReplacedNil;
     type RetryOptions<E> = RetryOptions<E>;
     type TimeoutOptions<E> = TimeoutOptions<E>;
     /**
@@ -991,10 +991,10 @@ declare namespace Op {
      *
      * @example
      * ```ts
-     * Op.error(new ApiError("not found")); // { kind: "OpError", error: ApiError }
+     * Op.err(new ApiError("not found")); // { kind: "OpErr", error: ApiError }
      * ```
      */
-    const error: <E>(error: E) => Error<E>;
+    const err: <E>(error: E) => Err<E>;
     /**
      * Returns `true` if the state is `Idle`.
      *
@@ -1051,16 +1051,16 @@ declare namespace Op {
      */
     const isOk: <E, A>(state: State<E, A>) => state is Ok<A>;
     /**
-     * Returns `true` if the state is `Error` (the operation failed with a typed error).
+     * Returns `true` if the state is `Err` (the operation failed with a typed error).
      *
      * @example
      * ```ts
      * manager.subscribe(state => {
-     *   if (Op.isError(state)) showError(state.error);
+     *   if (Op.isErr(state)) showError(state.error);
      * });
      * ```
      */
-    const isError: <E, A>(state: State<E, A>) => state is Error<E>;
+    const isErr: <E, A>(state: State<E, A>) => state is Err<E>;
     /**
      * Returns `true` if the state is `Nil` (the operation completed without a value or error).
      *
@@ -1079,19 +1079,19 @@ declare namespace Op {
      * ```ts
      * Op.match({
      *   ok:  (user) => render(user),
-     *   error: (e)    => showError(e.message),
+     *   err: (e)    => showError(e.message),
      *   nil: ()     => resetUI(),
      * })(outcome);
      * ```
      */
     const match: <E, A, B>(cases: {
         ok: (a: A) => B;
-        error: (e: E) => B;
+        err: (e: E) => B;
         nil: () => B;
     }) => (outcome: Outcome<E, A>) => B;
     /**
      * Eliminates an Outcome with positional handlers.
-     * Order: `onError`, `onOk`, `onNil` — mirrors `Result.fold` for the first two.
+     * Order: `onErr`, `onOk`, `onNil` — mirrors `Result.fold` for the first two.
      *
      * @example
      * ```ts
@@ -1102,7 +1102,7 @@ declare namespace Op {
      * )(outcome);
      * ```
      */
-    const fold: <E, A, B>(onError: (e: E) => B, onOk: (a: A) => B, onNil: () => B) => (outcome: Outcome<E, A>) => B;
+    const fold: <E, A, B>(onErr: (e: E) => B, onOk: (a: A) => B, onNil: () => B) => (outcome: Outcome<E, A>) => B;
     /**
      * Returns the success value, or the result of `defaultValue()` for `Err` or `Nil`.
      *
@@ -1137,7 +1137,7 @@ declare namespace Op {
      * ```ts
      * pipe(
      *   outcome,
-     *   Op.chain(user => user.active ? Op.ok(user) : Op.error(new Error("inactive"))),
+     *   Op.chain(user => user.active ? Op.ok(user) : Op.err(new Error("inactive"))),
      * );
      * ```
      */
@@ -1158,7 +1158,7 @@ declare namespace Op {
      * ```ts
      * pipe(
      *   outcome,
-     *   Op.recover(e => e.isRetryable ? Op.ok(cachedValue) : Op.error(e)),
+     *   Op.recover(e => e.isRetryable ? Op.ok(cachedValue) : Op.err(e)),
      * );
      * ```
      */
@@ -1369,7 +1369,7 @@ declare namespace Refinement {
      * Converts a `Refinement<A, B>` into a function `(a: A) => Maybe<B>`.
      *
      * Returns `Some(a)` when the refinement holds, `None` otherwise. Useful for
-     * integrating runtime validation into an `Maybe`-based pipeline.
+     * integrating runtime validation into a `Maybe`-based pipeline.
      *
      * @example
      * ```ts
@@ -1905,7 +1905,7 @@ declare namespace RemoteData {
      */
     const recover: <E, A, B>(fallback: (e: E) => RemoteData<E, B>) => (data: RemoteData<E, A>) => RemoteData<E, A | B>;
     /**
-     * Converts a RemoteData to an Maybe.
+     * Converts a RemoteData to a Maybe.
      * Success becomes Some, all other states become None.
      */
     const toMaybe: <E, A>(data: RemoteData<E, A>) => Maybe<A>;
@@ -1984,6 +1984,25 @@ declare namespace TaskResult {
      * Creates a failed TaskResult with the given error.
      */
     const err: <E, A>(error: E) => TaskResult<E, A>;
+    /**
+     * Creates a TaskResult from a nullable value.
+     * Returns Ok if the value is not null or undefined, err from onNull otherwise.
+     */
+    const fromNullable: <E>(onNull: () => E) => <A>(value: A | null | undefined) => TaskResult<E, A>;
+    /**
+     * Creates a TaskResult from a Maybe.
+     * Some becomes Ok, None becomes err from onNone.
+     */
+    const fromMaybe: <E>(onNone: () => E) => <A>(maybe: Maybe<A>) => TaskResult<E, A>;
+    /**
+     * Lifts a Result into a TaskResult.
+     */
+    const fromResult: <E, A>(result: Result<E, A>) => TaskResult<E, A>;
+    /**
+     * Wraps a Promise-returning function of any arguments, returning a new function
+     * that catches rejections and returns a TaskResult.
+     */
+    const fromThrowable: <Args extends readonly unknown[], A, E>(f: (...args: Args) => Promise<A>, onError: (e: unknown) => E) => (...args: Args) => TaskResult<E, A>;
     /**
      * Creates a TaskResult from a function that may throw.
      * Catches any errors and transforms them using the onError function.
@@ -2392,6 +2411,16 @@ declare namespace TaskMaybe {
      * Lifts an Option into a TaskMaybe.
      */
     const fromMaybe: <A>(option: Maybe<A>) => TaskMaybe<A>;
+    /**
+     * Creates a TaskMaybe from a nullable value.
+     * Returns Some if the value is not null or undefined, None otherwise.
+     */
+    const fromNullable: <A>(value: A | null | undefined) => TaskMaybe<A>;
+    /**
+     * Creates a TaskMaybe from a Result.
+     * Ok becomes Some, Error becomes None (the error value is discarded).
+     */
+    const fromResult: <E, A>(result: Result<E, A>) => TaskMaybe<A>;
     /**
      * Lifts a Task into a TaskMaybe by wrapping its result in Some.
      */
@@ -2481,11 +2510,11 @@ declare namespace TaskMaybe {
     const toTaskResult: <E>(onNone: () => E) => <A>(data: TaskMaybe<A>) => TaskResult<E, A>;
 }
 
-type Valid<A> = WithKind<"Valid"> & WithValue<A>;
-type Invalid<E> = WithKind<"Invalid"> & WithErrors<E>;
+type Passed<A> = WithKind<"Passed"> & WithValue<A>;
+type Failed<E> = WithKind<"Failed"> & WithErrors<E>;
 /**
- * Validation represents a value that is either valid with a success value,
- * or invalid with accumulated errors.
+ * 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).
@@ -2494,60 +2523,60 @@ type Invalid<E> = WithKind<"Invalid"> & WithErrors<E>;
  * @example
  * ```ts
  * const validateName = (name: string): Validation<string, string> =>
- *   name.length > 0 ? Validation.valid(name) : Validation.invalid("Name is required");
+ *   name.length > 0 ? Validation.passed(name) : Validation.failed("Name is required");
  *
  * const validateAge = (age: number): Validation<string, number> =>
- *   age >= 0 ? Validation.valid(age) : Validation.invalid("Age must be positive");
+ *   age >= 0 ? Validation.passed(age) : Validation.failed("Age must be positive");
  *
  * // Accumulates all errors using ap
  * pipe(
- *   Validation.valid((name: string) => (age: number) => ({ name, age })),
+ *   Validation.passed((name: string) => (age: number) => ({ name, age })),
  *   Validation.ap(validateName("")),
  *   Validation.ap(validateAge(-1))
  * );
- * // Invalid(["Name is required", "Age must be positive"])
+ * // Failed(["Name is required", "Age must be positive"])
  * ```
  */
-type Validation<E, A> = Valid<A> | Invalid<E>;
+type Validation<E, A> = Passed<A> | Failed<E>;
 declare namespace Validation {
     /**
-     * Wraps a value in a valid Validation.
+     * Wraps a value in a passed Validation.
      *
      * @example
      * ```ts
-     * Validation.valid(42); // Valid(42)
+     * Validation.passed(42); // Passed(42)
      * ```
      */
-    const valid: <E, A>(value: A) => Validation<E, A>;
+    const passed: <E, A>(value: A) => Validation<E, A>;
     /**
-     * Creates an invalid Validation from a single error.
+     * Creates a failed Validation from a single error.
      *
      * @example
      * ```ts
-     * Validation.invalid("Invalid input");
+     * Validation.failed("Invalid input");
      * ```
      */
-    const invalid: <E>(error: E) => Invalid<E>;
+    const failed: <E>(error: E) => Failed<E>;
     /**
-     * Creates an invalid Validation from multiple errors.
+     * Creates a failed Validation from multiple errors.
      *
      * @example
      * ```ts
-     * Validation.invalidAll(["Invalid input"]);
+     * Validation.failedAll(["Invalid input"]);
      * ```
      */
-    const invalidAll: <E>(errors: NonEmptyList<E>) => Invalid<E>;
+    const failedAll: <E>(errors: NonEmptyList<E>) => Failed<E>;
     /**
-     * Type guard that checks if a Validation is valid.
+     * Type guard that checks if a Validation is passed.
      */
-    const isValid: <E, A>(data: Validation<E, A>) => data is Valid<A>;
+    const isPassed: <E, A>(data: Validation<E, A>) => data is Passed<A>;
     /**
-     * Type guard that checks if a Validation is invalid.
+     * Type guard that checks if a Validation is failed.
      */
-    const isInvalid: <E, A>(data: Validation<E, A>) => data is Invalid<E>;
+    const isFailed: <E, A>(data: Validation<E, A>) => data is Failed<E>;
     /**
      * Creates a Validation from a predicate applied to a value.
-     * Returns Valid if the predicate passes, Invalid from `onFalse` otherwise.
+     * Returns Passed if the predicate passes, Failed from `onFalse` otherwise.
      *
      * @example
      * ```ts
@@ -2556,21 +2585,54 @@ declare namespace Validation {
      *   () => "Name is required"
      * );
      *
-     * validateName("Alice"); // Valid("Alice")
-     * validateName("");      // Invalid(["Name is required"])
+     * validateName("Alice"); // Passed("Alice")
+     * validateName("");      // Failed(["Name is required"])
      * ```
      */
     const fromPredicate: <E, A>(pred: (a: A) => boolean, onFalse: (a: A) => E) => (a: A) => Validation<E, A>;
+    /**
+     * Creates a Validation from a nullable value.
+     * If the value is null or undefined, returns Failed with the error from onNull.
+     * Otherwise, returns Passed.
+     *
+     * @example
+     * ```ts
+     * pipe(null, Validation.fromNullable(() => "is null")); // Failed(["is null"])
+     * pipe(42, Validation.fromNullable(() => "is null"));   // Passed(42)
+     * ```
+     */
+    const fromNullable: <E>(onNull: () => E) => <A>(value: A | null | undefined) => Validation<E, A>;
+    /**
+     * Creates a Validation from a Maybe.
+     * If the Maybe is None, returns Failed with the error from onNone.
+     * Otherwise, returns Passed.
+     *
+     * @example
+     * ```ts
+     * pipe(Maybe.none(), Validation.fromMaybe(() => "is none")); // Failed(["is none"])
+     * pipe(Maybe.some(42), Validation.fromMaybe(() => "is none")); // Passed(42)
+     * ```
+     */
+    const fromMaybe: <E>(onNone: () => E) => <A>(maybe: Maybe<A>) => Validation<E, A>;
     /**
      * Transforms the success value inside a Validation.
      *
      * @example
      * ```ts
-     * pipe(Validation.valid(5), Validation.map(n => n * 2)); // Valid(10)
-     * pipe(Validation.invalid("oops"), Validation.map(n => n * 2)); // Invalid(["oops"])
+     * pipe(Validation.passed(5), Validation.map(n => n * 2)); // Passed(10)
+     * pipe(Validation.failed("oops"), Validation.map(n => n * 2)); // Failed(["oops"])
      * ```
      */
     const map: <A, B>(f: (a: A) => B) => <E>(data: Validation<E, A>) => Validation<E, B>;
+    /**
+     * Transforms the error list inside a Validation.
+     *
+     * @example
+     * ```ts
+     * pipe(Validation.failed("oops"), Validation.mapError(e => e.toUpperCase())); // Failed(["OOPS"])
+     * ```
+     */
+    const mapError: <E, F, A>(f: (e: E) => F) => (data: Validation<E, A>) => Validation<F, A>;
     /**
      * Applies a function wrapped in a Validation to a value wrapped in a Validation.
      * Accumulates errors from both sides.
@@ -2579,16 +2641,16 @@ declare namespace Validation {
      * ```ts
      * const add = (a: number) => (b: number) => a + b;
      * pipe(
-     *   Validation.valid(add),
-     *   Validation.ap(Validation.valid(5)),
-     *   Validation.ap(Validation.valid(3))
-     * ); // Valid(8)
+     *   Validation.passed(add),
+     *   Validation.ap(Validation.passed(5)),
+     *   Validation.ap(Validation.passed(3))
+     * ); // Passed(8)
      *
      * pipe(
-     *   Validation.valid(add),
-     *   Validation.ap(Validation.invalid<string, number>("bad a")),
-     *   Validation.ap(Validation.invalid<string, number>("bad b"))
-     * ); // Invalid(["bad a", "bad b"])
+     *   Validation.passed(add),
+     *   Validation.ap(Validation.failed<string, number>("bad a")),
+     *   Validation.ap(Validation.failed<string, number>("bad b"))
+     * ); // Failed(["bad a", "bad b"])
      * ```
      */
     const ap: <E, A>(arg: Validation<E, A>) => <B>(data: Validation<E, (a: A) => B>) => Validation<E, B>;
@@ -2598,7 +2660,7 @@ declare namespace Validation {
      * @example
      * ```ts
      * pipe(
-     *   Validation.valid(42),
+     *   Validation.passed(42),
      *   Validation.fold(
      *     errors => `Errors: ${errors.join(", ")}`,
      *     value => `Value: ${value}`
@@ -2606,7 +2668,7 @@ declare namespace Validation {
      * );
      * ```
      */
-    const fold: <E, A, B>(onInvalid: (errors: NonEmptyList<E>) => B, onValid: (a: A) => B) => (data: Validation<E, A>) => B;
+    const fold: <E, A, B>(onFailed: (errors: NonEmptyList<E>) => B, onPassed: (a: A) => B) => (data: Validation<E, A>) => B;
     /**
      * Pattern matches on a Validation, returning the result of the matching case.
      *
@@ -2615,25 +2677,25 @@ declare namespace Validation {
      * pipe(
      *   validation,
      *   Validation.match({
-     *     valid: value => `Got ${value}`,
-     *     invalid: errors => `Failed: ${errors.join(", ")}`
+     *     passed: value => `Got ${value}`,
+     *     failed: errors => `Failed: ${errors.join(", ")}`
      *   })
      * );
      * ```
      */
     const match: <E, A, B>(cases: {
-        valid: (a: A) => B;
-        invalid: (errors: NonEmptyList<E>) => B;
+        passed: (a: A) => B;
+        failed: (errors: NonEmptyList<E>) => B;
     }) => (data: Validation<E, A>) => B;
     /**
-     * Returns the success value or a default value if the Validation is invalid.
+     * 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.valid(5), Validation.getOrElse(() => 0)); // 5
-     * pipe(Validation.invalid("oops"), Validation.getOrElse(() => 0)); // 0
-     * pipe(Validation.invalid("oops"), Validation.getOrElse(() => null)); // null — typed as number | null
+     * pipe(Validation.passed(5), Validation.getOrElse(() => 0)); // 5
+     * pipe(Validation.failed("oops"), Validation.getOrElse(() => 0)); // 0
+     * pipe(Validation.failed("oops"), Validation.getOrElse(() => null)); // null — typed as number | null
      * ```
      */
     const getOrElse: <E, A, B>(defaultValue: () => B) => (data: Validation<E, A>) => A | B;
@@ -2643,7 +2705,7 @@ declare namespace Validation {
      * @example
      * ```ts
      * pipe(
-     *   Validation.valid(5),
+     *   Validation.passed(5),
      *   Validation.tap(n => console.log("Value:", n)),
      *   Validation.map(n => n * 2)
      * );
@@ -2657,7 +2719,7 @@ declare namespace Validation {
      * @example
      * ```ts
      * pipe(
-     *   Validation.invalid("Name required"),
+     *   Validation.failed("Name required"),
      *   Validation.tapError(errors => console.error("validation failed:", errors)),
      *   Validation.map(toUser)
      * );
@@ -2665,82 +2727,82 @@ declare namespace Validation {
      */
     const tapError: <E, A>(f: (errors: NonEmptyList<E>) => void) => (data: Validation<E, A>) => Validation<E, A>;
     /**
-     * Recovers from an Invalid state by providing a fallback Validation.
+     * Recovers from a Failed state by providing a fallback Validation.
      * The fallback receives the accumulated error list so callers can inspect which errors occurred.
      * The fallback can produce a different success type, widening the result to `Validation<E, A | B>`.
      */
     const recover: <E, A, B>(fallback: (errors: NonEmptyList<E>) => Validation<E, B>) => (data: Validation<E, A>) => Validation<E, A | B>;
     /**
-     * Recovers from an Invalid state unless `isBlocked` returns true for any of the accumulated errors.
+     * Recovers from a Failed state unless `isBlocked` returns true for any of the accumulated errors.
      * The fallback can produce a different success type, widening the result to `Validation<E, A | B>`.
      *
      * @example
      * ```ts
      * pipe(
-     *   Validation.invalid("field-error"),
-     *   Validation.recoverUnless(e => e === "fatal", () => Validation.valid(0))
-     * ); // Valid(0)
+     *   Validation.failed("field-error"),
+     *   Validation.recoverUnless(e => e === "fatal", () => Validation.passed(0))
+     * ); // Passed(0)
      * ```
      */
     const recoverUnless: <E, A, B>(isBlocked: (e: E) => boolean, fallback: () => Validation<E, B>) => (data: Validation<E, A>) => Validation<E, A | B>;
     /**
      * Converts a Validation to a Result.
-     * Valid becomes Ok, Invalid becomes Err with the accumulated error list.
+     * Passed becomes Ok, Failed becomes Err with the accumulated error list.
      *
      * @example
      * ```ts
-     * Validation.toResult(Validation.valid(42));        // Ok(42)
-     * Validation.toResult(Validation.invalid("oops"));  // Err(["oops"])
+     * Validation.toResult(Validation.passed(42));        // Ok(42)
+     * Validation.toResult(Validation.failed("oops"));  // Err(["oops"])
      * ```
      */
     const toResult: <E, A>(data: Validation<E, A>) => Result<NonEmptyList<E>, A>;
     /**
-     * Converts a Validation to a Maybe. `Valid` becomes `Some`; `Invalid` becomes `None`
+     * Converts a Validation to a Maybe. `Passed` becomes `Some`; `Failed` becomes `None`
      * (errors are discarded).
      *
      * @example
      * ```ts
-     * Validation.toMaybe(Validation.valid(42));       // Some(42)
-     * Validation.toMaybe(Validation.invalid("bad"));  // None
+     * Validation.toMaybe(Validation.passed(42));       // Some(42)
+     * Validation.toMaybe(Validation.failed("bad"));  // None
      * ```
      */
     const toMaybe: <E, A>(data: Validation<E, A>) => Maybe<A>;
     /**
-     * Converts a `Result` to a `Validation`. `Ok` becomes `Valid`; `Err(e)` becomes `Invalid([e])`.
+     * Converts a `Result` to a `Validation`. `Ok` becomes `Passed`; `Err(e)` becomes `Failed([e])`.
      *
      * Useful when bridging from error-short-circuiting `Result` pipelines into
      * error-accumulating `Validation` pipelines.
      *
      * @example
      * ```ts
-     * Validation.fromResult(Result.ok(42));       // Valid(42)
-     * Validation.fromResult(Result.error("bad"));   // Invalid(["bad"])
+     * Validation.fromResult(Result.ok(42));       // Passed(42)
+     * Validation.fromResult(Result.err("bad"));   // Failed(["bad"])
      * ```
      */
     const fromResult: <E, A>(data: Result<E, A>) => Validation<E, A>;
     /**
      * Combines two independent Validation instances into a tuple.
-     * If both are Valid, returns Valid with both values as a tuple.
-     * If either is Invalid, accumulates errors from both sides.
+     * If both are Passed, returns Passed with both values as a tuple.
+     * If either is Failed, accumulates errors from both sides.
      *
      * @example
      * ```ts
      * Validation.product(
-     *   Validation.valid("alice"),
-     *   Validation.valid(30)
-     * ); // Valid(["alice", 30])
+     *   Validation.passed("alice"),
+     *   Validation.passed(30)
+     * ); // Passed(["alice", 30])
      *
      * Validation.product(
-     *   Validation.invalid("Name required"),
-     *   Validation.invalid("Age must be >= 0")
-     * ); // Invalid(["Name required", "Age must be >= 0"])
+     *   Validation.failed("Name required"),
+     *   Validation.failed("Age must be >= 0")
+     * ); // Failed(["Name required", "Age must be >= 0"])
      * ```
      */
     const product: <E, A, B>(first: Validation<E, A>, second: Validation<E, B>) => Validation<E, readonly [A, B]>;
     /**
      * Combines a non-empty list of Validation instances, accumulating all errors.
-     * If all are Valid, returns Valid with all values collected into an array.
-     * If any are Invalid, returns Invalid with all accumulated 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
@@ -2749,7 +2811,7 @@ declare namespace Validation {
      *   validateEmail(email),
      *   validateAge(age)
      * ]);
-     * // Valid([name, email, age]) or Invalid([...all errors])
+     * // Passed([name, email, age]) or Failed([...all errors])
      * ```
      */
     const productAll: <E, A>(data: NonEmptyList<Validation<E, A>>) => Validation<E, readonly A[]>;
@@ -2764,36 +2826,52 @@ declare namespace Validation {
  * ```ts
  * const validateName = (name: string): TaskValidation<string, string> =>
  *   name.length > 0
- *     ? TaskValidation.valid(name)
- *     : TaskValidation.invalid("Name is required");
+ *     ? TaskValidation.passed(name)
+ *     : TaskValidation.failed("Name is required");
  *
  * // Accumulate errors from multiple async validations using ap
  * pipe(
- *   TaskValidation.valid((name: string) => (age: number) => ({ name, age })),
+ *   TaskValidation.passed((name: string) => (age: number) => ({ name, age })),
  *   TaskValidation.ap(validateName("")),
  *   TaskValidation.ap(validateAge(-1))
  * )();
- * // Invalid(["Name is required", "Age must be positive"])
+ * // Failed(["Name is required", "Age must be positive"])
  * ```
  */
 type TaskValidation<E, A> = Task<Validation<E, A>>;
 declare namespace TaskValidation {
     /**
-     * Wraps a value in a valid TaskValidation.
+     * Wraps a value in a passed TaskValidation.
      */
-    const valid: <E, A>(value: A) => TaskValidation<E, A>;
+    const passed: <E, A>(value: A) => TaskValidation<E, A>;
     /**
      * Creates a failed TaskValidation with a single error.
      */
-    const invalid: <E, A>(error: E) => TaskValidation<E, A>;
+    const failed: <E, A>(error: E) => TaskValidation<E, A>;
     /**
-     * Creates an invalid TaskValidation from multiple errors.
+     * Creates a failed TaskValidation from multiple errors.
      */
-    const invalidAll: <E, A>(errors: NonEmptyList<E>) => TaskValidation<E, A>;
+    const failedAll: <E, A>(errors: NonEmptyList<E>) => TaskValidation<E, A>;
     /**
      * Lifts a Validation into a TaskValidation.
      */
     const fromValidation: <E, A>(validation: Validation<E, A>) => TaskValidation<E, A>;
+    /**
+     * Creates a TaskValidation from a nullable value.
+     * If the value is null or undefined, returns Failed with the error from onNull.
+     * Otherwise, returns Passed.
+     */
+    const fromNullable: <E>(onNull: () => E) => <A>(value: A | null | undefined) => TaskValidation<E, A>;
+    /**
+     * Creates a TaskValidation from a Maybe.
+     * Some becomes Passed, None becomes Failed with the error from onNone.
+     */
+    const fromMaybe: <E>(onNone: () => E) => <A>(maybe: Maybe<A>) => TaskValidation<E, A>;
+    /**
+     * Creates a TaskValidation from a Result.
+     * Ok becomes Passed, Err(e) becomes Failed([e]).
+     */
+    const fromResult: <E, A>(result: Result<E, A>) => TaskValidation<E, A>;
     /**
      * Creates a TaskValidation from a Promise-returning function.
      * Catches any errors and transforms them using the onError function.
@@ -2821,7 +2899,7 @@ declare namespace TaskValidation {
      * @example
      * ```ts
      * pipe(
-     *   TaskValidation.valid((name: string) => (age: number) => ({ name, age })),
+     *   TaskValidation.passed((name: string) => (age: number) => ({ name, age })),
      *   TaskValidation.ap(validateName(name)),
      *   TaskValidation.ap(validateAge(age))
      * )();
@@ -2831,7 +2909,7 @@ declare namespace TaskValidation {
     /**
      * Extracts a value from a TaskValidation by providing handlers for both cases.
      */
-    const fold: <E, A, B>(onInvalid: (errors: NonEmptyList<E>) => B, onValid: (a: A) => B) => (data: TaskValidation<E, A>) => Task<B>;
+    const fold: <E, A, B>(onFailed: (errors: NonEmptyList<E>) => B, onPassed: (a: A) => B) => (data: TaskValidation<E, A>) => Task<B>;
     /**
      * Pattern matches on a TaskValidation, returning a Task of the result.
      *
@@ -2840,18 +2918,18 @@ declare namespace TaskValidation {
      * pipe(
      *   validateForm(input),
      *   TaskValidation.match({
-     *     valid: data => save(data),
-     *     invalid: errors => showErrors(errors)
+     *     passed: data => save(data),
+     *     failed: errors => showErrors(errors)
      *   })
      * )();
      * ```
      */
     const match: <E, A, B>(cases: {
-        valid: (a: A) => B;
-        invalid: (errors: NonEmptyList<E>) => B;
+        passed: (a: A) => B;
+        failed: (errors: NonEmptyList<E>) => B;
     }) => (data: TaskValidation<E, A>) => Task<B>;
     /**
-     * Returns the success value or a default value if the TaskValidation is invalid.
+     * Returns the success value or a default value if the TaskValidation is failed.
      * The default can be a different type, widening the result to `Task<A | B>`.
      */
     const getOrElse: <E, A, B>(defaultValue: () => B) => (data: TaskValidation<E, A>) => Task<A | B>;
@@ -2861,14 +2939,14 @@ declare namespace TaskValidation {
      */
     const tap: <E, A>(f: (a: A) => void) => (data: TaskValidation<E, A>) => TaskValidation<E, A>;
     /**
-     * Recovers from an Invalid state by providing a fallback TaskValidation.
+     * Recovers from a Failed state by providing a fallback TaskValidation.
      * The fallback receives the accumulated error list so callers can inspect which errors occurred.
      * The fallback can produce a different success type, widening the result to `TaskValidation<E, A | B>`.
      */
     const recover: <E, A, B>(fallback: (errors: NonEmptyList<E>) => TaskValidation<E, B>) => (data: TaskValidation<E, A>) => TaskValidation<E, A | B>;
     /**
      * Runs two TaskValidations concurrently and combines their results into a tuple.
-     * If both are Valid, returns Valid with both values. If either fails, accumulates
+     * If both are Passed, returns Passed with both values. If either fails, accumulates
      * errors from both sides.
      *
      * @example
@@ -2876,14 +2954,14 @@ declare namespace TaskValidation {
      * await TaskValidation.product(
      *   validateName(form.name),
      *   validateAge(form.age),
-     * )(); // Valid(["Alice", 30]) or Invalid([...errors])
+     * )(); // Passed(["Alice", 30]) or Failed([...errors])
      * ```
      */
     const product: <E, A, B>(first: TaskValidation<E, A>, second: TaskValidation<E, B>) => TaskValidation<E, readonly [A, B]>;
     /**
      * Runs all TaskValidations concurrently and collects results.
-     * If all are Valid, returns Valid with all values as an array.
-     * If any fail, returns Invalid with all accumulated errors.
+     * If all are Passed, returns Passed with all values as an array.
+     * If any fail, returns Failed with all accumulated errors.
      *
      * @example
      * ```ts
@@ -2891,7 +2969,7 @@ declare namespace TaskValidation {
      *   validateName(form.name),
      *   validateEmail(form.email),
      *   validateAge(form.age),
-     * ])(); // Valid([name, email, age]) or Invalid([...all errors])
+     * ])(); // Passed([name, email, age]) or Failed([...all errors])
      * ```
      */
     const productAll: <E, A>(data: NonEmptyList<TaskValidation<E, A>>) => TaskValidation<E, readonly A[]>;
@@ -2951,7 +3029,7 @@ declare namespace These {
      * These.both(42, "Deprecated API used"); // { kind: "Both", first: 42, second: "Deprecated API used" }
      * ```
      */
-    const both: <A, B>(first: A, second: B) => TheseBoth<A, B>;
+    const both: <A, B>(f: A, s: B) => TheseBoth<A, B>;
     /**
      * Type guard — checks if a These holds only a first value.
      */
@@ -3250,4 +3328,4 @@ declare namespace Tuple {
     const tap: <A, B>(f: (a: A, b: B) => void) => (tuple: Tuple<A, B>) => Tuple<A, B>;
 }
 
-export { Combinable, Deferred, type Failure, type Invalid, Lazy, Lens, type Loading, Logged, Maybe, type NotAsked, Op, Optional, Predicate, Reader, Refinement, RemoteData, Resource, Result, State, type Success, Task, TaskMaybe, TaskResult, TaskValidation, These, type TheseBoth, type TheseFirst, type TheseSecond, Tuple, type Valid, Validation };
+export { Combinable, Deferred, type Failed, type Failure, Lazy, Lens, type Loading, Logged, Maybe, type NotAsked, Op, Optional, type Passed, Predicate, Reader, Refinement, RemoteData, Resource, Result, State, type Success, Task, TaskMaybe, TaskResult, TaskValidation, These, type TheseBoth, type TheseFirst, type TheseSecond, Tuple, Validation };