@nlozgachev/pipelined 0.28.0 → 0.29.0

package/README.md

@@ -34,18 +34,18 @@ 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"),
-	);
+  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"
+parseDiscount("150"); // "No discount"
+parseDiscount("abc"); // "No discount"
 ```
 
 Every step that sees `None` is skipped. The fallback runs once, at the end.
@@ -59,35 +59,35 @@ values — the error type is part of the signature, not a runtime surprise.
 import { pipe } from "@nlozgachev/pipelined/composition";
 import { Result, TaskResult } from "@nlozgachev/pipelined/core";
 
-type ApiError = { status: number; message: string };
+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,
-	);
+  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,
-	);
+  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 })),
-			)
-		),
-	);
+  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
@@ -95,12 +95,13 @@ both requests: abort at any point and whichever request is in flight is cancelle
 
 ```ts
 const controller = new AbortController();
-const result = await userWithPosts("42")(controller.signal);
+const fetchUserWithPosts = userWithPosts("42"); // build the lazy task
+const result = await fetchUserWithPosts(controller.signal); // run it — signal controls cancellation
 
 if (Result.isOk(result)) {
-	render(result.value); // { ...User, posts: Post[] }
+  render(result.value); // { ...User, posts: Post[] }
 } else {
-	showError(result.error); // ApiError — typed, not unknown
+  showError(result.error); // ApiError — typed, not unknown
 }
 ```
 
@@ -114,23 +115,23 @@ 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 };
+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 })),
-	);
+  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>
-	);
+  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
@@ -143,35 +144,35 @@ A careful, production-minded attempt at "fetch with retry, timeout, and cancella
 
 ```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);
 }
 ```
 
@@ -185,15 +186,16 @@ With **pipelined**:
 import { Op } from "@nlozgachev/pipelined/core";
 
 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") },
-	},
+  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") },
+  },
 );
 ```
 
@@ -205,9 +207,9 @@ propagation, and timeout wiring are handled automatically. The outcome type is t
 const outcome = await fetchUser.run("42");
 
 if (Op.isOk(outcome)) {
-	render(outcome.value); // User
+  render(outcome.value); // User
 } else if (Op.isErr(outcome)) {
-	showError(outcome.error); // ApiError, not unknown
+  showError(outcome.error); // ApiError, not unknown
 }
 
 // explicit cancellation — in-flight request is aborted immediately
@@ -228,21 +230,21 @@ different answer to the same question: _what happens to the previous call when a
 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 (Op.isPending(state)) showSpinner();
+  if (Op.isRetrying(state)) showSpinner(`retrying… attempt ${state.attempt}`);
+  if (Op.isOk(state)) showResults(state.value);
+  if (Op.isError(state)) showError(state.error);
 });
 
 input.addEventListener("input", (e) => search.run(e.currentTarget.value));
@@ -252,23 +254,24 @@ 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 = Op.isPending(state);
+  if (Op.isOk(state)) showConfirmation(state.value);
+  if (Op.isError(state)) 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
 });
 ```
 

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

@@ -107,15 +107,15 @@ type WithMinInterval = {
 };
 
 type Ok<A> = WithKind<"Ok"> & WithValue<A>;
-type Err<E> = WithKind<"Error"> & WithError<E>;
+type Error<E> = WithKind<"Error"> & WithError<E>;
 /**
- * Result represents a value that can be one of two types: a success (Ok) or a failure (Err).
+ * Result represents a value that can be one of two types: a success (Ok) or a failure (Error).
  * Use Result when an operation can fail with a meaningful error value.
  *
  * @example
  * ```ts
  * const divide = (a: number, b: number): Result<string, number> =>
- *   b === 0 ? Result.err("Division by zero") : Result.ok(a / b);
+ *   b === 0 ? Result.error("Division by zero") : Result.ok(a / b);
  *
  * pipe(
  *   divide(10, 2),
@@ -124,7 +124,7 @@ type Err<E> = WithKind<"Error"> & WithError<E>;
  * ); // 10
  * ```
  */
-type Result<E, A> = Ok<A> | Err<E>;
+type Result<E, A> = Ok<A> | Error<E>;
 declare namespace Result {
     /**
      * Creates a successful Result with the given value.
@@ -133,15 +133,15 @@ declare namespace Result {
     /**
      * Creates a failed Result with the given error.
      */
-    const err: <E>(error: E) => Err<E>;
+    const error: <E>(e: E) => Error<E>;
     /**
      * Type guard that checks if an Result is Ok.
      */
     const isOk: <E, A>(data: Result<E, A>) => data is Ok<A>;
     /**
-     * Type guard that checks if an Result is Err.
+     * Type guard that checks if an Result is Error.
      */
-    const isErr: <E, A>(data: Result<E, A>) => data is Err<E>;
+    const isError: <E, A>(data: Result<E, A>) => data is Error<E>;
     /**
      * Creates an Result from a function that may throw.
      * Catches any errors and transforms them using the onError function.
@@ -162,7 +162,7 @@ declare namespace Result {
      * @example
      * ```ts
      * pipe(Result.ok(5), Result.map(n => n * 2)); // Ok(10)
