@nlozgachev/pipelined 0.31.0 → 0.32.0

package/dist/{chunk-VIC54JR4.mjs → chunk-L3NC44SN.mjs}

@@ -3,7 +3,79 @@ import {
   Maybe,
   Result,
   Task
-} from "./chunk-SDGDJ7CU.mjs";
+} from "./chunk-TK5ZCGP2.mjs";
+
+// src/Core/Combinable.ts
+var Combinable;
+((Combinable2) => {
+  Combinable2.string = {
+    empty: "",
+    combine: (b) => (a) => a + b
+  };
+  Combinable2.sum = {
+    empty: 0,
+    combine: (b) => (a) => a + b
+  };
+  Combinable2.product = {
+    empty: 1,
+    combine: (b) => (a) => a * b
+  };
+  Combinable2.all = {
+    empty: true,
+    combine: (b) => (a) => a && b
+  };
+  Combinable2.any = {
+    empty: false,
+    combine: (b) => (a) => a || b
+  };
+  Combinable2.array = () => ({
+    empty: [],
+    combine: (b) => (a) => [...a, ...b]
+  });
+  Combinable2.maybe = (inner) => ({
+    empty: Maybe.none(),
+    combine: (b) => (a) => Maybe.isNone(a) ? b : Maybe.isNone(b) ? a : Maybe.some(inner.combine(b.value)(a.value))
+  });
+  Combinable2.fold = (c) => (data) => data.reduce((acc, x) => c.combine(x)(acc), c.empty);
+})(Combinable || (Combinable = {}));
+
+// src/Core/Equality.ts
+var Equality;
+((Equality2) => {
+  Equality2.string = (a, b) => a === b;
+  Equality2.number = (a, b) => a === b;
+  Equality2.boolean = (a, b) => a === b;
+  Equality2.date = (a, b) => a.getTime() === b.getTime();
+  Equality2.array = (eq) => (a, b) => a.length === b.length && a.every((x, i) => eq(x, b[i]));
+  Equality2.by = (f) => (eq) => (a, b) => eq(f(a), f(b));
+  Equality2.and = (eq2) => (eq1) => (a, b) => eq1(a, b) && eq2(a, b);
+})(Equality || (Equality = {}));
+
+// src/Core/Lazy.ts
+var Lazy;
+((Lazy2) => {
+  Lazy2.from = (f) => {
+    let done = false;
+    let cache;
+    return {
+      get: () => {
+        if (!done) {
+          cache = f();
+          done = true;
+        }
+        return cache;
+      }
+    };
+  };
+  Lazy2.evaluate = (lazy) => lazy.get();
+  Lazy2.map = (f) => (lazy) => Lazy2.from(() => f(lazy.get()));
+  Lazy2.chain = (f) => (lazy) => Lazy2.from(() => f(lazy.get()).get());
+  Lazy2.tap = (f) => (lazy) => Lazy2.from(() => {
+    const v = lazy.get();
+    f(v);
+    return v;
+  });
+})(Lazy || (Lazy = {}));
 
 // src/Core/Lens.ts
 var Lens;
@@ -1056,6 +1128,20 @@ var Optional;
   );
 })(Optional || (Optional = {}));
 
