@nlozgachev/pipelined 0.63.0 → 0.64.0

package/dist/index.mjs

@@ -2588,22 +2588,120 @@ function interpretFn(op, options) {
   }
 }
 var Op = {
-  nil: makeNil,
+  make: {
+    /**
+     * Creates an Ok outcome with the given value.
+     *
+     * @example
+     * ```ts
+     * Op.make.ok(42); // { kind: "OpOk", value: 42 }
+     * ```
+     */
+    ok: makeOk,
+    /**
+     * Creates an Err outcome with the given error.
+     *
+     * @example
+     * ```ts
+     * Op.make.err("Something went wrong"); // { kind: "OpErr", error: "Something went wrong" }
+     * ```
+     */
+    err: makeErr,
+    /**
+     * Creates a Nil outcome with the given cancellation/drop reason.
+     *
+     * @example
+     * ```ts
+     * Op.make.nil("aborted"); // { kind: "OpNil", reason: "aborted" }
+     * ```
+     */
+    nil: makeNil
+  },
+  is: {
+    /**
+     * Type guard that checks if an Op state is Idle.
+     *
+     * @example
+     * ```ts
+     * if (Op.is.idle(manager.state)) {
+     *   console.log("Ready to execute");
+     * }
+     * ```
+     */
+    idle: isIdle,
+    /**
+     * Type guard that checks if an Op state is Pending (actively executing).
+     *
+     * @example
+     * ```ts
+     * if (Op.is.pending(manager.state)) {
+     *   showSpinner();
+     * }
+     * ```
+     */
+    pending: isPending,
+    /**
+     * Type guard that checks if an Op state is Queued (waiting in a concurrency queue).
+     *
+     * @example
+     * ```ts
+     * if (Op.is.queued(manager.state)) {
+     *   console.log("Position in queue:", manager.state.position);
+     * }
+     * ```
+     */
+    queued: isQueued,
+    /**
+     * Type guard that checks if an Op state is Retrying after a failure.
+     *
+     * @example
+     * ```ts
+     * if (Op.is.retrying(manager.state)) {
+     *   console.log("Retry attempt:", manager.state.attempt);
+     * }
+     * ```
+     */
+    retrying: isRetrying,
+    /**
+     * Type guard that checks if an Op state or outcome is Ok.
+     *
+     * @example
+     * ```ts
+     * if (Op.is.ok(outcome)) {
+     *   render(outcome.value);
+     * }
+     * ```
+     */
+    ok: isOk,
+    /**
+     * Type guard that checks if an Op state or outcome is Err.
+     *
+     * @example
+     * ```ts
+     * if (Op.is.err(outcome)) {
+     *   showError(outcome.error);
+     * }
+     * ```
+     */
+    err: isErr,
+    /**
+     * Type guard that checks if an Op state or outcome is Nil.
+     *
+     * @example
+     * ```ts
+     * if (Op.is.nil(outcome)) {
+     *   console.log("Skipped due to:", outcome.reason);
+     * }
+     * ```
+     */
+    nil: isNil
+  },
   create: (factory, onError) => ({
     _factory: (input, signal) => Deferred.from.Promise(
       factory(signal)(input).then((value) => Result.make.ok(value)).catch((error) => signal.aborted ? null : Result.make.err(onError(error)))
     )
   }),
   lift: (f) => Op.create((signal) => (input) => f(input, signal), (e) => e),
-  ok: makeOk,
-  err: makeErr,
-  isIdle,
-  isPending,
-  isQueued,
-  isRetrying,
-  isOk,
-  isErr,
-  isNil,
   match: (cases) => (outcome) => {
     if (outcome.kind === "OpOk") {
       return cases.ok(outcome.value);
@@ -4759,9 +4857,9 @@ var Stream = {
 var makeSome2 = (value) => Task.resolve(Maybe.make.some(value));
 var makeNone2 = () => Task.resolve(Maybe.make.none());
 var mapTaskMaybe = (f) => (data) => Task.map(Maybe.map(f))(data);
-var chainTaskMaybe = (f) => (data) => Task.chain(
-  (option) => Maybe.is.some(option) ? f(option.value) : Task.resolve(Maybe.make.none())
-)(data);
+var chainTaskMaybe = (f) => (data) => Task.chain((option) => Maybe.is.some(option) ? f(option.value) : Task.resolve(Maybe.make.none()))(
+  data
+);
 var TaskMaybe = {
   /**
    * Wraps a value in a Some inside a Task.
@@ -4794,8 +4892,6 @@ var TaskMaybe = {
      */
     none: makeNone2
   },
-  some: makeSome2,
-  none: makeNone2,
   // --- from ---
   from: {
     /**
@@ -4931,7 +5027,7 @@ var TaskMaybe = {
    *
    * @example
    * ```ts
-   * pipe(Task.Maybe.some(42), Task.Maybe.bindTo("value")); // Task.Maybe({ value: 42 })
+   * pipe(Task.Maybe.make.some(42), Task.Maybe.bindTo("value")); // Task.Maybe({ value: 42 })
    * ```
    */
   bindTo: (key) => (data) => mapTaskMaybe((a) => ({ [key]: a }))(data),
@@ -4941,8 +5037,8 @@ var TaskMaybe = {
    * @example
    * ```ts
    * pipe(
-   *   Task.Maybe.some({ a: 1 }),
-   *   Task.Maybe.bind("b", ({ a }) => Task.Maybe.some(a + 1))
+   *   Task.Maybe.make.some({ a: 1 }),
+   *   Task.Maybe.bind("b", ({ a }) => Task.Maybe.make.some(a + 1))
    * ); // Task.Maybe({ a: 1, b: 2 })
    * ```
    */
@@ -4955,14 +5051,12 @@ var TaskMaybe = {
    * @example
    * ```ts
    * pipe(
-   *   Task.Maybe.none(),
-   *   Task.Maybe.recover(() => Task.Maybe.some(42))
+   *   Task.Maybe.make.none(),
+   *   Task.Maybe.recover(() => Task.Maybe.make.some(42))
    * ); // Task.Maybe(42)
    * ```
    */
-  recover: (fallback) => (data) => Task.chain((maybe) => Maybe.is.none(maybe) ? fallback() : Task.resolve(maybe))(
-    data
-  ),
+  recover: (fallback) => (data) => Task.chain((maybe) => Maybe.is.none(maybe) ? fallback() : Task.resolve(maybe))(data),
   /**
    * Combines a record of Task.Maybes into a single Task.Maybe of a record.
    * Evaluates fields in parallel and returns None if any task resolves to None.
@@ -4970,8 +5064,8 @@ var TaskMaybe = {
    * @example
    * ```ts
    * Task.Maybe.struct({
-   *   name: Task.Maybe.some("Alice"),
-   *   age: Task.Maybe.some(30)
+   *   name: Task.Maybe.make.some("Alice"),
+   *   age: Task.Maybe.make.some(30)
    * }); // Task.Maybe({ name: "Alice", age: 30 })
    * ```
    */
@@ -5032,8 +5126,6 @@ var TaskResult = {
      */
     err: makeErr3
   },
-  ok: makeOk3,
-  err: makeErr3,
   // --- from ---
   from: {
     /**
@@ -5075,7 +5167,7 @@ var TaskResult = {
      *
      * @example
      * ```ts
-     * const taskResult = Task.Result.ok(42);
+     * const taskResult = Task.Result.make.ok(42);
      * const taskMaybe = pipe(taskResult, Task.Result.to.Maybe);
      * ```
      */
@@ -5138,7 +5230,7 @@ var TaskResult = {
    *   fetchTask,
    *   Task.Result.recoverUnless(
    *     (e) => e === "fatal",
-   *     () => Task.Result.ok("fallback")
+   *     () => Task.Result.make.ok("fallback")
    *   )
    * );
    * ```
@@ -5201,7 +5293,7 @@ var TaskResult = {
    *
    * @example
    * ```ts
-   * pipe(Task.Result.ok(42), Task.Result.bindTo("value")); // Task.Result({ value: 42 })
+   * pipe(Task.Result.make.ok(42), Task.Result.bindTo("value")); // Task.Result({ value: 42 })
    * ```
    */
   bindTo: (key) => (data) => mapTaskResult((a) => ({ [key]: a }))(data),
@@ -5211,8 +5303,8 @@ var TaskResult = {
    * @example
    * ```ts
    * pipe(
-   *   Task.Result.ok({ a: 1 }),
-   *   Task.Result.bind("b", ({ a }) => Task.Result.ok(a + 1))
+   *   Task.Result.make.ok({ a: 1 }),
+   *   Task.Result.bind("b", ({ a }) => Task.Result.make.ok(a + 1))
    * ); // Task.Result({ a: 1, b: 2 })
    * ```
    */
@@ -5227,8 +5319,8 @@ var TaskResult = {
    * @example
    * ```ts
    * Task.Result.struct({
-   *   name: Task.Result.ok("Alice"),
-   *   age: Task.Result.ok(30)
+   *   name: Task.Result.make.ok("Alice"),
+   *   age: Task.Result.make.ok(30)
    * }); // Task.Result({ name: "Alice", age: 30 })
    * ```
    */
@@ -5348,1553 +5440,1550 @@ var TaskResult = {
 // src/internal/InternalTypes.ts
 var isNonEmptyArr = (list) => list.length > 0;
 
-// src/Core/TaskValidation.ts
-var makePassed = (value) => Task.resolve(Validation.make.passed(value));
-var makeFailed = (error) => Task.resolve(Validation.make.failed(error));
-var makeFailedAll = (errors) => Task.resolve(Validation.make.failedAll(errors));
-var TaskValidation = {
+// src/Core/Validation.ts
+var makePassed = (value) => ({ kind: "Passed", value });
+var makeFailed = (error) => ({ kind: "Failed", errors: [error] });
+var makeFailedAll = (errors) => ({ kind: "Failed", errors });
+var isPassed = (data) => data.kind === "Passed";
+var isFailed = (data) => data.kind === "Failed";
+function toResult(arg) {
+  if (typeof arg === "function") {
+    const combine = arg;
+    return (val) => isPassed(val) ? Result.make.ok(val.value) : Result.make.err(combine(val.errors));
+  }
+  return isPassed(arg) ? Result.make.ok(arg.value) : Result.make.err(arg.errors);
+}
+var Validation = {
   make: {
     /**
-     * Wraps a value in a passed Task.Validation.
+     * Wraps a value in a passed Validation.
      *
      * @example
      * ```ts
-     * const task = Task.Validation.make.passed(42);
-     * const res = await task(); // Passed(42)
+     * Validation.make.passed(42); // Passed(42)
      * ```
      */
     passed: makePassed,
     /**
-     * Creates a failed Task.Validation with a single error.
+     * Creates a failed Validation from a single error.
      *
      * @example
      * ```ts
-     * const task = Task.Validation.make.failed("invalid");
-     * const res = await task(); // Failed(["invalid"])
+     * Validation.make.failed("Invalid input");
      * ```
      */
     failed: makeFailed,
     /**
-     * Creates a failed Task.Validation from multiple errors.
+     * Creates a failed Validation from multiple errors.
      *
      * @example
      * ```ts
-     * const task = Task.Validation.make.failedAll(["err1", "err2"]);
-     * const res = await task(); // Failed(["err1", "err2"])
+     * Validation.make.failedAll(["Invalid input"]);
      * ```
      */
     failedAll: makeFailedAll
   },
-  passed: makePassed,
-  failed: makeFailed,
-  failedAll: makeFailedAll,
-  // --- from ---
-  from: {
+  is: {
     /**
-     * Lifts a Validation into a Task.Validation.
+     * Type guard that checks if a Validation is passed.
      *
      * @example
      * ```ts
-     * Task.Validation.from.Validation(Validation.make.passed(42));
+     * const v = Validation.make.passed(42);
+     * if (Validation.is.passed(v)) {
+     *   console.log(v.value); // 42
+     * }
      * ```
      */
-    Validation: (validation) => Task.resolve(validation),
+    passed: isPassed,
     /**
-     * Creates a Task.Validation from a nullable value.
-     * If the value is null or undefined, returns Failed with the error from onNull.
-     * Otherwise, returns Passed.
+     * Type guard that checks if a Validation is failed.
      *
      * @example
      * ```ts
-     * Task.Validation.from.nullable(() => "missing")(42);   // resolves to Passed(42)
-     * Task.Validation.from.nullable(() => "missing")(null); // resolves to Failed(["missing"])
+     * const v = Validation.make.failed("invalid");
+     * if (Validation.is.failed(v)) {
+     *   console.log(v.errors); // ["invalid"]
+     * }
      * ```
      */
-    nullable: (onNull) => (value) => Task.resolve(
-      value === null || value === void 0 ? Validation.make.failed(onNull()) : Validation.make.passed(value)
-    ),
+    failed: isFailed
+  },
+  /**
+   * Creates a Validation from a synchronous thunk that may throw.
+   * Catches any errors and transforms them using the `onError` function into a Failed validation.
+   *
+   * @example
+   * ```ts
+   * const result = Validation.tryCatch(
+   *   () => JSON.parse(rawString),
+   *   { onError: (e) => `Parse error: ${e}` }
+   * );
+   * ```
+   */
+  tryCatch: (f, options) => {
+    try {
+      return makePassed(f());
+    } catch (error) {
+      return makeFailed(options.onError(error));
+    }
+  },
+  // --- from ---
+  from: {
     /**
-     * Creates a Task.Validation from a Maybe.
-     * Some becomes Passed, None becomes Failed with the error from onNone.
+     * Creates a Validation from a predicate applied to a value.
+     * Returns Passed if the predicate passes, Failed from `onFalse` otherwise.
      *
      * @example
      * ```ts
-     * Task.Validation.from.Maybe(() => "empty")(Maybe.make.some(42)); // resolves to Passed(42)
-     * Task.Validation.from.Maybe(() => "empty")(Maybe.make.none());   // resolves to Failed(["empty"])
+     * const validateName = Validation.from.Predicate(
+     *   (s: string) => s.length > 0,
+     *   () => "Name is required"
+     * );
+     *
+     * validateName("Alice"); // Passed("Alice")
+     * validateName("");      // Failed(["Name is required"])
      * ```
      */
-    Maybe: (onNone) => (maybe) => Task.resolve(
-      Maybe.is.none(maybe) ? Validation.make.failed(onNone()) : Validation.make.passed(maybe.value)
-    ),
+    Predicate: (pred, onFalse) => (a) => pred(a) ? makePassed(a) : makeFailed(onFalse(a)),
     /**
-     * Creates a Task.Validation from a Result.
-     * Ok becomes Passed, Err(e) becomes Failed([e]).
+     * Creates a Validation from a nullable value.
+     * If the value is null or undefined, returns Failed with the error from onNull.
+     * Otherwise, returns Passed.
      *
      * @example
      * ```ts
-     * Task.Validation.from.Result(Result.make.ok(42));     // resolves to Passed(42)
-     * Task.Validation.from.Result(Result.make.err("bad")); // resolves to Failed(["bad"])
+     * pipe(null, Validation.from.nullable(() => "is null")); // Failed(["is null"])
+     * pipe(42, Validation.from.nullable(() => "is null"));   // Passed(42)
      * ```
      */
-    Result: (result) => Task.resolve(Validation.from.Result(result))
-  },
-  // --- to ---
-  to: {
+    nullable: (onNull) => (value) => value === null || value === void 0 ? makeFailed(onNull()) : makePassed(value),
     /**
-     * Converts a `Task.Validation` to a `Task.Result`, combining accumulated errors using `combineErrors`.
-     * `Passed(a)` becomes `Ok(a)`; `Failed(errors)` becomes `Err(combineErrors(errors))`.
+     * Creates a Validation from a Maybe.
+     * If the Maybe is None, returns Failed with the error from onNone.
+     * Otherwise, returns Passed.
      *
      * @example
      * ```ts
-     * Task.Validation.to.Result((errors) => errors.join(", "))(validationTask);
+     * pipe(Maybe.make.none(), Validation.from.Maybe(() => "is none")); // Failed(["is none"])
+     * pipe(Maybe.make.some(42), Validation.from.Maybe(() => "is none")); // Passed(42)
      * ```
      */
-    Result: (combineErrors) => (data) => Task.map(Validation.to.Result(combineErrors))(data),
+    Maybe: (onNone) => (maybe) => Maybe.is.none(maybe) ? makeFailed(onNone()) : makePassed(maybe.value),
     /**
-     * Converts a `Task.Validation` to a `Task.Maybe`.
-     * `Passed(a)` becomes `Some(a)`; `Failed(errors)` becomes `None` (errors are discarded).
+     * Converts a `Result` to a `Validation`. `Ok` becomes `Passed`; `Err(e)` becomes `Failed([e])`.
+     *
+     * Useful when bridging from error-short-circuiting `Result` pipelines into
+     * error-accumulating `Validation` pipelines.
      *
      * @example
      * ```ts
-     * Task.Validation.to.Maybe(validationTask);
+     * Validation.from.Result(Result.make.ok(42));       // Passed(42)
+     * Validation.from.Result(Result.make.err("bad"));   // Failed(["bad"])
      * ```
      */
-    Maybe: (data) => Task.map(Validation.to.Maybe)(data)
+    Result: (data) => data.kind === "Ok" ? makePassed(data.value) : makeFailed(data.error)
   },
   /**
-   * Creates a Task.Validation from a Promise-returning thunk that may throw or reject.
-   * Catches any errors and transforms them using the `onError` function into a Failed validation.
-   * The thunk optionally receives an `AbortSignal` forwarded from the call site.
+   * Transforms the success value inside a Validation.
    *
    * @example
    * ```ts
-   * const loadConfig = Task.Validation.tryCatch(
-   *   (signal) => configStore.get("default", { signal }),
-   *   { onError: (e) => `Failed to load config: ${e}` }
-   * );
+   * pipe(Validation.make.passed(5), Validation.map(n => n * 2)); // Passed(10)
+   * pipe(Validation.make.failed("oops"), Validation.map(n => n * 2)); // Failed(["oops"])
    * ```
    */
-  tryCatch: (f, options) => (signal) => Deferred.from.Promise(
-    // oxlint-disable-next-line require-await
-    globalThis.Promise.resolve().then(async () => f(signal)).then(Validation.make.passed).catch(
-      (error) => Validation.make.failed(options.onError(error))
-    )
-  ),
-  /**
-   * Transforms the success value inside a Task.Validation.
-   */
-  map: (f) => (data) => Task.map(Validation.map(f))(data),
+  map: (f) => (data) => isPassed(data) ? makePassed(f(data.value)) : data,
   /**
-   * Applies a function wrapped in a Task.Validation to a value wrapped in a
-   * Task.Validation. Both Tasks run in parallel and errors from both sides
-   * are accumulated.
+   * Transforms the error list inside a Validation.
    *
    * @example
    * ```ts
-   * pipe(
-   *   Task.Validation.passed((name: string) => (age: number) => ({ name, age })),
-   *   Task.Validation.ap(validateName(name)),
-   *   Task.Validation.ap(validateAge(age))
-   * )();
+   * pipe(Validation.make.failed("oops"), Validation.mapError(e => e.toUpperCase())); // Failed(["OOPS"])
    * ```
    */
-  ap: (arg) => (data) => (signal) => Deferred.from.Promise(
-    Promise.all([Deferred.to.Promise(data(signal)), Deferred.to.Promise(arg(signal))]).then(
-      ([vf, va]) => Validation.ap(va)(vf)
-    )
-  ),
-  /**
-   * Extracts a value from a Task.Validation by providing handlers for both cases.
-   */
-  fold: (onFailed, onPassed) => (data) => Task.map(Validation.fold(onFailed, onPassed))(data),
+  mapError: (f) => (data) => isFailed(data) ? makeFailedAll(data.errors.map(f)) : data,
   /**
-   * Pattern matches on a Task.Validation, returning a Task of the result.
+   * 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(
-   *   validateForm(input),
-   *   Task.Validation.match({
-   *     passed: data => save(data),
-   *     failed: errors => showErrors(errors)
-   *   })
-   * )();
+   *   Validation.make.passed(add),
+   *   Validation.ap(Validation.make.passed(5)),
+   *   Validation.ap(Validation.make.passed(3))
+   * ); // Passed(8)
+   *
+   * pipe(
+   *   Validation.make.passed(add),
+   *   Validation.ap(Validation.make.failed<string>("bad a")),
+   *   Validation.ap(Validation.make.failed<string>("bad b"))
+   * ); // Failed(["bad a", "bad b"])
    * ```
    */
-  match: (cases) => (data) => Task.map(Validation.match(cases))(data),
-  /**
-   * Returns the success value or a default value if the Task.Validation is failed.
-   * The default can be a different type, widening the result to `Task<A | B>`.
-   */
-  getOrElse: (defaultValue) => (data) => Task.map(Validation.getOrElse(defaultValue))(data),
-  /**
-   * Executes a side effect on the success value without changing the Task.Validation.
-   * Useful for logging or debugging.
-   */
-  tap: (f) => (data) => Task.map(Validation.tap(f))(data),
-  /**
-   * Recovers from a Failed state by providing a fallback Task.Validation.
-   * The fallback receives the accumulated error list so callers can inspect which errors occurred.
-   * The fallback can produce a different success type, widening the result to `Task.Validation<E, A | B>`.
-   */
-  recover: (fallback) => (data) => Task.chain(
-    (validation) => Validation.is.passed(validation) ? Task.resolve(validation) : fallback(validation.errors)
-  )(data),
+  ap: (arg) => (data) => {
+    if (isPassed(data)) {
+      return isPassed(arg) ? makePassed(data.value(arg.value)) : makeFailedAll(arg.errors);
+    }
+    return isPassed(arg) ? makeFailedAll(data.errors) : makeFailedAll([...data.errors, ...arg.errors]);
+  },
   /**
-   * Recovers from a Failed state unless the predicate `isBlocked` returns true for the accumulated errors.
-   * The fallback receives the accumulated errors and can produce a different success type, widening the result to `Task.Validation<E, A | B>`.
+   * Applies a function wrapped in a Validation to a value wrapped in a Validation,
+   * using a custom error concatenator function when both sides fail.
    *
    * @example
    * ```ts
-   * pipe(
-   *   validationTask,
-   *   Task.Validation.recoverUnless(
-   *     (errors) => errors.includes("fatal"),
-   *     (errors) => Task.Validation.passed("fallback")
-   *   )
-   * );
+   * const concat = (e1: NonEmptyArr<string>, e2: NonEmptyArr<string>): NonEmptyArr<string> =>
+   *   [...e1, ...e2];
+   * pipe(fnVal, Validation.apCustom(concat)(argVal));
    * ```
    */
-  recoverUnless: (isBlocked, fallback) => (data) => Task.chain(
-    (validation) => Validation.is.passed(validation) ? Task.resolve(validation) : isBlocked(validation.errors) ? Task.resolve(validation) : fallback(validation.errors)
-  )(data),
+  apCustom: (concat2) => (arg) => (data) => {
+    if (isPassed(data)) {
+      return isPassed(arg) ? makePassed(data.value(arg.value)) : makeFailedAll(arg.errors);
+    }
+    return isPassed(arg) ? makeFailedAll(data.errors) : makeFailedAll(concat2(data.errors, arg.errors));
+  },
   /**
-   * Runs two Task.Validations concurrently and combines their results into a tuple.
-   * If both are Passed, returns Passed with both values. If either fails, accumulates
-   * errors from both sides.
+   * Extracts the value from a Validation by providing handlers for both cases.
    *
    * @example
    * ```ts
-   * await Task.Validation.product(
-   *   validateName(form.name),
-   *   validateAge(form.age),
-   * )(); // Passed(["Alice", 30]) or Failed([...errors])
+   * pipe(
+   *   Validation.make.passed(42),
+   *   Validation.fold(
+   *     errors => `Errors: ${errors.join(", ")}`,
+   *     value => `Value: ${value}`
+   *   )
+   * );
    * ```
    */
-  product: (first, second) => (signal) => Deferred.from.Promise(
-    Promise.all([Deferred.to.Promise(first(signal)), Deferred.to.Promise(second(signal))]).then(
-      ([va, vb]) => Validation.product(va, vb)
-    )
-  ),
+  fold: (onFailed, onPassed) => (data) => isPassed(data) ? onPassed(data.value) : onFailed(data.errors),
   /**
-   * Runs all Task.Validations concurrently and collects results.
-   * If all are Passed, returns Passed with all values as an array.
-   * If any fail, returns Failed with all accumulated errors.
+   * Pattern matches on a Validation, returning the result of the matching case.
    *
    * @example
    * ```ts
-   * await Task.Validation.productAll([
-   *   validateName(form.name),
-   *   validateEmail(form.email),
-   *   validateAge(form.age),
-   * ])(); // Passed([name, email, age]) or Failed([...all errors])
+   * pipe(
+   *   validation,
+   *   Validation.match({
+   *     passed: value => `Got ${value}`,
+   *     failed: errors => `Failed: ${errors.join(", ")}`
+   *   })
+   * );
    * ```
    */
-  productAll: (data) => (signal) => Deferred.from.Promise(
-    Promise.all(data.map((t) => Deferred.to.Promise(t(signal)))).then((results) => {
-      const [first, ...rest] = results;
-      return Validation.productAll([first, ...rest]);
-    })
-  ),
+  match: (cases) => (data) => isPassed(data) ? cases.passed(data.value) : cases.failed(data.errors),
   /**
-   * Transforms all accumulated errors inside a Task.Validation.
+   * Returns the success value or a default value if the Validation is failed.
+   * The default can be a different type, widening the result to `A | B`.
    *
    * @example
    * ```ts
-   * pipe(
-   *   Task.Validation.failed("oops"),
-   *   Task.Validation.mapError(e => e.toUpperCase())
-   * ); // Task.Validation(Failed(["OOPS"]))
+   * pipe(Validation.make.passed(5), Validation.getOrElse(() => 0)); // 5
+   * pipe(Validation.make.failed("oops"), Validation.getOrElse(() => 0)); // 0
+   * pipe(Validation.make.failed("oops"), Validation.getOrElse(() => null)); // null — typed as number | null
    * ```
    */
-  mapError: (f) => (data) => Task.map(Validation.mapError(f))(data),
+  getOrElse: (defaultValue) => (data) => isPassed(data) ? data.value : defaultValue(),
   /**
-   * Executes a side effect on the accumulated errors without changing the Task.Validation.
+   * Executes a side effect on the success value without changing the Validation.
    *
    * @example
    * ```ts
    * pipe(
-   *   Task.Validation.failed("invalid name"),
-   *   Task.Validation.tapError(errs => logger.error(errs))
+   *   Validation.make.passed(5),
+   *   Validation.tap(n => console.log("Value:", n)),
+   *   Validation.map(n => n * 2)
    * );
    * ```
    */
-  tapError: (f) => (data) => Task.map(Validation.tapError(f))(data),
+  tap: (f) => (data) => {
+    if (isPassed(data)) {
+      f(data.value);
+    }
+    return data;
+  },
   /**
-   * Combines a record of Task.Validations into a single Task.Validation of a record.
-   * Evaluates fields in parallel and accumulates all validation errors.
+   * Executes a side effect on the accumulated errors without changing the Validation.
+   * Useful for logging or reporting validation failures.
    *
    * @example
    * ```ts
-   * Task.Validation.struct({
-   *   name: Task.Validation.passed("Alice"),
-   *   age: Task.Validation.passed(30)
-   * }); // Task.Validation({ name: "Alice", age: 30 })
+   * pipe(
+   *   Validation.make.failed("Name required"),
+   *   Validation.tapError(errors => console.error("validation failed:", errors)),
+   *   Validation.map(toUser)
+   * );
    * ```
    */
-  struct: (fields) => (signal) => Deferred.from.Promise((() => {
-    const keys3 = Object.keys(fields);
-    const promises = keys3.map((key) => Deferred.to.Promise(fields[key](signal)));
-    return Promise.all(promises).then((results) => {
-      const record = {};
-      const errors = [];
-      for (let i = 0; i < keys3.length; i++) {
-        const res = results[i];
-        if (Validation.is.passed(res)) {
-          record[keys3[i]] = res.value;
-        } else {
-          errors.push(...res.errors);
-        }
-      }
-      return isNonEmptyArr(errors) ? Validation.make.failedAll(errors) : Validation.make.passed(record);
-    });
-  })()),
+  tapError: (f) => (data) => {
+    if (isFailed(data)) {
+      f(data.errors);
+    }
+    return data;
+  },
   /**
-   * Creates a memoized version of a Task.Validation. The task is executed at most once on first call,
-   * and its resolved Validation is cached for all subsequent calls.
-   *
-   * @example
-   * ```ts
-   * const validate = Task.Validation.memoize(validateFormTask);
-   * ```
+   * 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>`.
    */
-  memoize: (task) => Task.memoize(task)
-};
-
-// src/Core/Task.ts
-var toPromise2 = (task, signal) => Deferred.to.Promise(task(signal));
-var fromPromise2 = (f) => (signal) => Deferred.from.Promise(f(signal));
-var getMs2 = (duration) => Duration.to.milliseconds(duration);
-var resolveTask = (value) => () => Deferred.from.Promise(globalThis.Promise.resolve(value));
-var syncTask = (f) => () => Deferred.from.Promise(globalThis.Promise.resolve(f()));
-var Task = {
+  recover: (fallback) => (data) => isPassed(data) ? data : fallback(data.errors),
   /**
-   * Creates a Task that immediately resolves to the given value.
+   * Recovers from a Failed state unless `isBlocked` returns true for any of the accumulated errors.
+   * The fallback can produce a different success type, widening the result to `Validation<E, A | B>`.
    *
    * @example
    * ```ts
-   * const task = Task.resolve(42);
-   * const value = await task(); // 42
+   * pipe(
+   *   Validation.make.failed("field-error"),
+   *   Validation.recoverUnless(e => e === "fatal", () => Validation.make.passed(0))
+   * ); // Passed(0)
    * ```
    */
-  resolve: resolveTask,
-  // --- from ---
-  from: {
+  recoverUnless: (isBlocked, fallback) => (data) => isFailed(data) && !data.errors.some(isBlocked) ? fallback() : data,
+  // --- to ---
+  to: {
     /**
-     * Creates a Task from a lazy synchronous thunk.
-     * Unlike `Task.resolve(f())`, `from.sync` does not evaluate `f` until the Task is called.
+     * Converts a Validation to a Result.
+     * Passed becomes Ok.
+     * Direct call converts Failed to Err with accumulated error list `NonEmptyArr<E>`.
+     * Curried call converts Failed to Err with combined error `E2` via `combineErrors`.
      *
      * @example
      * ```ts
-     * const t = Task.from.sync(() => Date.now()); // Date.now() not called yet
-     * const ts = await t(); // called here, every time
+     * Validation.to.Result(Validation.make.passed(42));        // Ok(42)
+     * Validation.to.Result(Validation.make.failed("oops"));  // Err(["oops"])
+     * pipe(Validation.make.failed("oops"), Validation.to.Result(errors => errors.join(", "))); // Err("oops")
      * ```
      */
-    sync: syncTask
+    Result: toResult,
+    /**
+     * Converts a Validation to a Maybe. `Passed` becomes `Some`; `Failed` becomes `None`
+     * (errors are discarded).
+     *
+     * @example
+     * ```ts
+     * Validation.to.Maybe(Validation.make.passed(42));       // Some(42)
+     * Validation.to.Maybe(Validation.make.failed("bad"));  // None
+     * ```
+     */
+    Maybe: (data) => isPassed(data) ? Maybe.make.some(data.value) : Maybe.make.none()
   },
   /**
-   * Wraps a Promise-returning thunk that may throw or reject,
-   * trapping errors with a fallback function and returning a guaranteed `Task<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
-   * const loadConfig = Task.tryCatch(
-   *   () => configStore.get("default"),
-   *   { onError: () => DEFAULT_CONFIG }
-   * );
+   * Validation.product(
+   *   Validation.make.passed("alice"),
+   *   Validation.make.passed(30)
+   * ); // Passed(["alice", 30])
+   *
+   * Validation.product(
+   *   Validation.make.failed("Name required"),
+   *   Validation.make.failed("Age must be >= 0")
+   * ); // Failed(["Name required", "Age must be >= 0"])
    * ```
    */
-  tryCatch: (f, options) => fromPromise2((signal) => globalThis.Promise.resolve().then(() => f(signal)).catch((err2) => options.onError(err2))),
+  product: (first, second) => {
+    if (isPassed(first)) {
+      return isPassed(second) ? makePassed([first.value, second.value]) : makeFailedAll(second.errors);
+    }
+    return isPassed(second) ? makeFailedAll(first.errors) : makeFailedAll([...first.errors, ...second.errors]);
+  },
   /**
-   * Transforms the value inside a Task.
+   * 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
-   * pipe(
-   *   Task.resolve(5),
-   *   Task.map(n => n * 2)
-   * )(); // Deferred<10>
+   * Validation.productAll([
+   *   validateName(name),
+   *   validateEmail(email),
+   *   validateAge(age)
+   * ]);
+   * // Passed([name, email, age]) or Failed([...all errors])
    * ```
    */
-  map: (f) => (data) => fromPromise2((signal) => toPromise2(data, signal).then(f)),
+  productAll: (data) => {
+    const values3 = [];
+    const errors = [];
+    for (const v of data) {
+      if (isPassed(v)) {
+        values3.push(v.value);
+      } else {
+        errors.push(...v.errors);
+      }
+    }
+    return isNonEmptyArr(errors) ? makeFailedAll(errors) : makePassed(values3);
+  },
   /**
-   * Chains Task computations. Passes the resolved value of the first Task to f.
+   * Combines a record of Validations into a single Validation of a record.
+   * Accumulates all failed branches' errors.
    *
    * @example
    * ```ts
-   * const readUserId: Task<string> = Task.resolve(session.userId);
-   * const loadPrefs = (id: string): Task<Preferences> =>
-   *   Task.resolve(prefsCache.get(id));
+   * Validation.struct({
+   *   name: Validation.make.passed("Alice"),
+   *   age: Validation.make.passed(30)
+   * }); // Passed({ name: "Alice", age: 30 })
    *
-   * pipe(
-   *   readUserId,
-   *   Task.chain(loadPrefs)
-   * )(); // Deferred<Preferences>
+   * Validation.struct({
+   *   name: Validation.make.failed("Name required"),
+   *   age: Validation.make.failed("Age must be >= 0")
+   * }); // Failed(["Name required", "Age must be >= 0"])
    * ```
    */
-  chain: (f) => (data) => fromPromise2((signal) => toPromise2(data, signal).then((a) => toPromise2(f(a), signal))),
+  struct: (fields) => {
+    const record = {};
+    const errors = [];
+    for (const key in fields) {
+      if (Object.hasOwn(fields, key)) {
+        const val = fields[key];
+        if (isPassed(val)) {
+          record[key] = val.value;
+        } else {
+          errors.push(...val.errors);
+        }
+      }
+    }
+    return isNonEmptyArr(errors) ? makeFailedAll(errors) : makePassed(record);
+  }
+};
+
+// src/Core/TaskValidation.ts
+var makePassed2 = (value) => Task.resolve(Validation.make.passed(value));
+var makeFailed2 = (error) => Task.resolve(Validation.make.failed(error));
+var makeFailedAll2 = (errors) => Task.resolve(Validation.make.failedAll(errors));
+var TaskValidation = {
+  make: {
+    /**
+     * Wraps a value in a passed Task.Validation.
+     *
+     * @example
+     * ```ts
+     * const task = Task.Validation.make.passed(42);
+     * const res = await task(); // Passed(42)
+     * ```
+     */
+    passed: makePassed2,
+    /**
+     * Creates a failed Task.Validation with a single error.
+     *
+     * @example
+     * ```ts
+     * const task = Task.Validation.make.failed("invalid");
+     * const res = await task(); // Failed(["invalid"])
+     * ```
+     */
+    failed: makeFailed2,
+    /**
+     * Creates a failed Task.Validation from multiple errors.
+     *
+     * @example
+     * ```ts
+     * const task = Task.Validation.make.failedAll(["err1", "err2"]);
+     * const res = await task(); // Failed(["err1", "err2"])
+     * ```
+     */
+    failedAll: makeFailedAll2
+  },
+  // --- from ---
+  from: {
+    /**
+     * Lifts a Validation into a Task.Validation.
+     *
+     * @example
+     * ```ts
+     * Task.Validation.from.Validation(Validation.make.passed(42));
+     * ```
+     */
+    Validation: (validation) => Task.resolve(validation),
+    /**
+     * Creates a Task.Validation from a nullable value.
+     * If the value is null or undefined, returns Failed with the error from onNull.
+     * Otherwise, returns Passed.
+     *
+     * @example
+     * ```ts
+     * Task.Validation.from.nullable(() => "missing")(42);   // resolves to Passed(42)
+     * Task.Validation.from.nullable(() => "missing")(null); // resolves to Failed(["missing"])
+     * ```
+     */
+    nullable: (onNull) => (value) => Task.resolve(
+      value === null || value === void 0 ? Validation.make.failed(onNull()) : Validation.make.passed(value)
+    ),
+    /**
+     * Creates a Task.Validation from a Maybe.
+     * Some becomes Passed, None becomes Failed with the error from onNone.
+     *
+     * @example
+     * ```ts
+     * Task.Validation.from.Maybe(() => "empty")(Maybe.make.some(42)); // resolves to Passed(42)
+     * Task.Validation.from.Maybe(() => "empty")(Maybe.make.none());   // resolves to Failed(["empty"])
+     * ```
+     */
+    Maybe: (onNone) => (maybe) => Task.resolve(
+      Maybe.is.none(maybe) ? Validation.make.failed(onNone()) : Validation.make.passed(maybe.value)
+    ),
+    /**
+     * Creates a Task.Validation from a Result.
+     * Ok becomes Passed, Err(e) becomes Failed([e]).
+     *
+     * @example
+     * ```ts
+     * Task.Validation.from.Result(Result.make.ok(42));     // resolves to Passed(42)
+     * Task.Validation.from.Result(Result.make.err("bad")); // resolves to Failed(["bad"])
+     * ```
+     */
+    Result: (result) => Task.resolve(Validation.from.Result(result))
+  },
+  // --- to ---
+  to: {
+    /**
+     * Converts a `Task.Validation` to a `Task.Result`, combining accumulated errors using `combineErrors`.
+     * `Passed(a)` becomes `Ok(a)`; `Failed(errors)` becomes `Err(combineErrors(errors))`.
+     *
+     * @example
+     * ```ts
+     * Task.Validation.to.Result((errors) => errors.join(", "))(validationTask);
+     * ```
+     */
+    Result: (combineErrors) => (data) => Task.map(Validation.to.Result(combineErrors))(data),
+    /**
+     * Converts a `Task.Validation` to a `Task.Maybe`.
+     * `Passed(a)` becomes `Some(a)`; `Failed(errors)` becomes `None` (errors are discarded).
+     *
+     * @example
+     * ```ts
+     * Task.Validation.to.Maybe(validationTask);
+     * ```
+     */
+    Maybe: (data) => Task.map(Validation.to.Maybe)(data)
+  },
   /**
-   * Applies a function wrapped in a Task to a value wrapped in a Task.
-   * Both Tasks run in parallel.
+   * Creates a Task.Validation from a Promise-returning thunk that may throw or reject.
+   * Catches any errors and transforms them using the `onError` function into a Failed validation.
+   * The thunk optionally receives an `AbortSignal` forwarded from the call site.
    *
    * @example
    * ```ts
-   * const add = (a: number) => (b: number) => a + b;
-   * pipe(
-   *   Task.resolve(add),
-   *   Task.ap(Task.resolve(5)),
-   *   Task.ap(Task.resolve(3))
-   * )(); // Deferred<8>
+   * const loadConfig = Task.Validation.tryCatch(
+   *   (signal) => configStore.get("default", { signal }),
+   *   { onError: (e) => `Failed to load config: ${e}` }
+   * );
    * ```
    */
-  ap: (arg) => (data) => fromPromise2((signal) => Promise.all([toPromise2(data, signal), toPromise2(arg, signal)]).then(([f, a]) => f(a))),
+  tryCatch: (f, options) => (signal) => Deferred.from.Promise(
+    // oxlint-disable-next-line require-await
+    globalThis.Promise.resolve().then(async () => f(signal)).then(Validation.make.passed).catch(
+      (error) => Validation.make.failed(options.onError(error))
+    )
+  ),
   /**
-   * Executes a side effect on the value without changing the Task.
-   * Useful for logging or debugging.
+   * Transforms the success value inside a Task.Validation.
+   */
+  map: (f) => (data) => Task.map(Validation.map(f))(data),
+  /**
+   * Applies a function wrapped in a Task.Validation to a value wrapped in a
+   * Task.Validation. Both Tasks run in parallel and errors from both sides
+   * are accumulated.
    *
    * @example
    * ```ts
    * pipe(
-   *   loadConfig,
-   *   Task.tap(cfg => console.log("Config:", cfg)),
-   *   Task.map(buildReport)
-   * );
+   *   Task.Validation.make.passed((name: string) => (age: number) => ({ name, age })),
+   *   Task.Validation.ap(validateName(name)),
+   *   Task.Validation.ap(validateAge(age))
+   * )();
    * ```
    */
-  tap: (f) => (data) => fromPromise2(
-    (signal) => toPromise2(data, signal).then((a) => {
-      f(a);
-      return a;
-    })
+  ap: (arg) => (data) => (signal) => Deferred.from.Promise(
+    Promise.all([Deferred.to.Promise(data(signal)), Deferred.to.Promise(arg(signal))]).then(
+      ([vf, va]) => Validation.ap(va)(vf)
+    )
   ),
   /**
-   * Runs multiple Tasks in parallel and collects their results.
+   * Extracts a value from a Task.Validation by providing handlers for both cases.
+   */
+  fold: (onFailed, onPassed) => (data) => Task.map(Validation.fold(onFailed, onPassed))(data),
+  /**
+   * Pattern matches on a Task.Validation, returning a Task of the result.
    *
    * @example
    * ```ts
-   * Task.all([loadConfig, detectLocale, loadTheme])();
-   * // Deferred<[Config, string, Theme]>
+   * pipe(
+   *   validateForm(input),
+   *   Task.Validation.match({
+   *     passed: data => save(data),
+   *     failed: errors => showErrors(errors)
+   *   })
+   * )();
    * ```
    */
-  all: (tasks) => fromPromise2(
-    (signal) => Promise.all(tasks.map((t) => toPromise2(t, signal)))
-  ),
+  match: (cases) => (data) => Task.map(Validation.match(cases))(data),
   /**
-   * Delays the execution of a Task by the specified duration.
-   * Useful for debouncing or rate limiting.
+   * Returns the success value or a default value if the Task.Validation is failed.
+   * The default can be a different type, widening the result to `Task<A | B>`.
+   */
+  getOrElse: (defaultValue) => (data) => Task.map(Validation.getOrElse(defaultValue))(data),
+  /**
+   * Executes a side effect on the success value without changing the Task.Validation.
+   * Useful for logging or debugging.
+   */
+  tap: (f) => (data) => Task.map(Validation.tap(f))(data),
+  /**
+   * Recovers from a Failed state by providing a fallback Task.Validation.
+   * The fallback receives the accumulated error list so callers can inspect which errors occurred.
+   * The fallback can produce a different success type, widening the result to `Task.Validation<E, A | B>`.
+   */
+  recover: (fallback) => (data) => Task.chain(
+    (validation) => Validation.is.passed(validation) ? Task.resolve(validation) : fallback(validation.errors)
+  )(data),
+  /**
+   * Recovers from a Failed state unless the predicate `isBlocked` returns true for the accumulated errors.
+   * The fallback receives the accumulated errors and can produce a different success type, widening the result to `Task.Validation<E, A | B>`.
    *
    * @example
    * ```ts
    * pipe(
-   *   Task.resolve(42),
-   *   Task.delay(Duration.seconds(1))
-   * )(); // Resolves after 1 second
+   *   validationTask,
+   *   Task.Validation.recoverUnless(
+   *     (errors) => errors.includes("fatal"),
+   *     (errors) => Task.Validation.make.passed("fallback")
+   *   )
+   * );
    * ```
    */
-  delay: (duration) => (data) => fromPromise2(
-    (signal) => new Promise((res) => {
-      let timerId;
-      const onAbort = () => {
-        clearTimeout(timerId);
-        res(toPromise2(data, signal));
-      };
-      if (signal) {
-        if (signal.aborted) {
-          return res(toPromise2(data, signal));
-        }
-        signal.addEventListener("abort", onAbort, { once: true });
-      }
-      timerId = setTimeout(() => {
-        signal?.removeEventListener("abort", onAbort);
-        res(toPromise2(data, signal));
-      }, getMs2(duration));
-    })
-  ),
+  recoverUnless: (isBlocked, fallback) => (data) => Task.chain(
+    (validation) => Validation.is.passed(validation) ? Task.resolve(validation) : isBlocked(validation.errors) ? Task.resolve(validation) : fallback(validation.errors)
+  )(data),
   /**
-   * Runs a Task a fixed number of times sequentially, collecting all results into an array.
-   * An optional delay duration can be inserted between runs.
+   * Runs two Task.Validations concurrently and combines their results into a tuple.
+   * If both are Passed, returns Passed with both values. If either fails, accumulates
+   * errors from both sides.
    *
    * @example
    * ```ts
-   * pipe(
-   *   pollSensor,
-   *   Task.repeat({ times: 5, delay: Duration.seconds(1) })
-   * )(); // Task<Reading[]> — 5 readings, one per second
+   * await Task.Validation.product(
+   *   validateName(form.name),
+   *   validateAge(form.age),
+   * )(); // Passed(["Alice", 30]) or Failed([...errors])
    * ```
    */
-  repeat: (options) => (task) => fromPromise2((signal) => {
-    const { times, delay: delayDuration } = options;
-    if (times <= 0) {
-      return Promise.resolve([]);
-    }
-    const results = [];
-    const wait = () => new Promise((r) => {
-      let timerId;
-      const onAbort = () => {
-        clearTimeout(timerId);
-        r();
-      };
-      if (signal) {
-        signal.addEventListener("abort", onAbort, { once: true });
-      }
-      timerId = setTimeout(() => {
-        signal?.removeEventListener("abort", onAbort);
-        r();
-      }, delayDuration ? getMs2(delayDuration) : 0);
-    });
-    const run = (left) => {
-      if (signal?.aborted) {
-        return Promise.resolve(results);
-      }
-      return toPromise2(task, signal).then((a) => {
-        results.push(a);
-        if (left <= 1 || signal?.aborted) {
-          return results;
-        }
-        return wait().then(() => run(left - 1));
-      });
-    };
-    return run(times);
-  }),
+  product: (first, second) => (signal) => Deferred.from.Promise(
+    Promise.all([Deferred.to.Promise(first(signal)), Deferred.to.Promise(second(signal))]).then(
+      ([va, vb]) => Validation.product(va, vb)
+    )
+  ),
   /**
-   * Runs a Task repeatedly until the result satisfies a predicate, returning that result.
-   * An optional delay duration can be inserted between runs.
-   * An optional `maxAttempts` cap stops the loop after N calls — the last value is returned
-   * regardless of whether the predicate was satisfied.
+   * Runs all Task.Validations concurrently and collects results.
+   * If all are Passed, returns Passed with all values as an array.
+   * If any fail, returns Failed with all accumulated errors.
    *
    * @example
    * ```ts
-   * pipe(
-   *   checkStatus,
-   *   Task.repeatUntil({ when: (s) => s === "ready", delay: Duration.milliseconds(500) })
-   * )(); // polls every 500ms until status is "ready"
+   * await Task.Validation.productAll([
+   *   validateName(form.name),
+   *   validateEmail(form.email),
+   *   validateAge(form.age),
+   * ])(); // Passed([name, email, age]) or Failed([...all errors])
    * ```
    */
-  repeatUntil: (options) => (task) => fromPromise2((signal) => {
-    const { when: predicate, delay: delayDuration, maxAttempts } = options;
-    const wait = () => new Promise((r) => {
-      let timerId;
-      const onAbort = () => {
-        clearTimeout(timerId);
-        r();
-      };
-      if (signal) {
-        signal.addEventListener("abort", onAbort, { once: true });
-      }
-      timerId = setTimeout(() => {
-        signal?.removeEventListener("abort", onAbort);
-        r();
-      }, delayDuration ? getMs2(delayDuration) : 0);
-    });
-    const run = (attempt, lastValue) => {
-      if (signal?.aborted && lastValue !== void 0) {
-        return Promise.resolve(lastValue);
-      }
-      return toPromise2(task, signal).then((a) => {
-        if (predicate(a)) {
-          return a;
-        }
-        if (maxAttempts !== void 0 && attempt >= maxAttempts) {
-          return a;
-        }
-        if (signal?.aborted) {
-          return a;
-        }
-        return wait().then(() => run(attempt + 1, a));
-      });
-    };
-    return run(1);
-  }),
+  productAll: (data) => (signal) => Deferred.from.Promise(
+    Promise.all(data.map((t) => Deferred.to.Promise(t(signal)))).then((results) => {
+      const [first, ...rest] = results;
+      return Validation.productAll([first, ...rest]);
+    })
+  ),
   /**
-   * Resolves with the value of the first Task to complete. All Tasks start
-   * immediately. When one resolves, the other tasks are cancelled (aborted)
-   * downstream.
+   * Transforms all accumulated errors inside a Task.Validation.
    *
    * @example
    * ```ts
-   * const fast = Task.resolve("fast");
-   * const slow = Task.delay(Duration.milliseconds(200))(Task.resolve("slow"));
-   *
-   * await Task.race([fast, slow])(); // "fast"
+   * pipe(
+   *   Task.Validation.make.failed("oops"),
+   *   Task.Validation.mapError(e => e.toUpperCase())
+   * ); // Task.Validation(Failed(["OOPS"]))
    * ```
    */
-  race: (tasks) => {
-    if (tasks.length === 0) {
-      return () => Deferred.from.Promise(new Promise(() => {
-      }));
-    }
-    return fromPromise2((outerSignal) => {
-      const controllers = tasks.map(() => new AbortController());
-      const onOuterAbort = () => {
-        for (const ctrl of controllers) {
-          ctrl.abort();
-        }
-      };
-      if (outerSignal) {
-        if (outerSignal.aborted) {
-          onOuterAbort();
-        } else {
-          outerSignal.addEventListener("abort", onOuterAbort, { once: true });
-        }
-      }
-      const promises = tasks.map((task, idx) => {
-        const ctrl = controllers[idx];
-        return toPromise2(task, ctrl.signal).then((result) => {
-          for (let i = 0; i < controllers.length; i++) {
-            if (i !== idx) {
-              controllers[i].abort();
-            }
-          }
-          outerSignal?.removeEventListener("abort", onOuterAbort);
-          return result;
-        });
-      });
-      return Promise.race(promises);
-    });
-  },
+  mapError: (f) => (data) => Task.map(Validation.mapError(f))(data),
   /**
-   * Runs an array of Tasks concurrently and collects their results in an array.
-   * Forward-propagates the call site's AbortSignal to all subtasks concurrently.
+   * Executes a side effect on the accumulated errors without changing the Task.Validation.
    *
    * @example
    * ```ts
-   * Task.sequence([loadConfig, detectLocale, loadTheme])();
-   * // Deferred<[Config, string, Theme]>
+   * pipe(
+   *   Task.Validation.make.failed("invalid name"),
+   *   Task.Validation.tapError(errs => logger.error(errs))
+   * );
    * ```
    */
-  sequence: (tasks) => fromPromise2((signal) => Promise.all(tasks.map((t) => toPromise2(t, signal)))),
+  tapError: (f) => (data) => Task.map(Validation.tapError(f))(data),
   /**
-   * Runs an array of Tasks one at a time in order, collecting all results.
-   * Each Task starts only after the previous one resolves.
+   * Combines a record of Task.Validations into a single Task.Validation of a record.
+   * Evaluates fields in parallel and accumulates all validation errors.
    *
    * @example
    * ```ts
-   * let log: number[] = [];
-   * const makeTask = (n: number) => Task.resolve(n);
-   *
-   * await Task.sequential([makeTask(1), makeTask(2), makeTask(3)])();
-   * // log = [1, 2, 3] — tasks ran in order
+   * Task.Validation.struct({
+   *   name: Task.Validation.make.passed("Alice"),
+   *   age: Task.Validation.make.passed(30)
+   * }); // Task.Validation({ name: "Alice", age: 30 })
    * ```
    */
-  sequential: (tasks) => fromPromise2(async (signal) => {
-    const results = [];
-    for (const task of tasks) {
-      if (signal?.aborted) {
-        break;
+  struct: (fields) => (signal) => Deferred.from.Promise((() => {
+    const keys3 = Object.keys(fields);
+    const promises = keys3.map((key) => Deferred.to.Promise(fields[key](signal)));
+    return Promise.all(promises).then((results) => {
+      const record = {};
+      const errors = [];
+      for (let i = 0; i < keys3.length; i++) {
+        const res = results[i];
+        if (Validation.is.passed(res)) {
+          record[keys3[i]] = res.value;
+        } else {
+          errors.push(...res.errors);
+        }
       }
-      results.push(await toPromise2(task, signal));
-    }
-    return results;
-  }),
+      return isNonEmptyArr(errors) ? Validation.make.failedAll(errors) : Validation.make.passed(record);
+    });
+  })()),
   /**
-   * Converts a `Task<A>` into a `Task<Result<E, A>>`, resolving to `Err` if the
-   * Task does not complete within the given duration. The inner Task receives an
-   * `AbortSignal` that fires when the deadline passes, so asynchronous operations
-   * that accept a signal are cancelled rather than left dangling.
+   * Creates a memoized version of a Task.Validation. The task is executed at most once on first call,
+   * and its resolved Validation is cached for all subsequent calls.
    *
    * @example
    * ```ts
-   * pipe(
-   *   heavyComputation,
-   *   Task.timeout({ duration: Duration.seconds(5), onTimeout: () => "timed out" }),
-   *   Task.Result.chain(processResult)
-   * );
+   * const validate = Task.Validation.memoize(validateFormTask);
    * ```
    */
-  timeout: (options) => (task) => fromPromise2((outerSignal) => {
-    const { duration, onTimeout } = options;
-    const controller = new AbortController();
-    let timerId;
-    let cleanUp = () => {
-    };
-    const onOuterAbort = () => {
-      cleanUp();
-      controller.abort();
-    };
-    cleanUp = () => {
-      clearTimeout(timerId);
-      outerSignal?.removeEventListener("abort", onOuterAbort);
-    };
-    if (outerSignal) {
-      if (outerSignal.aborted) {
-        controller.abort();
-      } else {
-        outerSignal.addEventListener("abort", onOuterAbort, { once: true });
-      }
-    }
-    return Promise.race([
-      toPromise2(task, controller.signal).then((a) => {
-        cleanUp();
-        return Result.make.ok(a);
-      }),
-      new Promise((res) => {
-        timerId = setTimeout(() => {
-          controller.abort();
-          cleanUp();
-          res(Result.make.err(onTimeout()));
-        }, getMs2(duration));
-      })
-    ]);
-  }),
+  memoize: (task) => Task.memoize(task)
+};
+
+// src/Core/Task.ts
+var toPromise2 = (task, signal) => Deferred.to.Promise(task(signal));
+var fromPromise2 = (f) => (signal) => Deferred.from.Promise(f(signal));
+var getMs2 = (duration) => Duration.to.milliseconds(duration);
+var resolveTask = (value) => () => Deferred.from.Promise(globalThis.Promise.resolve(value));
+var syncTask = (f) => () => Deferred.from.Promise(globalThis.Promise.resolve(f()));
+var Task = {
   /**
-   * Creates a Task paired with an `abort` handle. Calling `abort()` cancels the
-   * current in-flight call immediately. Unlike a one-shot abort, calling `task()`
-   * again after `abort()` starts a fresh call with a new signal.
-   *
-   * Each invocation of `task()` automatically cancels the previous in-flight call,
-   * making it safe to call repeatedly (e.g. on user input) without leaking promises.
-   *
-   * If an outer signal is also present (passed at the call site), aborting it
-   * propagates into the internal controller.
+   * Creates a Task that immediately resolves to the given value.
    *
    * @example
    * ```ts
-   * const { task: poll, abort } = Task.abortable(
-   *   (signal) => waitForEvent(bus, "ready", { signal }),
-   * );
-   *
-   * onUnmount(abort);
-   * await poll();
+   * const task = Task.resolve(42);
+   * const value = await task(); // 42
    * ```
    */
-  abortable: (factory) => {
-    let currentController = null;
-    const abort = () => currentController?.abort();
-    const task = (outerSignal) => {
-      currentController?.abort();
-      currentController = new AbortController();
-      const controller = currentController;
-      if (outerSignal) {
-        if (outerSignal.aborted) {
-          controller.abort(outerSignal.reason);
-        } else {
-          outerSignal.addEventListener("abort", () => controller.abort(outerSignal.reason), { once: true });
-        }
-      }
-      return Deferred.from.Promise(factory(controller.signal));
-    };
-    return { task, abort };
+  resolve: resolveTask,
+  // --- from ---
+  from: {
+    /**
+     * Creates a Task from a lazy synchronous thunk.
+     * Unlike `Task.resolve(f())`, `from.sync` does not evaluate `f` until the Task is called.
+     *
+     * @example
+     * ```ts
+     * const t = Task.from.sync(() => Date.now()); // Date.now() not called yet
+     * const ts = await t(); // called here, every time
+     * ```
+     */
+    sync: syncTask
   },
   /**
-   * Executes a task with an optional signal. Use as a terminal step in a `pipe` chain.
+   * Wraps a Promise-returning thunk that may throw or reject,
+   * trapping errors with a fallback function and returning a guaranteed `Task<A>`.
    *
    * @example
    * ```ts
-   * const name = await pipe(
-   *     loadConfig,
-   *     Task.map(config => config.name),
-   *     Task.run(),
+   * const loadConfig = Task.tryCatch(
+   *   () => configStore.get("default"),
+   *   { onError: () => DEFAULT_CONFIG }
    * );
    * ```
    */
-  run: (signal) => (task) => task(signal),
+  tryCatch: (f, options) => fromPromise2((signal) => globalThis.Promise.resolve().then(() => f(signal)).catch((err2) => options.onError(err2))),
   /**
-   * Converts a Task value into an object containing a single property.
-   * Initiates the pipeline accumulator record.
+   * Transforms the value inside a Task.
    *
    * @example
    * ```ts
-   * pipe(Task.resolve(42), Task.bindTo("value")); // Task({ value: 42 })
+   * pipe(
+   *   Task.resolve(5),
+   *   Task.map(n => n * 2)
+   * )(); // Deferred<10>
    * ```
    */
-  bindTo: (key) => (data) => fromPromise2((signal) => toPromise2(data, signal).then((a) => ({ [key]: a }))),
+  map: (f) => (data) => fromPromise2((signal) => toPromise2(data, signal).then(f)),
   /**
-   * Evaluates a new Task using the current accumulator and attaches the output to a new key.
+   * Chains Task computations. Passes the resolved value of the first Task to f.
    *
    * @example
    * ```ts
+   * const readUserId: Task<string> = Task.resolve(session.userId);
+   * const loadPrefs = (id: string): Task<Preferences> =>
+   *   Task.resolve(prefsCache.get(id));
+   *
    * pipe(
-   *   Task.resolve({ a: 1 }),
-   *   Task.bind("b", ({ a }) => Task.resolve(a + 1))
-   * ); // Task({ a: 1, b: 2 })
+   *   readUserId,
+   *   Task.chain(loadPrefs)
+   * )(); // Deferred<Preferences>
    * ```
    */
-  bind: (key, f) => (data) => fromPromise2(
-    (signal) => toPromise2(data, signal).then(
-      (a) => toPromise2(f(a), signal).then((b) => ({ ...a, [key]: b }))
-    )
-  ),
+  chain: (f) => (data) => fromPromise2((signal) => toPromise2(data, signal).then((a) => toPromise2(f(a), signal))),
   /**
-   * Creates a memoized version of a Task. The task is executed at most once on first call,
-   * and its resolved value is cached for all subsequent calls.
+   * Applies a function wrapped in a Task to a value wrapped in a Task.
+   * Both Tasks run in parallel.
    *
    * @example
    * ```ts
-   * const loadToken = Task.memoize(loadAuthToken);
-   * const token1 = await loadToken(); // loads token
-   * const token2 = await loadToken(); // returns cached token immediately
+   * const add = (a: number) => (b: number) => a + b;
+   * pipe(
+   *   Task.resolve(add),
+   *   Task.ap(Task.resolve(5)),
+   *   Task.ap(Task.resolve(3))
+   * )(); // Deferred<8>
    * ```
    */
-  memoize: (task) => {
-    let cached = null;
-    return (signal) => {
-      if (cached === null) {
-        cached = task(signal);
-      }
-      return cached;
-    };
-  },
+  ap: (arg) => (data) => fromPromise2((signal) => Promise.all([toPromise2(data, signal), toPromise2(arg, signal)]).then(([f, a]) => f(a))),
   /**
-   * Monitors progress of a Task by calling `onProgress(0)` before execution and `onProgress(1)` upon completion.
+   * Executes a side effect on the value without changing the Task.
+   * Useful for logging or debugging.
    *
    * @example
    * ```ts
-   * const taskWithProgress = pipe(
-   *   readTask,
-   *   Task.withProgress((ratio) => console.log(`Progress: ${ratio * 100}%`))
+   * pipe(
+   *   loadConfig,
+   *   Task.tap(cfg => console.log("Config:", cfg)),
+   *   Task.map(buildReport)
    * );
    * ```
    */
-  withProgress: (onProgress) => (task) => (signal) => {
-    onProgress(0);
-    const d = task(signal);
-    return Deferred.from.Promise(
-      Deferred.to.Promise(d).then((res) => {
-        onProgress(1);
-        return res;
-      })
-    );
-  },
+  tap: (f) => (data) => fromPromise2(
+    (signal) => toPromise2(data, signal).then((a) => {
+      f(a);
+      return a;
+    })
+  ),
   /**
-   * Attaches a read-only `.label` property to a Task, preserving the literal string generic type for IDE tooltips.
+   * Runs multiple Tasks in parallel and collects their results.
    *
    * @example
    * ```ts
-   * const labeledTask = pipe(readTask, Task.withLabel("readUser"));
-   * console.log(labeledTask.label); // "readUser"
+   * Task.all([loadConfig, detectLocale, loadTheme])();
+   * // Deferred<[Config, string, Theme]>
    * ```
    */
-  withLabel: (label) => (task) => {
-    const fn = ((signal) => task(signal));
-    Object.defineProperty(fn, "label", { value: label, writable: false, enumerable: true, configurable: true });
-    return fn;
-  },
-  Maybe: TaskMaybe,
-  Result: TaskResult,
-  Validation: TaskValidation
-};
-
-// src/Core/These.ts
-var makeFirst = (value) => ({ kind: "First", first: value });
-var makeSecond = (value) => ({ kind: "Second", second: value });
-var makeBoth = (f, s) => ({ kind: "Both", first: f, second: s });
-var isFirst = (data) => data.kind === "First";
-var isSecond = (data) => data.kind === "Second";
-var isBoth = (data) => data.kind === "Both";
-var hasFirst = (data) => data.kind === "First" || data.kind === "Both";
-var hasSecond = (data) => data.kind === "Second" || data.kind === "Both";
-var These = {
-  make: {
-    /**
-     * Creates a These holding only a first value.
-     *
-     * @example
-     * ```ts
-     * These.make.first(42); // { kind: "First", first: 42 }
-     * ```
-     */
-    first: makeFirst,
-    /**
-     * Creates a These holding only a second value.
-     *
-     * @example
-     * ```ts
-     * These.make.second("warning"); // { kind: "Second", second: "warning" }
-     * ```
-     */
-    second: makeSecond,
-    /**
-     * Creates a These holding both a first and a second value simultaneously.
-     *
-     * @example
-     * ```ts
-     * These.make.both(42, "Deprecated API used"); // { kind: "Both", first: 42, second: "Deprecated API used" }
-     * ```
-     */
-    both: makeBoth
-  },
-  is: {
-    /**
-     * Type guard — checks if a These holds only a first value.
-     *
-     * @example
-     * ```ts
-     * const val = These.make.first(42);
-     * if (These.is.first(val)) {
-     *   console.log(val.first); // 42
-     * }
-     * ```
-     */
-    first: isFirst,
-    /**
-     * Type guard — checks if a These holds only a second value.
-     *
-     * @example
-     * ```ts
-     * const val = These.make.second("warning");
-     * if (These.is.second(val)) {
-     *   console.log(val.second); // "warning"
-     * }
-     * ```
-     */
-    second: isSecond,
-    /**
-     * Type guard — checks if a These holds both values simultaneously.
-     *
-     * @example
-     * ```ts
-     * const val = These.make.both(42, "warning");
-     * if (These.is.both(val)) {
-     *   console.log(val.first, val.second); // 42 "warning"
-     * }
-     * ```
-     */
-    both: isBoth
-  },
+  all: (tasks) => fromPromise2(
+    (signal) => Promise.all(tasks.map((t) => toPromise2(t, signal)))
+  ),
   /**
-   * Returns true if the These contains a first value (First or Both).
+   * Delays the execution of a Task by the specified duration.
+   * Useful for debouncing or rate limiting.
    *
    * @example
    * ```ts
-   * These.hasFirst(These.make.first(42));       // true
-   * These.hasFirst(These.make.both(42, "warn"));// true
-   * These.hasFirst(These.make.second("warn"));  // false
+   * pipe(
+   *   Task.resolve(42),
+   *   Task.delay(Duration.seconds(1))
+   * )(); // Resolves after 1 second
    * ```
    */
-  hasFirst,
+  delay: (duration) => (data) => fromPromise2(
+    (signal) => new Promise((res) => {
+      let timerId;
+      const onAbort = () => {
+        clearTimeout(timerId);
+        res(toPromise2(data, signal));
+      };
+      if (signal) {
+        if (signal.aborted) {
+          return res(toPromise2(data, signal));
+        }
+        signal.addEventListener("abort", onAbort, { once: true });
+      }
+      timerId = setTimeout(() => {
+        signal?.removeEventListener("abort", onAbort);
+        res(toPromise2(data, signal));
+      }, getMs2(duration));
+    })
+  ),
+  /**
+   * Runs a Task a fixed number of times sequentially, collecting all results into an array.
+   * An optional delay duration can be inserted between runs.
+   *
+   * @example
+   * ```ts
+   * pipe(
+   *   pollSensor,
+   *   Task.repeat({ times: 5, delay: Duration.seconds(1) })
+   * )(); // Task<Reading[]> — 5 readings, one per second
+   * ```
+   */
+  repeat: (options) => (task) => fromPromise2((signal) => {
+    const { times, delay: delayDuration } = options;
+    if (times <= 0) {
+      return Promise.resolve([]);
+    }
+    const results = [];
+    const wait = () => new Promise((r) => {
+      let timerId;
+      const onAbort = () => {
+        clearTimeout(timerId);
+        r();
+      };
+      if (signal) {
+        signal.addEventListener("abort", onAbort, { once: true });
+      }
+      timerId = setTimeout(() => {
+        signal?.removeEventListener("abort", onAbort);
+        r();
+      }, delayDuration ? getMs2(delayDuration) : 0);
+    });
+    const run = (left) => {
+      if (signal?.aborted) {
+        return Promise.resolve(results);
+      }
+      return toPromise2(task, signal).then((a) => {
+        results.push(a);
+        if (left <= 1 || signal?.aborted) {
+          return results;
+        }
+        return wait().then(() => run(left - 1));
+      });
+    };
+    return run(times);
+  }),
   /**
-   * Returns true if the These contains a second value (Second or Both).
+   * Runs a Task repeatedly until the result satisfies a predicate, returning that result.
+   * An optional delay duration can be inserted between runs.
+   * An optional `maxAttempts` cap stops the loop after N calls — the last value is returned
+   * regardless of whether the predicate was satisfied.
    *
    * @example
    * ```ts
-   * These.hasSecond(These.make.second("warn"));  // true
-   * These.hasSecond(These.make.both(42, "warn"));// true
-   * These.hasSecond(These.make.first(42));       // false
+   * pipe(
+   *   checkStatus,
+   *   Task.repeatUntil({ when: (s) => s === "ready", delay: Duration.milliseconds(500) })
+   * )(); // polls every 500ms until status is "ready"
    * ```
    */
-  hasSecond,
+  repeatUntil: (options) => (task) => fromPromise2((signal) => {
+    const { when: predicate, delay: delayDuration, maxAttempts } = options;
+    const wait = () => new Promise((r) => {
+      let timerId;
+      const onAbort = () => {
+        clearTimeout(timerId);
+        r();
+      };
+      if (signal) {
+        signal.addEventListener("abort", onAbort, { once: true });
+      }
+      timerId = setTimeout(() => {
+        signal?.removeEventListener("abort", onAbort);
+        r();
+      }, delayDuration ? getMs2(delayDuration) : 0);
+    });
+    const run = (attempt, lastValue) => {
+      if (signal?.aborted && lastValue !== void 0) {
+        return Promise.resolve(lastValue);
+      }
+      return toPromise2(task, signal).then((a) => {
+        if (predicate(a)) {
+          return a;
+        }
+        if (maxAttempts !== void 0 && attempt >= maxAttempts) {
+          return a;
+        }
+        if (signal?.aborted) {
+          return a;
+        }
+        return wait().then(() => run(attempt + 1, a));
+      });
+    };
+    return run(1);
+  }),
   /**
-   * Transforms the first value, leaving the second unchanged.
+   * Resolves with the value of the first Task to complete. All Tasks start
+   * immediately. When one resolves, the other tasks are cancelled (aborted)
+   * downstream.
    *
    * @example
    * ```ts
-   * pipe(These.make.first(5), These.mapFirst(n => n * 2));           // First(10)
-   * pipe(These.make.both(5, "warn"), These.mapFirst(n => n * 2));    // Both(10, "warn")
-   * pipe(These.make.second("warn"), These.mapFirst(n => n * 2));     // Second("warn")
+   * const fast = Task.resolve("fast");
+   * const slow = Task.delay(Duration.milliseconds(200))(Task.resolve("slow"));
+   *
+   * await Task.race([fast, slow])(); // "fast"
    * ```
    */
-  mapFirst: (f) => (data) => {
-    if (isSecond(data)) {
-      return data;
-    }
-    if (isFirst(data)) {
-      return makeFirst(f(data.first));
+  race: (tasks) => {
+    if (tasks.length === 0) {
+      return () => Deferred.from.Promise(new Promise(() => {
+      }));
     }
-    return makeBoth(f(data.first), data.second);
+    return fromPromise2((outerSignal) => {
+      const controllers = tasks.map(() => new AbortController());
+      const onOuterAbort = () => {
+        for (const ctrl of controllers) {
+          ctrl.abort();
+        }
+      };
+      if (outerSignal) {
+        if (outerSignal.aborted) {
+          onOuterAbort();
+        } else {
+          outerSignal.addEventListener("abort", onOuterAbort, { once: true });
+        }
+      }
+      const promises = tasks.map((task, idx) => {
+        const ctrl = controllers[idx];
+        return toPromise2(task, ctrl.signal).then((result) => {
+          for (let i = 0; i < controllers.length; i++) {
+            if (i !== idx) {
+              controllers[i].abort();
+            }
+          }
+          outerSignal?.removeEventListener("abort", onOuterAbort);
+          return result;
+        });
+      });
+      return Promise.race(promises);
+    });
   },
   /**
-   * Transforms the second value, leaving the first unchanged.
+   * Runs an array of Tasks concurrently and collects their results in an array.
+   * Forward-propagates the call site's AbortSignal to all subtasks concurrently.
    *
    * @example
    * ```ts
-   * pipe(These.make.second("warn"), These.mapSecond(e => e.toUpperCase()));     // Second("WARN")
-   * pipe(These.make.both(5, "warn"), These.mapSecond(e => e.toUpperCase()));    // Both(5, "WARN")
+   * Task.sequence([loadConfig, detectLocale, loadTheme])();
+   * // Deferred<[Config, string, Theme]>
    * ```
    */
-  mapSecond: (f) => (data) => {
-    if (isFirst(data)) {
-      return data;
-    }
-    if (isSecond(data)) {
-      return makeSecond(f(data.second));
-    }
-    return makeBoth(data.first, f(data.second));
-  },
+  sequence: (tasks) => fromPromise2((signal) => Promise.all(tasks.map((t) => toPromise2(t, signal)))),
   /**
-   * Transforms both the first and second values independently.
+   * Runs an array of Tasks one at a time in order, collecting all results.
+   * Each Task starts only after the previous one resolves.
    *
    * @example
    * ```ts
-   * pipe(
-   *   These.make.both(5, "warn"),
-   *   These.mapBoth(n => n * 2, e => e.toUpperCase())
-   * ); // Both(10, "WARN")
+   * let log: number[] = [];
+   * const makeTask = (n: number) => Task.resolve(n);
+   *
+   * await Task.sequential([makeTask(1), makeTask(2), makeTask(3)])();
+   * // log = [1, 2, 3] — tasks ran in order
    * ```
    */
-  mapBoth: (onFirst, onSecond) => (data) => {
-    if (isSecond(data)) {
-      return makeSecond(onSecond(data.second));
-    }
-    if (isFirst(data)) {
-      return makeFirst(onFirst(data.first));
+  sequential: (tasks) => fromPromise2(async (signal) => {
+    const results = [];
+    for (const task of tasks) {
+      if (signal?.aborted) {
+        break;
+      }
+      results.push(await toPromise2(task, signal));
     }
-    return makeBoth(onFirst(data.first), onSecond(data.second));
-  },
+    return results;
+  }),
   /**
-   * Chains These computations by passing the first value to f.
-   * Second propagates unchanged; First and Both apply f to the first value.
+   * Converts a `Task<A>` into a `Task<Result<E, A>>`, resolving to `Err` if the
+   * Task does not complete within the given duration. The inner Task receives an
+   * `AbortSignal` that fires when the deadline passes, so asynchronous operations
+   * that accept a signal are cancelled rather than left dangling.
    *
    * @example
    * ```ts
-   * const double = (n: number): These<number, string> => These.make.first(n * 2);
-   *
-   * pipe(These.make.first(5), These.chainFirst(double));            // First(10)
-   * pipe(These.make.both(5, "warn"), These.chainFirst(double));     // First(10)
-   * pipe(These.make.second("warn"), These.chainFirst(double));      // Second("warn")
+   * pipe(
+   *   heavyComputation,
+   *   Task.timeout({ duration: Duration.seconds(5), onTimeout: () => "timed out" }),
+   *   Task.Result.chain(processResult)
+   * );
    * ```
    */
-  chainFirst: (f) => (data) => {
-    if (isSecond(data)) {
-      return data;
+  timeout: (options) => (task) => fromPromise2((outerSignal) => {
+    const { duration, onTimeout } = options;
+    const controller = new AbortController();
+    let timerId;
+    let cleanUp = () => {
+    };
+    const onOuterAbort = () => {
+      cleanUp();
+      controller.abort();
+    };
+    cleanUp = () => {
+      clearTimeout(timerId);
+      outerSignal?.removeEventListener("abort", onOuterAbort);
+    };
+    if (outerSignal) {
+      if (outerSignal.aborted) {
+        controller.abort();
+      } else {
+        outerSignal.addEventListener("abort", onOuterAbort, { once: true });
+      }
     }
-    return f(data.first);
-  },
+    return Promise.race([
+      toPromise2(task, controller.signal).then((a) => {
+        cleanUp();
+        return Result.make.ok(a);
+      }),
+      new Promise((res) => {
+        timerId = setTimeout(() => {
+          controller.abort();
+          cleanUp();
+          res(Result.make.err(onTimeout()));
+        }, getMs2(duration));
+      })
+    ]);
+  }),
   /**
-   * Chains These computations by passing the second value to f.
-   * First propagates unchanged; Second and Both apply f to the second value.
+   * Creates a Task paired with an `abort` handle. Calling `abort()` cancels the
+   * current in-flight call immediately. Unlike a one-shot abort, calling `task()`
+   * again after `abort()` starts a fresh call with a new signal.
+   *
+   * Each invocation of `task()` automatically cancels the previous in-flight call,
+   * making it safe to call repeatedly (e.g. on user input) without leaking promises.
+   *
+   * If an outer signal is also present (passed at the call site), aborting it
+   * propagates into the internal controller.
    *
    * @example
    * ```ts
-   * const shout = (s: string): These<number, string> => These.make.second(s.toUpperCase());
+   * const { task: poll, abort } = Task.abortable(
+   *   (signal) => waitForEvent(bus, "ready", { signal }),
+   * );
    *
-   * pipe(These.make.second("warn"), These.chainSecond(shout));      // Second("WARN")
-   * pipe(These.make.both(5, "warn"), These.chainSecond(shout));     // Second("WARN")
-   * pipe(These.make.first(5), These.chainSecond(shout));            // First(5)
+   * onUnmount(abort);
+   * await poll();
    * ```
    */
-  chainSecond: (f) => (data) => {
-    if (isFirst(data)) {
-      return data;
-    }
-    return f(data.second);
+  abortable: (factory) => {
+    let currentController = null;
+    const abort = () => currentController?.abort();
+    const task = (outerSignal) => {
+      currentController?.abort();
+      currentController = new AbortController();
+      const controller = currentController;
+      if (outerSignal) {
+        if (outerSignal.aborted) {
+          controller.abort(outerSignal.reason);
+        } else {
+          outerSignal.addEventListener("abort", () => controller.abort(outerSignal.reason), { once: true });
+        }
+      }
+      return Deferred.from.Promise(factory(controller.signal));
+    };
+    return { task, abort };
   },
   /**
-   * Extracts a value from a These by providing handlers for all three cases.
+   * Executes a task with an optional signal. Use as a terminal step in a `pipe` chain.
    *
    * @example
    * ```ts
-   * pipe(
-   *   these,
-   *   These.fold(
-   *     a => `First: ${a}`,
-   *     b => `Second: ${b}`,
-   *     (a, b) => `Both: ${a} / ${b}`
-   *   )
+   * const name = await pipe(
+   *     loadConfig,
+   *     Task.map(config => config.name),
+   *     Task.run(),
    * );
    * ```
    */
-  fold: (onFirst, onSecond, onBoth) => (data) => {
-    if (isSecond(data)) {
-      return onSecond(data.second);
-    }
-    if (isFirst(data)) {
-      return onFirst(data.first);
-    }
-    return onBoth(data.first, data.second);
-  },
+  run: (signal) => (task) => task(signal),
   /**
-   * Pattern matches on a These, returning the result of the matching case.
+   * Converts a Task value into an object containing a single property.
+   * Initiates the pipeline accumulator record.
    *
    * @example
    * ```ts
-   * pipe(
-   *   these,
-   *   These.match({
-   *     first: a => `First: ${a}`,
-   *     second: b => `Second: ${b}`,
-   *     both: (a, b) => `Both: ${a} / ${b}`
-   *   })
-   * );
+   * pipe(Task.resolve(42), Task.bindTo("value")); // Task({ value: 42 })
    * ```
    */
-  match: (cases) => (data) => {
-    if (isSecond(data)) {
-      return cases.second(data.second);
-    }
-    if (isFirst(data)) {
-      return cases.first(data.first);
-    }
-    return cases.both(data.first, data.second);
-  },
+  bindTo: (key) => (data) => fromPromise2((signal) => toPromise2(data, signal).then((a) => ({ [key]: a }))),
   /**
-   * Returns the first value, or a default if the These has no first value.
-   * The default can be a different type, widening the result to `A | C`.
+   * Evaluates a new Task using the current accumulator and attaches the output to a new key.
    *
    * @example
    * ```ts
-   * pipe(These.make.first(5), These.getFirstOrElse(() => 0));            // 5
-   * pipe(These.make.both(5, "warn"), These.getFirstOrElse(() => 0));     // 5
-   * pipe(These.make.second("warn"), These.getFirstOrElse(() => 0));      // 0
-   * pipe(These.make.second("warn"), These.getFirstOrElse(() => null));   // null — typed as number | null
+   * pipe(
+   *   Task.resolve({ a: 1 }),
+   *   Task.bind("b", ({ a }) => Task.resolve(a + 1))
+   * ); // Task({ a: 1, b: 2 })
    * ```
    */
-  getFirstOrElse: (defaultValue) => (data) => hasFirst(data) ? data.first : defaultValue(),
+  bind: (key, f) => (data) => fromPromise2(
+    (signal) => toPromise2(data, signal).then(
+      (a) => toPromise2(f(a), signal).then((b) => ({ ...a, [key]: b }))
+    )
+  ),
   /**
-   * Returns the second value, or a default if the These has no second value.
-   * The default can be a different type, widening the result to `B | D`.
+   * Creates a memoized version of a Task. The task is executed at most once on first call,
+   * and its resolved value is cached for all subsequent calls.
    *
    * @example
    * ```ts
-   * pipe(These.make.second("warn"), These.getSecondOrElse(() => "none")); // "warn"
-   * pipe(These.make.both(5, "warn"), These.getSecondOrElse(() => "none")); // "warn"
-   * pipe(These.make.first(5), These.getSecondOrElse(() => "none"));       // "none"
-   * pipe(These.make.first(5), These.getSecondOrElse(() => null));         // null — typed as string | null
+   * const loadToken = Task.memoize(loadAuthToken);
+   * const token1 = await loadToken(); // loads token
+   * const token2 = await loadToken(); // returns cached token immediately
    * ```
    */
-  getSecondOrElse: (defaultValue) => (data) => hasSecond(data) ? data.second : defaultValue(),
+  memoize: (task) => {
+    let cached = null;
+    return (signal) => {
+      if (cached === null) {
+        cached = task(signal);
+      }
+      return cached;
+    };
+  },
   /**
-   * Runs a side effect on the first value without changing the These.
-   * Useful for logging or debugging.
+   * Monitors progress of a Task by calling `onProgress(0)` before execution and `onProgress(1)` upon completion.
    *
    * @example
    * ```ts
-   * pipe(These.make.first(5), These.tap(console.log)); // logs 5, returns First(5)
+   * const taskWithProgress = pipe(
+   *   readTask,
+   *   Task.withProgress((ratio) => console.log(`Progress: ${ratio * 100}%`))
+   * );
    * ```
    */
-  tap: (f) => (data) => {
-    if (hasFirst(data)) {
-      f(data.first);
-    }
-    return data;
+  withProgress: (onProgress) => (task) => (signal) => {
+    onProgress(0);
+    const d = task(signal);
+    return Deferred.from.Promise(
+      Deferred.to.Promise(d).then((res) => {
+        onProgress(1);
+        return res;
+      })
+    );
   },
   /**
-   * Swaps the roles of first and second values.
-   * - First(a)    → Second(a)
-   * - Second(b)   → First(b)
-   * - Both(a, b)  → Both(b, a)
+   * Attaches a read-only `.label` property to a Task, preserving the literal string generic type for IDE tooltips.
    *
    * @example
    * ```ts
-   * These.swap(These.make.first(5));            // Second(5)
-   * These.swap(These.make.second("warn"));      // First("warn")
-   * These.swap(These.make.both(5, "warn"));     // Both("warn", 5)
+   * const labeledTask = pipe(readTask, Task.withLabel("readUser"));
+   * console.log(labeledTask.label); // "readUser"
    * ```
    */
-  swap: (data) => {
-    if (isSecond(data)) {
-      return makeFirst(data.second);
-    }
-    if (isFirst(data)) {
-      return makeSecond(data.first);
-    }
-    return makeBoth(data.second, data.first);
-  }
+  withLabel: (label) => (task) => {
+    const fn = ((signal) => task(signal));
+    Object.defineProperty(fn, "label", { value: label, writable: false, enumerable: true, configurable: true });
+    return fn;
+  },
+  Maybe: TaskMaybe,
+  Result: TaskResult,
+  Validation: TaskValidation
 };
 
-// src/Core/Validation.ts
-var makePassed2 = (value) => ({ kind: "Passed", value });
-var makeFailed2 = (error) => ({ kind: "Failed", errors: [error] });
-var makeFailedAll2 = (errors) => ({ kind: "Failed", errors });
-var isPassed = (data) => data.kind === "Passed";
-var isFailed = (data) => data.kind === "Failed";
-function toResult(arg) {
-  if (typeof arg === "function") {
-    const combine = arg;
-    return (val) => isPassed(val) ? Result.make.ok(val.value) : Result.make.err(combine(val.errors));
-  }
-  return isPassed(arg) ? Result.make.ok(arg.value) : Result.make.err(arg.errors);
-}
-var Validation = {
+// src/Core/These.ts
+var makeFirst = (value) => ({ kind: "First", first: value });
+var makeSecond = (value) => ({ kind: "Second", second: value });
+var makeBoth = (f, s) => ({ kind: "Both", first: f, second: s });
+var isFirst = (data) => data.kind === "First";
+var isSecond = (data) => data.kind === "Second";
+var isBoth = (data) => data.kind === "Both";
+var hasFirst = (data) => data.kind === "First" || data.kind === "Both";
+var hasSecond = (data) => data.kind === "Second" || data.kind === "Both";
+var These = {
   make: {
     /**
-     * Wraps a value in a passed Validation.
+     * Creates a These holding only a first value.
      *
      * @example
      * ```ts
-     * Validation.make.passed(42); // Passed(42)
+     * These.make.first(42); // { kind: "First", first: 42 }
      * ```
      */
-    passed: makePassed2,
+    first: makeFirst,
     /**
-     * Creates a failed Validation from a single error.
+     * Creates a These holding only a second value.
      *
      * @example
      * ```ts
-     * Validation.make.failed("Invalid input");
+     * These.make.second("warning"); // { kind: "Second", second: "warning" }
      * ```
      */
-    failed: makeFailed2,
+    second: makeSecond,
     /**
-     * Creates a failed Validation from multiple errors.
+     * Creates a These holding both a first and a second value simultaneously.
      *
      * @example
      * ```ts
-     * Validation.make.failedAll(["Invalid input"]);
+     * These.make.both(42, "Deprecated API used"); // { kind: "Both", first: 42, second: "Deprecated API used" }
      * ```
      */
-    failedAll: makeFailedAll2
+    both: makeBoth
   },
   is: {
     /**
-     * Type guard that checks if a Validation is passed.
+     * Type guard — checks if a These holds only a first value.
      *
      * @example
      * ```ts
-     * const v = Validation.make.passed(42);
-     * if (Validation.is.passed(v)) {
-     *   console.log(v.value); // 42
+     * const val = These.make.first(42);
+     * if (These.is.first(val)) {
+     *   console.log(val.first); // 42
      * }
      * ```
      */
-    passed: isPassed,
+    first: isFirst,
     /**
-     * Type guard that checks if a Validation is failed.
+     * Type guard — checks if a These holds only a second value.
      *
      * @example
      * ```ts
-     * const v = Validation.make.failed("invalid");
-     * if (Validation.is.failed(v)) {
-     *   console.log(v.errors); // ["invalid"]
+     * const val = These.make.second("warning");
+     * if (These.is.second(val)) {
+     *   console.log(val.second); // "warning"
      * }
      * ```
      */
-    failed: isFailed
-  },
-  /**
-   * Creates a Validation from a synchronous thunk that may throw.
-   * Catches any errors and transforms them using the `onError` function into a Failed validation.
-   *
-   * @example
-   * ```ts
-   * const result = Validation.tryCatch(
-   *   () => JSON.parse(rawString),
-   *   { onError: (e) => `Parse error: ${e}` }
-   * );
-   * ```
-   */
-  tryCatch: (f, options) => {
-    try {
-      return makePassed2(f());
-    } catch (error) {
-      return makeFailed2(options.onError(error));
-    }
-  },
-  // --- from ---
-  from: {
-    /**
-     * Creates a Validation from a predicate applied to a value.
-     * Returns Passed if the predicate passes, Failed from `onFalse` otherwise.
-     *
-     * @example
-     * ```ts
-     * const validateName = Validation.from.Predicate(
-     *   (s: string) => s.length > 0,
-     *   () => "Name is required"
-     * );
-     *
-     * validateName("Alice"); // Passed("Alice")
-     * validateName("");      // Failed(["Name is required"])
-     * ```
-     */
-    Predicate: (pred, onFalse) => (a) => pred(a) ? makePassed2(a) : makeFailed2(onFalse(a)),
-    /**
-     * Creates a Validation from a nullable value.
-     * If the value is null or undefined, returns Failed with the error from onNull.
-     * Otherwise, returns Passed.
-     *
-     * @example
-     * ```ts
-     * pipe(null, Validation.from.nullable(() => "is null")); // Failed(["is null"])
-     * pipe(42, Validation.from.nullable(() => "is null"));   // Passed(42)
-     * ```
-     */
-    nullable: (onNull) => (value) => value === null || value === void 0 ? makeFailed2(onNull()) : makePassed2(value),
-    /**
-     * Creates a Validation from a Maybe.
-     * If the Maybe is None, returns Failed with the error from onNone.
-     * Otherwise, returns Passed.
-     *
-     * @example
-     * ```ts
-     * pipe(Maybe.make.none(), Validation.from.Maybe(() => "is none")); // Failed(["is none"])
-     * pipe(Maybe.make.some(42), Validation.from.Maybe(() => "is none")); // Passed(42)
-     * ```
-     */
-    Maybe: (onNone) => (maybe) => Maybe.is.none(maybe) ? makeFailed2(onNone()) : makePassed2(maybe.value),
+    second: isSecond,
     /**
-     * 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.
+     * Type guard — checks if a These holds both values simultaneously.
      *
      * @example
      * ```ts
-     * Validation.from.Result(Result.make.ok(42));       // Passed(42)
-     * Validation.from.Result(Result.make.err("bad"));   // Failed(["bad"])
+     * const val = These.make.both(42, "warning");
+     * if (These.is.both(val)) {
+     *   console.log(val.first, val.second); // 42 "warning"
+     * }
      * ```
      */
-    Result: (data) => data.kind === "Ok" ? makePassed2(data.value) : makeFailed2(data.error)
+    both: isBoth
   },
   /**
-   * Transforms the success value inside a Validation.
+   * Returns true if the These contains a first value (First or Both).
    *
    * @example
    * ```ts
-   * pipe(Validation.make.passed(5), Validation.map(n => n * 2)); // Passed(10)
-   * pipe(Validation.make.failed("oops"), Validation.map(n => n * 2)); // Failed(["oops"])
+   * These.hasFirst(These.make.first(42));       // true
+   * These.hasFirst(These.make.both(42, "warn"));// true
+   * These.hasFirst(These.make.second("warn"));  // false
    * ```
    */
-  map: (f) => (data) => isPassed(data) ? makePassed2(f(data.value)) : data,
+  hasFirst,
   /**
-   * Transforms the error list inside a Validation.
+   * Returns true if the These contains a second value (Second or Both).
    *
    * @example
    * ```ts
-   * pipe(Validation.make.failed("oops"), Validation.mapError(e => e.toUpperCase())); // Failed(["OOPS"])
+   * These.hasSecond(These.make.second("warn"));  // true
+   * These.hasSecond(These.make.both(42, "warn"));// true
+   * These.hasSecond(These.make.first(42));       // false
    * ```
    */
-  mapError: (f) => (data) => isFailed(data) ? makeFailedAll2(data.errors.map(f)) : data,
+  hasSecond,
   /**
-   * Applies a function wrapped in a Validation to a value wrapped in a Validation.
-   * Accumulates errors from both sides.
+   * Transforms the first value, leaving the second unchanged.
    *
    * @example
    * ```ts
-   * const add = (a: number) => (b: number) => a + b;
-   * pipe(
-   *   Validation.make.passed(add),
-   *   Validation.ap(Validation.make.passed(5)),
-   *   Validation.ap(Validation.make.passed(3))
-   * ); // Passed(8)
-   *
-   * pipe(
-   *   Validation.make.passed(add),
-   *   Validation.ap(Validation.make.failed<string>("bad a")),
-   *   Validation.ap(Validation.make.failed<string>("bad b"))
-   * ); // Failed(["bad a", "bad b"])
+   * pipe(These.make.first(5), These.mapFirst(n => n * 2));           // First(10)
+   * pipe(These.make.both(5, "warn"), These.mapFirst(n => n * 2));    // Both(10, "warn")
+   * pipe(These.make.second("warn"), These.mapFirst(n => n * 2));     // Second("warn")
    * ```
    */
-  ap: (arg) => (data) => {
-    if (isPassed(data)) {
-      return isPassed(arg) ? makePassed2(data.value(arg.value)) : makeFailedAll2(arg.errors);
+  mapFirst: (f) => (data) => {
+    if (isSecond(data)) {
+      return data;
+    }
+    if (isFirst(data)) {
+      return makeFirst(f(data.first));
     }
-    return isPassed(arg) ? makeFailedAll2(data.errors) : makeFailedAll2([...data.errors, ...arg.errors]);
+    return makeBoth(f(data.first), data.second);
   },
   /**
-   * Applies a function wrapped in a Validation to a value wrapped in a Validation,
-   * using a custom error concatenator function when both sides fail.
+   * Transforms the second value, leaving the first unchanged.
    *
    * @example
    * ```ts
-   * const concat = (e1: NonEmptyArr<string>, e2: NonEmptyArr<string>): NonEmptyArr<string> =>
-   *   [...e1, ...e2];
-   * pipe(fnVal, Validation.apCustom(concat)(argVal));
+   * pipe(These.make.second("warn"), These.mapSecond(e => e.toUpperCase()));     // Second("WARN")
+   * pipe(These.make.both(5, "warn"), These.mapSecond(e => e.toUpperCase()));    // Both(5, "WARN")
    * ```
    */
-  apCustom: (concat2) => (arg) => (data) => {
-    if (isPassed(data)) {
-      return isPassed(arg) ? makePassed2(data.value(arg.value)) : makeFailedAll2(arg.errors);
+  mapSecond: (f) => (data) => {
+    if (isFirst(data)) {
+      return data;
+    }
+    if (isSecond(data)) {
+      return makeSecond(f(data.second));
     }
-    return isPassed(arg) ? makeFailedAll2(data.errors) : makeFailedAll2(concat2(data.errors, arg.errors));
+    return makeBoth(data.first, f(data.second));
   },
   /**
-   * Extracts the value from a Validation by providing handlers for both cases.
+   * Transforms both the first and second values independently.
    *
    * @example
    * ```ts
    * pipe(
-   *   Validation.make.passed(42),
-   *   Validation.fold(
-   *     errors => `Errors: ${errors.join(", ")}`,
-   *     value => `Value: ${value}`
-   *   )
-   * );
+   *   These.make.both(5, "warn"),
+   *   These.mapBoth(n => n * 2, e => e.toUpperCase())
+   * ); // Both(10, "WARN")
    * ```
    */
-  fold: (onFailed, onPassed) => (data) => isPassed(data) ? onPassed(data.value) : onFailed(data.errors),
+  mapBoth: (onFirst, onSecond) => (data) => {
+    if (isSecond(data)) {
+      return makeSecond(onSecond(data.second));
+    }
+    if (isFirst(data)) {
+      return makeFirst(onFirst(data.first));
+    }
+    return makeBoth(onFirst(data.first), onSecond(data.second));
+  },
   /**
-   * Pattern matches on a Validation, returning the result of the matching case.
+   * Chains These computations by passing the first value to f.
+   * Second propagates unchanged; First and Both apply f to the first value.
    *
    * @example
    * ```ts
-   * pipe(
-   *   validation,
-   *   Validation.match({
-   *     passed: value => `Got ${value}`,
-   *     failed: errors => `Failed: ${errors.join(", ")}`
-   *   })
-   * );
+   * const double = (n: number): These<number, string> => These.make.first(n * 2);
+   *
+   * pipe(These.make.first(5), These.chainFirst(double));            // First(10)
+   * pipe(These.make.both(5, "warn"), These.chainFirst(double));     // First(10)
+   * pipe(These.make.second("warn"), These.chainFirst(double));      // Second("warn")
    * ```
    */
-  match: (cases) => (data) => isPassed(data) ? cases.passed(data.value) : cases.failed(data.errors),
+  chainFirst: (f) => (data) => {
+    if (isSecond(data)) {
+      return data;
+    }
+    return f(data.first);
+  },
   /**
-   * 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`.
+   * Chains These computations by passing the second value to f.
+   * First propagates unchanged; Second and Both apply f to the second value.
    *
    * @example
    * ```ts
-   * pipe(Validation.make.passed(5), Validation.getOrElse(() => 0)); // 5
-   * pipe(Validation.make.failed("oops"), Validation.getOrElse(() => 0)); // 0
-   * pipe(Validation.make.failed("oops"), Validation.getOrElse(() => null)); // null — typed as number | null
+   * const shout = (s: string): These<number, string> => These.make.second(s.toUpperCase());
+   *
+   * pipe(These.make.second("warn"), These.chainSecond(shout));      // Second("WARN")
+   * pipe(These.make.both(5, "warn"), These.chainSecond(shout));     // Second("WARN")
+   * pipe(These.make.first(5), These.chainSecond(shout));            // First(5)
    * ```
    */
-  getOrElse: (defaultValue) => (data) => isPassed(data) ? data.value : defaultValue(),
+  chainSecond: (f) => (data) => {
+    if (isFirst(data)) {
+      return data;
+    }
+    return f(data.second);
+  },
   /**
-   * Executes a side effect on the success value without changing the Validation.
+   * Extracts a value from a These by providing handlers for all three cases.
    *
    * @example
    * ```ts
    * pipe(
-   *   Validation.make.passed(5),
-   *   Validation.tap(n => console.log("Value:", n)),
-   *   Validation.map(n => n * 2)
+   *   these,
+   *   These.fold(
+   *     a => `First: ${a}`,
+   *     b => `Second: ${b}`,
+   *     (a, b) => `Both: ${a} / ${b}`
+   *   )
    * );
    * ```
    */
-  tap: (f) => (data) => {
-    if (isPassed(data)) {
-      f(data.value);
+  fold: (onFirst, onSecond, onBoth) => (data) => {
+    if (isSecond(data)) {
+      return onSecond(data.second);
     }
-    return data;
+    if (isFirst(data)) {
+      return onFirst(data.first);
+    }
+    return onBoth(data.first, data.second);
   },
   /**
-   * Executes a side effect on the accumulated errors without changing the Validation.
-   * Useful for logging or reporting validation failures.
+   * Pattern matches on a These, returning the result of the matching case.
    *
    * @example
    * ```ts
    * pipe(
-   *   Validation.make.failed("Name required"),
-   *   Validation.tapError(errors => console.error("validation failed:", errors)),
-   *   Validation.map(toUser)
+   *   these,
+   *   These.match({
+   *     first: a => `First: ${a}`,
+   *     second: b => `Second: ${b}`,
+   *     both: (a, b) => `Both: ${a} / ${b}`
+   *   })
    * );
    * ```
    */
-  tapError: (f) => (data) => {
-    if (isFailed(data)) {
-      f(data.errors);
+  match: (cases) => (data) => {
+    if (isSecond(data)) {
+      return cases.second(data.second);
     }
-    return data;
+    if (isFirst(data)) {
+      return cases.first(data.first);
+    }
+    return cases.both(data.first, data.second);
   },
   /**
-   * Recovers from a Failed state by providing a fallback Validation.
-   * The fallback receives the accumulated error list so callers can inspect which errors occurred.
-   * The fallback can produce a different success type, widening the result to `Validation<E, A | B>`.
-   */
-  recover: (fallback) => (data) => isPassed(data) ? data : fallback(data.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>`.
+   * Returns the first value, or a default if the These has no first value.
+   * The default can be a different type, widening the result to `A | C`.
    *
    * @example
    * ```ts
-   * pipe(
-   *   Validation.make.failed("field-error"),
-   *   Validation.recoverUnless(e => e === "fatal", () => Validation.make.passed(0))
-   * ); // Passed(0)
+   * pipe(These.make.first(5), These.getFirstOrElse(() => 0));            // 5
+   * pipe(These.make.both(5, "warn"), These.getFirstOrElse(() => 0));     // 5
+   * pipe(These.make.second("warn"), These.getFirstOrElse(() => 0));      // 0
+   * pipe(These.make.second("warn"), These.getFirstOrElse(() => null));   // null — typed as number | null
    * ```
    */
-  recoverUnless: (isBlocked, fallback) => (data) => isFailed(data) && !data.errors.some(isBlocked) ? fallback() : data,
-  // --- to ---
-  to: {
-    /**
-     * Converts a Validation to a Result.
-     * Passed becomes Ok.
-     * Direct call converts Failed to Err with accumulated error list `NonEmptyArr<E>`.
-     * Curried call converts Failed to Err with combined error `E2` via `combineErrors`.
-     *
-     * @example
-     * ```ts
-     * Validation.to.Result(Validation.make.passed(42));        // Ok(42)
-     * Validation.to.Result(Validation.make.failed("oops"));  // Err(["oops"])
-     * pipe(Validation.make.failed("oops"), Validation.to.Result(errors => errors.join(", "))); // Err("oops")
-     * ```
-     */
-    Result: toResult,
-    /**
-     * Converts a Validation to a Maybe. `Passed` becomes `Some`; `Failed` becomes `None`
-     * (errors are discarded).
-     *
-     * @example
-     * ```ts
-     * Validation.to.Maybe(Validation.make.passed(42));       // Some(42)
-     * Validation.to.Maybe(Validation.make.failed("bad"));  // None
-     * ```
-     */
-    Maybe: (data) => isPassed(data) ? Maybe.make.some(data.value) : Maybe.make.none()
-  },
+  getFirstOrElse: (defaultValue) => (data) => hasFirst(data) ? data.first : defaultValue(),
   /**
-   * 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.
+   * Returns the second value, or a default if the These has no second value.
+   * The default can be a different type, widening the result to `B | D`.
    *
    * @example
    * ```ts
-   * Validation.product(
-   *   Validation.make.passed("alice"),
-   *   Validation.make.passed(30)
-   * ); // Passed(["alice", 30])
-   *
-   * Validation.product(
-   *   Validation.make.failed("Name required"),
-   *   Validation.make.failed("Age must be >= 0")
-   * ); // Failed(["Name required", "Age must be >= 0"])
+   * pipe(These.make.second("warn"), These.getSecondOrElse(() => "none")); // "warn"
+   * pipe(These.make.both(5, "warn"), These.getSecondOrElse(() => "none")); // "warn"
+   * pipe(These.make.first(5), These.getSecondOrElse(() => "none"));       // "none"
+   * pipe(These.make.first(5), These.getSecondOrElse(() => null));         // null — typed as string | null
    * ```
    */
-  product: (first, second) => {
-    if (isPassed(first)) {
-      return isPassed(second) ? makePassed2([first.value, second.value]) : makeFailedAll2(second.errors);
-    }
-    return isPassed(second) ? makeFailedAll2(first.errors) : makeFailedAll2([...first.errors, ...second.errors]);
-  },
+  getSecondOrElse: (defaultValue) => (data) => hasSecond(data) ? data.second : defaultValue(),
   /**
-   * 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.
+   * Runs a side effect on the first value without changing the These.
+   * Useful for logging or debugging.
    *
-   * @example
-   * ```ts
-   * Validation.productAll([
-   *   validateName(name),
-   *   validateEmail(email),
-   *   validateAge(age)
-   * ]);
-   * // Passed([name, email, age]) or Failed([...all errors])
-   * ```
-   */
-  productAll: (data) => {
-    const values3 = [];
-    const errors = [];
-    for (const v of data) {
-      if (isPassed(v)) {
-        values3.push(v.value);
-      } else {
-        errors.push(...v.errors);
-      }
+   * @example
+   * ```ts
+   * pipe(These.make.first(5), These.tap(console.log)); // logs 5, returns First(5)
+   * ```
+   */
+  tap: (f) => (data) => {
+    if (hasFirst(data)) {
+      f(data.first);
     }
-    return isNonEmptyArr(errors) ? makeFailedAll2(errors) : makePassed2(values3);
+    return data;
   },
   /**
-   * Combines a record of Validations into a single Validation of a record.
-   * Accumulates all failed branches' errors.
+   * Swaps the roles of first and second values.
+   * - First(a)    → Second(a)
+   * - Second(b)   → First(b)
+   * - Both(a, b)  → Both(b, a)
    *
    * @example
    * ```ts
-   * Validation.struct({
-   *   name: Validation.make.passed("Alice"),
-   *   age: Validation.make.passed(30)
-   * }); // Passed({ name: "Alice", age: 30 })
-   *
-   * Validation.struct({
-   *   name: Validation.make.failed("Name required"),
-   *   age: Validation.make.failed("Age must be >= 0")
-   * }); // Failed(["Name required", "Age must be >= 0"])
+   * These.swap(These.make.first(5));            // Second(5)
+   * These.swap(These.make.second("warn"));      // First("warn")
+   * These.swap(These.make.both(5, "warn"));     // Both("warn", 5)
    * ```
    */
-  struct: (fields) => {
-    const record = {};
-    const errors = [];
-    for (const key in fields) {
-      if (Object.hasOwn(fields, key)) {
-        const val = fields[key];
-        if (isPassed(val)) {
-          record[key] = val.value;
-        } else {
-          errors.push(...val.errors);
-        }
-      }
+  swap: (data) => {
+    if (isSecond(data)) {
+      return makeFirst(data.second);
+    }
+    if (isFirst(data)) {
+      return makeSecond(data.first);
     }
-    return isNonEmptyArr(errors) ? makeFailedAll2(errors) : makePassed2(record);
+    return makeBoth(data.second, data.first);
   }
 };
 
@@ -7433,6 +7522,60 @@ var Arr = {
 
 // src/Data/BigNum.ts
 var BigNum = {
+  is: {
+    /**
+     * Returns `true` when the bigint is equal to zero (`0n`).
+     *
+     * @example
+     * ```ts
+     * BigNum.is.zero(0n); // true
+     * BigNum.is.zero(5n); // false
+     * ```
+     */
+    zero: (b) => b === 0n,
+    /**
+     * Returns `true` when the bigint is an even integer.
+     *
+     * @example
+     * ```ts
+     * BigNum.is.even(4n); // true
+     * BigNum.is.even(3n); // false
+     * ```
+     */
+    even: (b) => b % 2n === 0n,
+    /**
+     * Returns `true` when the bigint is an odd integer.
+     *
+     * @example
+     * ```ts
+     * BigNum.is.odd(3n); // true
+     * BigNum.is.odd(4n); // false
+     * ```
+     */
+    odd: (b) => b % 2n !== 0n,
+    /**
+     * Returns `true` when the bigint is strictly greater than zero (`0n`).
+     *
+     * @example
+     * ```ts
+     * BigNum.is.positive(5n);  // true
+     * BigNum.is.positive(0n);  // false
+     * BigNum.is.positive(-5n); // false
+     * ```
+     */
+    positive: (b) => b > 0n,
+    /**
+     * Returns `true` when the bigint is strictly less than zero (`0n`).
+     *
+     * @example
+     * ```ts
+     * BigNum.is.negative(-5n); // true
+     * BigNum.is.negative(0n);  // false
+     * BigNum.is.negative(5n);  // false
+     * ```
+     */
+    negative: (b) => b < 0n
+  },
   // --- from ---
   from: {
     /**
@@ -7582,6 +7725,345 @@ var BigNum = {
   max: (b) => (a) => a > b ? a : b
 };
 
+// src/Data/Bool.ts
+var isBoolean = (u) => typeof u === "boolean";
+var isTrue = (u) => u === true;
+var isFalse = (u) => u === false;
+var isTruthy = (u) => Boolean(u);
+var isFalsy = (u) => !u;
+var not2 = (b) => !b;
+var and2 = (that) => (self) => self && that;
+var or2 = (that) => (self) => self || that;
+var xor = (that) => (self) => self !== that;
+var andLazy = (that) => (self) => self && that();
+var orLazy = (that) => (self) => self || that();
+var all = (booleans) => {
+  for (let i = 0; i < booleans.length; i++) {
+    if (!booleans[i]) {
+      return false;
+    }
+  }
+  return true;
+};
+var any = (booleans) => {
+  for (let i = 0; i < booleans.length; i++) {
+    if (booleans[i]) {
+      return true;
+    }
+  }
+  return false;
+};
+var fold = (onFalse, onTrue) => (b) => b ? onTrue() : onFalse();
+var match = (cases) => (b) => b ? cases.true() : cases.false();
+var fromString = (s) => {
+  const trimmed = s.trim().toLowerCase();
+  if (trimmed === "true") {
+    return Maybe.make.some(true);
+  }
+  if (trimmed === "false") {
+    return Maybe.make.some(false);
+  }
+  return Maybe.make.none();
+};
+var fromNumber = (n) => {
+  if (n === 1) {
+    return Maybe.make.some(true);
+  }
+  if (n === 0) {
+    return Maybe.make.some(false);
+  }
+  return Maybe.make.none();
+};
+var fromTruthy = (value) => Boolean(value);
+var toMaybe = (onTrue) => (b) => b ? Maybe.make.some(onTrue()) : Maybe.make.none();
+var toResult2 = (onErr, onOk) => (b) => b ? Result.make.ok(onOk()) : Result.make.err(onErr());
+var toNumber = (b) => b ? 1 : 0;
+var toString = (b) => b ? "true" : "false";
+var Bool = {
+  is: {
+    /**
+     * Type guard — checks if a value is a primitive boolean.
+     *
+     * @example
+     * ```ts
+     * Bool.is.boolean(true);      // true
+     * Bool.is.boolean(false);     // true
+     * Bool.is.boolean("true");    // false
+     * Bool.is.boolean(null);      // false
+     * ```
+     */
+    boolean: isBoolean,
+    /**
+     * Narrowing guard — checks if a value is strictly `true`.
+     *
+     * @example
+     * ```ts
+     * Bool.is.true(true);  // true
+     * Bool.is.true(false); // false
+     * ```
+     */
+    true: isTrue,
+    /**
+     * Narrowing guard — checks if a value is strictly `false`.
+     *
+     * @example
+     * ```ts
+     * Bool.is.false(false); // true
+     * Bool.is.false(true);  // false
+     * ```
+     */
+    false: isFalse,
+    /**
+     * Type guard — checks if a value is truthy (not `false`, `0`, `0n`, `""`, `null`, `undefined`, or `NaN`).
+     *
+     * @example
+     * ```ts
+     * Bool.is.truthy("hello"); // true
+     * Bool.is.truthy(42);      // true
+     * Bool.is.truthy(0);       // false
+     * Bool.is.truthy(null);    // false
+     * ```
+     */
+    truthy: isTruthy,
+    /**
+     * Type guard — checks if a value is falsy (`false`, `0`, `0n`, `""`, `null`, `undefined`, or `NaN`).
+     *
+     * @example
+     * ```ts
+     * Bool.is.falsy("");        // true
+     * Bool.is.falsy(null);      // true
+     * Bool.is.falsy("content"); // false
+     * ```
+     */
+    falsy: isFalsy
+  },
+  /**
+   * Unary boolean negation: inverts the given boolean value.
+   *
+   * @example
+   * ```ts
+   * Bool.not(true);  // false
+   * Bool.not(false); // true
+   * ```
+   */
+  not: not2,
+  /**
+   * Logical AND combinator. Returns `true` only if both `self` and `that` are `true`.
+   *
+   * Data-last: `pipe(self, Bool.and(that))`.
+   *
+   * @example
+   * ```ts
+   * pipe(true, Bool.and(true));  // true
+   * pipe(true, Bool.and(false)); // false
+   * ```
+   */
+  and: and2,
+  /**
+   * Logical OR combinator. Returns `true` if either `self` or `that` is `true`.
+   *
+   * Data-last: `pipe(self, Bool.or(that))`.
+   *
+   * @example
+   * ```ts
+   * pipe(false, Bool.or(true));  // true
+   * pipe(false, Bool.or(false)); // false
+   * ```
+   */
+  or: or2,
+  /**
+   * Logical XOR (exclusive OR) combinator. Returns `true` if exactly one of `self` and `that` is `true`.
+   *
+   * Data-last: `pipe(self, Bool.xor(that))`.
+   *
+   * @example
+   * ```ts
+   * pipe(true, Bool.xor(false)); // true
+   * pipe(true, Bool.xor(true));  // false
+   * ```
+   */
+  xor,
+  /**
+   * Lazy logical AND combinator.
+   * If `self` is `false`, the `that` computation is never evaluated.
+   *
+   * Data-last: `pipe(self, Bool.andLazy(that))`.
+   *
+   * @example
+   * ```ts
+   * pipe(
+   *   isCached,
+   *   Bool.andLazy(() => checkPermissions())
+   * );
+   * ```
+   */
+  andLazy,
+  /**
+   * Lazy logical OR combinator.
+   * If `self` is `true`, the `that` computation is never evaluated.
+   *
+   * Data-last: `pipe(self, Bool.orLazy(that))`.
+   *
+   * @example
+   * ```ts
+   * pipe(
+   *   isAdmin,
+   *   Bool.orLazy(() => hasAccess(userId))
+   * );
+   * ```
+   */
+  orLazy,
+  /**
+   * N-ary AND aggregation across an array of booleans.
+   * Returns `true` if every boolean is `true`, or for an empty array (vacuous truth).
+   * Short-circuits on the first `false`.
+   *
+   * @example
+   * ```ts
+   * Bool.all([true, true, true]);  // true
+   * Bool.all([true, false, true]); // false
+   * Bool.all([]);                  // true
+   * ```
+   */
+  all,
+  /**
+   * N-ary OR aggregation across an array of booleans.
+   * Returns `true` if at least one boolean is `true`. Returns `false` for an empty array.
+   * Short-circuits on the first `true`.
+   *
+   * @example
+   * ```ts
+   * Bool.any([false, true, false]); // true
+   * Bool.any([false, false]);       // false
+   * Bool.any([]);                   // false
+   * ```
+   */
+  any,
+  /**
+   * Catamorphism for boolean: evaluates `onFalse()` when `false` and `onTrue()` when `true`.
+   *
+   * Positional ordering: `onFalse` first, `onTrue` second.
+   * Aligned with `Result.fold(onErr, onOk)` and `Maybe.fold(onNone, onSome)`.
+   *
+   * @example
+   * ```ts
+   * pipe(
+   *   isDarkMode,
+   *   Bool.fold(
+   *     () => "light-theme",
+   *     () => "dark-theme"
+   *   )
+   * );
+   * ```
+   */
+  fold,
+  /**
+   * Pattern matching on boolean using named cases `{ true, false }`.
+   *
+   * @example
+   * ```ts
+   * pipe(
+   *   isEnabled,
+   *   Bool.match({
+   *     true: () => "Feature Active",
+   *     false: () => "Feature Disabled",
+   *   })
+   * );
+   * ```
+   */
+  match,
+  // --- from ---
+  from: {
+    /**
+     * Parses a string into a `Maybe<boolean>`.
+     * Returns `Some(true)` for `"true"`, `Some(false)` for `"false"` (case-insensitive & trimmed),
+     * and `None` for any other string.
+     *
+     * @example
+     * ```ts
+     * Bool.from.string("true");  // Some(true)
+     * Bool.from.string("FALSE"); // Some(false)
+     * Bool.from.string("yes");   // None
+     * ```
+     */
+    string: fromString,
+    /**
+     * Converts a number into a `Maybe<boolean>`.
+     * Returns `Some(true)` for `1`, `Some(false)` for `0`, and `None` for any other number.
+     *
+     * @example
+     * ```ts
+     * Bool.from.number(1);  // Some(true)
+     * Bool.from.number(0);  // Some(false)
+     * Bool.from.number(42); // None
+     * ```
+     */
+    number: fromNumber,
+    /**
+     * Coerces any unknown value into a boolean via standard JS `Boolean(value)`.
+     *
+     * @example
+     * ```ts
+     * Bool.from.truthy("hello"); // true
+     * Bool.from.truthy(0);       // false
+     * ```
+     */
+    truthy: fromTruthy
+  },
+  // --- to ---
+  to: {
+    /**
+     * Lifts a boolean condition into a `Maybe`.
+     * Returns `Some(onTrue())` when `true`, and `None` when `false`.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   user.isVerified,
+     *   Bool.to.Maybe(() => user.profile)
+     * ); // Some(profile) or None
+     * ```
+     */
+    Maybe: toMaybe,
+    /**
+     * Lifts a boolean condition into a `Result`.
+     * Returns `Ok(onOk())` when `true`, and `Err(onErr())` when `false`.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   hasPermission,
+     *   Bool.to.Result(
+     *     () => "Permission denied",
+     *     () => sessionData
+     *   )
+     * ); // Ok(sessionData) or Err("Permission denied")
+     * ```
+     */
+    Result: toResult2,
+    /**
+     * Converts a boolean to numeric `1` or `0`.
+     *
+     * @example
+     * ```ts
+     * Bool.to.number(true);  // 1
+     * Bool.to.number(false); // 0
+     * ```
+     */
+    number: toNumber,
+    /**
+     * Converts a boolean to literal string `"true"` or `"false"`.
+     *
+     * @example
+     * ```ts
+     * Bool.to.string(true);  // "true"
+     * Bool.to.string(false); // "false"
+     * ```
+     */
+    string: toString
+  }
+};
+
 // src/Data/Dict.ts
 var DictIs = {
   empty: (m) => m.size === 0,
@@ -8970,6 +9452,7 @@ var Uniq = {
 export {
   Arr,
   BigNum,
+  Bool,
   Brand,
   Combinable,
   Deferred,