-     * pipe(Result.err("error"), Result.map(n => n * 2)); // Err("error")
+     * pipe(Result.error("error"), Result.map(n => n * 2)); // Error("error")
      * ```
      */
     const map: <E, A, B>(f: (a: A) => B) => (data: Result<E, A>) => Result<E, B>;
@@ -171,7 +171,7 @@ declare namespace Result {
      *
      * @example
      * ```ts
-     * pipe(Result.err("oops"), Result.mapError(e => e.toUpperCase())); // Err("OOPS")
+     * pipe(Result.error("oops"), Result.mapError(e => e.toUpperCase())); // Error("OOPS")
      * ```
      */
     const mapError: <E, F, A>(f: (e: E) => F) => (data: Result<E, A>) => Result<F, A>;
@@ -182,10 +182,10 @@ declare namespace Result {
      * @example
      * ```ts
      * const validatePositive = (n: number): Result<string, number> =>
-     *   n > 0 ? Result.ok(n) : Result.err("Must be positive");
+     *   n > 0 ? Result.ok(n) : Result.error("Must be positive");
      *
      * pipe(Result.ok(5), Result.chain(validatePositive)); // Ok(5)
-     * pipe(Result.ok(-1), Result.chain(validatePositive)); // Err("Must be positive")
+     * pipe(Result.ok(-1), Result.chain(validatePositive)); // Error("Must be positive")
      * ```
      */
     const chain: <E, A, B>(f: (a: A) => Result<E, B>) => (data: Result<E, A>) => Result<E, B>;
@@ -230,8 +230,8 @@ declare namespace Result {
      * @example
      * ```ts
      * pipe(Result.ok(5), Result.getOrElse(() => 0)); // 5
-     * pipe(Result.err("error"), Result.getOrElse(() => 0)); // 0
-     * pipe(Result.err("error"), Result.getOrElse(() => null)); // null — typed as number | null
+     * pipe(Result.error("error"), Result.getOrElse(() => 0)); // 0
+     * pipe(Result.error("error"), Result.getOrElse(() => null)); // null — typed as number | null
      * ```
      */
     const getOrElse: <E, A, B>(defaultValue: () => B) => (data: Result<E, A>) => A | B;
@@ -256,7 +256,7 @@ declare namespace Result {
      * @example
      * ```ts
      * pipe(
-     *   Result.err("not found"),
+     *   Result.error("not found"),
      *   Result.tapError(e => console.error("validation failed:", e)),
      *   Result.chain(save),
      * )