+// src/Core/Ordering.ts
+var Ordering;
+((Ordering2) => {
+  Ordering2.string = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+  Ordering2.number = (a, b) => a - b;
+  Ordering2.date = (a, b) => a.getTime() - b.getTime();
+  Ordering2.reverse = (ord) => (a, b) => ord(b, a);
+  Ordering2.thenBy = (ord2) => (ord1) => (a, b) => {
+    const r = ord1(a, b);
+    return r !== 0 ? r : ord2(a, b);
+  };
+  Ordering2.by = (f) => (ord) => (a, b) => ord(f(a), f(b));
+})(Ordering || (Ordering = {}));
+
 // src/Core/Predicate.ts
 var Predicate;
 ((Predicate2) => {
@@ -1178,28 +1264,33 @@ var Resource;
     release
   });
   Resource2.use = (f) => (resource) => Task.from(
-    () => Deferred.toPromise(resource.acquire()).then(async (acquired) => {
+    (signal) => Deferred.toPromise(resource.acquire(signal)).then(async (acquired) => {
       if (Result.isError(acquired)) return acquired;
       const a = acquired.value;
-      const usageResult = await Deferred.toPromise(f(a)());
-      await Deferred.toPromise(resource.release(a)());
-      return usageResult;
+      try {
+        const usageResult = await Deferred.toPromise(f(a)(signal));
+        return usageResult;
+      } finally {
+        await Deferred.toPromise(resource.release(a)(signal));
+      }
     })
   );
   Resource2.combine = (resourceA, resourceB) => ({
     acquire: Task.from(
-      () => Deferred.toPromise(resourceA.acquire()).then(async (acquiredA) => {
+      (signal) => Deferred.toPromise(resourceA.acquire(signal)).then(async (acquiredA) => {
         if (Result.isError(acquiredA)) return acquiredA;
         const a = acquiredA.value;
-        const acquiredB = await Deferred.toPromise(resourceB.acquire());
+        const acquiredB = await Deferred.toPromise(resourceB.acquire(signal));
         if (Result.isError(acquiredB)) {
-          await Deferred.toPromise(resourceA.release(a)());
+          await Deferred.toPromise(resourceA.release(a)(signal));
           return acquiredB;
         }
         return Result.ok([a, acquiredB.value]);
       })
     ),
-    release: ([a, b]) => Task.from(() => Deferred.toPromise(resourceB.release(b)()).then(() => Deferred.toPromise(resourceA.release(a)())))
+    release: ([a, b]) => Task.from(
+      (signal) => Deferred.toPromise(resourceB.release(b)(signal)).then(() => Deferred.toPromise(resourceA.release(a)(signal)))
+    )
   });
 })(Resource || (Resource = {}));
 
@@ -1242,14 +1333,14 @@ var TaskMaybe;
   TaskMaybe2.fromMaybe = (option) => Task.resolve(option);
   TaskMaybe2.fromTask = (task) => Task.map(Maybe.some)(task);
   TaskMaybe2.tryCatch = (f) => Task.from(
-    () => f().then(Maybe.some).catch(() => Maybe.none())
+    (signal) => f(signal).then(Maybe.some).catch(() => Maybe.none())
   );
   TaskMaybe2.map = (f) => (data) => Task.map(Maybe.map(f))(data);
   TaskMaybe2.chain = (f) => (data) => Task.chain((option) => Maybe.isSome(option) ? f(option.value) : Task.resolve(Maybe.none()))(data);
   TaskMaybe2.ap = (arg) => (data) => Task.from(
-    () => Promise.all([
-      Deferred.toPromise(data()),
-      Deferred.toPromise(arg())
+    (signal) => Promise.all([
+      Deferred.toPromise(data(signal)),
+      Deferred.toPromise(arg(signal))
     ]).then(([of_, oa]) => Maybe.ap(oa)(of_))
   );
   TaskMaybe2.fold = (onNone, onSome) => (data) => Task.map(Maybe.fold(onNone, onSome))(data);
@@ -1283,6 +1374,12 @@ var TaskResult;
   TaskResult2.getOrElse = (defaultValue) => (data) => Task.map(Result.getOrElse(defaultValue))(data);
   TaskResult2.tap = (f) => (data) => Task.map(Result.tap(f))(data);
   TaskResult2.tapError = (f) => (data) => Task.map(Result.tapError(f))(data);
+  TaskResult2.ap = (arg) => (data) => Task.from(
+    (signal) => Promise.all([
+      Deferred.toPromise(data(signal)),
+      Deferred.toPromise(arg(signal))
+    ]).then(([of_, oa]) => Result.ap(oa)(of_))
+  );
   TaskResult2.run = (signal) => (task) => Deferred.toPromise(task(signal));
 })(TaskResult || (TaskResult = {}));
 
@@ -1356,13 +1453,13 @@ var TaskValidation;
   TaskValidation2.invalidAll = (errors) => Task.resolve(Validation.invalidAll(errors));
   TaskValidation2.fromValidation = (validation) => Task.resolve(validation);
   TaskValidation2.tryCatch = (f, onError) => Task.from(
-    () => f().then(Validation.valid).catch((e) => Validation.invalid(onError(e)))
+    (signal) => f(signal).then(Validation.valid).catch((e) => Validation.invalid(onError(e)))
   );
   TaskValidation2.map = (f) => (data) => Task.map(Validation.map(f))(data);
   TaskValidation2.ap = (arg) => (data) => Task.from(
-    () => Promise.all([
-      Deferred.toPromise(data()),
-      Deferred.toPromise(arg())
+    (signal) => Promise.all([
+      Deferred.toPromise(data(signal)),
+      Deferred.toPromise(arg(signal))
     ]).then(([vf, va]) => Validation.ap(va)(vf))
   );
   TaskValidation2.fold = (onInvalid, onValid) => (data) => Task.map(Validation.fold(onInvalid, onValid))(data);
@@ -1373,13 +1470,13 @@ var TaskValidation;
     (validation) => Validation.isValid(validation) ? Task.resolve(validation) : fallback(validation.errors)
   )(data);
   TaskValidation2.product = (first, second) => Task.from(
-    () => Promise.all([
-      Deferred.toPromise(first()),
-      Deferred.toPromise(second())
+    (signal) => Promise.all([
+      Deferred.toPromise(first(signal)),
+      Deferred.toPromise(second(signal))
     ]).then(([va, vb]) => Validation.product(va, vb))
   );
   TaskValidation2.productAll = (data) => Task.from(
-    () => Promise.all(data.map((t) => Deferred.toPromise(t()))).then((results) => Validation.productAll(results))
+    (signal) => Promise.all(data.map((t) => Deferred.toPromise(t(signal)))).then((results) => Validation.productAll(results))
   );
 })(TaskValidation || (TaskValidation = {}));
 
@@ -1466,10 +1563,14 @@ var Tuple;
 })(Tuple || (Tuple = {}));
 
 export {
+  Combinable,
+  Equality,
+  Lazy,
   Lens,
   Logged,
   Op,
   Optional,
+  Ordering,
   Predicate,
   Reader,
   Refinement,

package/dist/{chunk-SDGDJ7CU.mjs → chunk-TK5ZCGP2.mjs}

@@ -1,13 +1,3 @@
-// src/Core/Deferred.ts
-var Deferred;
-((Deferred2) => {
-  Deferred2.fromPromise = (p) => (
-    // eslint-disable-next-line unicorn/no-thenable -- Deferred is intentionally thenable; it is the mechanism that makes Task awaitable
-    { then: ((f) => p.then(f)) }
-  );
-  Deferred2.toPromise = (d) => new Promise((resolve) => d.then(resolve));
-})(Deferred || (Deferred = {}));
-
 // src/Core/Maybe.ts
 var _none = { kind: "None" };
 var Maybe;
@@ -71,6 +61,16 @@ var Result;
   Result2.ap = (arg) => (data) => (0, Result2.isOk)(data) && (0, Result2.isOk)(arg) ? (0, Result2.ok)(data.value(arg.value)) : (0, Result2.isError)(data) ? data : arg;
 })(Result || (Result = {}));
 
