@nlozgachev/pipelined 0.37.0 → 0.37.1

package/dist/core.d.ts

@@ -1,5 +1,5 @@
-import { M as Maybe, q as WithValue, k as WithLog, D as Deferred, R as Result, j as WithKind, g as WithError, c as RetryOptions, d as TimeoutOptions, p as WithTimeout, l as WithMinInterval, e as WithCooldown, W as WithConcurrency, o as WithSize, f as WithDuration, m as WithN, T as Task, h as WithErrors, i as WithFirst, n as WithSecond } from './Task-DIgwvoIb.js';
-export { E as Equality, a as Err, N as None, O as Ok, b as Ordering, S as Some } from './Task-DIgwvoIb.js';
+import { M as Maybe, q as WithValue, k as WithLog, D as Deferred, R as Result, j as WithKind, g as WithError, c as RetryOptions, d as TimeoutOptions, p as WithTimeout, l as WithMinInterval, e as WithCooldown, W as WithConcurrency, o as WithSize, f as WithDuration, m as WithN, T as Task, i as WithFirst, n as WithSecond, h as WithErrors } from './Task-uupX7xd9.js';
+export { E as Equality, a as Err, N as None, O as Ok, b as Ordering, S as Some } from './Task-uupX7xd9.js';
 import { Duration, NonEmptyList } from './types.js';
 
 /**
@@ -166,161 +166,6 @@ declare namespace Lazy {
     const tap: <A>(f: (a: A) => void) => (lazy: Lazy<A>) => Lazy<A>;
 }
 
-/** Keys of T for which undefined is assignable (i.e. optional fields). */
-type OptionalKeys<T> = {
-    [K in keyof T]-?: undefined extends T[K] ? K : never;
-}[keyof T];
-/**
- * Optional<S, A> focuses on a value A inside a structure S that may or may
- * not be present. Like a Lens, but get returns Maybe<A>.
- *
- * Compose with other Optionals via `andThen`, or with a Lens via `andThenLens`.
- * Convert a Lens to an Optional with `Lens.toOptional`.
- *
- * @example
- * ```ts
- * type Profile = { username: string; bio?: string };
- *
- * const bioOpt = Optional.prop<Profile>()("bio");
- *
- * pipe(profile, Optional.get(bioOpt));               // Some("hello") or None
- * pipe(profile, Optional.set(bioOpt)("hello"));      // new Profile with bio set
- * pipe(profile, Optional.modify(bioOpt)(s => s + "!")); // appends if present
- * ```
- */
-type Optional<S, A> = {
-    readonly get: (s: S) => Maybe<A>;
-    readonly set: (a: A) => (s: S) => S;
-};
-declare namespace Optional {
-    /**
-     * Constructs an Optional from a getter (returning Maybe<A>) and a setter.
-     *
-     * @example
-     * ```ts
-     * const firstChar = Optional.make(
-     *   (s: string) => s.length > 0 ? Maybe.some(s[0]) : Maybe.none(),
-     *   (c) => (s) => s.length > 0 ? c + s.slice(1) : s,
-     * );
-     * ```
-     */
-    const make: <S, A>(get: (s: S) => Maybe<A>, set: (a: A) => (s: S) => S) => Optional<S, A>;
-    /**
-     * Creates an Optional that focuses on an optional property of an object.
-     * Only keys whose type includes undefined (i.e. `field?: T`) are accepted.
-     * Call with the structure type first, then the key.
-     *
-     * @example
-     * ```ts
-     * type Profile = { username: string; bio?: string };
-     * const bioOpt = Optional.prop<Profile>()("bio");
-     * ```
-     */
-    const prop: <S>() => <K extends OptionalKeys<S>>(key: K) => Optional<S, NonNullable<S[K]>>;
-    /**
-     * Creates an Optional that focuses on an element at a given index in an array.
-     * Returns None when the index is out of bounds; set is a no-op when out of bounds.
-     *
-     * @example
-     * ```ts
-     * const firstItem = Optional.index<string>(0);
-     *
-     * pipe(["a", "b"], Optional.get(firstItem)); // Some("a")
-     * pipe([], Optional.get(firstItem));         // None
-     * ```
-     */
-    const index: <A>(i: number) => Optional<A[], A>;
-    /**
-     * Reads the focused value from a structure, returning Maybe<A>.
-     *
-     * @example
-     * ```ts
-     * pipe(profile, Optional.get(bioOpt)); // Some("...") or None
-     * ```
-     */
-    const get: <S, A>(opt: Optional<S, A>) => (s: S) => Maybe<A>;
-    /**
-     * Replaces the focused value within a structure.
-     * For indexed focuses, this is a no-op when the index is out of bounds.
-     *
-     * @example
-     * ```ts
-     * pipe(profile, Optional.set(bioOpt)("hello"));
-     * ```
-     */
-    const set: <S, A>(opt: Optional<S, A>) => (a: A) => (s: S) => S;
-    /**
-     * Applies a function to the focused value if it is present; returns the
-     * structure unchanged if the focus is absent.
-     *
-     * @example
-     * ```ts
-     * pipe(profile, Optional.modify(bioOpt)(s => s.toUpperCase()));
-     * ```
-     */
-    const modify: <S, A>(opt: Optional<S, A>) => (f: (a: A) => A) => (s: S) => S;
-    /**
-     * Returns the focused value or a default when the focus is absent.
-     *
-     * @example
-     * ```ts
-     * pipe(profile, Optional.getOrElse(bioOpt)(() => "no bio"));
-     * ```
-     */
-    const getOrElse: <S, A>(opt: Optional<S, A>) => (defaultValue: () => A) => (s: S) => A;
-    /**
-     * Extracts a value from an Optional focus using handlers for the present
-     * and absent cases.
-     *
-     * @example
-     * ```ts
-     * pipe(profile, Optional.fold(bioOpt)(() => "no bio", (bio) => bio.toUpperCase()));
-     * ```
-     */
-    const fold: <S, A>(opt: Optional<S, A>) => <B>(onNone: () => B, onSome: (a: A) => B) => (s: S) => B;
-    /**
-     * Pattern matches on an Optional focus using a named-case object.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   profile,
-     *   Optional.match(bioOpt)({ none: () => "no bio", some: (bio) => bio }),
-     * );
-     * ```
-     */
-    const match: <S, A>(opt: Optional<S, A>) => <B>(cases: {
-        none: () => B;
-        some: (a: A) => B;
-    }) => (s: S) => B;
-    /**
-     * Composes two Optionals: focuses through the outer, then through the inner.
-     * Returns None if either focus is absent.
-     *
-     * @example
-     * ```ts
-     * const deepOpt = pipe(
-     *   Optional.prop<User>()("address"),
-     *   Optional.andThen(Optional.prop<Address>()("landmark")),
-     * );
-     * ```
-     */
-    const andThen: <A, B>(inner: Optional<A, B>) => <S>(outer: Optional<S, A>) => Optional<S, B>;
-    /**
-     * Composes an Optional with a Lens, producing an Optional.
-     * The Lens focuses within the value found by the Optional.
-     *
-     * @example
-     * ```ts
-     * const cityOpt = pipe(
-     *   Optional.prop<User>()("address"),
-     *   Optional.andThenLens(Lens.prop<Address>()("city")),
-     * );
-     * ```
-     */
-    const andThenLens: <A, B>(inner: Lens<A, B>) => <S>(outer: Optional<S, A>) => Optional<S, B>;
-}
-
 /**
  * Lens<S, A> focuses on a single value A inside a structure S, providing
  * a composable way to read and immutably update nested data.
@@ -1286,140 +1131,159 @@ declare namespace Op {
     function interpret<I, E, A, O extends AllInterpretOptions<I, E>>(op: Op<I, E, A>, options: O): InterpretResult<I, E, A, O>;
 }
 
+/** Keys of T for which undefined is assignable (i.e. optional fields). */
+type OptionalKeys<T> = {
+    [K in keyof T]-?: undefined extends T[K] ? K : never;
+}[keyof T];
 /**
- * A function from `A` to `A is B` — a type predicate paired with a runtime check.
+ * Optional<S, A> focuses on a value A inside a structure S that may or may
+ * not be present. Like a Lens, but get returns Maybe<A>.
  *
- * A `Refinement<A, B>` proves at compile time that a value of type `A` is actually
- * the narrower type `B extends A`, backed by a runtime boolean test. Use it to
- * express domain invariants (non-empty strings, positive numbers, valid emails) as
- * first-class, composable values rather than one-off type guards scattered across
- * the codebase.
+ * Compose with other Optionals via `andThen`, or with a Lens via `andThenLens`.
+ * Convert a Lens to an Optional with `Lens.toOptional`.
  *
  * @example
  * ```ts
- * type NonEmptyString = string & { readonly _tag: "NonEmptyString" };
+ * type Profile = { username: string; bio?: string };
  *
- * const isNonEmpty: Refinement<string, NonEmptyString> =
- *   Refinement.make(s => s.length > 0);
+ * const bioOpt = Optional.prop<Profile>()("bio");
  *
- * pipe(
- *   "hello",
- *   Refinement.toFilter(isNonEmpty)
- * ); // Some("hello")
+ * pipe(profile, Optional.get(bioOpt));               // Some("hello") or None
+ * pipe(profile, Optional.set(bioOpt)("hello"));      // new Profile with bio set
+ * pipe(profile, Optional.modify(bioOpt)(s => s + "!")); // appends if present
  * ```
  */
