@nlozgachev/pipelined 0.26.0 → 0.28.0

package/README.md

@@ -2,7 +2,6 @@
 
 [![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)
 
-
 Opinionated functional abstractions for TypeScript.
 
 > **Note:** pipelined is pre-1.0. The API may change between minor versions until the 1.0 release.
@@ -14,49 +13,165 @@ npm add @nlozgachev/pipelined
 ## Possibly maybe
 
 **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.
+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 keep failures as typed values and propagate cancellation
+automatically. `Op<I, E, A>` for managing repeated async interactions — retry, timeout, and
+concurrency strategy in one place. And, of course, there is more than that.
 
 ## Documentation
 
 Full guides and API reference at **[pipelined.lozgachev.dev](https://pipelined.lozgachev.dev)**.
 
-## Example: a single async call
+## Example: composing optional values
+
+`null` checks accumulate fast. Each one is a conditional branch that the type system can't help you
+forget. `Maybe<A>` turns absence into a value that composes — the same operations apply whether or
+not anything is there:
+
+```ts
+import { pipe } from "@nlozgachev/pipelined/composition";
+import { Maybe } from "@nlozgachev/pipelined/core";
+import { Num, Str } from "@nlozgachev/pipelined/utils";
+
+const parseDiscount = (raw: string): string =>
+	pipe(
+		raw,
+		Str.trim,
+		Num.parse,                              // "10" → Some(10), "abc" → None
+		Maybe.filter((n) => n >= 0 && n <= 100), // out of range → None
+		Maybe.map((n) => `${n}% off`),
+		Maybe.getOrElse(() => "No discount"),
+	);
+
+parseDiscount("  15  "); // "15% off"
+parseDiscount("150");    // "No discount"
+parseDiscount("abc");    // "No discount"
+```
+
+Every step that sees `None` is skipped. The fallback runs once, at the end.
+
+## Example: typed async errors
+
+Unhandled rejections are invisible until they crash. `TaskResult<E, A>` keeps failures as typed
+values — the error type is part of the signature, not a runtime surprise.
+
+```ts
+import { pipe } from "@nlozgachev/pipelined/composition";
+import { Result, TaskResult } from "@nlozgachev/pipelined/core";
+
+type ApiError = { status: number; message: string };
+
+const fetchUser = (id: string): TaskResult<ApiError, User> =>
+	TaskResult.tryCatch(
+		(signal) =>
+			fetch(`/users/${id}`, { signal }).then((r) => {
+				if (!r.ok) throw { status: r.status, message: r.statusText };
+				return r.json() as Promise<User>;
+			}),
+		(e) => e as ApiError,
+	);
+
+const fetchPosts = (userId: string): TaskResult<ApiError, Post[]> =>
+	TaskResult.tryCatch(
+		(signal) => fetch(`/users/${userId}/posts`, { signal }).then((r) => r.json()),
+		(e) => e as ApiError,
+	);
+
+// Chain two requests — the AbortSignal propagates to both automatically
+const userWithPosts = (id: string) =>
+	pipe(
+		fetchUser(id),
+		TaskResult.chain((user) =>
+			pipe(
+				fetchPosts(user.id),
+				TaskResult.map((posts) => ({ ...user, posts })),
+			)
+		),
+	);
+```
+
+`userWithPosts` is a lazy function — nothing runs until called. The `AbortSignal` threads through
+both requests: abort at any point and whichever request is in flight is cancelled immediately.
+
+```ts
+const controller = new AbortController();
+const result = await userWithPosts("42")(controller.signal);
+
+if (Result.isOk(result)) {
+	render(result.value); // { ...User, posts: Post[] }
+} else {
+	showError(result.error); // ApiError — typed, not unknown
+}
+```
+
+## Example: transforming data
+
+The utils modules wrap JavaScript's built-in types with data-last, curried operations that return
+`Maybe` wherever a value might be absent. They compose naturally with the core types:
+
+```ts
+import { pipe } from "@nlozgachev/pipelined/composition";
+import { Maybe } from "@nlozgachev/pipelined/core";
+import { Arr, Num, Rec, Str } from "@nlozgachev/pipelined/utils";
+
+type RawItem = { name: string; price: string; category: string };
+type Item = { name: string; price: number; category: string };
+
+const normalise = (raw: RawItem): Maybe<Item> =>
+	pipe(
+		Num.parse(raw.price),                              // "9.99" → Some(9.99), "n/a" → None
+		Maybe.map((price) => ({ name: Str.trim(raw.name), price, category: raw.category })),
+	);
+
+const cheapestByCategory = (items: RawItem[]) =>
+	pipe(
+		items,
+		Arr.filterMap(normalise),                          // parse + drop unparseable prices in one pass
+		Arr.sortBy((a, b) => a.price - b.price),           // ascending price
+		Arr.groupBy((item) => item.category),              // Record<string, NonEmptyList<Item>>
+		Rec.map((group) => Arr.head(group)),               // cheapest per category — Maybe<Item>
+	);
+```
+
+`filterMap` applies a function that returns `Maybe` and collects only the `Some` results — one step
+replaces a `map` followed by a `filter`. `Arr.head` returns `Maybe<Item>` rather than `Item | undefined`,
+so the absence is explicit in the type and the rest of the pipeline handles it the same way.
+
+## Example: retry, timeout, and cancellation
 
 A careful, production-minded attempt at "fetch with retry, timeout, and cancellation":
 
 ```ts
 type UserResult =
-  | { ok: true; user: User; }
-  | { ok: false; error: "Timeout" | "NetworkError"; };
+	| { ok: true; user: User; }
+	| { ok: false; error: "Timeout" | "NetworkError"; };
 
 async function fetchUser(
-  id: string,
-  signal?: AbortSignal,
+	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);
+	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);
 }
 ```
 
@@ -67,38 +182,43 @@ to thread the attempt count.
 With **pipelined**:
 
 ```ts
-import { pipe } from "@nlozgachev/pipelined/composition";
-import { Result, TaskResult } from "@nlozgachev/pipelined/core";
+import { Op } 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 }),
-  );
+const fetchUser = Op.interpret(
+	Op.create(
+		(signal) => (id: string) => fetch(`/users/${id}`, { signal }).then((r) => r.json() as Promise<User>),
+		(e) => new ApiError(e),
+	),
+	{
+		strategy: "restartable",
+		retry: { attempts: 3, backoff: (n) => n * 1000 },
+		timeout: { ms: 5000, onTimeout: () => new ApiError("request timed out") },
+	},
+);
 ```
 
-`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.
+`fetchUser` is a managed operator — nothing runs until you call `run`. Retry logic, signal
+propagation, and timeout wiring are handled automatically. The outcome type is the contract:
+`ApiError` on the left, `User` on the right, nothing escapes as an unhandled exception.
 
 ```ts
-const controller = new AbortController();
-const result = await fetchUser("42")(controller.signal);
+const outcome = await fetchUser.run("42");
 
-if (Result.isOk(result)) {
-  render(result.value); // User
-} else {
-  showError(result.error); // ApiError, not unknown
+if (Op.isOk(outcome)) {
+	render(outcome.value); // User
+} else if (Op.isErr(outcome)) {
+	showError(outcome.error); // ApiError, not unknown
 }
+
+// explicit cancellation — in-flight request is aborted immediately
+fetchUser.abort();
 ```
 
 ## Example: repeated interactions
 
-`TaskResult` handles one call well. Real UIs make the same call many times — a search input fires on every keystroke, a submit button gets clicked twice, a polling loop needs to stop when something newer starts. Each scenario has a different answer to the same question: *what happens to the previous call when a new one arrives?*
+Real UIs make the same call many times — a search input fires on every keystroke, a submit button
+gets clicked twice, a polling loop needs to stop when something newer starts. Each scenario has a
+different answer to the same question: _what happens to the previous call when a new one arrives?_
 
 `Op` makes that question a one-word configuration choice.
 
@@ -108,21 +228,21 @@ if (Result.isOk(result)) {
 import { Op } from "@nlozgachev/pipelined/core";
 
 const searchOp = Op.create(
-  (signal) => (query: string) =>
-    fetch(`/search?q=${query}`, { signal }).then((r) => r.json() as Promise<SearchResult[]>),
-  (e) => new SearchError(e),
+	(signal) => (query: string) =>
+		fetch(`/search?q=${query}`, { signal }).then((r) => r.json() as Promise<SearchResult[]>),
+	(e) => new SearchError(e),
 );
 
 const search = Op.interpret(searchOp, {
-  strategy: "restartable", // new call cancels the previous one
-  retry: { attempts: 2, backoff: 300 },
+	strategy: "restartable", // new call cancels the previous one
+	retry: { attempts: 2, backoff: 300 },
 });
 
 search.subscribe((state) => {
-  if (state.kind === "Pending")  showSpinner();
-  if (state.kind === "Retrying") showSpinner(`retrying… attempt ${state.attempt}`);
-  if (state.kind === "Ok")       showResults(state.value);
-  if (state.kind === "Err")      showError(state.error);
+	if (state.kind === "Pending") showSpinner();
+	if (state.kind === "Retrying") showSpinner(`retrying… attempt ${state.attempt}`);
+	if (state.kind === "Ok") showResults(state.value);
+	if (state.kind === "Err") showError(state.error);
 });
 
 input.addEventListener("input", (e) => search.run(e.currentTarget.value));
@@ -132,28 +252,27 @@ input.addEventListener("input", (e) => search.run(e.currentTarget.value));
 
 ```ts
 const submitOp = Op.create(
-  (signal) => (data: FormData) =>
-    fetch("/orders", { method: "POST", body: data, signal }).then((r) => r.json()),
-  (e) => new ApiError(e),
+	(signal) => (data: FormData) => fetch("/orders", { method: "POST", body: data, signal }).then((r) => r.json()),
+	(e) => new ApiError(e),
 );
 
 const submit = Op.interpret(submitOp, {
-  strategy: "exclusive", // in-flight? new calls are dropped immediately
+	strategy: "exclusive", // in-flight? new calls are dropped immediately
 });
 
 submit.subscribe((state) => {
-  submitButton.disabled = state.kind === "Pending";
-  if (state.kind === "Ok")  showConfirmation(state.value);
-  if (state.kind === "Err") showError(state.error);
+	submitButton.disabled = state.kind === "Pending";
+	if (state.kind === "Ok") showConfirmation(state.value);
+	if (state.kind === "Err") showError(state.error);
 });
 
 form.addEventListener("submit", (e) => {
-  e.preventDefault();
-  submit.run(new FormData(form)); // double-clicks and rage-clicks are ignored
+	e.preventDefault();
+	submit.run(new FormData(form)); // double-clicks and rage-clicks are ignored
 });
 ```
 
-`restartable`, `exclusive`, `debounced`, `throttled`, `queue`, `concurrent`, `keyed` — each strategy is a complete, tested answer to one concurrency scenario. Swap the word, keep the rest of the code.
+`restartable`, `exclusive`, `debounced`, `throttled`, `queue`, `buffered`, `concurrent`, `keyed`, `once` — each strategy is a complete, tested answer to one concurrency scenario. Swap the word, keep the rest of the code.
 
 ## What's included?
 
@@ -168,7 +287,7 @@ The library covers the states you encounter in real applications: values that ma
 - **`TaskResult<E, A>`** — a lazy async operation that can fail with a typed error.
 - **`TaskMaybe<A>`** — a lazy async operation that may produce nothing.
 - **`TaskValidation<E, A>`** — a lazy async operation that accumulates validation errors.
-- **`Op<I, E, A>`** — a managed async operation with a named concurrency strategy: `restartable`, `exclusive`, `debounced`, `throttled`, `queue`, `concurrent`, `keyed`, or `once`. Handles retry, timeout, cancellation, and state in one place.
+- **`Op<I, E, A>`** — a managed async operation with a named concurrency strategy: `restartable`, `exclusive`, `debounced`, `throttled`, `queue`, `buffered`, `concurrent`, `keyed`, or `once`. Handles retry, timeout, cancellation, and state in one place.
 - **`RemoteData<E, A>`** — the four states of a data fetch: `NotAsked`, `Loading`, `Failure`, `Success`.
 - **`These<A, B>`** — an inclusive OR: holds a first value, a second, or both at once.
 - **`Lens<S, A>`** — focus on a required field in a nested structure. Read, set, and modify immutably.

package/dist/{Task-7brqoQrb.d.ts → Task-BW66NsGR.d.ts}

@@ -263,16 +263,36 @@ declare namespace Result {
      * ```
      */
     const tapError: <E, A>(f: (e: E) => void) => (data: Result<E, A>) => Result<E, A>;
+    /**
+     * Creates a Result from a predicate applied to a value.
+     * Returns Ok if the predicate passes, Err from onFalse otherwise.
+     *
+     * @example
+     * ```ts
+     * pipe(5, Result.fromPredicate(n => n > 0, n => `${n} is not positive`));  // Ok(5)
+     * pipe(-1, Result.fromPredicate(n => n > 0, n => `${n} is not positive`)); // Err("-1 is not positive")
+     * pipe("", Result.fromPredicate(s => s.length > 0, () => "empty string")); // Err("empty string")
+     * ```
+     */
+    const fromPredicate: <E, A>(pred: (a: A) => boolean, onFalse: (a: A) => E) => (a: A) => Result<E, A>;
     /**
      * Recovers from an error by providing a fallback Result.
      * The fallback can produce a different success type, widening the result to `Result<E, A | B>`.
      */
     const recover: <E, A, B>(fallback: (e: E) => Result<E, B>) => (data: Result<E, A>) => Result<E, A | B>;
     /**
-     * Recovers from an error unless it matches the blocked error.
+     * Recovers from an error unless the predicate `isBlocked` returns true for that error.
      * The fallback can produce a different success type, widening the result to `Result<E, A | B>`.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   Result.err(new Error("not found")),
+     *   Result.recoverUnless(e => e.message === "fatal", () => Result.ok(0))
+     * ); // Ok(0)
+     * ```
      */
-    const recoverUnless: <E, A, B>(blockedErr: E, fallback: () => Result<E, B>) => (data: Result<E, A>) => Result<E, A | B>;
+    const recoverUnless: <E, A, B>(isBlocked: (e: E) => boolean, fallback: () => Result<E, B>) => (data: Result<E, A>) => Result<E, A | B>;
     /**
      * Converts a Result to an Maybe.
      * Ok becomes Some, Err becomes None (the error is discarded).
@@ -355,11 +375,6 @@ declare namespace Maybe {
      * Extracts the value from a Maybe, returning undefined if None.
      */
     const toUndefined: <A>(data: Maybe<A>) => A | undefined;
-    /**
-     * Creates a Maybe from a possibly undefined value.
-     * Returns None if undefined, Some otherwise.
-     */
-    const fromUndefined: <A>(value: A | undefined) => Maybe<A>;
     /**
      * Creates a Maybe from a predicate applied to a value.
      * Returns Some if the predicate passes, None otherwise.
@@ -585,6 +600,17 @@ declare namespace Task {
      * ```
      */
     const from: <A>(f: (signal?: AbortSignal) => Promise<A>) => Task<A>;
+    /**
+     * Creates a Task from a lazy synchronous thunk.
+     * Unlike `Task.resolve(f())`, `fromSync` does not evaluate `f` until the Task is called.
+     *
+     * @example
+     * ```ts
+     * const t = Task.fromSync(() => Date.now()); // Date.now() not called yet
+     * const ts = await t(); // called here, every time
+     * ```
+     */
+    const fromSync: <A>(f: () => A) => Task<A>;
     /**
      * Transforms the value inside a Task.
      *
@@ -680,10 +706,12 @@ declare namespace Task {
     const repeat: (options: {
         times: number;
         delay?: number;
-    }) => <A>(task: Task<A>) => Task<A[]>;
+    }) => <A>(task: Task<A>) => Task<readonly A[]>;
     /**
      * Runs a Task repeatedly until the result satisfies a predicate, returning that result.
      * An optional delay (ms) 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
@@ -696,6 +724,7 @@ declare namespace Task {
     const repeatUntil: <A>(options: {
         when: (a: A) => boolean;
         delay?: number;
+        maxAttempts?: number;
     }) => (task: Task<A>) => Task<A>;
     /**
      * Resolves with the value of the first Task to complete. All Tasks start
@@ -744,9 +773,12 @@ 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.
+     * 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.

package/dist/{Task-BoqaFsUR.d.mts → Task-BZT0wedE.d.mts}

@@ -263,16 +263,36 @@ declare namespace Result {
      * ```
      */
     const tapError: <E, A>(f: (e: E) => void) => (data: Result<E, A>) => Result<E, A>;
+    /**
+     * Creates a Result from a predicate applied to a value.
+     * Returns Ok if the predicate passes, Err from onFalse otherwise.
+     *
+     * @example
+     * ```ts
+     * pipe(5, Result.fromPredicate(n => n > 0, n => `${n} is not positive`));  // Ok(5)
+     * pipe(-1, Result.fromPredicate(n => n > 0, n => `${n} is not positive`)); // Err("-1 is not positive")
+     * pipe("", Result.fromPredicate(s => s.length > 0, () => "empty string")); // Err("empty string")
+     * ```
+     */
+    const fromPredicate: <E, A>(pred: (a: A) => boolean, onFalse: (a: A) => E) => (a: A) => Result<E, A>;
     /**
      * Recovers from an error by providing a fallback Result.
      * The fallback can produce a different success type, widening the result to `Result<E, A | B>`.
      */
     const recover: <E, A, B>(fallback: (e: E) => Result<E, B>) => (data: Result<E, A>) => Result<E, A | B>;
     /**
-     * Recovers from an error unless it matches the blocked error.
+     * Recovers from an error unless the predicate `isBlocked` returns true for that error.
      * The fallback can produce a different success type, widening the result to `Result<E, A | B>`.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   Result.err(new Error("not found")),
+     *   Result.recoverUnless(e => e.message === "fatal", () => Result.ok(0))
+     * ); // Ok(0)
+     * ```
      */
-    const recoverUnless: <E, A, B>(blockedErr: E, fallback: () => Result<E, B>) => (data: Result<E, A>) => Result<E, A | B>;
+    const recoverUnless: <E, A, B>(isBlocked: (e: E) => boolean, fallback: () => Result<E, B>) => (data: Result<E, A>) => Result<E, A | B>;
     /**
      * Converts a Result to an Maybe.
      * Ok becomes Some, Err becomes None (the error is discarded).
@@ -355,11 +375,6 @@ declare namespace Maybe {
      * Extracts the value from a Maybe, returning undefined if None.
      */
     const toUndefined: <A>(data: Maybe<A>) => A | undefined;
-    /**
-     * Creates a Maybe from a possibly undefined value.
-     * Returns None if undefined, Some otherwise.
-     */
-    const fromUndefined: <A>(value: A | undefined) => Maybe<A>;
     /**
      * Creates a Maybe from a predicate applied to a value.
      * Returns Some if the predicate passes, None otherwise.
@@ -585,6 +600,17 @@ declare namespace Task {
      * ```
      */
     const from: <A>(f: (signal?: AbortSignal) => Promise<A>) => Task<A>;
+    /**
+     * Creates a Task from a lazy synchronous thunk.
+     * Unlike `Task.resolve(f())`, `fromSync` does not evaluate `f` until the Task is called.
+     *
+     * @example
+     * ```ts
+     * const t = Task.fromSync(() => Date.now()); // Date.now() not called yet
+     * const ts = await t(); // called here, every time
+     * ```
+     */
+    const fromSync: <A>(f: () => A) => Task<A>;
     /**
      * Transforms the value inside a Task.
      *
@@ -680,10 +706,12 @@ declare namespace Task {
     const repeat: (options: {
         times: number;
         delay?: number;
-    }) => <A>(task: Task<A>) => Task<A[]>;
+    }) => <A>(task: Task<A>) => Task<readonly A[]>;
     /**
      * Runs a Task repeatedly until the result satisfies a predicate, returning that result.
      * An optional delay (ms) 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
@@ -696,6 +724,7 @@ declare namespace Task {
     const repeatUntil: <A>(options: {
         when: (a: A) => boolean;
         delay?: number;
+        maxAttempts?: number;
     }) => (task: Task<A>) => Task<A>;
     /**
      * Resolves with the value of the first Task to complete. All Tasks start
@@ -744,9 +773,12 @@ 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.
+     * 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.

package/dist/{chunk-Z3DYYR43.mjs → chunk-7JF44HJH.mjs}

@@ -19,7 +19,6 @@ var Maybe;
   Maybe2.fromNullable = (value) => value === null || value === void 0 ? (0, Maybe2.none)() : (0, Maybe2.some)(value);
   Maybe2.toNullable = (data) => (0, Maybe2.isSome)(data) ? data.value : null;
   Maybe2.toUndefined = (data) => (0, Maybe2.isSome)(data) ? data.value : void 0;
-  Maybe2.fromUndefined = (value) => value === void 0 ? (0, Maybe2.none)() : (0, Maybe2.some)(value);
   Maybe2.fromPredicate = (pred) => (a) => pred(a) ? (0, Maybe2.some)(a) : (0, Maybe2.none)();
   Maybe2.toResult = (onNone) => (data) => (0, Maybe2.isSome)(data) ? Result.ok(data.value) : Result.err(onNone());
   Maybe2.fromResult = (data) => Result.isOk(data) ? (0, Maybe2.some)(data.value) : (0, Maybe2.none)();
@@ -65,8 +64,9 @@ var Result;
     if ((0, Result2.isErr)(data)) f(data.error);
     return data;
   };
+  Result2.fromPredicate = (pred, onFalse) => (a) => pred(a) ? (0, Result2.ok)(a) : (0, Result2.err)(onFalse(a));
   Result2.recover = (fallback) => (data) => (0, Result2.isOk)(data) ? data : fallback(data.error);
-  Result2.recoverUnless = (blockedErr, fallback) => (data) => (0, Result2.isErr)(data) && data.error !== blockedErr ? fallback() : data;
+  Result2.recoverUnless = (isBlocked, fallback) => (data) => (0, Result2.isErr)(data) && !isBlocked(data.error) ? fallback() : data;
   Result2.toMaybe = (data) => (0, Result2.isOk)(data) ? Maybe.some(data.value) : Maybe.none();
   Result2.ap = (arg) => (data) => (0, Result2.isOk)(data) && (0, Result2.isOk)(arg) ? (0, Result2.ok)(data.value(arg.value)) : (0, Result2.isErr)(data) ? data : arg;
 })(Result || (Result = {}));
@@ -77,6 +77,7 @@ var Task;
 ((Task2) => {
   Task2.resolve = (value) => () => Deferred.fromPromise(Promise.resolve(value));
   Task2.from = (f) => (signal) => Deferred.fromPromise(f(signal));
+  Task2.fromSync = (f) => () => Deferred.fromPromise(Promise.resolve(f()));
   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)(
@@ -115,13 +116,14 @@ var Task;
     return run(times);
   });
   Task2.repeatUntil = (options) => (task) => (0, Task2.from)((signal) => {
-    const { when: predicate, delay: ms } = options;
+    const { when: predicate, delay: ms, maxAttempts } = options;
     const wait = () => ms !== void 0 && ms > 0 ? new Promise((r) => setTimeout(r, ms)) : Promise.resolve();
-    const run = () => toPromise(task, signal).then((a) => {
+    const run = (attempt) => toPromise(task, signal).then((a) => {
       if (predicate(a)) return a;
-      return wait().then(run);
+      if (maxAttempts !== void 0 && attempt >= maxAttempts) return a;
+      return wait().then(() => run(attempt + 1));
     });
-    return run();
+    return run(1);
   });
   Task2.race = (tasks) => (0, Task2.from)((signal) => Promise.race(tasks.map((t) => toPromise(t, signal))));
   Task2.sequential = (tasks) => (0, Task2.from)(async (signal) => {
@@ -152,8 +154,12 @@ var Task;
     ]);
   });
   Task2.abortable = (factory) => {
-    const controller = new AbortController();
+    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);
@@ -163,7 +169,7 @@ var Task;
       }
       return Deferred.fromPromise(factory(controller.signal));
     };
-    return { task, abort: () => controller.abort() };
+    return { task, abort };
   };
 })(Task || (Task = {}));