+// src/Core/Deferred.ts
+var Deferred;
+((Deferred2) => {
+  Deferred2.fromPromise = (p) => (
+    // eslint-disable-next-line unicorn/no-thenable -- Deferred is intentionally thenable; it is the mechanism that makes Task awaitable
+    { then: ((f) => p.then(f)) }
+  );
+  Deferred2.toPromise = (d) => new Promise((resolve) => d.then(resolve));
+})(Deferred || (Deferred = {}));
+
 // src/Core/Task.ts
 var toPromise = (task, signal) => Deferred.toPromise(task(signal));
 var Task;
@@ -96,58 +96,135 @@ var Task;
     (signal) => Promise.all(tasks.map((t) => toPromise(t, signal)))
   );
   Task2.delay = (ms) => (data) => (0, Task2.from)(
-    (signal) => new Promise(
-      (resolve2) => setTimeout(
-        () => toPromise(data, signal).then(resolve2),
-        ms
-      )
-    )
+    (signal) => new Promise((resolve2) => {
+      let timerId = void 0;
+      const onAbort = () => {
+        if (timerId !== void 0) {
+          clearTimeout(timerId);
+        }
+        resolve2(toPromise(data, signal));
+      };
+      if (signal) {
+        if (signal.aborted) {
+          return resolve2(toPromise(data, signal));
+        }
+        signal.addEventListener("abort", onAbort, { once: true });
+      }
+      timerId = setTimeout(() => {
+        signal?.removeEventListener("abort", onAbort);
+        resolve2(toPromise(data, signal));
+      }, ms);
+    })
   );
   Task2.repeat = (options) => (task) => (0, Task2.from)((signal) => {
     const { times, delay: ms } = options;
     if (times <= 0) return Promise.resolve([]);
     const results = [];
-    const wait = () => ms !== void 0 && ms > 0 ? new Promise((r) => setTimeout(r, ms)) : Promise.resolve();
-    const run2 = (left) => toPromise(task, signal).then((a) => {
-      results.push(a);
-      if (left <= 1) return results;
-      return wait().then(() => run2(left - 1));
-    });
+    const wait = () => {
+      if (signal?.aborted) return Promise.resolve();
+      return new Promise((r) => {
+        let timerId = void 0;
+        const onAbort = () => {
+          if (timerId !== void 0) {
+            clearTimeout(timerId);
+          }
+          r();
+        };
+        if (signal) {
+          signal.addEventListener("abort", onAbort, { once: true });
+        }
+        timerId = setTimeout(() => {
+          signal?.removeEventListener("abort", onAbort);
+          r();
+        }, ms || 0);
+      });
+    };
+    const run2 = (left) => {
+      if (signal?.aborted) {
+        return Promise.resolve(results);
+      }
+      return toPromise(task, signal).then((a) => {
+        results.push(a);
+        if (left <= 1 || signal?.aborted) return results;
+        return wait().then(() => run2(left - 1));
+      });
+    };
     return run2(times);
   });
   Task2.repeatUntil = (options) => (task) => (0, Task2.from)((signal) => {
     const { when: predicate, delay: ms, maxAttempts } = options;
-    const wait = () => ms !== void 0 && ms > 0 ? new Promise((r) => setTimeout(r, ms)) : Promise.resolve();
-    const run2 = (attempt) => toPromise(task, signal).then((a) => {
-      if (predicate(a)) return a;
-      if (maxAttempts !== void 0 && attempt >= maxAttempts) return a;
-      return wait().then(() => run2(attempt + 1));
-    });
+    const wait = () => {
+      if (signal?.aborted) return Promise.resolve();
+      return new Promise((r) => {
+        let timerId = void 0;
+        const onAbort = () => {
+          if (timerId !== void 0) {
+            clearTimeout(timerId);
+          }
+          r();
+        };
+        if (signal) {
+          signal.addEventListener("abort", onAbort, { once: true });
+        }
+        timerId = setTimeout(() => {
+          signal?.removeEventListener("abort", onAbort);
+          r();
+        }, ms || 0);
+      });
+    };
+    const run2 = (attempt, lastValue) => {
+      if (signal?.aborted && lastValue !== void 0) {
+        return Promise.resolve(lastValue);
+      }
+      return toPromise(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(() => run2(attempt + 1, a));
+      });
+    };
     return run2(1);
   });
   Task2.race = (tasks) => (0, Task2.from)((signal) => Promise.race(tasks.map((t) => toPromise(t, signal))));
   Task2.sequential = (tasks) => (0, Task2.from)(async (signal) => {
     const results = [];
     for (const task of tasks) {
+      if (signal?.aborted) {
+        break;
+      }
       results.push(await toPromise(task, signal));
     }
     return results;
   });
   Task2.timeout = (ms, onTimeout) => (task) => (0, Task2.from)((outerSignal) => {
     const controller = new AbortController();
-    const onOuterAbort = () => controller.abort();
-    outerSignal?.addEventListener("abort", onOuterAbort, { once: true });
     let timerId;
+    const cleanUp = () => {
+      if (timerId !== void 0) {
+        clearTimeout(timerId);
+      }
+      outerSignal?.removeEventListener("abort", onOuterAbort);
+    };
+    const onOuterAbort = () => {
+      cleanUp();
+      controller.abort();
+    };
+    if (outerSignal) {
+      if (outerSignal.aborted) {
+        controller.abort();
+      } else {
+        outerSignal.addEventListener("abort", onOuterAbort, { once: true });
+      }
+    }
     return Promise.race([
       toPromise(task, controller.signal).then((a) => {
-        clearTimeout(timerId);
-        outerSignal?.removeEventListener("abort", onOuterAbort);
+        cleanUp();
         return Result.ok(a);
       }),
       new Promise((resolve2) => {
         timerId = setTimeout(() => {
           controller.abort();
-          outerSignal?.removeEventListener("abort", onOuterAbort);
+          cleanUp();
           resolve2(Result.error(onTimeout()));
         }, ms);
       })
@@ -175,8 +252,8 @@ var Task;
 })(Task || (Task = {}));
 
 export {
-  Deferred,
   Result,
   Maybe,
+  Deferred,
   Task
 };

package/dist/core.d.mts

@@ -1,7 +1,171 @@
-import { M as Maybe, W as WithValue, a as WithLog, D as Deferred, R as Result, b as WithKind, c as WithError, d as RetryOptions, e as TimeoutOptions, f as WithTimeout, g as WithMinInterval, h as WithCooldown, i as WithConcurrency, j as WithSize, k as WithMs, l as WithN, T as Task, m as WithErrors, n as WithFirst, o as WithSecond } from './Task-BDcKwFAj.mjs';
-export { E as Error, N as None, O as Ok, S as Some } from './Task-BDcKwFAj.mjs';
+import { M as Maybe, W as WithValue, c as WithLog, D as Deferred, R as Result, d as WithKind, e as WithError, f as RetryOptions, g as TimeoutOptions, h as WithTimeout, i as WithMinInterval, j as WithCooldown, k as WithConcurrency, l as WithSize, m as WithMs, n as WithN, T as Task, o as WithErrors, p as WithFirst, q as WithSecond } from './Task-CJZfcOkO.mjs';
+export { E as Equality, a as Error, N as None, O as Ok, b as Ordering, S as Some } from './Task-CJZfcOkO.mjs';
 import { N as NonEmptyList } from './NonEmptyList-BlGFjor5.mjs';
 
+/**
+ * A type that can combine two values of type `A` into one, with a neutral starting value.
+ * `empty` is the identity: `combine(empty)(a) === a` and `combine(a)(empty) === a`.
+ * `combine(b)(a)` appends `b` onto `a` — `a` is the accumulated value, `b` is the new element.
+ *
+ * @example
+ * ```ts
+ * pipe(["hello", ", ", "world"], Combinable.fold(Combinable.string)); // "hello, world"
+ * pipe([1, 2, 3, 4, 5], Combinable.fold(Combinable.sum));            // 15
+ * ```
+ */
+type Combinable<A> = {
+    readonly empty: A;
+    readonly combine: (b: A) => (a: A) => A;
+};
+declare namespace Combinable {
+    /**
+     * Combines strings by concatenation. Empty string is the neutral element.
+     *
+     * @example
+     * ```ts
+     * pipe(["a", "b", "c"], Combinable.fold(Combinable.string)); // "abc"
+     * ```
+     */
+    const string: Combinable<string>;
+    /**
+     * Combines numbers by addition. `0` is the neutral element.
+     *
+     * @example
+     * ```ts
+     * pipe([1, 2, 3], Combinable.fold(Combinable.sum)); // 6
+     * ```
+     */
+    const sum: Combinable<number>;
+    /**
+     * Combines numbers by multiplication. `1` is the neutral element.
+     *
+     * @example
+     * ```ts
+     * pipe([2, 3, 4], Combinable.fold(Combinable.product)); // 24
+     * ```
+     */
+    const product: Combinable<number>;
+    /**
+     * Combines booleans with logical AND. `true` is the neutral element.
+     *
+     * @example
+     * ```ts
+     * pipe([true, true, false], Combinable.fold(Combinable.all)); // false
+     * ```
+     */
+    const all: Combinable<boolean>;
+    /**
+     * Combines booleans with logical OR. `false` is the neutral element.
+     *
+     * @example
+     * ```ts
+     * pipe([false, false, true], Combinable.fold(Combinable.any)); // true
+     * ```
+     */
+    const any: Combinable<boolean>;
+    /**
+     * Combines arrays by concatenation. Empty array is the neutral element.
+     *
+     * @example
+     * ```ts
+     * pipe([[1, 2], [3], [4, 5]], Combinable.fold(Combinable.array<number>())); // [1, 2, 3, 4, 5]
+     * ```
+     */
+    const array: <A>() => Combinable<readonly A[]>;
+    /**
+     * Lifts a `Combinable<A>` to `Combinable<Maybe<A>>`. `None` is the neutral element —
+     * combining with `None` on either side returns the other value unchanged.
+     * Two `Some` values combine their inner values using the inner `Combinable`.
+     *
+     * @example
+     * ```ts
+     * const c = Combinable.maybe(Combinable.sum);
+     * c.combine(Maybe.some(3))(Maybe.some(2)); // Some(5)
+     * c.combine(Maybe.none())(Maybe.some(5));  // Some(5)
+     * ```
+     */
+    const maybe: <A>(inner: Combinable<A>) => Combinable<Maybe<A>>;
+    /**
+     * Folds an array into a single value using the `Combinable`'s `empty` as the starting point.
+     *
+     * @example
+     * ```ts
+     * pipe([1, 2, 3, 4, 5], Combinable.fold(Combinable.sum)); // 15
+     * pipe([], Combinable.fold(Combinable.sum));               // 0
+     * ```
+     */
+    const fold: <A>(c: Combinable<A>) => (data: readonly A[]) => A;
+}
+
+/**
+ * A synchronous memoized computation. The factory function runs exactly once —
+ * on the first call to `Lazy.evaluate` — and the result is cached for all subsequent calls.
+ *
+ * @example
+ * ```ts
+ * const config = Lazy.from(() => parseConfig(rawInput));
+ *
+ * pipe(
+ *   config,
+ *   Lazy.map(cfg => cfg.port),
+ *   Lazy.evaluate,
+ * ); // parseConfig ran once; cfg.port returned
+ * ```
+ */
+type Lazy<A> = {
+    readonly get: () => A;
+};
+declare namespace Lazy {
+    /**
+     * Wraps a thunk in a `Lazy`. The thunk runs exactly once, on first `evaluate`.
+     *
+     * @example
+     * ```ts
+     * const expensive = Lazy.from(() => computeExpensiveValue(input));
+     * ```
+     */
+    const from: <A>(f: () => A) => Lazy<A>;
+    /**
+     * Forces evaluation and returns the cached result. Safe to call multiple times.
+     *
+     * @example
+     * ```ts
+     * const value = Lazy.evaluate(Lazy.from(() => 42)); // 42
+     * ```
+     */
+    const evaluate: <A>(lazy: Lazy<A>) => A;
+    /**
+     * Transforms the result of a `Lazy` without triggering evaluation.
+     *
+     * @example
+     * ```ts
+     * pipe(Lazy.from(() => loadConfig()), Lazy.map(cfg => cfg.port));
+     * ```
+     */
+    const map: <A, B>(f: (a: A) => B) => (lazy: Lazy<A>) => Lazy<B>;
+    /**
+     * Chains a `Lazy`-returning transformation without triggering evaluation.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   Lazy.from(() => loadConfig()),
+     *   Lazy.chain(cfg => Lazy.from(() => openConnection(cfg.dbUrl))),
+     * );
+     * ```
+     */
+    const chain: <A, B>(f: (a: A) => Lazy<B>) => (lazy: Lazy<A>) => Lazy<B>;
+    /**
+     * Runs a side effect on the value without changing it. Fires once, on first `evaluate`.
+     *
+     * @example
+     * ```ts
+     * pipe(Lazy.from(() => compute()), Lazy.tap(v => console.log("computed:", v)));
+     * ```
+     */
+    const tap: <A>(f: (a: A) => void) => (lazy: Lazy<A>) => Lazy<A>;
+}
+
 /** Keys of T for which undefined is assignable (i.e. optional fields). */
 type OptionalKeys<T> = {
     [K in keyof T]-?: undefined extends T[K] ? K : never;
@@ -1888,6 +2052,11 @@ declare namespace TaskResult {
      * ```
      */
     const tapError: <E, A>(f: (e: E) => void) => (data: TaskResult<E, A>) => TaskResult<E, A>;
+    /**
+     * Applies a function wrapped in a TaskResult to a value wrapped in a TaskResult.
+     * Both Tasks run in parallel.
+     */
+    const ap: <E, A>(arg: TaskResult<E, A>) => <B>(data: TaskResult<E, (a: A) => B>) => TaskResult<E, B>;
     /**
      * Executes a `TaskResult` with an optional signal, returning `Promise<Result<E, A>>`.
      * Use as a terminal step in a `pipe` chain.
@@ -2230,15 +2399,16 @@ declare namespace TaskMaybe {
     /**
      * Creates a TaskMaybe from a Promise-returning function.
      * Returns Some if the promise resolves, None if it rejects.
+     * The factory optionally receives an `AbortSignal` forwarded from the call site.
      *
      * @example
      * ```ts
-     * const fetchUser = TaskMaybe.tryCatch(() =>
-     *   fetch("/user/1").then(r => r.json())
+     * const fetchUser = TaskMaybe.tryCatch((signal) =>
+     *   fetch("/user/1", { signal }).then(r => r.json())
      * );
      * ```
      */
-    const tryCatch: <A>(f: () => Promise<A>) => TaskMaybe<A>;
+    const tryCatch: <A>(f: (signal?: AbortSignal) => Promise<A>) => TaskMaybe<A>;
     /**
      * Transforms the value inside a TaskMaybe.
      */
@@ -2627,17 +2797,18 @@ declare namespace TaskValidation {
     /**
      * Creates a TaskValidation from a Promise-returning function.
      * Catches any errors and transforms them using the onError function.
+     * The factory optionally receives an `AbortSignal` forwarded from the call site.
      *
      * @example
      * ```ts
      * const fetchUser = (id: string): TaskValidation<string, User> =>
      *   TaskValidation.tryCatch(
-     *     () => fetch(`/users/${id}`).then(r => r.json()),
+     *     (signal) => fetch(`/users/${id}`, { signal }).then(r => r.json()),
      *     e => `Failed to fetch user: ${e}`
      *   );
      * ```
      */
-    const tryCatch: <E, A>(f: () => Promise<A>, onError: (e: unknown) => E) => TaskValidation<E, A>;
+    const tryCatch: <E, A>(f: (signal?: AbortSignal) => Promise<A>, onError: (e: unknown) => E) => TaskValidation<E, A>;
     /**
      * Transforms the success value inside a TaskValidation.
      */
@@ -3079,4 +3250,4 @@ declare namespace Tuple {
     const tap: <A, B>(f: (a: A, b: B) => void) => (tuple: Tuple<A, B>) => Tuple<A, B>;
 }
 
-export { Deferred, type Failure, type Invalid, Lens, type Loading, Logged, Maybe, type NotAsked, Op, Optional, Predicate, Reader, Refinement, RemoteData, Resource, Result, State, type Success, Task, TaskMaybe, TaskResult, TaskValidation, These, type TheseBoth, type TheseFirst, type TheseSecond, Tuple, type Valid, Validation };
+export { Combinable, Deferred, type Failure, type Invalid, Lazy, Lens, type Loading, Logged, Maybe, type NotAsked, Op, Optional, Predicate, Reader, Refinement, RemoteData, Resource, Result, State, type Success, Task, TaskMaybe, TaskResult, TaskValidation, These, type TheseBoth, type TheseFirst, type TheseSecond, Tuple, type Valid, Validation };