@nlozgachev/pipelined 0.19.0 → 0.21.0

package/README.md

@@ -1,6 +1,6 @@
 # pipelined
 
-[![npm](https://img.shields.io/npm/v/@nlozgachev/pipelined?style=for-the-badge&color=000&logo=npm&label&logoColor=fff)](https://www.npmjs.com/package/@nlozgachev/pipelined)[![GitHub Actions Workflow Status](https://img.shields.io/github/actions/workflow/status/nlozgachev/pipelined/publish.yml?style=for-the-badge&color=000&logo=githubactions&label&logoColor=fff)](https://github.com/nlozgachev/pipelined/actions/workflows/publish.yml)[![Codecov](https://img.shields.io/codecov/c/github/nlozgachev/pipelined?style=for-the-badge&color=000&logo=codecov&label&logoColor=fff)](https://app.codecov.io/github/nlozgachev/pipelined)[![TypeScript](https://img.shields.io/badge/-0?style=for-the-badge&color=000&logo=typescript&label&logoColor=fff)](https://www.typescriptlang.org)
+[![npm](https://img.shields.io/npm/v/@nlozgachev/pipelined?style=for-the-badge&color=000&logo=npm&label&logoColor=fff)](https://www.npmjs.com/package/@nlozgachev/pipelined) [![GitHub Actions Workflow Status](https://img.shields.io/github/actions/workflow/status/nlozgachev/pipelined/publish.yml?style=for-the-badge&color=000&logo=githubactions&label&logoColor=fff)](https://github.com/nlozgachev/pipelined/actions/workflows/publish.yml) [![Codecov](https://img.shields.io/codecov/c/github/nlozgachev/pipelined?style=for-the-badge&color=000&logo=codecov&label&logoColor=fff)](https://app.codecov.io/github/nlozgachev/pipelined) [![TypeScript](https://img.shields.io/badge/-0?style=for-the-badge&color=000&logo=typescript&label&logoColor=fff)](https://www.typescriptlang.org)
 
 Opinionated functional abstractions for TypeScript.
 
@@ -10,15 +10,99 @@ Opinionated functional abstractions for TypeScript.
 npm add @nlozgachev/pipelined
 ```
 
-## What is this?
+## Possibly maybe
 
-A toolkit for expressing uncertainty precisely. Instead of `T | null`, `try/catch`, and loading
-state flag soup, you get types that name every possible state and make invalid ones unrepresentable.
-Each type comes with a consistent set of operations — `map`, `chain`, `match`, `getOrElse` — that
-compose with `pipe` and `flow`.
+**pipelined** names every possible state and gives you operations that compose. `Maybe<A>` for values
+that may or may not be there. `Result<E, A>` for operations that succeed or fail
+with a typed error. `TaskResult<E, A>` for async operations that do both — lazily, with retry,
+timeout, and cancellation built in. And, of course, there is more than that.
+
+## Documentation
+
+Full guides and API reference at **[pipelined.lozgachev.dev](https://pipelined.lozgachev.dev)**.
+
+## Example
+
+A careful, production-minded attempt at "fetch with retry, timeout, and cancellation":
+
+```ts
+type UserResult =
+	| { ok: true; user: User; }
+	| { ok: false; error: "Timeout" | "NetworkError"; };
+
+async function fetchUser(
+	id: string,
+	signal?: AbortSignal,
+): Promise<UserResult> {
+	async function attempt(n: number): Promise<UserResult> {
+		const controller = new AbortController();
+		const timerId = setTimeout(() => controller.abort(), 5000);
+		signal?.addEventListener("abort", () => controller.abort(), { once: true });
+
+		try {
+			const res = await fetch(`/users/${id}`, { signal: controller.signal });
+			clearTimeout(timerId);
+			return { ok: true, user: await res.json() };
+		} catch (e) {
+			clearTimeout(timerId);
+			if ((e as Error).name === "AbortError" && !signal?.aborted) {
+				return { ok: false, error: "Timeout" };
+			}
+			if (n < 3) {
+				await new Promise((r) => setTimeout(r, n * 1000));
+				return attempt(n + 1);
+			}
+			return { ok: false, error: "NetworkError" };
+		}
+	}
+	return attempt(1);
+}
+```
+
+The signal is forwarded by hand. The timeout needs its own controller. Timed-out aborts are
+distinguished from external cancellation by checking `signal?.aborted`. The retry is recursive
+to thread the attempt count.
+
+With **pipelined**:
+
+```ts
+import { pipe } from "@nlozgachev/pipelined/composition";
+import { Result, TaskResult } from "@nlozgachev/pipelined/core";
+
+const fetchUser = (id: string): TaskResult<ApiError, User> =>
+	pipe(
+		TaskResult.tryCatch(
+			(signal) => fetch(`/users/${id}`, { signal }).then((r) => r.json()),
+			(e) => new ApiError(e),
+		),
+		TaskResult.timeout(5000, () => new ApiError("request timed out")),
+		TaskResult.retry({ attempts: 3, backoff: (n) => n * 1000 }),
+	);
+```
+
+`TaskResult<ApiError, User>` is a lazy function — nothing runs until called. The `AbortSignal`
+threads through every retry and the timeout automatically. The return type is the contract:
+`ApiError` on the left, `User` on the right, nothing escapes as an exception.
+
+```ts
+const controller = new AbortController();
+const result = await fetchUser("42")(controller.signal);
+
+if (Result.isOk(result)) {
+	render(result.value); // User
+} else {
+	showError(result.error); // ApiError, not unknown
+}
+```
 
 ## What's included?
 
+`TaskResult` is one type. The library also covers the rest of the states you encounter in real
+applications: values that may be absent, operations that accumulate multiple errors, data that moves
+through `NotAsked >> Loading >> ( Success | Failure )`, nested immutable updates, and computations that
+share a common environment. Every type follows the same conventions — `map`, `chain`, `match`,
+`getOrElse` — so moving between them feels familiar.
+
 ### pipelined/core
 
 - **`Maybe<A>`** — a value that may not exist; propagates absence without null checks.
@@ -38,16 +122,22 @@ compose with `pipe` and `flow`.
 - **`Reader<R, A>`** — a computation that depends on an environment `R`, supplied once at the
   boundary.
 
-
 ### pipelined/utils
 
 Everyday utilities for built-in JS types.
 
 - **`Arr`** — array utilities, data-last, returning `Maybe` instead of `undefined`.
 - **`Rec`** — record/object utilities, data-last, with `Maybe`-returning key lookup.
+- **`Dict`** — `ReadonlyMap<K, V>` utilities: `lookup`, `groupBy`, `upsert`, set operations.
+- **`Uniq`** — `ReadonlySet<A>` utilities: `insert`, `remove`, `union`, `intersection`, `difference`.
 - **`Num`** — number utilities: `range`, `clamp`, `between`, safe `parse`, and curried arithmetic.
 - **`Str`** — string utilities: `split`, `trim`, `words`, `lines`, and safe `parse.int` / `parse.float`.
 
+Every utility is benchmarked against its native equivalent. The data-last currying adds a function
+call; that is the expected cost of composability. Operations that exceeded a reasonable overhead
+have custom implementations that in several cases run faster than the native method they replace. See the
+[benchmarks page](https://pipelined.lozgachev.dev/appendix/benchmarks) for the methodology.
+
 ### pipelined/types
 
 - **`Brand<K, T>`** — nominal typing at compile time, zero runtime cost.
@@ -58,34 +148,6 @@ Everyday utilities for built-in JS types.
 - **`pipe`**, **`flow`**, **`compose`** — function composition.
 - **`curry`** / **`uncurry`**, **`tap`**, **`memoize`**, and other function utilities.
 
-## Example
-
-```ts
-import { Maybe, Result } from "@nlozgachev/pipelined/core";
-import { pipe } from "@nlozgachev/pipelined/composition";
-
-// Chain nullable lookups without nested null checks
-const city = pipe(
-  getUser(userId), // User | null
-  Maybe.fromNullable, // Maybe<User>
-  Maybe.chain((u) => Maybe.fromNullable(u.address)), // Maybe<Address>
-  Maybe.chain((a) => Maybe.fromNullable(a.city)), // Maybe<string>
-  Maybe.map((c) => c.toUpperCase()), // Maybe<string>
-  Maybe.getOrElse("UNKNOWN"), // string
-);
-
-// Parse input and look up a record — both steps can fail
-const record = pipe(
-  parseId(rawInput), // Result<ParseError, number>
-  Result.chain((id) => db.find(id)), // Result<ParseError | NotFoundError, Record>
-  Result.map((r) => r.name), // Result<ParseError | NotFoundError, string>
-);
-```
-
-## Documentation
-
-Full guides and API reference at **[pipelined.lozgachev.dev](https://pipelined.lozgachev.dev)**.
-
 ## License
 
 BSD-3-Clause

package/dist/{Task-DBW4nOZR.d.mts → Task-CT8iwwuB.d.mts}

@@ -22,13 +22,17 @@ declare const _deferred: unique symbol;
  */
 type Deferred<A> = {
     readonly [_deferred]: A;
-    readonly then: (onfulfilled: (value: A) => void) => void;
+    readonly then: (onfulfilled: (value: A) => unknown) => void;
 };
 declare namespace Deferred {
     /**
      * Wraps a `Promise` into a `Deferred`, structurally excluding rejection handlers,
      * `.catch()`, `.finally()`, and chainable `.then()`.
      *
+     * **Precondition**: `p` must never reject. If `p` rejects, the returned `Deferred` will
+     * never resolve — `await`-ing it will hang indefinitely. Use `TaskResult.tryCatch` to
+     * handle operations that may fail before converting to a `Deferred`.
+     *
      * @example
      * ```ts
      * const d = Deferred.fromPromise(Promise.resolve("hello"));
@@ -69,6 +73,76 @@ type WithSecond<T> = {
 type WithLog<T> = {
     readonly log: ReadonlyArray<T>;
 };
+/** Retry policy for `Op.interpret`. */
+type RetryOptions<E> = {
+    readonly attempts: number;
+    readonly backoff?: number | ((attempt: number) => number);
+    readonly when?: (error: E) => boolean;
+};
+/** Timeout policy for `Op.interpret`. Wraps the entire retry sequence. */
+type TimeoutOptions<E> = {
+    readonly ms: number;
+    readonly onTimeout: () => E;
+};
+type WithRetry<E> = {
+    readonly retry: RetryOptions<E>;
+};
+type WithTimeout<E> = {
+    readonly timeout?: TimeoutOptions<E>;
+};
+type WithMs = {
+    readonly ms: number;
+};
+/** For `throttled`: also fire on the trailing edge after the cooldown. */
+type WithTrailing = {
+    readonly trailing: true;
+};
+/** For `debounced`: also fire on the leading edge (first call). */
+type WithLeading = {
+    readonly leading: true;
+};
+/** For `debounced`: maximum ms before the trailing call fires regardless of continued activity. */
+type WithMaxWait = {
+    readonly maxWait: number;
+};
+type WithN = {
+    readonly n: number;
+};
+/**
+ * `O` is a string literal (or union of literals) representing the overflow value.
+ * The generic lets overload signatures discriminate on the specific value:
+ *   `WithOverflow<"drop">` → `{ overflow: "drop" }`
+ *   `WithOverflow<"replace-last">` → `{ overflow: "replace-last" }`
+ * Used by both `concurrent` (`"drop" | "queue"`) and `queue` (`"drop" | "replace-last"`).
+ * `extends string` prevents `WithOverflow<42>` from being valid.
+ */
+type WithOverflow<O extends string> = {
+    readonly overflow: O;
+};
+type WithMaxSize = {
+    readonly maxSize: number;
+};
+type WithConcurrency = {
+    readonly concurrency?: number;
+};
+type WithDedupe<I> = {
+    readonly dedupe: (a: I, b: I) => boolean;
+};
+type WithSize = {
+    readonly size?: number;
+};
+type WithCooldown = {
+    readonly cooldown?: number;
+};
+type WithMinInterval = {
+    readonly minInterval?: number;
+};
+type WithKey<I, K> = {
+    readonly key: (input: I) => K;
+};
+type WithPerKey<S extends string> = {
+    readonly perKey: S;
+};
 
 type Ok<A> = WithKind<"Ok"> & WithValue<A>;
 type Err<E> = WithKind<"Error"> & WithError<E>;
@@ -465,6 +539,10 @@ declare namespace Maybe {
  * - **Infallible** — it never rejects. If failure is possible, encode it in the
  *   return type using `TaskResult<E, A>` instead.
  *
+ * An optional `AbortSignal` can be passed at the call site. Combinators like
+ * `retry`, `pollUntil`, and `timeout` thread it automatically to every inner
+ * operation. Existing tasks that ignore the signal continue to work unchanged.
+ *
  * Calling a Task returns a `Deferred<A>` — a one-shot async value that supports
  * `await` but has no `.catch()`, `.finally()`, or chainable `.then()`.
  *
@@ -495,7 +573,7 @@ declare namespace Maybe {
  * const result = await formatted();
  * ```
  */
-type Task<A> = () => Deferred<A>;
+type Task<A> = (signal?: AbortSignal) => Deferred<A>;
 declare namespace Task {
     /**
      * Creates a Task that immediately resolves to the given value.
@@ -509,13 +587,14 @@ declare namespace Task {
     const resolve: <A>(value: A) => Task<A>;
     /**
      * Creates a Task from a function that returns a Promise.
+     * The factory optionally receives an `AbortSignal` forwarded from the call site.
      *
      * @example
      * ```ts
      * const getTimestamp = Task.from(() => Promise.resolve(Date.now()));
      * ```
      */
-    const from: <A>(f: () => Promise<A>) => Task<A>;
+    const from: <A>(f: (signal?: AbortSignal) => Promise<A>) => Task<A>;
     /**
      * Transforms the value inside a Task.
      *
@@ -660,7 +739,9 @@ declare namespace Task {
     const sequential: <A>(tasks: ReadonlyArray<Task<A>>) => Task<ReadonlyArray<A>>;
     /**
      * Converts a `Task<A>` into a `Task<Result<E, A>>`, resolving to `Err` if the
-     * Task does not complete within the given time.
+     * Task does not complete within the given time. The inner Task receives an
+     * `AbortSignal` that fires when the deadline passes, so operations like `fetch`
+     * that accept a signal are cancelled rather than left dangling.
      *
      * @example
      * ```ts
@@ -672,6 +753,28 @@ declare namespace Task {
      * ```
      */
     const timeout: <E>(ms: number, onTimeout: () => E) => <A>(task: Task<A>) => Task<Result<E, A>>;
+    /**
+     * Creates a Task paired with an `abort` handle. When `abort()` is called the
+     * `AbortSignal` passed to the factory is fired, cancelling any in-flight
+     * operation (e.g. a `fetch`) immediately.
+     *
+     * If an outer signal is also present (passed at the call site), aborting it
+     * propagates into the internal controller.
+     *
+     * @example
+     * ```ts
+     * const { task: poll, abort } = Task.abortable(
+     *   (signal) => waitForEvent(bus, "ready", { signal }),
+     * );
+     *
+     * onUnmount(abort);
+     * await poll();
+     * ```
+     */
+    const abortable: <A>(factory: (signal: AbortSignal) => Promise<A>) => {
+        task: Task<A>;
+        abort: () => void;
+    };
 }
 
-export { Deferred as D, type Err as E, Maybe as M, type None as N, type Ok as O, Result as R, type Some as S, Task as T, type WithValue as W, type WithLog as a, type WithKind as b, type WithError as c, type WithErrors as d, type WithFirst as e, type WithSecond as f };
+export { Deferred as D, type Err as E, Maybe as M, type None as N, type Ok as O, Result as R, type Some as S, Task as T, type WithValue as W, type WithLog as a, type WithKind as b, type WithError as c, type RetryOptions as d, type TimeoutOptions as e, type WithMs as f, type WithTrailing as g, type WithRetry as h, type WithTimeout as i, type WithLeading as j, type WithMaxWait as k, type WithN as l, type WithOverflow as m, type WithKey as n, type WithPerKey as o, type WithMinInterval as p, type WithCooldown as q, type WithMaxSize as r, type WithDedupe as s, type WithConcurrency as t, type WithSize as u, type WithErrors as v, type WithFirst as w, type WithSecond as x };

package/dist/{Task-DUdIQm-Q.d.ts → Task-GSGtQO1m.d.ts}

@@ -22,13 +22,17 @@ declare const _deferred: unique symbol;
  */
 type Deferred<A> = {
     readonly [_deferred]: A;
-    readonly then: (onfulfilled: (value: A) => void) => void;
+    readonly then: (onfulfilled: (value: A) => unknown) => void;
 };
 declare namespace Deferred {
     /**
      * Wraps a `Promise` into a `Deferred`, structurally excluding rejection handlers,
      * `.catch()`, `.finally()`, and chainable `.then()`.
      *
+     * **Precondition**: `p` must never reject. If `p` rejects, the returned `Deferred` will
+     * never resolve — `await`-ing it will hang indefinitely. Use `TaskResult.tryCatch` to
+     * handle operations that may fail before converting to a `Deferred`.
+     *
      * @example
      * ```ts
      * const d = Deferred.fromPromise(Promise.resolve("hello"));
@@ -69,6 +73,76 @@ type WithSecond<T> = {
 type WithLog<T> = {
     readonly log: ReadonlyArray<T>;
 };
+/** Retry policy for `Op.interpret`. */
+type RetryOptions<E> = {
+    readonly attempts: number;
+    readonly backoff?: number | ((attempt: number) => number);
+    readonly when?: (error: E) => boolean;
+};
+/** Timeout policy for `Op.interpret`. Wraps the entire retry sequence. */
+type TimeoutOptions<E> = {
+    readonly ms: number;
+    readonly onTimeout: () => E;
+};
+type WithRetry<E> = {
+    readonly retry: RetryOptions<E>;
+};
+type WithTimeout<E> = {
+    readonly timeout?: TimeoutOptions<E>;
+};
+type WithMs = {
+    readonly ms: number;
+};
+/** For `throttled`: also fire on the trailing edge after the cooldown. */
+type WithTrailing = {
+    readonly trailing: true;
+};
+/** For `debounced`: also fire on the leading edge (first call). */
+type WithLeading = {
+    readonly leading: true;
+};
+/** For `debounced`: maximum ms before the trailing call fires regardless of continued activity. */
+type WithMaxWait = {
+    readonly maxWait: number;
+};
+type WithN = {
+    readonly n: number;
+};
+/**
+ * `O` is a string literal (or union of literals) representing the overflow value.
+ * The generic lets overload signatures discriminate on the specific value:
+ *   `WithOverflow<"drop">` → `{ overflow: "drop" }`
+ *   `WithOverflow<"replace-last">` → `{ overflow: "replace-last" }`
+ * Used by both `concurrent` (`"drop" | "queue"`) and `queue` (`"drop" | "replace-last"`).
+ * `extends string` prevents `WithOverflow<42>` from being valid.
+ */
+type WithOverflow<O extends string> = {
+    readonly overflow: O;
+};
+type WithMaxSize = {
+    readonly maxSize: number;
+};
+type WithConcurrency = {
+    readonly concurrency?: number;
+};
+type WithDedupe<I> = {
+    readonly dedupe: (a: I, b: I) => boolean;
+};
+type WithSize = {
+    readonly size?: number;
+};
+type WithCooldown = {
+    readonly cooldown?: number;
+};
+type WithMinInterval = {
+    readonly minInterval?: number;
+};
+type WithKey<I, K> = {
+    readonly key: (input: I) => K;
+};
+type WithPerKey<S extends string> = {
+    readonly perKey: S;
+};
 
 type Ok<A> = WithKind<"Ok"> & WithValue<A>;
 type Err<E> = WithKind<"Error"> & WithError<E>;
@@ -465,6 +539,10 @@ declare namespace Maybe {
  * - **Infallible** — it never rejects. If failure is possible, encode it in the
  *   return type using `TaskResult<E, A>` instead.
  *
+ * An optional `AbortSignal` can be passed at the call site. Combinators like
+ * `retry`, `pollUntil`, and `timeout` thread it automatically to every inner
+ * operation. Existing tasks that ignore the signal continue to work unchanged.
+ *
  * Calling a Task returns a `Deferred<A>` — a one-shot async value that supports
  * `await` but has no `.catch()`, `.finally()`, or chainable `.then()`.
  *
@@ -495,7 +573,7 @@ declare namespace Maybe {
  * const result = await formatted();
  * ```
  */
-type Task<A> = () => Deferred<A>;
+type Task<A> = (signal?: AbortSignal) => Deferred<A>;
 declare namespace Task {
     /**
      * Creates a Task that immediately resolves to the given value.
@@ -509,13 +587,14 @@ declare namespace Task {
     const resolve: <A>(value: A) => Task<A>;
     /**
      * Creates a Task from a function that returns a Promise.
+     * The factory optionally receives an `AbortSignal` forwarded from the call site.
      *
      * @example
      * ```ts
      * const getTimestamp = Task.from(() => Promise.resolve(Date.now()));
      * ```
      */
-    const from: <A>(f: () => Promise<A>) => Task<A>;
+    const from: <A>(f: (signal?: AbortSignal) => Promise<A>) => Task<A>;
     /**
      * Transforms the value inside a Task.
      *
@@ -660,7 +739,9 @@ declare namespace Task {
     const sequential: <A>(tasks: ReadonlyArray<Task<A>>) => Task<ReadonlyArray<A>>;
     /**
      * Converts a `Task<A>` into a `Task<Result<E, A>>`, resolving to `Err` if the
-     * Task does not complete within the given time.
+     * Task does not complete within the given time. The inner Task receives an
+     * `AbortSignal` that fires when the deadline passes, so operations like `fetch`
+     * that accept a signal are cancelled rather than left dangling.
      *
      * @example
      * ```ts
@@ -672,6 +753,28 @@ declare namespace Task {
      * ```
      */
     const timeout: <E>(ms: number, onTimeout: () => E) => <A>(task: Task<A>) => Task<Result<E, A>>;
+    /**
+     * Creates a Task paired with an `abort` handle. When `abort()` is called the
+     * `AbortSignal` passed to the factory is fired, cancelling any in-flight
+     * operation (e.g. a `fetch`) immediately.
+     *
+     * If an outer signal is also present (passed at the call site), aborting it
+     * propagates into the internal controller.
+     *
+     * @example
+     * ```ts
+     * const { task: poll, abort } = Task.abortable(
+     *   (signal) => waitForEvent(bus, "ready", { signal }),
+     * );
+     *
+     * onUnmount(abort);
+     * await poll();
+     * ```
+     */
+    const abortable: <A>(factory: (signal: AbortSignal) => Promise<A>) => {
+        task: Task<A>;
+        abort: () => void;
+    };
 }
 
-export { Deferred as D, type Err as E, Maybe as M, type None as N, type Ok as O, Result as R, type Some as S, Task as T, type WithValue as W, type WithLog as a, type WithKind as b, type WithError as c, type WithErrors as d, type WithFirst as e, type WithSecond as f };
+export { Deferred as D, type Err as E, Maybe as M, type None as N, type Ok as O, Result as R, type Some as S, Task as T, type WithValue as W, type WithLog as a, type WithKind as b, type WithError as c, type RetryOptions as d, type TimeoutOptions as e, type WithMs as f, type WithTrailing as g, type WithRetry as h, type WithTimeout as i, type WithLeading as j, type WithMaxWait as k, type WithN as l, type WithOverflow as m, type WithKey as n, type WithPerKey as o, type WithMinInterval as p, type WithCooldown as q, type WithMaxSize as r, type WithDedupe as s, type WithConcurrency as t, type WithSize as u, type WithErrors as v, type WithFirst as w, type WithSecond as x };

package/dist/{chunk-EAR4TIGH.mjs → chunk-2DPG2RDB.mjs}

@@ -1,13 +1,11 @@
 // src/Core/Deferred.ts
-var _store = /* @__PURE__ */ new WeakMap();
 var Deferred;
 ((Deferred2) => {
-  Deferred2.fromPromise = (p) => {
-    const d = { then: ((f) => p.then(f)) };
-    _store.set(d, p);
-    return d;
-  };
-  Deferred2.toPromise = (d) => _store.get(d) ?? new Promise((resolve) => d.then(resolve));
+  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
@@ -69,77 +67,99 @@ var Result;
 })(Result || (Result = {}));
 
 // src/Core/Task.ts
-var toPromise = (task) => Deferred.toPromise(task());
+var toPromise = (task, signal) => Deferred.toPromise(task(signal));
 var Task;
 ((Task2) => {
   Task2.resolve = (value) => () => Deferred.fromPromise(Promise.resolve(value));
-  Task2.from = (f) => () => Deferred.fromPromise(f());
-  Task2.map = (f) => (data) => (0, Task2.from)(() => toPromise(data).then(f));
-  Task2.chain = (f) => (data) => (0, Task2.from)(() => toPromise(data).then((a) => toPromise(f(a))));
+  Task2.from = (f) => (signal) => Deferred.fromPromise(f(signal));
+  Task2.map = (f) => (data) => (0, Task2.from)((signal) => toPromise(data, signal).then(f));
+  Task2.chain = (f) => (data) => (0, Task2.from)((signal) => toPromise(data, signal).then((a) => toPromise(f(a), signal)));
   Task2.ap = (arg) => (data) => (0, Task2.from)(
-    () => Promise.all([
-      toPromise(data),
-      toPromise(arg)
+    (signal) => Promise.all([
+      toPromise(data, signal),
+      toPromise(arg, signal)
     ]).then(([f, a]) => f(a))
   );
   Task2.tap = (f) => (data) => (0, Task2.from)(
-    () => toPromise(data).then((a) => {
+    (signal) => toPromise(data, signal).then((a) => {
       f(a);
       return a;
     })
   );
   Task2.all = (tasks) => (0, Task2.from)(
-    () => Promise.all(tasks.map((t) => toPromise(t)))
+    (signal) => Promise.all(tasks.map((t) => toPromise(t, signal)))
   );
   Task2.delay = (ms) => (data) => (0, Task2.from)(
-    () => new Promise(
+    (signal) => new Promise(
       (resolve2) => setTimeout(
-        () => toPromise(data).then(resolve2),
+        () => toPromise(data, signal).then(resolve2),
         ms
       )
     )
   );
-  Task2.repeat = (options) => (task) => (0, Task2.from)(() => {
+  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 run = (left) => toPromise(task).then((a) => {
+    const run = (left) => toPromise(task, signal).then((a) => {
       results.push(a);
       if (left <= 1) return results;
       return wait().then(() => run(left - 1));
     });
     return run(times);
   });
-  Task2.repeatUntil = (options) => (task) => (0, Task2.from)(() => {
+  Task2.repeatUntil = (options) => (task) => (0, Task2.from)((signal) => {
     const { when: predicate, delay: ms } = options;
     const wait = () => ms !== void 0 && ms > 0 ? new Promise((r) => setTimeout(r, ms)) : Promise.resolve();
-    const run = () => toPromise(task).then((a) => {
+    const run = () => toPromise(task, signal).then((a) => {
       if (predicate(a)) return a;
       return wait().then(run);
     });
     return run();
   });
-  Task2.race = (tasks) => (0, Task2.from)(() => Promise.race(tasks.map(toPromise)));
-  Task2.sequential = (tasks) => (0, Task2.from)(async () => {
+  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) {
-      results.push(await toPromise(task));
+      results.push(await toPromise(task, signal));
     }
     return results;
   });
-  Task2.timeout = (ms, onTimeout) => (task) => (0, Task2.from)(() => {
+  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;
     return Promise.race([
-      toPromise(task).then((a) => {
+      toPromise(task, controller.signal).then((a) => {
         clearTimeout(timerId);
+        outerSignal?.removeEventListener("abort", onOuterAbort);
         return Result.ok(a);
       }),
       new Promise((resolve2) => {
-        timerId = setTimeout(() => resolve2(Result.err(onTimeout())), ms);
+        timerId = setTimeout(() => {
+          controller.abort();
+          outerSignal?.removeEventListener("abort", onOuterAbort);
+          resolve2(Result.err(onTimeout()));
+        }, ms);
       })
     ]);
   });
+  Task2.abortable = (factory) => {
+    const controller = new AbortController();
+    const task = (outerSignal) => {
+      if (outerSignal) {
+        if (outerSignal.aborted) {
+          controller.abort(outerSignal.reason);
+        } else {
+          outerSignal.addEventListener("abort", () => controller.abort(outerSignal.reason), { once: true });
+        }
+      }
+      return Deferred.fromPromise(factory(controller.signal));
+    };
+    return { task, abort: () => controller.abort() };
+  };
 })(Task || (Task = {}));
 
 export {