@@ -270,8 +270,8 @@ declare namespace Result {
      * @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")
+     * pipe(-1, Result.fromPredicate(n => n > 0, n => `${n} is not positive`)); // Error("-1 is not positive")
+     * pipe("", Result.fromPredicate(s => s.length > 0, () => "empty string")); // Error("empty string")
      * ```
      */
     const fromPredicate: <E, A>(pred: (a: A) => boolean, onFalse: (a: A) => E) => (a: A) => Result<E, A>;
@@ -287,7 +287,7 @@ declare namespace Result {
      * @example
      * ```ts
      * pipe(
-     *   Result.err(new Error("not found")),
+     *   Result.error(new Error("not found")),
      *   Result.recoverUnless(e => e.message === "fatal", () => Result.ok(0))
      * ); // Ok(0)
      * ```
@@ -300,7 +300,7 @@ declare namespace Result {
      * @example
      * ```ts
      * Result.toMaybe(Result.ok(42)); // Some(42)
-     * Result.toMaybe(Result.err("oops")); // None
+     * Result.toMaybe(Result.error("oops")); // None
      * ```
      */
     const toMaybe: <E, A>(data: Result<E, A>) => Maybe<A>;
@@ -414,7 +414,7 @@ declare namespace Maybe {
      * @example
      * ```ts
      * Maybe.fromResult(Result.ok(42)); // Some(42)
-     * Maybe.fromResult(Result.err("oops")); // None
+     * Maybe.fromResult(Result.error("oops")); // None
      * ```
      */
     const fromResult: <E, A>(data: Result<E, A>) => Maybe<A>;
@@ -797,6 +797,19 @@ declare namespace Task {
         task: Task<A>;
         abort: () => void;
     };
+    /**
+     * Executes a task with an optional signal. Use as a terminal step in a `pipe` chain.
+     *
+     * @example
+     * ```ts
+     * const name = await pipe(
+     *     fetchConfig,
+     *     Task.map(config => config.name),
+     *     Task.run(),
+     * );
+     * ```
+     */
+    const run: (signal?: AbortSignal) => <A>(task: Task<A>) => Promise<A>;
 }
 
-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 WithTimeout as f, type WithMinInterval as g, type WithCooldown as h, type WithConcurrency as i, type WithSize as j, type WithMs as k, type WithN as l, type WithErrors as m, type WithFirst as n, type WithSecond as o };
+export { Deferred as D, type Error 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 WithTimeout as f, type WithMinInterval as g, type WithCooldown as h, type WithConcurrency as i, type WithSize as j, type WithMs as k, type WithN as l, type WithErrors as m, type WithFirst as n, type WithSecond as o };

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

@@ -107,15 +107,15 @@ type WithMinInterval = {
 };
 
 type Ok<A> = WithKind<"Ok"> & WithValue<A>;
-type Err<E> = WithKind<"Error"> & WithError<E>;
+type Error<E> = WithKind<"Error"> & WithError<E>;
 /**
- * Result represents a value that can be one of two types: a success (Ok) or a failure (Err).
+ * Result represents a value that can be one of two types: a success (Ok) or a failure (Error).
  * Use Result when an operation can fail with a meaningful error value.
  *
  * @example
  * ```ts
  * const divide = (a: number, b: number): Result<string, number> =>
- *   b === 0 ? Result.err("Division by zero") : Result.ok(a / b);
+ *   b === 0 ? Result.error("Division by zero") : Result.ok(a / b);
  *
  * pipe(
  *   divide(10, 2),
@@ -124,7 +124,7 @@ type Err<E> = WithKind<"Error"> & WithError<E>;
  * ); // 10
  * ```
  */
-type Result<E, A> = Ok<A> | Err<E>;
+type Result<E, A> = Ok<A> | Error<E>;
 declare namespace Result {
     /**
      * Creates a successful Result with the given value.
@@ -133,15 +133,15 @@ declare namespace Result {
     /**
      * Creates a failed Result with the given error.
      */
-    const err: <E>(error: E) => Err<E>;
+    const error: <E>(e: E) => Error<E>;
     /**
      * Type guard that checks if an Result is Ok.
      */
     const isOk: <E, A>(data: Result<E, A>) => data is Ok<A>;
     /**
-     * Type guard that checks if an Result is Err.
+     * Type guard that checks if an Result is Error.
      */
-    const isErr: <E, A>(data: Result<E, A>) => data is Err<E>;
+    const isError: <E, A>(data: Result<E, A>) => data is Error<E>;
     /**
      * Creates an Result from a function that may throw.
      * Catches any errors and transforms them using the onError function.
@@ -162,7 +162,7 @@ declare namespace Result {
      * @example
      * ```ts
      * pipe(Result.ok(5), Result.map(n => n * 2)); // Ok(10)
-     * pipe(Result.err("error"), Result.map(n => n * 2)); // Err("error")
+     * pipe(Result.error("error"), Result.map(n => n * 2)); // Error("error")
      * ```
      */
     const map: <E, A, B>(f: (a: A) => B) => (data: Result<E, A>) => Result<E, B>;
@@ -171,7 +171,7 @@ declare namespace Result {
      *
      * @example
      * ```ts
-     * pipe(Result.err("oops"), Result.mapError(e => e.toUpperCase())); // Err("OOPS")
+     * pipe(Result.error("oops"), Result.mapError(e => e.toUpperCase())); // Error("OOPS")
      * ```
      */
     const mapError: <E, F, A>(f: (e: E) => F) => (data: Result<E, A>) => Result<F, A>;
@@ -182,10 +182,10 @@ declare namespace Result {
      * @example
      * ```ts
      * const validatePositive = (n: number): Result<string, number> =>
-     *   n > 0 ? Result.ok(n) : Result.err("Must be positive");
+     *   n > 0 ? Result.ok(n) : Result.error("Must be positive");
      *
      * pipe(Result.ok(5), Result.chain(validatePositive)); // Ok(5)
-     * pipe(Result.ok(-1), Result.chain(validatePositive)); // Err("Must be positive")
+     * pipe(Result.ok(-1), Result.chain(validatePositive)); // Error("Must be positive")
      * ```
      */
     const chain: <E, A, B>(f: (a: A) => Result<E, B>) => (data: Result<E, A>) => Result<E, B>;
@@ -230,8 +230,8 @@ declare namespace Result {
      * @example
      * ```ts
      * pipe(Result.ok(5), Result.getOrElse(() => 0)); // 5
-     * pipe(Result.err("error"), Result.getOrElse(() => 0)); // 0
-     * pipe(Result.err("error"), Result.getOrElse(() => null)); // null — typed as number | null
+     * pipe(Result.error("error"), Result.getOrElse(() => 0)); // 0
+     * pipe(Result.error("error"), Result.getOrElse(() => null)); // null — typed as number | null
      * ```
      */
     const getOrElse: <E, A, B>(defaultValue: () => B) => (data: Result<E, A>) => A | B;
@@ -256,7 +256,7 @@ declare namespace Result {
      * @example
      * ```ts
      * pipe(
-     *   Result.err("not found"),
+     *   Result.error("not found"),
      *   Result.tapError(e => console.error("validation failed:", e)),
      *   Result.chain(save),
      * )
@@ -270,8 +270,8 @@ declare namespace Result {
      * @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")
+     * pipe(-1, Result.fromPredicate(n => n > 0, n => `${n} is not positive`)); // Error("-1 is not positive")
+     * pipe("", Result.fromPredicate(s => s.length > 0, () => "empty string")); // Error("empty string")
      * ```
      */
     const fromPredicate: <E, A>(pred: (a: A) => boolean, onFalse: (a: A) => E) => (a: A) => Result<E, A>;
@@ -287,7 +287,7 @@ declare namespace Result {
      * @example
      * ```ts
      * pipe(
-     *   Result.err(new Error("not found")),
+     *   Result.error(new Error("not found")),
      *   Result.recoverUnless(e => e.message === "fatal", () => Result.ok(0))
      * ); // Ok(0)
      * ```
@@ -300,7 +300,7 @@ declare namespace Result {
      * @example
      * ```ts
      * Result.toMaybe(Result.ok(42)); // Some(42)
-     * Result.toMaybe(Result.err("oops")); // None
+     * Result.toMaybe(Result.error("oops")); // None
      * ```
      */
     const toMaybe: <E, A>(data: Result<E, A>) => Maybe<A>;
@@ -414,7 +414,7 @@ declare namespace Maybe {
      * @example
      * ```ts
      * Maybe.fromResult(Result.ok(42)); // Some(42)
-     * Maybe.fromResult(Result.err("oops")); // None
+     * Maybe.fromResult(Result.error("oops")); // None
      * ```
      */
     const fromResult: <E, A>(data: Result<E, A>) => Maybe<A>;
@@ -797,6 +797,19 @@ declare namespace Task {
         task: Task<A>;
         abort: () => void;
     };
+    /**
+     * Executes a task with an optional signal. Use as a terminal step in a `pipe` chain.
+     *
+     * @example
+     * ```ts
+     * const name = await pipe(
+     *     fetchConfig,
+     *     Task.map(config => config.name),
+     *     Task.run(),
+     * );
+     * ```
+     */
+    const run: (signal?: AbortSignal) => <A>(task: Task<A>) => Promise<A>;
 }
 
-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 WithTimeout as f, type WithMinInterval as g, type WithCooldown as h, type WithConcurrency as i, type WithSize as j, type WithMs as k, type WithN as l, type WithErrors as m, type WithFirst as n, type WithSecond as o };
+export { Deferred as D, type Error 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 WithTimeout as f, type WithMinInterval as g, type WithCooldown as h, type WithConcurrency as i, type WithSize as j, type WithMs as k, type WithN as l, type WithErrors as m, type WithFirst as n, type WithSecond as o };

package/dist/{chunk-CA3VE4YD.mjs → chunk-FWYOEWJ2.mjs}

@@ -3,7 +3,7 @@ import {
   Maybe,
   Result,
   Task
-} from "./chunk-7JF44HJH.mjs";
+} from "./chunk-SDGDJ7CU.mjs";
 import {
   isNonEmptyList
 } from "./chunk-DBIC62UV.mjs";
@@ -166,7 +166,7 @@ var Arr;
     const result = [];
     for (const a of data) {
       const r = await Deferred.toPromise(f(a)());
-      if (Result.isErr(r)) return r;
+      if (Result.isError(r)) return r;
       result.push(r.value);
     }
     return Result.ok(result);
@@ -307,6 +307,14 @@ var Dict;
     }
     return result;
   };
+  Dict2.filterMap = (f) => (m) => {
+    const result = new globalThis.Map();
+    for (const [key, value] of m) {
+      const mapped = f(value);
+      if (mapped.kind === "Some") result.set(key, mapped.value);
+    }
+    return result;
+  };
   Dict2.union = (other) => (m) => {
     const result = new globalThis.Map(m);
     for (const [k, v] of other) {