-type Refinement<A, B extends A> = (a: A) => a is B;
-declare namespace Refinement {
+type Optional<S, A> = {
+    readonly get: (s: S) => Maybe<A>;
+    readonly set: (a: A) => (s: S) => S;
+};
+declare namespace Optional {
     /**
-     * Creates a `Refinement<A, B>` from a plain boolean predicate.
-     *
-     * This is an unsafe cast — the caller is responsible for ensuring that the
-     * predicate truly characterises values of type `B`. Use this only when
-     * bootstrapping a new refinement; prefer `compose`, `and`, or `or` to build
-     * derived refinements from existing ones.
+     * Constructs an Optional from a getter (returning Maybe<A>) and a setter.
      *
      * @example
      * ```ts
-     * type PositiveNumber = number & { readonly _tag: "PositiveNumber" };
-     *
-     * const isPositive: Refinement<number, PositiveNumber> =
-     *   Refinement.make(n => n > 0);
+     * const firstChar = Optional.make(
+     *   (s: string) => s.length > 0 ? Maybe.some(s[0]) : Maybe.none(),
+     *   (c) => (s) => s.length > 0 ? c + s.slice(1) : s,
+     * );
      * ```
      */
-    const make: <A, B extends A>(f: (a: A) => boolean) => Refinement<A, B>;
+    const make: <S, A>(get: (s: S) => Maybe<A>, set: (a: A) => (s: S) => S) => Optional<S, A>;
     /**
-     * Chains two refinements: if `ab` narrows `A` to `B` and `bc` narrows `B` to `C`,
-     * the result narrows `A` directly to `C`.
-     *
-     * Data-last — the first refinement `ab` is the data being piped.
+     * Creates an Optional that focuses on an optional property of an object.
+     * Only keys whose type includes undefined (i.e. `field?: T`) are accepted.
+     * Call with the structure type first, then the key.
      *
      * @example
      * ```ts
-     * type NonEmptyString = string & { readonly _tag: "NonEmpty" };
-     * type TrimmedString  = NonEmptyString & { readonly _tag: "Trimmed" };
-     *
-     * const isNonEmpty: Refinement<string, NonEmptyString> =
-     *   Refinement.make(s => s.length > 0);
-     * const isTrimmed: Refinement<NonEmptyString, TrimmedString> =
-     *   Refinement.make(s => s === s.trim());
-     *
-     * const isNonEmptyTrimmed: Refinement<string, TrimmedString> = pipe(
-     *   isNonEmpty,
-     *   Refinement.compose(isTrimmed)
-     * );
+     * type Profile = { username: string; bio?: string };
+     * const bioOpt = Optional.prop<Profile>()("bio");
      * ```
      */
-    const compose: <A, B extends A, C extends B>(bc: Refinement<B, C>) => (ab: Refinement<A, B>) => Refinement<A, C>;
+    const prop: <S>() => <K extends OptionalKeys<S>>(key: K) => Optional<S, NonNullable<S[K]>>;
     /**
-     * Intersects two refinements: the result narrows `A` to `B & C`, passing only
-     * when both refinements hold simultaneously.
-     *
-     * Data-last — the first refinement is the data being piped.
+     * Creates an Optional that focuses on an element at a given index in an array.
+     * Returns None when the index is out of bounds; set is a no-op when out of bounds.
      *
      * @example
      * ```ts
-     * const isString: Refinement<unknown, string> = Refinement.make(x => typeof x === "string");
-     * const isNonEmpty: Refinement<unknown, { length: number }> =
-     *   Refinement.make(x => (x as any).length > 0);
+     * const firstItem = Optional.index<string>(0);
      *
-     * const isNonEmptyString = pipe(isString, Refinement.and(isNonEmpty));
-     * isNonEmptyString("hi");  // true
-     * isNonEmptyString("");    // false
+     * pipe(["a", "b"], Optional.get(firstItem)); // Some("a")
+     * pipe([], Optional.get(firstItem));         // None
      * ```
      */
-    const and: <A, C extends A>(second: Refinement<A, C>) => <B extends A>(first: Refinement<A, B>) => Refinement<A, B & C>;
+    const index: <A>(i: number) => Optional<A[], A>;
     /**
-     * Unions two refinements: the result narrows `A` to `B | C`, passing when either
-     * refinement holds.
-     *
-     * Data-last — the first refinement is the data being piped.
+     * Reads the focused value from a structure, returning Maybe<A>.
      *
      * @example
      * ```ts
-     * const isString:  Refinement<unknown, string>  = Refinement.make(x => typeof x === "string");
-     * const isNumber:  Refinement<unknown, number>  = Refinement.make(x => typeof x === "number");
-     *
-     * const isStringOrNumber = pipe(isString, Refinement.or(isNumber));
-     * isStringOrNumber("hi"); // true
-     * isStringOrNumber(42);   // true
-     * isStringOrNumber(true); // false
+     * pipe(profile, Optional.get(bioOpt)); // Some("...") or None
      * ```
      */
-    const or: <A, C extends A>(second: Refinement<A, C>) => <B extends A>(first: Refinement<A, B>) => Refinement<A, B | C>;
+    const get: <S, A>(opt: Optional<S, A>) => (s: S) => Maybe<A>;
     /**
-     * Converts a `Refinement<A, B>` into a function `(a: A) => Maybe<B>`.
+     * Replaces the focused value within a structure.
+     * For indexed focuses, this is a no-op when the index is out of bounds.
      *
-     * Returns `Some(a)` when the refinement holds, `None` otherwise. Useful for
-     * integrating runtime validation into a `Maybe`-based pipeline.
+     * @example
+     * ```ts
+     * pipe(profile, Optional.set(bioOpt)("hello"));
+     * ```
+     */
+    const set: <S, A>(opt: Optional<S, A>) => (a: A) => (s: S) => S;
+    /**
+     * Applies a function to the focused value if it is present; returns the
+     * structure unchanged if the focus is absent.
      *
      * @example
      * ```ts
-     * type PositiveNumber = number & { readonly _tag: "Positive" };
-     * const isPositive: Refinement<number, PositiveNumber> =
-     *   Refinement.make(n => n > 0);
+     * pipe(profile, Optional.modify(bioOpt)(s => s.toUpperCase()));
+     * ```
+     */
+    const modify: <S, A>(opt: Optional<S, A>) => (f: (a: A) => A) => (s: S) => S;
+    /**
+     * Returns the focused value or a default when the focus is absent.
      *
-     * pipe(-1, Refinement.toFilter(isPositive)); // None
-     * pipe(42, Refinement.toFilter(isPositive)); // Some(42)
+     * @example
+     * ```ts
+     * pipe(profile, Optional.getOrElse(bioOpt)(() => "no bio"));
      * ```
      */
-    const toFilter: <A, B extends A>(r: Refinement<A, B>) => (a: A) => Maybe<B>;
+    const getOrElse: <S, A>(opt: Optional<S, A>) => (defaultValue: () => A) => (s: S) => A;
     /**
-     * Converts a `Refinement<A, B>` into a function `(a: A) => Result<E, B>`.
+     * Extracts a value from an Optional focus using handlers for the present
+     * and absent cases.
      *
-     * Returns `Ok(a)` when the refinement holds, `Err(onFail(a))` otherwise. Use
-     * this to surface validation failures as typed errors inside a `Result` pipeline.
+     * @example
+     * ```ts
+     * pipe(profile, Optional.fold(bioOpt)(() => "no bio", (bio) => bio.toUpperCase()));
+     * ```
+     */
+    const fold: <S, A>(opt: Optional<S, A>) => <B>(onNone: () => B, onSome: (a: A) => B) => (s: S) => B;
+    /**
+     * Pattern matches on an Optional focus using a named-case object.
      *
      * @example
      * ```ts
-     * type NonEmptyString = string & { readonly _tag: "NonEmpty" };
-     * const isNonEmpty: Refinement<string, NonEmptyString> =
-     *   Refinement.make(s => s.length > 0);
+     * pipe(
+     *   profile,
+     *   Optional.match(bioOpt)({ none: () => "no bio", some: (bio) => bio }),
+     * );
+     * ```
+     */
+    const match: <S, A>(opt: Optional<S, A>) => <B>(cases: {
+        none: () => B;
+        some: (a: A) => B;
+    }) => (s: S) => B;
+    /**
+     * Composes two Optionals: focuses through the outer, then through the inner.
+     * Returns None if either focus is absent.
      *
-     * pipe("", Refinement.toResult(isNonEmpty, () => "must not be empty")); // Err(...)
-     * pipe("hi", Refinement.toResult(isNonEmpty, () => "must not be empty")); // Ok("hi")
+     * @example
+     * ```ts
+     * const deepOpt = pipe(
+     *   Optional.prop<User>()("address"),
+     *   Optional.andThen(Optional.prop<Address>()("landmark")),
+     * );
      * ```
      */
-    const toResult: <A, B extends A, E>(r: Refinement<A, B>, onFail: (a: A) => E) => (a: A) => Result<E, B>;
+    const andThen: <A, B>(inner: Optional<A, B>) => <S>(outer: Optional<S, A>) => Optional<S, B>;
+    /**
+     * Composes an Optional with a Lens, producing an Optional.
+     * The Lens focuses within the value found by the Optional.
+     *
+     * @example
+     * ```ts
+     * const cityOpt = pipe(
+     *   Optional.prop<User>()("address"),
+     *   Optional.andThenLens(Lens.prop<Address>()("city")),
+     * );
+     * ```
+     */
+    const andThenLens: <A, B>(inner: Lens<A, B>) => <S>(outer: Optional<S, A>) => Optional<S, B>;
 }
 
 /**
@@ -1759,6 +1623,142 @@ declare namespace Reader {
     const bind: <K extends string, R, A, B>(key: K, f: (a: A) => Reader<R, B>) => (data: Reader<R, A>) => Reader<R, A & { [P in K]: B; }>;
 }
 
+/**
+ * A function from `A` to `A is B` — a type predicate paired with a runtime check.
+ *
+ * A `Refinement<A, B>` proves at compile time that a value of type `A` is actually
+ * the narrower type `B extends A`, backed by a runtime boolean test. Use it to
+ * express domain invariants (non-empty strings, positive numbers, valid emails) as
+ * first-class, composable values rather than one-off type guards scattered across
+ * the codebase.
+ *
+ * @example
+ * ```ts
+ * type NonEmptyString = string & { readonly _tag: "NonEmptyString" };
+ *
+ * const isNonEmpty: Refinement<string, NonEmptyString> =
+ *   Refinement.make(s => s.length > 0);
+ *
+ * pipe(
+ *   "hello",
+ *   Refinement.toFilter(isNonEmpty)
+ * ); // Some("hello")
+ * ```
+ */
+type Refinement<A, B extends A> = (a: A) => a is B;
+declare namespace Refinement {
+    /**
+     * Creates a `Refinement<A, B>` from a plain boolean predicate.
+     *
+     * This is an unsafe cast — the caller is responsible for ensuring that the
+     * predicate truly characterises values of type `B`. Use this only when
+     * bootstrapping a new refinement; prefer `compose`, `and`, or `or` to build
+     * derived refinements from existing ones.
+     *
+     * @example
+     * ```ts
+     * type PositiveNumber = number & { readonly _tag: "PositiveNumber" };
+     *
+     * const isPositive: Refinement<number, PositiveNumber> =
+     *   Refinement.make(n => n > 0);
+     * ```
+     */
+    const make: <A, B extends A>(f: (a: A) => boolean) => Refinement<A, B>;
+    /**
+     * Chains two refinements: if `ab` narrows `A` to `B` and `bc` narrows `B` to `C`,
+     * the result narrows `A` directly to `C`.
+     *
+     * Data-last — the first refinement `ab` is the data being piped.
+     *
+     * @example
+     * ```ts
+     * type NonEmptyString = string & { readonly _tag: "NonEmpty" };
+     * type TrimmedString  = NonEmptyString & { readonly _tag: "Trimmed" };
+     *
+     * const isNonEmpty: Refinement<string, NonEmptyString> =
+     *   Refinement.make(s => s.length > 0);
+     * const isTrimmed: Refinement<NonEmptyString, TrimmedString> =
+     *   Refinement.make(s => s === s.trim());
+     *
+     * const isNonEmptyTrimmed: Refinement<string, TrimmedString> = pipe(
+     *   isNonEmpty,
+     *   Refinement.compose(isTrimmed)
+     * );
+     * ```
+     */
+    const compose: <A, B extends A, C extends B>(bc: Refinement<B, C>) => (ab: Refinement<A, B>) => Refinement<A, C>;
+    /**
+     * Intersects two refinements: the result narrows `A` to `B & C`, passing only
+     * when both refinements hold simultaneously.
+     *
+     * Data-last — the first refinement is the data being piped.
+     *
+     * @example
+     * ```ts
+     * const isString: Refinement<unknown, string> = Refinement.make(x => typeof x === "string");
+     * const isNonEmpty: Refinement<unknown, { length: number }> =
+     *   Refinement.make(x => (x as any).length > 0);
+     *
+     * const isNonEmptyString = pipe(isString, Refinement.and(isNonEmpty));
+     * isNonEmptyString("hi");  // true
+     * isNonEmptyString("");    // false
+     * ```
+     */
+    const and: <A, C extends A>(second: Refinement<A, C>) => <B extends A>(first: Refinement<A, B>) => Refinement<A, B & C>;
+    /**
+     * Unions two refinements: the result narrows `A` to `B | C`, passing when either
+     * refinement holds.
+     *
+     * Data-last — the first refinement is the data being piped.
+     *
+     * @example
+     * ```ts
+     * const isString:  Refinement<unknown, string>  = Refinement.make(x => typeof x === "string");
+     * const isNumber:  Refinement<unknown, number>  = Refinement.make(x => typeof x === "number");
+     *
+     * const isStringOrNumber = pipe(isString, Refinement.or(isNumber));
+     * isStringOrNumber("hi"); // true
+     * isStringOrNumber(42);   // true
+     * isStringOrNumber(true); // false
+     * ```
+     */
+    const or: <A, C extends A>(second: Refinement<A, C>) => <B extends A>(first: Refinement<A, B>) => Refinement<A, B | C>;
+    /**
+     * 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 a `Maybe`-based pipeline.
+     *
+     * @example
+     * ```ts
+     * type PositiveNumber = number & { readonly _tag: "Positive" };
+     * const isPositive: Refinement<number, PositiveNumber> =
+     *   Refinement.make(n => n > 0);
+     *
+     * pipe(-1, Refinement.toFilter(isPositive)); // None
+     * pipe(42, Refinement.toFilter(isPositive)); // Some(42)
+     * ```
+     */
+    const toFilter: <A, B extends A>(r: Refinement<A, B>) => (a: A) => Maybe<B>;
+    /**
+     * Converts a `Refinement<A, B>` into a function `(a: A) => Result<E, B>`.
+     *
+     * Returns `Ok(a)` when the refinement holds, `Err(onFail(a))` otherwise. Use
+     * this to surface validation failures as typed errors inside a `Result` pipeline.
+     *
+     * @example
+     * ```ts
+     * type NonEmptyString = string & { readonly _tag: "NonEmpty" };
+     * const isNonEmpty: Refinement<string, NonEmptyString> =
+     *   Refinement.make(s => s.length > 0);
+     *
+     * pipe("", Refinement.toResult(isNonEmpty, () => "must not be empty")); // Err(...)
+     * pipe("hi", Refinement.toResult(isNonEmpty, () => "must not be empty")); // Ok("hi")
+     * ```
+     */
+    const toResult: <A, B extends A, E>(r: Refinement<A, B>, onFail: (a: A) => E) => (a: A) => Result<E, B>;
+}
+
 type NotAsked = WithKind<"NotAsked">;
 type Loading = WithKind<"Loading">;
 type Failure<E> = WithKind<"Failure"> & WithError<E>;
@@ -2004,186 +2004,31 @@ declare namespace RemoteData {
 }
 
 /**
- * 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.
+ * A Resource pairs an async acquisition step with a guaranteed cleanup step.
+ *
+ * Use it whenever something must be explicitly closed, released, or torn down
+ * after you are done with it — database connections, file handles, locks,
+ * temporary directories, or any object with a lifecycle.
+ *
+ * The key guarantee: `release` always runs after `Resource.use`, even when
+ * the work function returns an error. If `acquire` itself fails, `release` is
+ * skipped — there is nothing to clean up.
+ *
+ * Build a Resource with `Resource.make` or `Resource.fromTask`, then run it
+ * with `Resource.use`.
  *
  * @example
  * ```ts
- * const fetchUser = (id: string): TaskResult<Error, User> =>
- *   TaskResult.tryCatch(
- *     (signal) => fetch(`/users/${id}`, { signal }).then(r => r.json()),
- *     (e) => new Error(`Failed to fetch user: ${e}`)
- *   );
- * ```
- */
-type TaskResult<E, A> = Task<Result<E, A>>;
-declare namespace TaskResult {
-    /**
-     * Wraps a value in a successful TaskResult.
-     */
-    const ok: <E, A>(value: A) => TaskResult<E, A>;
-    /**
-     * Creates a failed TaskResult with the given error.
-     */
-    const err: <E, A>(error: E) => TaskResult<E, A>;
-    /**
-     * Creates a TaskResult from a nullable value.
-     * Returns Ok if the value is not null or undefined, err from onNull otherwise.
-     */
-    const fromNullable: <E>(onNull: () => E) => <A>(value: A | null | undefined) => TaskResult<E, A>;
-    /**
-     * Creates a TaskResult from a Maybe.
-     * Some becomes Ok, None becomes err from onNone.
-     */
-    const fromMaybe: <E>(onNone: () => E) => <A>(maybe: Maybe<A>) => TaskResult<E, A>;
-    /**
-     * Lifts a Result into a TaskResult.
-     */
-    const fromResult: <E, A>(result: Result<E, A>) => TaskResult<E, A>;
-    /**
-     * Wraps a Promise-returning function of any arguments, returning a new function
-     * that catches rejections and returns a TaskResult.
-     */
-    const fromThrowable: <Args extends readonly unknown[], A, E>(f: (...args: Args) => Promise<A>, onError: (e: unknown) => E) => (...args: Args) => TaskResult<E, A>;
-    /**
-     * Creates a TaskResult from a function that may throw.
-     * Catches any errors and transforms them using the onError function.
-     * The factory optionally receives an `AbortSignal` forwarded from the call site.
-     *
-     * @example
-     * ```ts
-     * const fetchUser = (id: string): TaskResult<string, User> =>
-     *   TaskResult.tryCatch(
-     *     (signal) => fetch(`/users/${id}`, { signal }).then(r => r.json()),
-     *     String
-     *   );
-     * ```
-     */
-    const tryCatch: <E, A>(f: (signal?: AbortSignal) => Promise<A>, onError: (e: unknown) => E) => TaskResult<E, A>;
-    /**
-     * Transforms the success value inside a TaskResult.
-     */
-    const map: <E, A, B>(f: (a: A) => B) => (data: TaskResult<E, A>) => TaskResult<E, B>;
-    /**
-     * Transforms the error value inside a TaskResult.
-     */
-    const mapError: <E, F, A>(f: (e: E) => F) => (data: TaskResult<E, A>) => TaskResult<F, A>;
-    /**
-     * Chains TaskResult computations. If the first succeeds, passes the value to f.
-     * If the first fails, propagates the error.
-     */
-    const chain: <E, A, B>(f: (a: A) => TaskResult<E, B>) => (data: TaskResult<E, A>) => TaskResult<E, B>;
-    /**
-     * Extracts the value from a TaskResult by providing handlers for both cases.
-     */
-    const fold: <E, A, B>(onErr: (e: E) => B, onOk: (a: A) => B) => (data: TaskResult<E, A>) => Task<B>;
-    /**
-     * Pattern matches on a TaskResult, returning a Task of the result.
-     */
-    const match: <E, A, B>(cases: {
-        err: (e: E) => B;
-        ok: (a: A) => B;
-    }) => (data: TaskResult<E, A>) => Task<B>;
-    /**
-     * Recovers from an error by providing a fallback TaskResult.
-     * The fallback can produce a different success type, widening the result to `TaskResult<E, A | B>`.
-     */
-    const recover: <E, A, B>(fallback: (e: E) => TaskResult<E, B>) => (data: TaskResult<E, A>) => TaskResult<E, A | B>;
-    /**
-     * Returns the success value or a default value if the TaskResult is an error.
-     * The default can be a different type, widening the result to `Task<A | B>`.
-     */
-    const getOrElse: <E, A, B>(defaultValue: () => B) => (data: TaskResult<E, A>) => Task<A | B>;
-    /**
-     * Executes a side effect on the success value without changing the TaskResult.
-     * Useful for logging or debugging.
-     */
-    const tap: <E, A>(f: (a: A) => void) => (data: TaskResult<E, A>) => TaskResult<E, A>;
-    /**
-     * Executes a side effect on the error value without changing the TaskResult.
-     * Useful for logging or reporting async errors.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   fetchUser(id),
-     *   TaskResult.tapError(e => console.error("fetch failed:", e)),
-     *   TaskResult.chain(saveToCache),
-     * )
-     * ```
-     */
-    const tapError: <E, A>(f: (e: E) => void) => (data: TaskResult<E, A>) => TaskResult<E, A>;
-    /**
-     * Applies a function wrapped in a TaskResult to a value wrapped in a TaskResult.
-     * Both Tasks run in parallel.
-     */
-    const ap: <E, A>(arg: TaskResult<E, A>) => <B>(data: TaskResult<E, (a: A) => B>) => TaskResult<E, B>;
-    /**
-     * Executes a `TaskResult` with an optional signal, returning `Promise<Result<E, A>>`.
-     * Use as a terminal step in a `pipe` chain.
-     *
-     * @example
-     * ```ts
-     * const controller = new AbortController();
-     * const result = await pipe(
-     *     fetchUser("42"),
-     *     TaskResult.chain(user => fetchPosts(user.id)),
-     *     TaskResult.run(controller.signal),
-     * );
-     * if (Result.isOk(result)) render(result.value);
-     * ```
-     */
-    const run: (signal?: AbortSignal) => <E, A>(task: TaskResult<E, A>) => Promise<Result<E, A>>;
-    /**
-     * Converts a TaskResult value into an object containing a single property.
-     * Initiates the pipeline accumulator record.
-     *
-     * @example
-     * ```ts
-     * pipe(TaskResult.ok(42), TaskResult.bindTo("value")); // TaskResult({ value: 42 })
-     * ```
-     */
-    const bindTo: <K extends string>(key: K) => <E, A>(data: TaskResult<E, A>) => TaskResult<E, { [P in K]: A; }>;
-    /**
-     * Evaluates a new TaskResult using the current accumulator and attaches the output to a new key.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   TaskResult.ok({ a: 1 }),
-     *   TaskResult.bind("b", ({ a }) => TaskResult.ok(a + 1))
-     * ); // TaskResult({ a: 1, b: 2 })
-     * ```
-     */
-    const bind: <K extends string, E, A, B>(key: K, f: (a: A) => TaskResult<E, B>) => (data: TaskResult<E, A>) => TaskResult<E, A & { [P in K]: B; }>;
-}
-
-/**
- * A Resource pairs an async acquisition step with a guaranteed cleanup step.
- *
- * Use it whenever something must be explicitly closed, released, or torn down
- * after you are done with it — database connections, file handles, locks,
- * temporary directories, or any object with a lifecycle.
- *
- * The key guarantee: `release` always runs after `Resource.use`, even when
- * the work function returns an error. If `acquire` itself fails, `release` is
- * skipped — there is nothing to clean up.
- *
- * Build a Resource with `Resource.make` or `Resource.fromTask`, then run it
- * with `Resource.use`.
- *
- * @example
- * ```ts
- * const dbResource = Resource.make(
- *   TaskResult.tryCatch(() => openConnection(config), (e) => new DbError(e)),
- *   (conn) => Task.from(() => conn.close())
- * );
- *
- * const result = await pipe(
- *   dbResource,
- *   Resource.use((conn) => queryUser(conn, userId))
- * )();
- * // conn.close() is called whether queryUser succeeds or fails
+ * const dbResource = Resource.make(
+ *   TaskResult.tryCatch(() => openConnection(config), (e) => new DbError(e)),
+ *   (conn) => Task.from(() => conn.close())
+ * );
+ *
+ * const result = await pipe(
+ *   dbResource,
+ *   Resource.use((conn) => queryUser(conn, userId))
+ * )();
+ * // conn.close() is called whether queryUser succeeds or fails
  * ```
  */
 type Resource<E, A> = {
@@ -2616,311 +2461,173 @@ declare namespace TaskMaybe {
     const bind: <K extends string, A, B>(key: K, f: (a: A) => TaskMaybe<B>) => (data: TaskMaybe<A>) => TaskMaybe<A & { [P in K]: B; }>;
 }
 
-type Passed<A> = WithKind<"Passed"> & WithValue<A>;
-type Failed<E> = WithKind<"Failed"> & WithErrors<E>;
 /**
- * Validation represents a value that is either passed with a success value,
- * or failed with accumulated errors.
- * Unlike Result, Validation can accumulate multiple errors instead of short-circuiting.
- *
- * Use Validation when you need to collect all errors (e.g., form validation).
- * Use Result when you want to fail fast on the first error.
+ * 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 validateName = (name: string): Validation<string, string> =>
- *   name.length > 0 ? Validation.passed(name) : Validation.failed("Name is required");
- *
- * const validateAge = (age: number): Validation<string, number> =>
- *   age >= 0 ? Validation.passed(age) : Validation.failed("Age must be positive");
- *
- * // Accumulates all errors using ap
- * pipe(
- *   Validation.passed((name: string) => (age: number) => ({ name, age })),
- *   Validation.ap(validateName("")),
- *   Validation.ap(validateAge(-1))
- * );
- * // Failed(["Name is required", "Age must be positive"])
+ * const fetchUser = (id: string): TaskResult<Error, User> =>
+ *   TaskResult.tryCatch(
+ *     (signal) => fetch(`/users/${id}`, { signal }).then(r => r.json()),
+ *     (e) => new Error(`Failed to fetch user: ${e}`)
+ *   );
  * ```
  */
-type Validation<E, A> = Passed<A> | Failed<E>;
-declare namespace Validation {
+type TaskResult<E, A> = Task<Result<E, A>>;
+declare namespace TaskResult {
     /**
-     * Wraps a value in a passed Validation.
-     *
-     * @example
-     * ```ts
-     * Validation.passed(42); // Passed(42)
-     * ```
+     * Wraps a value in a successful TaskResult.
      */
-    const passed: <E, A>(value: A) => Validation<E, A>;
+    const ok: <E, A>(value: A) => TaskResult<E, A>;
     /**
-     * Creates a failed Validation from a single error.
-     *
-     * @example
-     * ```ts
-     * Validation.failed("Invalid input");
-     * ```
+     * Creates a failed TaskResult with the given error.
      */
-    const failed: <E>(error: E) => Failed<E>;
+    const err: <E, A>(error: E) => TaskResult<E, A>;
     /**
-     * Creates a failed Validation from multiple errors.
-     *
-     * @example
-     * ```ts
-     * Validation.failedAll(["Invalid input"]);
-     * ```
+     * Creates a TaskResult from a nullable value.
+     * Returns Ok if the value is not null or undefined, err from onNull otherwise.
      */
-    const failedAll: <E>(errors: NonEmptyList<E>) => Failed<E>;
+    const fromNullable: <E>(onNull: () => E) => <A>(value: A | null | undefined) => TaskResult<E, A>;
     /**
-     * Type guard that checks if a Validation is passed.
+     * Creates a TaskResult from a Maybe.
+     * Some becomes Ok, None becomes err from onNone.
      */
-    const isPassed: <E, A>(data: Validation<E, A>) => data is Passed<A>;
+    const fromMaybe: <E>(onNone: () => E) => <A>(maybe: Maybe<A>) => TaskResult<E, A>;
     /**
-     * Type guard that checks if a Validation is failed.
+     * Lifts a Result into a TaskResult.
      */
-    const isFailed: <E, A>(data: Validation<E, A>) => data is Failed<E>;
+    const fromResult: <E, A>(result: Result<E, A>) => TaskResult<E, A>;
     /**
-     * Creates a Validation from a predicate applied to a value.
-     * Returns Passed if the predicate passes, Failed from `onFalse` otherwise.
+     * Wraps a Promise-returning function of any arguments, returning a new function
+     * that catches rejections and returns a TaskResult.
+     */
+    const fromThrowable: <Args extends readonly unknown[], A, E>(f: (...args: Args) => Promise<A>, onError: (e: unknown) => E) => (...args: Args) => TaskResult<E, A>;
+    /**
+     * Creates a TaskResult from a function that may throw.
+     * Catches any errors and transforms them using the onError function.
+     * The factory optionally receives an `AbortSignal` forwarded from the call site.
      *
      * @example
      * ```ts
-     * const validateName = Validation.fromPredicate(
-     *   (s: string) => s.length > 0,
-     *   () => "Name is required"
-     * );
-     *
-     * validateName("Alice"); // Passed("Alice")
-     * validateName("");      // Failed(["Name is required"])
+     * const fetchUser = (id: string): TaskResult<string, User> =>
+     *   TaskResult.tryCatch(
+     *     (signal) => fetch(`/users/${id}`, { signal }).then(r => r.json()),
+     *     String
+     *   );
      * ```
      */
-    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>;
+    const tryCatch: <E, A>(f: (signal?: AbortSignal) => Promise<A>, onError: (e: unknown) => E) => TaskResult<E, A>;
     /**
-     * Transforms the success value inside a Validation.
-     *
-     * @example
-     * ```ts
-     * pipe(Validation.passed(5), Validation.map(n => n * 2)); // Passed(10)
-     * pipe(Validation.failed("oops"), Validation.map(n => n * 2)); // Failed(["oops"])
-     * ```
+     * Transforms the success value inside a TaskResult.
      */
-    const map: <A, B>(f: (a: A) => B) => <E>(data: Validation<E, A>) => Validation<E, B>;
+    const map: <E, A, B>(f: (a: A) => B) => (data: TaskResult<E, A>) => TaskResult<E, B>;
     /**
-     * Transforms the error list inside a Validation.
-     *
-     * @example
-     * ```ts
-     * pipe(Validation.failed("oops"), Validation.mapError(e => e.toUpperCase())); // Failed(["OOPS"])
-     * ```
+     * Transforms the error value inside a TaskResult.
      */
-    const mapError: <E, F, A>(f: (e: E) => F) => (data: Validation<E, A>) => Validation<F, A>;
+    const mapError: <E, F, A>(f: (e: E) => F) => (data: TaskResult<E, A>) => TaskResult<F, A>;
     /**
-     * Applies a function wrapped in a Validation to a value wrapped in a Validation.
-     * Accumulates errors from both sides.
-     *
-     * @example
-     * ```ts
-     * const add = (a: number) => (b: number) => a + b;
-     * pipe(
-     *   Validation.passed(add),
-     *   Validation.ap(Validation.passed(5)),
-     *   Validation.ap(Validation.passed(3))
-     * ); // Passed(8)
-     *
-     * pipe(
-     *   Validation.passed(add),
-     *   Validation.ap(Validation.failed<string, number>("bad a")),
-     *   Validation.ap(Validation.failed<string, number>("bad b"))
-     * ); // Failed(["bad a", "bad b"])
-     * ```
+     * Chains TaskResult computations. If the first succeeds, passes the value to f.
+     * If the first fails, propagates the error.
      */
-    const ap: <E, A>(arg: Validation<E, A>) => <B>(data: Validation<E, (a: A) => B>) => Validation<E, B>;
+    const chain: <E, A, B>(f: (a: A) => TaskResult<E, B>) => (data: TaskResult<E, A>) => TaskResult<E, B>;
     /**
-     * Extracts the value from a Validation by providing handlers for both cases.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   Validation.passed(42),
-     *   Validation.fold(
-     *     errors => `Errors: ${errors.join(", ")}`,
-     *     value => `Value: ${value}`
-     *   )
-     * );
-     * ```
+     * Extracts the value from a TaskResult by providing handlers for both cases.
      */
-    const fold: <E, A, B>(onFailed: (errors: NonEmptyList<E>) => B, onPassed: (a: A) => B) => (data: Validation<E, A>) => B;
+    const fold: <E, A, B>(onErr: (e: E) => B, onOk: (a: A) => B) => (data: TaskResult<E, A>) => Task<B>;
     /**
-     * Pattern matches on a Validation, returning the result of the matching case.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   validation,
-     *   Validation.match({
-     *     passed: value => `Got ${value}`,
-     *     failed: errors => `Failed: ${errors.join(", ")}`
-     *   })
-     * );
-     * ```
+     * Pattern matches on a TaskResult, returning a Task of the result.
      */
     const match: <E, A, B>(cases: {
-        passed: (a: A) => B;
-        failed: (errors: NonEmptyList<E>) => B;
-    }) => (data: Validation<E, A>) => B;
-    /**
-     * Returns the success value or a default value if the Validation is failed.
-     * The default can be a different type, widening the result to `A | B`.
-     *
-     * @example
-     * ```ts
-     * pipe(Validation.passed(5), Validation.getOrElse(() => 0)); // 5
-     * pipe(Validation.failed("oops"), Validation.getOrElse(() => 0)); // 0
-     * pipe(Validation.failed("oops"), Validation.getOrElse(() => null)); // null — typed as number | null
-     * ```
-     */
-    const getOrElse: <E, A, B>(defaultValue: () => B) => (data: Validation<E, A>) => A | B;
+        err: (e: E) => B;
+        ok: (a: A) => B;
+    }) => (data: TaskResult<E, A>) => Task<B>;
     /**
-     * Executes a side effect on the success value without changing the Validation.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   Validation.passed(5),
-     *   Validation.tap(n => console.log("Value:", n)),
-     *   Validation.map(n => n * 2)
-     * );
-     * ```
+     * Recovers from an error by providing a fallback TaskResult.
+     * The fallback can produce a different success type, widening the result to `TaskResult<E, A | B>`.
      */
-    const tap: <E, A>(f: (a: A) => void) => (data: Validation<E, A>) => Validation<E, A>;
+    const recover: <E, A, B>(fallback: (e: E) => TaskResult<E, B>) => (data: TaskResult<E, A>) => TaskResult<E, A | B>;
     /**
-     * Executes a side effect on the accumulated errors without changing the Validation.
-     * Useful for logging or reporting validation failures.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   Validation.failed("Name required"),
-     *   Validation.tapError(errors => console.error("validation failed:", errors)),
-     *   Validation.map(toUser)
-     * );
-     * ```
+     * Returns the success value or a default value if the TaskResult is an error.
+     * The default can be a different type, widening the result to `Task<A | B>`.
      */
-    const tapError: <E, A>(f: (errors: NonEmptyList<E>) => void) => (data: Validation<E, A>) => Validation<E, A>;
+    const getOrElse: <E, A, B>(defaultValue: () => B) => (data: TaskResult<E, A>) => Task<A | B>;
     /**
-     * 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>`.
+     * Executes a side effect on the success value without changing the TaskResult.
+     * Useful for logging or debugging.
      */
-    const recover: <E, A, B>(fallback: (errors: NonEmptyList<E>) => Validation<E, B>) => (data: Validation<E, A>) => Validation<E, A | B>;
+    const tap: <E, A>(f: (a: A) => void) => (data: TaskResult<E, A>) => TaskResult<E, 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>`.
+     * Executes a side effect on the error value without changing the TaskResult.
+     * Useful for logging or reporting async errors.
      *
      * @example
      * ```ts
      * pipe(
-     *   Validation.failed("field-error"),
-     *   Validation.recoverUnless(e => e === "fatal", () => Validation.passed(0))
-     * ); // Passed(0)
+     *   fetchUser(id),
+     *   TaskResult.tapError(e => console.error("fetch failed:", e)),
+     *   TaskResult.chain(saveToCache),
+     * )
      * ```
      */
-    const recoverUnless: <E, A, B>(isBlocked: (e: E) => boolean, fallback: () => Validation<E, B>) => (data: Validation<E, A>) => Validation<E, A | B>;
+    const tapError: <E, A>(f: (e: E) => void) => (data: TaskResult<E, A>) => TaskResult<E, A>;
     /**
-     * Converts a Validation to a Result.
-     * Passed becomes Ok, Failed becomes Err with the accumulated error list.
-     *
-     * @example
-     * ```ts
-     * Validation.toResult(Validation.passed(42));        // Ok(42)
-     * Validation.toResult(Validation.failed("oops"));  // Err(["oops"])
-     * ```
+     * Applies a function wrapped in a TaskResult to a value wrapped in a TaskResult.
+     * Both Tasks run in parallel.
      */
-    const toResult: <E, A>(data: Validation<E, A>) => Result<NonEmptyList<E>, A>;
+    const ap: <E, A>(arg: TaskResult<E, A>) => <B>(data: TaskResult<E, (a: A) => B>) => TaskResult<E, B>;
     /**
-     * Converts a Validation to a Maybe. `Passed` becomes `Some`; `Failed` becomes `None`
-     * (errors are discarded).
+     * Executes a `TaskResult` with an optional signal, returning `Promise<Result<E, A>>`.
+     * Use as a terminal step in a `pipe` chain.
      *
      * @example
      * ```ts
-     * Validation.toMaybe(Validation.passed(42));       // Some(42)
-     * Validation.toMaybe(Validation.failed("bad"));  // None
+     * const controller = new AbortController();
+     * const result = await pipe(
+     *     fetchUser("42"),
+     *     TaskResult.chain(user => fetchPosts(user.id)),
+     *     TaskResult.run(controller.signal),
+     * );
+     * if (Result.isOk(result)) render(result.value);
      * ```
      */
-    const toMaybe: <E, A>(data: Validation<E, A>) => Maybe<A>;
+    const run: (signal?: AbortSignal) => <E, A>(task: TaskResult<E, A>) => Promise<Result<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.
+     * Converts a TaskResult value into an object containing a single property.
+     * Initiates the pipeline accumulator record.
      *
      * @example
      * ```ts
-     * Validation.fromResult(Result.ok(42));       // Passed(42)
-     * Validation.fromResult(Result.err("bad"));   // Failed(["bad"])
+     * pipe(TaskResult.ok(42), TaskResult.bindTo("value")); // TaskResult({ value: 42 })
      * ```
      */
-    const fromResult: <E, A>(data: Result<E, A>) => Validation<E, A>;
+    const bindTo: <K extends string>(key: K) => <E, A>(data: TaskResult<E, A>) => TaskResult<E, { [P in K]: A; }>;
     /**
-     * Combines two independent Validation instances into a tuple.
-     * If both are Passed, returns Passed with both values as a tuple.
-     * If either is Failed, accumulates errors from both sides.
+     * Evaluates a new TaskResult using the current accumulator and attaches the output to a new key.
      *
      * @example
      * ```ts
-     * Validation.product(
-     *   Validation.passed("alice"),
-     *   Validation.passed(30)
-     * ); // Passed(["alice", 30])
-     *
-     * Validation.product(
-     *   Validation.failed("Name required"),
-     *   Validation.failed("Age must be >= 0")
-     * ); // Failed(["Name required", "Age must be >= 0"])
+     * pipe(
+     *   TaskResult.ok({ a: 1 }),
+     *   TaskResult.bind("b", ({ a }) => TaskResult.ok(a + 1))
+     * ); // TaskResult({ a: 1, b: 2 })
      * ```
      */
-    const product: <E, A, B>(first: Validation<E, A>, second: Validation<E, B>) => Validation<E, readonly [A, B]>;
+    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 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.
+     * Combines a record of TaskResults into a single TaskResult of a record.
+     * Evaluates all tasks in parallel, forwarding the AbortSignal down to each sub-task.
+     * Returns the first Err encountered in key order.
      *
      * @example
      * ```ts
-     * Validation.productAll([
-     *   validateName(name),
-     *   validateEmail(email),
-     *   validateAge(age)
-     * ]);
-     * // Passed([name, email, age]) or Failed([...all errors])
+     * TaskResult.struct({
+     *   name: TaskResult.ok("Alice"),
+     *   age: TaskResult.ok(30)
+     * }); // TaskResult({ name: "Alice", age: 30 })
      * ```
      */
-    const productAll: <E, A>(data: NonEmptyList<Validation<E, A>>) => Validation<E, readonly A[]>;
+    const struct: <E, R extends Record<string, any>>(fields: { [K in keyof R]: TaskResult<E, R[K]>; }) => TaskResult<E, R>;
 }
 
 /**
@@ -3434,4 +3141,329 @@ declare namespace Tuple {
     const tap: <A, B>(f: (a: A, b: B) => void) => (tuple: Tuple<A, B>) => Tuple<A, B>;
 }
 
+type Passed<A> = WithKind<"Passed"> & WithValue<A>;
+type Failed<E> = WithKind<"Failed"> & WithErrors<E>;
+/**
+ * Validation represents a value that is either passed with a success value,
+ * or failed with accumulated errors.
+ * Unlike Result, Validation can accumulate multiple errors instead of short-circuiting.
+ *
+ * Use Validation when you need to collect all errors (e.g., form validation).
+ * Use Result when you want to fail fast on the first error.
+ *
+ * @example
+ * ```ts
+ * const validateName = (name: string): Validation<string, string> =>
+ *   name.length > 0 ? Validation.passed(name) : Validation.failed("Name is required");
+ *
+ * const validateAge = (age: number): Validation<string, number> =>
+ *   age >= 0 ? Validation.passed(age) : Validation.failed("Age must be positive");
+ *
+ * // Accumulates all errors using ap
+ * pipe(
+ *   Validation.passed((name: string) => (age: number) => ({ name, age })),
+ *   Validation.ap(validateName("")),
+ *   Validation.ap(validateAge(-1))
+ * );
+ * // Failed(["Name is required", "Age must be positive"])
+ * ```
+ */
+type Validation<E, A> = Passed<A> | Failed<E>;
+declare namespace Validation {
+    /**
+     * Wraps a value in a passed Validation.
+     *
+     * @example
+     * ```ts
+     * Validation.passed(42); // Passed(42)
+     * ```
+     */
+    const passed: <E, A>(value: A) => Validation<E, A>;
+    /**
+     * Creates a failed Validation from a single error.
+     *
+     * @example
+     * ```ts
+     * Validation.failed("Invalid input");
+     * ```
+     */
+    const failed: <E>(error: E) => Failed<E>;
+    /**
+     * Creates a failed Validation from multiple errors.
+     *
+     * @example
+     * ```ts
+     * Validation.failedAll(["Invalid input"]);
+     * ```
+     */
+    const failedAll: <E>(errors: NonEmptyList<E>) => Failed<E>;
+    /**
+     * Type guard that checks if a Validation is passed.
+     */
+    const isPassed: <E, A>(data: Validation<E, A>) => data is Passed<A>;
+    /**
+     * Type guard that checks if a Validation is failed.
+     */
+    const isFailed: <E, A>(data: Validation<E, A>) => data is Failed<E>;
+    /**
+     * Creates a Validation from a predicate applied to a value.
+     * Returns Passed if the predicate passes, Failed from `onFalse` otherwise.
+     *
+     * @example
+     * ```ts
+     * const validateName = Validation.fromPredicate(
+     *   (s: string) => s.length > 0,
+     *   () => "Name is required"
+     * );
+     *
+     * validateName("Alice"); // Passed("Alice")
+     * validateName("");      // Failed(["Name is required"])
+     * ```
+     */
+    const fromPredicate: <E, A>(pred: (a: A) => boolean, onFalse: (a: A) => E) => (a: A) => Validation<E, A>;
+    /**
+     * Creates a Validation from a nullable value.
+     * If the value is null or undefined, returns Failed with the error from onNull.
+     * Otherwise, returns Passed.
+     *
+     * @example
+     * ```ts
+     * pipe(null, Validation.fromNullable(() => "is null")); // Failed(["is null"])
+     * pipe(42, Validation.fromNullable(() => "is null"));   // Passed(42)
+     * ```
+     */
+    const fromNullable: <E>(onNull: () => E) => <A>(value: A | null | undefined) => Validation<E, A>;
+    /**
+     * Creates a Validation from a Maybe.
+     * If the Maybe is None, returns Failed with the error from onNone.
+     * Otherwise, returns Passed.
+     *
+     * @example
+     * ```ts
+     * pipe(Maybe.none(), Validation.fromMaybe(() => "is none")); // Failed(["is none"])
+     * pipe(Maybe.some(42), Validation.fromMaybe(() => "is none")); // Passed(42)
+     * ```
+     */
+    const fromMaybe: <E>(onNone: () => E) => <A>(maybe: Maybe<A>) => Validation<E, A>;
+    /**
+     * Transforms the success value inside a Validation.
+     *
+     * @example
+     * ```ts
+     * pipe(Validation.passed(5), Validation.map(n => n * 2)); // Passed(10)
+     * pipe(Validation.failed("oops"), Validation.map(n => n * 2)); // Failed(["oops"])
+     * ```
+     */
+    const map: <A, B>(f: (a: A) => B) => <E>(data: Validation<E, A>) => Validation<E, B>;
+    /**
+     * Transforms the error list inside a Validation.
+     *
+     * @example
+     * ```ts
+     * pipe(Validation.failed("oops"), Validation.mapError(e => e.toUpperCase())); // Failed(["OOPS"])
+     * ```
+     */
+    const mapError: <E, F, A>(f: (e: E) => F) => (data: Validation<E, A>) => Validation<F, A>;
+    /**
+     * Applies a function wrapped in a Validation to a value wrapped in a Validation.
+     * Accumulates errors from both sides.
+     *
+     * @example
+     * ```ts
+     * const add = (a: number) => (b: number) => a + b;
+     * pipe(
+     *   Validation.passed(add),
+     *   Validation.ap(Validation.passed(5)),
+     *   Validation.ap(Validation.passed(3))
+     * ); // Passed(8)
+     *
+     * pipe(
+     *   Validation.passed(add),
+     *   Validation.ap(Validation.failed<string, number>("bad a")),
+     *   Validation.ap(Validation.failed<string, number>("bad b"))
+     * ); // Failed(["bad a", "bad b"])
+     * ```
+     */
+    const ap: <E, A>(arg: Validation<E, A>) => <B>(data: Validation<E, (a: A) => B>) => Validation<E, B>;
+    /**
+     * Extracts the value from a Validation by providing handlers for both cases.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   Validation.passed(42),
+     *   Validation.fold(
+     *     errors => `Errors: ${errors.join(", ")}`,
+     *     value => `Value: ${value}`
+     *   )
+     * );
+     * ```
+     */
+    const fold: <E, A, B>(onFailed: (errors: NonEmptyList<E>) => B, onPassed: (a: A) => B) => (data: Validation<E, A>) => B;
+    /**
+     * Pattern matches on a Validation, returning the result of the matching case.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   validation,
+     *   Validation.match({
+     *     passed: value => `Got ${value}`,
+     *     failed: errors => `Failed: ${errors.join(", ")}`
+     *   })
+     * );
+     * ```
+     */
+    const match: <E, A, B>(cases: {
+        passed: (a: A) => B;
+        failed: (errors: NonEmptyList<E>) => B;
+    }) => (data: Validation<E, A>) => B;
+    /**
+     * Returns the success value or a default value if the Validation is failed.
+     * The default can be a different type, widening the result to `A | B`.
+     *
+     * @example
+     * ```ts
+     * pipe(Validation.passed(5), Validation.getOrElse(() => 0)); // 5
+     * pipe(Validation.failed("oops"), Validation.getOrElse(() => 0)); // 0
+     * pipe(Validation.failed("oops"), Validation.getOrElse(() => null)); // null — typed as number | null
+     * ```
+     */
+    const getOrElse: <E, A, B>(defaultValue: () => B) => (data: Validation<E, A>) => A | B;
+    /**
+     * Executes a side effect on the success value without changing the Validation.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   Validation.passed(5),
+     *   Validation.tap(n => console.log("Value:", n)),
+     *   Validation.map(n => n * 2)
+     * );
+     * ```
+     */
+    const tap: <E, A>(f: (a: A) => void) => (data: Validation<E, A>) => Validation<E, A>;
+    /**
+     * Executes a side effect on the accumulated errors without changing the Validation.
+     * Useful for logging or reporting validation failures.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   Validation.failed("Name required"),
+     *   Validation.tapError(errors => console.error("validation failed:", errors)),
+     *   Validation.map(toUser)
+     * );
+     * ```
+     */
+    const tapError: <E, A>(f: (errors: NonEmptyList<E>) => void) => (data: Validation<E, A>) => Validation<E, A>;
+    /**
+     * Recovers from a Failed state by providing a fallback Validation.
+     * The fallback receives the accumulated error list so callers can inspect which errors occurred.
+     * The fallback can produce a different success type, widening the result to `Validation<E, A | B>`.
+     */
+    const recover: <E, A, B>(fallback: (errors: NonEmptyList<E>) => Validation<E, B>) => (data: Validation<E, A>) => Validation<E, A | B>;
+    /**
+     * Recovers from a Failed state unless `isBlocked` returns true for any of the accumulated errors.
+     * The fallback can produce a different success type, widening the result to `Validation<E, A | B>`.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   Validation.failed("field-error"),
+     *   Validation.recoverUnless(e => e === "fatal", () => Validation.passed(0))
+     * ); // Passed(0)
+     * ```
+     */
+    const recoverUnless: <E, A, B>(isBlocked: (e: E) => boolean, fallback: () => Validation<E, B>) => (data: Validation<E, A>) => Validation<E, A | B>;
+    /**
+     * Converts a Validation to a Result.
+     * Passed becomes Ok, Failed becomes Err with the accumulated error list.
+     *
+     * @example
+     * ```ts
+     * Validation.toResult(Validation.passed(42));        // Ok(42)
+     * Validation.toResult(Validation.failed("oops"));  // Err(["oops"])
+     * ```
+     */
+    const toResult: <E, A>(data: Validation<E, A>) => Result<NonEmptyList<E>, A>;
+    /**
+     * Converts a Validation to a Maybe. `Passed` becomes `Some`; `Failed` becomes `None`
+     * (errors are discarded).
+     *
+     * @example
+     * ```ts
+     * Validation.toMaybe(Validation.passed(42));       // Some(42)
+     * Validation.toMaybe(Validation.failed("bad"));  // None
+     * ```
+     */
+    const toMaybe: <E, A>(data: Validation<E, A>) => Maybe<A>;
+    /**
+     * Converts a `Result` to a `Validation`. `Ok` becomes `Passed`; `Err(e)` becomes `Failed([e])`.
+     *
+     * Useful when bridging from error-short-circuiting `Result` pipelines into
+     * error-accumulating `Validation` pipelines.
+     *
+     * @example
+     * ```ts
+     * Validation.fromResult(Result.ok(42));       // Passed(42)
+     * Validation.fromResult(Result.err("bad"));   // Failed(["bad"])
+     * ```
+     */
+    const fromResult: <E, A>(data: Result<E, A>) => Validation<E, A>;
+    /**
+     * Combines two independent Validation instances into a tuple.
+     * If both are Passed, returns Passed with both values as a tuple.
+     * If either is Failed, accumulates errors from both sides.
+     *
+     * @example
+     * ```ts
+     * Validation.product(
+     *   Validation.passed("alice"),
+     *   Validation.passed(30)
+     * ); // Passed(["alice", 30])
+     *
+     * Validation.product(
+     *   Validation.failed("Name required"),
+     *   Validation.failed("Age must be >= 0")
+     * ); // Failed(["Name required", "Age must be >= 0"])
+     * ```
+     */
+    const product: <E, A, B>(first: Validation<E, A>, second: Validation<E, B>) => Validation<E, readonly [A, B]>;
+    /**
+     * Combines a non-empty list of Validation instances, accumulating all errors.
+     * If all are Passed, returns Passed with all values collected into an array.
+     * If any are Failed, returns Failed with all accumulated errors.
+     *
+     * @example
+     * ```ts
+     * Validation.productAll([
+     *   validateName(name),
+     *   validateEmail(email),
+     *   validateAge(age)
+     * ]);
+     * // Passed([name, email, age]) or Failed([...all errors])
+     * ```
+     */
+    const productAll: <E, A>(data: NonEmptyList<Validation<E, A>>) => Validation<E, readonly A[]>;
+    /**
+     * Combines a record of Validations into a single Validation of a record.
+     * Accumulates all failed branches' errors.
+     *
+     * @example
+     * ```ts
+     * Validation.struct({
+     *   name: Validation.passed("Alice"),
+     *   age: Validation.passed(30)
+     * }); // Passed({ name: "Alice", age: 30 })
+     *
+     * Validation.struct({
+     *   name: Validation.failed("Name required"),
+     *   age: Validation.failed("Age must be >= 0")
+     * }); // Failed(["Name required", "Age must be >= 0"])
+     * ```
+     */
+    const struct: <E, R extends Record<string, any>>(fields: { [K in keyof R]: Validation<E, R[K]>; }) => Validation<E, R>;
+}
+
 export { Combinable, Deferred, type Failed, type Failure, Lazy, Lens, type Loading, Logged, Maybe, type NotAsked, Op, Optional, type Passed, Predicate, Reader, Refinement, RemoteData, Resource, Result, State, type Success, Task, TaskMaybe, TaskResult, TaskValidation, These, type TheseBoth, type TheseFirst, type TheseSecond, Tuple, Validation };