@nlozgachev/pipelined 0.24.0 → 0.26.0

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

@@ -84,50 +84,18 @@ 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;
 };
@@ -137,12 +105,6 @@ type WithCooldown = {
 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>;
@@ -287,6 +249,20 @@ declare namespace Result {
      * ```
      */
     const tap: <E, A>(f: (a: A) => void) => (data: Result<E, A>) => Result<E, A>;
+    /**
+     * Executes a side effect on the error value without changing the Result.
+     * Useful for logging or reporting errors.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   Result.err("not found"),
+     *   Result.tapError(e => console.error("validation failed:", e)),
+     *   Result.chain(save),
+     * )
+     * ```
+     */
+    const tapError: <E, A>(f: (e: E) => void) => (data: Result<E, 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>`.
@@ -384,6 +360,20 @@ declare namespace Maybe {
      * 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.
+     *
+     * @example
+     * ```ts
+     * Maybe.fromPredicate((n: number) => n >= 18)(21); // Some(21)
+     * Maybe.fromPredicate((n: number) => n >= 18)(15); // None
+     *
+     * pipe("hello", Maybe.fromPredicate((s: string) => s.length > 0)); // Some("hello")
+     * pipe("", Maybe.fromPredicate((s: string) => s.length > 0));      // None
+     * ```
+     */
+    const fromPredicate: <A>(pred: (a: A) => boolean) => (a: A) => Maybe<A>;
     /**
      * Converts an Maybe to a Result.
      * Some becomes Ok, None becomes Err with the provided error.
@@ -777,4 +767,4 @@ declare namespace Task {
     };
 }
 
-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 };
+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 };

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

@@ -84,50 +84,18 @@ 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;
 };
@@ -137,12 +105,6 @@ type WithCooldown = {
 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>;
@@ -287,6 +249,20 @@ declare namespace Result {
      * ```
      */
     const tap: <E, A>(f: (a: A) => void) => (data: Result<E, A>) => Result<E, A>;
+    /**
+     * Executes a side effect on the error value without changing the Result.
+     * Useful for logging or reporting errors.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   Result.err("not found"),
+     *   Result.tapError(e => console.error("validation failed:", e)),
+     *   Result.chain(save),
+     * )
+     * ```
+     */
+    const tapError: <E, A>(f: (e: E) => void) => (data: Result<E, 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>`.
@@ -384,6 +360,20 @@ declare namespace Maybe {
      * 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.
+     *
+     * @example
+     * ```ts
+     * Maybe.fromPredicate((n: number) => n >= 18)(21); // Some(21)
+     * Maybe.fromPredicate((n: number) => n >= 18)(15); // None
+     *
+     * pipe("hello", Maybe.fromPredicate((s: string) => s.length > 0)); // Some("hello")
+     * pipe("", Maybe.fromPredicate((s: string) => s.length > 0));      // None
+     * ```
+     */
+    const fromPredicate: <A>(pred: (a: A) => boolean) => (a: A) => Maybe<A>;
     /**
      * Converts an Maybe to a Result.
      * Some becomes Ok, None becomes Err with the provided error.
@@ -777,4 +767,4 @@ declare namespace Task {
     };
 }
 
-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 };
+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 };

package/dist/{chunk-C3Z56PCR.mjs → chunk-6H373E63.mjs}

@@ -3,7 +3,7 @@ import {
   Maybe,
   Result,
   Task
-} from "./chunk-2DPG2RDB.mjs";
+} from "./chunk-Z3DYYR43.mjs";
 import {
   isNonEmptyList
 } from "./chunk-DBIC62UV.mjs";
@@ -43,6 +43,14 @@ var Arr;
     }
     return result;
   };
+  Arr2.filterMap = (f) => (data) => {
+    const result = [];
+    for (let i = 0; i < data.length; i++) {
+      const mapped = f(data[i]);
+      if (mapped.kind === "Some") result.push(mapped.value);
+    }
+    return result;
+  };
   Arr2.partition = (predicate) => (data) => {
     const pass = [];
     const fail = [];
@@ -471,6 +479,8 @@ var Str;
   Str2.split = (separator) => (s) => s.split(separator);
   Str2.trim = (s) => s.trim();
   Str2.includes = (substring) => (s) => s.includes(substring);
+  Str2.replace = (pattern, replacement) => (s) => s.replace(pattern, replacement);
+  Str2.replaceAll = (pattern, replacement) => (s) => s.replaceAll(pattern, replacement);
   Str2.startsWith = (prefix) => (s) => s.startsWith(prefix);
   Str2.endsWith = (suffix) => (s) => s.endsWith(suffix);
   Str2.toUpperCase = (s) => s.toUpperCase();

package/dist/{chunk-UFQE2J63.mjs → chunk-NTISCH7Z.mjs}

@@ -3,7 +3,7 @@ import {
   Maybe,
   Result,
   Task
-} from "./chunk-2DPG2RDB.mjs";
+} from "./chunk-Z3DYYR43.mjs";
 
 // src/Core/Lens.ts
 var Lens;
@@ -1092,6 +1092,7 @@ var RemoteData;
   RemoteData2.recover = (fallback) => (data) => (0, RemoteData2.isFailure)(data) ? fallback(data.error) : data;
   RemoteData2.toMaybe = (data) => (0, RemoteData2.isSuccess)(data) ? Maybe.some(data.value) : Maybe.none();
   RemoteData2.toResult = (onNotReady) => (data) => (0, RemoteData2.isSuccess)(data) ? Result.ok(data.value) : Result.err((0, RemoteData2.isFailure)(data) ? data.error : onNotReady());
+  RemoteData2.fromResult = (data) => Result.isOk(data) ? (0, RemoteData2.success)(data.value) : (0, RemoteData2.failure)(data.error);
 })(RemoteData || (RemoteData = {}));
 
 // src/Core/Resource.ts
@@ -1205,6 +1206,7 @@ var TaskResult;
   )(data);
   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);
 })(TaskResult || (TaskResult = {}));
 
 // src/Core/Validation.ts

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

@@ -20,6 +20,7 @@ var Maybe;
   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)();
   Maybe2.map = (f) => (data) => (0, Maybe2.isSome)(data) ? (0, Maybe2.some)(f(data.value)) : data;
@@ -60,6 +61,10 @@ var Result;
     if ((0, Result2.isOk)(data)) f(data.value);
     return data;
   };
+  Result2.tapError = (f) => (data) => {
+    if ((0, Result2.isErr)(data)) f(data.error);
+    return data;
+  };
   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.toMaybe = (data) => (0, Result2.isOk)(data) ? Maybe.some(data.value) : Maybe.none();

package/dist/core.d.mts

@@ -1,5 +1,5 @@
-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 WithMs, g as WithTrailing, h as WithRetry, i as WithTimeout, j as WithLeading, k as WithMaxWait, l as WithN, m as WithOverflow, n as WithKey, o as WithPerKey, p as WithMinInterval, q as WithCooldown, r as WithMaxSize, s as WithDedupe, t as WithConcurrency, u as WithSize, T as Task, v as WithErrors, w as WithFirst, x as WithSecond } from './Task-CT8iwwuB.mjs';
-export { E as Err, N as None, O as Ok, S as Some } from './Task-CT8iwwuB.mjs';
+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-BoqaFsUR.mjs';
+export { E as Err, N as None, O as Ok, S as Some } from './Task-BoqaFsUR.mjs';
 import { N as NonEmptyList } from './NonEmptyList-BlGFjor5.mjs';
 
 /** Keys of T for which undefined is assignable (i.e. optional fields). */
@@ -399,6 +399,89 @@ declare namespace Logged {
     const run: <W, A>(data: Logged<W, A>) => readonly [A, ReadonlyArray<W>];
 }
 
+type MaybeRetry<E, O> = O extends {
+    retry: RetryOptions<E>;
+} ? Op.Retrying<E> : never;
+type AllInterpretOptions<I, E> = ({
+    strategy: "once";
+    retry?: RetryOptions<E>;
+} & WithTimeout<E>) | ({
+    strategy: "restartable";
+    retry?: RetryOptions<E>;
+} & WithMinInterval & WithTimeout<E>) | ({
+    strategy: "exclusive";
+    retry?: RetryOptions<E>;
+} & WithCooldown & WithTimeout<E>) | ({
+    strategy: "queue";
+    retry?: RetryOptions<E>;
+    maxSize?: number;
+    overflow?: "drop" | "replace-last";
+    dedupe?: (a: I, b: I) => boolean;
+} & WithConcurrency & WithTimeout<E>) | ({
+    strategy: "buffered";
+    retry?: RetryOptions<E>;
+} & WithSize & WithTimeout<E>) | ({
+    strategy: "debounced";
+    retry?: RetryOptions<E>;
+    leading?: true;
+    maxWait?: number;
+} & WithMs & WithTimeout<E>) | ({
+    strategy: "throttled";
+    retry?: RetryOptions<E>;
+    trailing?: true;
+} & WithMs & WithTimeout<E>) | ({
+    strategy: "concurrent";
+    retry?: RetryOptions<E>;
+    overflow?: "queue" | "drop";
+} & WithN & WithTimeout<E>) | ({
+    strategy: "keyed";
+    perKey?: "exclusive" | "restartable";
+    key: (input: I) => unknown;
+} & WithTimeout<E>);
+type KeyType<I, O> = O extends {
+    key: (input: I) => infer K;
+} ? K : unknown;
+type InterpretResult<I, E, A, O> = [O] extends [{
+    strategy: "throttled";
+    trailing: true;
+}] ? Op.Manager<I, E, A, Op.ThrottledTrailingState<E, A> | MaybeRetry<E, O>> : [O] extends [{
+    strategy: "throttled";
+}] ? Op.Manager<I, E, A, Op.ThrottledState<E, A> | MaybeRetry<E, O>> : [O] extends [{
+    strategy: "debounced";
+}] ? Op.Manager<I, E, A, Op.DebouncedState<E, A> | MaybeRetry<E, O>> : [O] extends [{
+    strategy: "concurrent";
+    overflow: "queue";
+}] ? Op.Manager<I, E, A, Op.ConcurrentQueueState<E, A> | MaybeRetry<E, O>> : [O] extends [{
+    strategy: "concurrent";
+}] ? Op.Manager<I, E, A, Op.ConcurrentDropState<E, A> | MaybeRetry<E, O>> : [O] extends [{
+    strategy: "keyed";
+    perKey: "restartable";
+}] ? Op.KeyedManager<I, KeyType<I, O>, E, Op.KeyedRestartablePerKey<E, A>> : [O] extends [{
+    strategy: "keyed";
+}] ? Op.KeyedManager<I, KeyType<I, O>, E, Op.KeyedExclusivePerKey<E, A>> : [O] extends [{
+    strategy: "once";
+}] ? Op.Manager<I, E, A, Op.OnceState<E, A> | MaybeRetry<E, O>> : [O] extends [{
+    strategy: "restartable";
+}] ? Op.Manager<I, E, A, Op.RestartableState<E, A> | MaybeRetry<E, O>> : [O] extends [{
+    strategy: "exclusive";
+}] ? Op.Manager<I, E, A, Op.ExclusiveState<E, A> | MaybeRetry<E, O>> : [O] extends [{
+    strategy: "queue";
+    overflow: "replace-last";
+    dedupe: (a: I, b: I) => boolean;
+}] ? Op.Manager<I, E, A, Op.QueueDropAndReplaceState<E, A> | MaybeRetry<E, O>> : [O] extends [{
+    strategy: "queue";
+    overflow: "replace-last";
+}] ? Op.Manager<I, E, A, Op.QueueReplaceState<E, A> | MaybeRetry<E, O>> : [O] extends [{
+    strategy: "queue";
+    maxSize: number;
+}] ? Op.Manager<I, E, A, Op.QueueDropState<E, A> | MaybeRetry<E, O>> : [O] extends [{
+    strategy: "queue";
+    dedupe: (a: I, b: I) => boolean;
+}] ? Op.Manager<I, E, A, Op.QueueDropState<E, A> | MaybeRetry<E, O>> : [O] extends [{
+    strategy: "queue";
+}] ? Op.Manager<I, E, A, Op.QueueState<E, A> | MaybeRetry<E, O>> : [O] extends [{
+    strategy: "buffered";
+}] ? Op.Manager<I, E, A, Op.BufferedState<E, A> | MaybeRetry<E, O>> : never;
 /**
  * A reusable description of async work — decoupled from execution strategy and lifetime.
  *
@@ -412,7 +495,11 @@ declare namespace Logged {
  * @example
  * ```ts
  * const fetchUser = Op.create(
- *   (signal) => (id: string) => fetch(`/users/${id}`, { signal }).then(r => r.json()),
+ *   (signal) => (id: string) =>
+ *     fetch(`/users/${id}`, { signal }).then(r => {
+ *       if (!r.ok) throw new Error(`${r.status} ${r.statusText}`);
+ *       return r.json() as Promise<User>;
+ *     }),
  *   (e) => new ApiError(e),
  * );
  *
@@ -655,22 +742,42 @@ declare namespace Op {
     /**
      * Creates an `Op` from an async factory and an error mapper.
      *
-     * The factory receives an `AbortSignal` and returns a function that takes the input.
-     * Operations that support cancellation (like `fetch`) should capture the signal in the
-     * outer closure. The error mapper converts any thrown value into a typed error; it is
-     * never called for aborts.
+     * The factory receives an `AbortSignal` and returns a function that takes the input. Capture
+     * the signal in the outer closure and pass it to cancellable APIs like `fetch`. The error
+     * mapper converts any thrown value into a typed error; it is never called for aborts.
+     *
+     * **If the factory ignores the signal**, cancellation silently stops working: the operation
+     * runs to completion and emits `Ok` even after the strategy has aborted it. This is harmless
+     * for `exclusive` and `once` (which do not abort in-flight work), but causes stale `Ok`
+     * emissions on `restartable`, `debounced`, `throttled`, `buffered`, and `queue` strategies
+     * where in-flight runs are regularly replaced or dropped.
      *
      * @example
      * ```ts
+     * // With cancellation — fetch is aborted when the Op is replaced or aborted
      * const saveProfile = Op.create(
      *   (signal) => (data: ProfileData) =>
      *     fetch("/profile", { method: "POST", body: JSON.stringify(data), signal })
-     *       .then(r => r.json()),
+     *       .then(r => {
+     *         if (!r.ok) throw new Error(`${r.status} ${r.statusText}`);
+     *         return r.json() as Promise<ProfileData>;
+     *       }),
      *   (e) => new ApiError(e),
      * );
+     *
+     * // No input — fetches the current user; manager.run() takes no arguments
+     * const fetchCurrentUser = Op.create(
+     *   (signal) => () => fetch("/me", { signal }).then(r => {
+     *     if (!r.ok) throw new Error(`${r.status} ${r.statusText}`);
+     *     return r.json() as Promise<User>;
+     *   }),
+     *   (e) => new ApiError(e),
+     * );
+     * const manager = Op.interpret(fetchCurrentUser, { strategy: "once" });
+     * manager.run(); // no argument needed
      * ```
      */
-    const create: <I, E, A>(factory: (signal: AbortSignal) => (input: I) => Promise<A>, onError: (e: unknown) => E) => Op<I, E, A>;
+    const create: <E, A, I = void>(factory: (signal: AbortSignal) => (input: I) => Promise<A>, onError: (e: unknown) => E) => Op<I, E, A>;
     /**
      * Creates a successful Outcome.
      *
@@ -890,108 +997,7 @@ declare namespace Op {
      * const save = Op.interpret(saveOp, { strategy: "buffered" });
      * ```
      */
-    function interpret<I, E, A>(op: Op<I, E, A>, options: {
-        strategy: "throttled";
-    } & WithMs & WithTrailing & WithRetry<E> & WithTimeout<E>): Manager<I, E, A, RetryableThrottledTrailingState<E, A>>;
-    function interpret<I, E, A>(op: Op<I, E, A>, options: {
-        strategy: "throttled";
-    } & WithMs & WithTrailing & WithTimeout<E>): Manager<I, E, A, ThrottledTrailingState<E, A>>;
-    function interpret<I, E, A>(op: Op<I, E, A>, options: {
-        strategy: "throttled";
-    } & WithMs & WithRetry<E> & WithTimeout<E>): Manager<I, E, A, RetryableThrottledState<E, A>>;
-    function interpret<I, E, A>(op: Op<I, E, A>, options: {
-        strategy: "throttled";
-    } & WithMs & WithTimeout<E>): Manager<I, E, A, ThrottledState<E, A>>;
-    function interpret<I, E, A>(op: Op<I, E, A>, options: {
-        strategy: "debounced";
-    } & WithMs & WithLeading & WithMaxWait & WithRetry<E> & WithTimeout<E>): Manager<I, E, A, RetryableDebouncedState<E, A>>;
-    function interpret<I, E, A>(op: Op<I, E, A>, options: {
-        strategy: "debounced";
-    } & WithMs & WithLeading & WithMaxWait & WithTimeout<E>): Manager<I, E, A, DebouncedState<E, A>>;
-    function interpret<I, E, A>(op: Op<I, E, A>, options: {
-        strategy: "debounced";
-    } & WithMs & WithLeading & WithRetry<E> & WithTimeout<E>): Manager<I, E, A, RetryableDebouncedState<E, A>>;
-    function interpret<I, E, A>(op: Op<I, E, A>, options: {
-        strategy: "debounced";
-    } & WithMs & WithLeading & WithTimeout<E>): Manager<I, E, A, DebouncedState<E, A>>;
-    function interpret<I, E, A>(op: Op<I, E, A>, options: {
-        strategy: "debounced";
-    } & WithMs & WithMaxWait & WithRetry<E> & WithTimeout<E>): Manager<I, E, A, RetryableDebouncedState<E, A>>;
-    function interpret<I, E, A>(op: Op<I, E, A>, options: {
-        strategy: "debounced";
-    } & WithMs & WithMaxWait & WithTimeout<E>): Manager<I, E, A, DebouncedState<E, A>>;
-    function interpret<I, E, A>(op: Op<I, E, A>, options: {
-        strategy: "debounced";
-    } & WithMs & WithRetry<E> & WithTimeout<E>): Manager<I, E, A, RetryableDebouncedState<E, A>>;
-    function interpret<I, E, A>(op: Op<I, E, A>, options: {
-        strategy: "debounced";
-    } & WithMs & WithTimeout<E>): Manager<I, E, A, DebouncedState<E, A>>;
-    function interpret<I, E, A>(op: Op<I, E, A>, options: {
-        strategy: "concurrent";
-    } & WithN & WithOverflow<"queue"> & WithRetry<E> & WithTimeout<E>): Manager<I, E, A, RetryableConcurrentQueueState<E, A>>;
-    function interpret<I, E, A>(op: Op<I, E, A>, options: {
-        strategy: "concurrent";
-    } & WithN & WithOverflow<"queue"> & WithTimeout<E>): Manager<I, E, A, ConcurrentQueueState<E, A>>;
-    function interpret<I, E, A>(op: Op<I, E, A>, options: {
-        strategy: "concurrent";
-    } & WithN & WithOverflow<"drop"> & WithRetry<E> & WithTimeout<E>): Manager<I, E, A, RetryableConcurrentDropState<E, A>>;
-    function interpret<I, E, A>(op: Op<I, E, A>, options: {
-        strategy: "concurrent";
-    } & WithN & WithOverflow<"drop"> & WithTimeout<E>): Manager<I, E, A, ConcurrentDropState<E, A>>;
-    function interpret<I, K, E, A>(op: Op<I, E, A>, options: {
-        strategy: "keyed";
-    } & WithKey<I, K> & WithPerKey<"exclusive"> & WithTimeout<E>): KeyedManager<I, K, E, KeyedExclusivePerKey<E, A>>;
-    function interpret<I, K, E, A>(op: Op<I, E, A>, options: {
-        strategy: "keyed";
-    } & WithKey<I, K> & WithPerKey<"restartable"> & WithTimeout<E>): KeyedManager<I, K, E, KeyedRestartablePerKey<E, A>>;
-    function interpret<I, E, A>(op: Op<I, E, A>, options: {
-        strategy: "once";
-    } & WithRetry<E> & WithTimeout<E>): Manager<I, E, A, RetryableOnceState<E, A>>;
-    function interpret<I, E, A>(op: Op<I, E, A>, options: {
-        strategy: "once";
-    } & WithTimeout<E>): Manager<I, E, A, OnceState<E, A>>;
-    function interpret<I, E, A>(op: Op<I, E, A>, options: {
-        strategy: "restartable";
-    } & WithMinInterval & WithRetry<E> & WithTimeout<E>): Manager<I, E, A, RetryableRestartableState<E, A>>;
-    function interpret<I, E, A>(op: Op<I, E, A>, options: {
-        strategy: "restartable";
-    } & WithMinInterval & WithTimeout<E>): Manager<I, E, A, RestartableState<E, A>>;
-    function interpret<I, E, A>(op: Op<I, E, A>, options: {
-        strategy: "exclusive";
-    } & WithCooldown & WithRetry<E> & WithTimeout<E>): Manager<I, E, A, RetryableExclusiveState<E, A>>;
-    function interpret<I, E, A>(op: Op<I, E, A>, options: {
-        strategy: "exclusive";
-    } & WithCooldown & WithTimeout<E>): Manager<I, E, A, ExclusiveState<E, A>>;
-    function interpret<I, E, A>(op: Op<I, E, A>, options: {
-        strategy: "queue";
-    } & WithMaxSize & WithOverflow<"replace-last"> & WithDedupe<I> & WithRetry<E> & WithConcurrency & WithTimeout<E>): Manager<I, E, A, RetryableQueueDropAndReplaceState<E, A>>;
-    function interpret<I, E, A>(op: Op<I, E, A>, options: {
-        strategy: "queue";
-    } & WithMaxSize & WithOverflow<"replace-last"> & WithDedupe<I> & WithConcurrency & WithTimeout<E>): Manager<I, E, A, QueueDropAndReplaceState<E, A>>;
-    function interpret<I, E, A>(op: Op<I, E, A>, options: {
-        strategy: "queue";
-    } & WithMaxSize & WithOverflow<"replace-last"> & WithRetry<E> & WithConcurrency & WithTimeout<E>): Manager<I, E, A, RetryableQueueReplaceState<E, A>>;
-    function interpret<I, E, A>(op: Op<I, E, A>, options: {
-        strategy: "queue";
-    } & WithMaxSize & WithOverflow<"replace-last"> & WithConcurrency & WithTimeout<E>): Manager<I, E, A, QueueReplaceState<E, A>>;
-    function interpret<I, E, A>(op: Op<I, E, A>, options: {
-        strategy: "queue";
-    } & (WithMaxSize | WithDedupe<I>) & WithRetry<E> & WithConcurrency & WithTimeout<E>): Manager<I, E, A, RetryableQueueDropState<E, A>>;
-    function interpret<I, E, A>(op: Op<I, E, A>, options: {
-        strategy: "queue";
-    } & (WithMaxSize | WithDedupe<I>) & WithConcurrency & WithTimeout<E>): Manager<I, E, A, QueueDropState<E, A>>;
-    function interpret<I, E, A>(op: Op<I, E, A>, options: {
-        strategy: "queue";
-    } & WithRetry<E> & WithConcurrency & WithTimeout<E>): Manager<I, E, A, RetryableQueueState<E, A>>;
-    function interpret<I, E, A>(op: Op<I, E, A>, options: {
-        strategy: "queue";
-    } & WithConcurrency & WithTimeout<E>): Manager<I, E, A, QueueState<E, A>>;
-    function interpret<I, E, A>(op: Op<I, E, A>, options: {
-        strategy: "buffered";
-    } & WithSize & WithRetry<E> & WithTimeout<E>): Manager<I, E, A, RetryableBufferedState<E, A>>;
-    function interpret<I, E, A>(op: Op<I, E, A>, options: {
-        strategy: "buffered";
-    } & WithSize & WithTimeout<E>): Manager<I, E, A, BufferedState<E, A>>;
+    function interpret<I, E, A, O extends AllInterpretOptions<I, E>>(op: Op<I, E, A>, options: O): InterpretResult<I, E, A, O>;
 }
 
 /**
@@ -1638,6 +1644,17 @@ declare namespace RemoteData {
      * ```
      */
     const toResult: <E>(onNotReady: () => E) => <A>(data: RemoteData<E, A>) => Result<E, A>;
+    /**
+     * Converts a Result to a RemoteData.
+     * Ok becomes Success, Err becomes Failure.
+     *
+     * @example
+     * ```ts
+     * const result = await TaskResult.tryCatch(fetchUser, String)();
+     * setState(RemoteData.fromResult(result)); // Success(user) or Failure(msg)
+     * ```
+     */
+    const fromResult: <E, A>(data: Result<E, A>) => RemoteData<E, A>;
 }
 
 /**
@@ -1717,6 +1734,20 @@ declare namespace TaskResult {
      * Useful for logging or debugging.
      */
     const tap: <E, A>(f: (a: A) => void) => (data: TaskResult<E, A>) => TaskResult<E, A>;
+    /**
+     * Executes a side effect on the error value without changing the TaskResult.
+     * Useful for logging or reporting async errors.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   fetchUser(id),
+     *   TaskResult.tapError(e => console.error("fetch failed:", e)),
+     *   TaskResult.chain(saveToCache),
+     * )
+     * ```
+     */
+    const tapError: <E, A>(f: (e: E) => void) => (data: TaskResult<E, A>) => TaskResult<E, A>;
 }
 
 /**

package/dist/core.d.ts

@@ -1,5 +1,5 @@
-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 WithMs, g as WithTrailing, h as WithRetry, i as WithTimeout, j as WithLeading, k as WithMaxWait, l as WithN, m as WithOverflow, n as WithKey, o as WithPerKey, p as WithMinInterval, q as WithCooldown, r as WithMaxSize, s as WithDedupe, t as WithConcurrency, u as WithSize, T as Task, v as WithErrors, w as WithFirst, x as WithSecond } from './Task-GSGtQO1m.js';
-export { E as Err, N as None, O as Ok, S as Some } from './Task-GSGtQO1m.js';
+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-7brqoQrb.js';
+export { E as Err, N as None, O as Ok, S as Some } from './Task-7brqoQrb.js';
 import { N as NonEmptyList } from './NonEmptyList-BlGFjor5.js';
 
 /** Keys of T for which undefined is assignable (i.e. optional fields). */
@@ -399,6 +399,89 @@ declare namespace Logged {
     const run: <W, A>(data: Logged<W, A>) => readonly [A, ReadonlyArray<W>];
 }
 
+type MaybeRetry<E, O> = O extends {
+    retry: RetryOptions<E>;
+} ? Op.Retrying<E> : never;
+type AllInterpretOptions<I, E> = ({
+    strategy: "once";
+    retry?: RetryOptions<E>;
+} & WithTimeout<E>) | ({
+    strategy: "restartable";
+    retry?: RetryOptions<E>;
+} & WithMinInterval & WithTimeout<E>) | ({
+    strategy: "exclusive";
+    retry?: RetryOptions<E>;
+} & WithCooldown & WithTimeout<E>) | ({
+    strategy: "queue";
+    retry?: RetryOptions<E>;
+    maxSize?: number;
+    overflow?: "drop" | "replace-last";
+    dedupe?: (a: I, b: I) => boolean;
+} & WithConcurrency & WithTimeout<E>) | ({
+    strategy: "buffered";
+    retry?: RetryOptions<E>;
+} & WithSize & WithTimeout<E>) | ({
+    strategy: "debounced";
+    retry?: RetryOptions<E>;
+    leading?: true;
+    maxWait?: number;
+} & WithMs & WithTimeout<E>) | ({
+    strategy: "throttled";
+    retry?: RetryOptions<E>;
+    trailing?: true;
+} & WithMs & WithTimeout<E>) | ({
+    strategy: "concurrent";
+    retry?: RetryOptions<E>;
+    overflow?: "queue" | "drop";
+} & WithN & WithTimeout<E>) | ({
+    strategy: "keyed";
+    perKey?: "exclusive" | "restartable";
+    key: (input: I) => unknown;
+} & WithTimeout<E>);
+type KeyType<I, O> = O extends {
+    key: (input: I) => infer K;
+} ? K : unknown;
+type InterpretResult<I, E, A, O> = [O] extends [{
+    strategy: "throttled";
+    trailing: true;
+}] ? Op.Manager<I, E, A, Op.ThrottledTrailingState<E, A> | MaybeRetry<E, O>> : [O] extends [{
+    strategy: "throttled";
+}] ? Op.Manager<I, E, A, Op.ThrottledState<E, A> | MaybeRetry<E, O>> : [O] extends [{
+    strategy: "debounced";
+}] ? Op.Manager<I, E, A, Op.DebouncedState<E, A> | MaybeRetry<E, O>> : [O] extends [{
+    strategy: "concurrent";
+    overflow: "queue";
+}] ? Op.Manager<I, E, A, Op.ConcurrentQueueState<E, A> | MaybeRetry<E, O>> : [O] extends [{
+    strategy: "concurrent";
+}] ? Op.Manager<I, E, A, Op.ConcurrentDropState<E, A> | MaybeRetry<E, O>> : [O] extends [{
+    strategy: "keyed";
+    perKey: "restartable";
+}] ? Op.KeyedManager<I, KeyType<I, O>, E, Op.KeyedRestartablePerKey<E, A>> : [O] extends [{
+    strategy: "keyed";
+}] ? Op.KeyedManager<I, KeyType<I, O>, E, Op.KeyedExclusivePerKey<E, A>> : [O] extends [{
+    strategy: "once";
+}] ? Op.Manager<I, E, A, Op.OnceState<E, A> | MaybeRetry<E, O>> : [O] extends [{
+    strategy: "restartable";
+}] ? Op.Manager<I, E, A, Op.RestartableState<E, A> | MaybeRetry<E, O>> : [O] extends [{
+    strategy: "exclusive";
+}] ? Op.Manager<I, E, A, Op.ExclusiveState<E, A> | MaybeRetry<E, O>> : [O] extends [{
+    strategy: "queue";
+    overflow: "replace-last";
+    dedupe: (a: I, b: I) => boolean;
+}] ? Op.Manager<I, E, A, Op.QueueDropAndReplaceState<E, A> | MaybeRetry<E, O>> : [O] extends [{
+    strategy: "queue";
+    overflow: "replace-last";
+}] ? Op.Manager<I, E, A, Op.QueueReplaceState<E, A> | MaybeRetry<E, O>> : [O] extends [{
+    strategy: "queue";
+    maxSize: number;
+}] ? Op.Manager<I, E, A, Op.QueueDropState<E, A> | MaybeRetry<E, O>> : [O] extends [{
+    strategy: "queue";
+    dedupe: (a: I, b: I) => boolean;
+}] ? Op.Manager<I, E, A, Op.QueueDropState<E, A> | MaybeRetry<E, O>> : [O] extends [{
+    strategy: "queue";
+}] ? Op.Manager<I, E, A, Op.QueueState<E, A> | MaybeRetry<E, O>> : [O] extends [{
+    strategy: "buffered";
+}] ? Op.Manager<I, E, A, Op.BufferedState<E, A> | MaybeRetry<E, O>> : never;
 /**
  * A reusable description of async work — decoupled from execution strategy and lifetime.
  *
@@ -412,7 +495,11 @@ declare namespace Logged {
  * @example
  * ```ts
  * const fetchUser = Op.create(
- *   (signal) => (id: string) => fetch(`/users/${id}`, { signal }).then(r => r.json()),
+ *   (signal) => (id: string) =>
+ *     fetch(`/users/${id}`, { signal }).then(r => {
+ *       if (!r.ok) throw new Error(`${r.status} ${r.statusText}`);
+ *       return r.json() as Promise<User>;
+ *     }),
  *   (e) => new ApiError(e),
  * );
  *
@@ -655,22 +742,42 @@ declare namespace Op {
     /**
      * Creates an `Op` from an async factory and an error mapper.
      *
-     * The factory receives an `AbortSignal` and returns a function that takes the input.
-     * Operations that support cancellation (like `fetch`) should capture the signal in the
-     * outer closure. The error mapper converts any thrown value into a typed error; it is
-     * never called for aborts.
+     * The factory receives an `AbortSignal` and returns a function that takes the input. Capture
+     * the signal in the outer closure and pass it to cancellable APIs like `fetch`. The error
+     * mapper converts any thrown value into a typed error; it is never called for aborts.
+     *
+     * **If the factory ignores the signal**, cancellation silently stops working: the operation
+     * runs to completion and emits `Ok` even after the strategy has aborted it. This is harmless
+     * for `exclusive` and `once` (which do not abort in-flight work), but causes stale `Ok`
+     * emissions on `restartable`, `debounced`, `throttled`, `buffered`, and `queue` strategies
+     * where in-flight runs are regularly replaced or dropped.
      *
      * @example
      * ```ts
+     * // With cancellation — fetch is aborted when the Op is replaced or aborted
      * const saveProfile = Op.create(
      *   (signal) => (data: ProfileData) =>
      *     fetch("/profile", { method: "POST", body: JSON.stringify(data), signal })
-     *       .then(r => r.json()),
+     *       .then(r => {
+     *         if (!r.ok) throw new Error(`${r.status} ${r.statusText}`);
+     *         return r.json() as Promise<ProfileData>;
+     *       }),
      *   (e) => new ApiError(e),
      * );
+     *
+     * // No input — fetches the current user; manager.run() takes no arguments
+     * const fetchCurrentUser = Op.create(
+     *   (signal) => () => fetch("/me", { signal }).then(r => {
+     *     if (!r.ok) throw new Error(`${r.status} ${r.statusText}`);
+     *     return r.json() as Promise<User>;
+     *   }),
+     *   (e) => new ApiError(e),
+     * );
+     * const manager = Op.interpret(fetchCurrentUser, { strategy: "once" });
+     * manager.run(); // no argument needed
      * ```
      */
-    const create: <I, E, A>(factory: (signal: AbortSignal) => (input: I) => Promise<A>, onError: (e: unknown) => E) => Op<I, E, A>;
+    const create: <E, A, I = void>(factory: (signal: AbortSignal) => (input: I) => Promise<A>, onError: (e: unknown) => E) => Op<I, E, A>;
     /**
      * Creates a successful Outcome.
      *
@@ -890,108 +997,7 @@ declare namespace Op {
      * const save = Op.interpret(saveOp, { strategy: "buffered" });
      * ```
      */
-    function interpret<I, E, A>(op: Op<I, E, A>, options: {
-        strategy: "throttled";
-    } & WithMs & WithTrailing & WithRetry<E> & WithTimeout<E>): Manager<I, E, A, RetryableThrottledTrailingState<E, A>>;
-    function interpret<I, E, A>(op: Op<I, E, A>, options: {
-        strategy: "throttled";
-    } & WithMs & WithTrailing & WithTimeout<E>): Manager<I, E, A, ThrottledTrailingState<E, A>>;
-    function interpret<I, E, A>(op: Op<I, E, A>, options: {
-        strategy: "throttled";
-    } & WithMs & WithRetry<E> & WithTimeout<E>): Manager<I, E, A, RetryableThrottledState<E, A>>;
-    function interpret<I, E, A>(op: Op<I, E, A>, options: {
-        strategy: "throttled";
-    } & WithMs & WithTimeout<E>): Manager<I, E, A, ThrottledState<E, A>>;
-    function interpret<I, E, A>(op: Op<I, E, A>, options: {
-        strategy: "debounced";
-    } & WithMs & WithLeading & WithMaxWait & WithRetry<E> & WithTimeout<E>): Manager<I, E, A, RetryableDebouncedState<E, A>>;
-    function interpret<I, E, A>(op: Op<I, E, A>, options: {
-        strategy: "debounced";
-    } & WithMs & WithLeading & WithMaxWait & WithTimeout<E>): Manager<I, E, A, DebouncedState<E, A>>;
-    function interpret<I, E, A>(op: Op<I, E, A>, options: {
-        strategy: "debounced";
-    } & WithMs & WithLeading & WithRetry<E> & WithTimeout<E>): Manager<I, E, A, RetryableDebouncedState<E, A>>;
-    function interpret<I, E, A>(op: Op<I, E, A>, options: {
-        strategy: "debounced";
-    } & WithMs & WithLeading & WithTimeout<E>): Manager<I, E, A, DebouncedState<E, A>>;
-    function interpret<I, E, A>(op: Op<I, E, A>, options: {
-        strategy: "debounced";
-    } & WithMs & WithMaxWait & WithRetry<E> & WithTimeout<E>): Manager<I, E, A, RetryableDebouncedState<E, A>>;
-    function interpret<I, E, A>(op: Op<I, E, A>, options: {
-        strategy: "debounced";
-    } & WithMs & WithMaxWait & WithTimeout<E>): Manager<I, E, A, DebouncedState<E, A>>;
-    function interpret<I, E, A>(op: Op<I, E, A>, options: {
-        strategy: "debounced";
-    } & WithMs & WithRetry<E> & WithTimeout<E>): Manager<I, E, A, RetryableDebouncedState<E, A>>;
-    function interpret<I, E, A>(op: Op<I, E, A>, options: {
-        strategy: "debounced";
-    } & WithMs & WithTimeout<E>): Manager<I, E, A, DebouncedState<E, A>>;
-    function interpret<I, E, A>(op: Op<I, E, A>, options: {
-        strategy: "concurrent";
-    } & WithN & WithOverflow<"queue"> & WithRetry<E> & WithTimeout<E>): Manager<I, E, A, RetryableConcurrentQueueState<E, A>>;
-    function interpret<I, E, A>(op: Op<I, E, A>, options: {
-        strategy: "concurrent";
-    } & WithN & WithOverflow<"queue"> & WithTimeout<E>): Manager<I, E, A, ConcurrentQueueState<E, A>>;
-    function interpret<I, E, A>(op: Op<I, E, A>, options: {
-        strategy: "concurrent";
-    } & WithN & WithOverflow<"drop"> & WithRetry<E> & WithTimeout<E>): Manager<I, E, A, RetryableConcurrentDropState<E, A>>;
-    function interpret<I, E, A>(op: Op<I, E, A>, options: {
-        strategy: "concurrent";
-    } & WithN & WithOverflow<"drop"> & WithTimeout<E>): Manager<I, E, A, ConcurrentDropState<E, A>>;
-    function interpret<I, K, E, A>(op: Op<I, E, A>, options: {
-        strategy: "keyed";
-    } & WithKey<I, K> & WithPerKey<"exclusive"> & WithTimeout<E>): KeyedManager<I, K, E, KeyedExclusivePerKey<E, A>>;
-    function interpret<I, K, E, A>(op: Op<I, E, A>, options: {
-        strategy: "keyed";
-    } & WithKey<I, K> & WithPerKey<"restartable"> & WithTimeout<E>): KeyedManager<I, K, E, KeyedRestartablePerKey<E, A>>;
-    function interpret<I, E, A>(op: Op<I, E, A>, options: {
-        strategy: "once";
-    } & WithRetry<E> & WithTimeout<E>): Manager<I, E, A, RetryableOnceState<E, A>>;
-    function interpret<I, E, A>(op: Op<I, E, A>, options: {
-        strategy: "once";
-    } & WithTimeout<E>): Manager<I, E, A, OnceState<E, A>>;
-    function interpret<I, E, A>(op: Op<I, E, A>, options: {
-        strategy: "restartable";
-    } & WithMinInterval & WithRetry<E> & WithTimeout<E>): Manager<I, E, A, RetryableRestartableState<E, A>>;
-    function interpret<I, E, A>(op: Op<I, E, A>, options: {
-        strategy: "restartable";
-    } & WithMinInterval & WithTimeout<E>): Manager<I, E, A, RestartableState<E, A>>;
-    function interpret<I, E, A>(op: Op<I, E, A>, options: {
-        strategy: "exclusive";
-    } & WithCooldown & WithRetry<E> & WithTimeout<E>): Manager<I, E, A, RetryableExclusiveState<E, A>>;
-    function interpret<I, E, A>(op: Op<I, E, A>, options: {
-        strategy: "exclusive";
-    } & WithCooldown & WithTimeout<E>): Manager<I, E, A, ExclusiveState<E, A>>;
-    function interpret<I, E, A>(op: Op<I, E, A>, options: {
-        strategy: "queue";
-    } & WithMaxSize & WithOverflow<"replace-last"> & WithDedupe<I> & WithRetry<E> & WithConcurrency & WithTimeout<E>): Manager<I, E, A, RetryableQueueDropAndReplaceState<E, A>>;
-    function interpret<I, E, A>(op: Op<I, E, A>, options: {
-        strategy: "queue";
-    } & WithMaxSize & WithOverflow<"replace-last"> & WithDedupe<I> & WithConcurrency & WithTimeout<E>): Manager<I, E, A, QueueDropAndReplaceState<E, A>>;
-    function interpret<I, E, A>(op: Op<I, E, A>, options: {
-        strategy: "queue";
-    } & WithMaxSize & WithOverflow<"replace-last"> & WithRetry<E> & WithConcurrency & WithTimeout<E>): Manager<I, E, A, RetryableQueueReplaceState<E, A>>;
-    function interpret<I, E, A>(op: Op<I, E, A>, options: {
-        strategy: "queue";
-    } & WithMaxSize & WithOverflow<"replace-last"> & WithConcurrency & WithTimeout<E>): Manager<I, E, A, QueueReplaceState<E, A>>;
-    function interpret<I, E, A>(op: Op<I, E, A>, options: {
-        strategy: "queue";
-    } & (WithMaxSize | WithDedupe<I>) & WithRetry<E> & WithConcurrency & WithTimeout<E>): Manager<I, E, A, RetryableQueueDropState<E, A>>;
-    function interpret<I, E, A>(op: Op<I, E, A>, options: {
-        strategy: "queue";
-    } & (WithMaxSize | WithDedupe<I>) & WithConcurrency & WithTimeout<E>): Manager<I, E, A, QueueDropState<E, A>>;
-    function interpret<I, E, A>(op: Op<I, E, A>, options: {
-        strategy: "queue";
-    } & WithRetry<E> & WithConcurrency & WithTimeout<E>): Manager<I, E, A, RetryableQueueState<E, A>>;
-    function interpret<I, E, A>(op: Op<I, E, A>, options: {
-        strategy: "queue";
-    } & WithConcurrency & WithTimeout<E>): Manager<I, E, A, QueueState<E, A>>;
-    function interpret<I, E, A>(op: Op<I, E, A>, options: {
-        strategy: "buffered";
-    } & WithSize & WithRetry<E> & WithTimeout<E>): Manager<I, E, A, RetryableBufferedState<E, A>>;
-    function interpret<I, E, A>(op: Op<I, E, A>, options: {
-        strategy: "buffered";
-    } & WithSize & WithTimeout<E>): Manager<I, E, A, BufferedState<E, A>>;
+    function interpret<I, E, A, O extends AllInterpretOptions<I, E>>(op: Op<I, E, A>, options: O): InterpretResult<I, E, A, O>;
 }
 
 /**
@@ -1638,6 +1644,17 @@ declare namespace RemoteData {
      * ```
      */
     const toResult: <E>(onNotReady: () => E) => <A>(data: RemoteData<E, A>) => Result<E, A>;
+    /**
+     * Converts a Result to a RemoteData.
+     * Ok becomes Success, Err becomes Failure.
+     *
+     * @example
+     * ```ts
+     * const result = await TaskResult.tryCatch(fetchUser, String)();
+     * setState(RemoteData.fromResult(result)); // Success(user) or Failure(msg)
+     * ```
+     */
+    const fromResult: <E, A>(data: Result<E, A>) => RemoteData<E, A>;
 }
 
 /**
@@ -1717,6 +1734,20 @@ declare namespace TaskResult {
      * Useful for logging or debugging.
      */
     const tap: <E, A>(f: (a: A) => void) => (data: TaskResult<E, A>) => TaskResult<E, A>;
+    /**
+     * Executes a side effect on the error value without changing the TaskResult.
+     * Useful for logging or reporting async errors.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   fetchUser(id),
+     *   TaskResult.tapError(e => console.error("fetch failed:", e)),
+     *   TaskResult.chain(saveToCache),
+     * )
+     * ```
+     */
+    const tapError: <E, A>(f: (e: E) => void) => (data: TaskResult<E, A>) => TaskResult<E, A>;
 }
 
 /**

package/dist/core.js

@@ -126,6 +126,10 @@ var Result;
     if ((0, Result2.isOk)(data)) f(data.value);
     return data;
   };
+  Result2.tapError = (f) => (data) => {
+    if ((0, Result2.isErr)(data)) f(data.error);
+    return data;
+  };
   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.toMaybe = (data) => (0, Result2.isOk)(data) ? Maybe.some(data.value) : Maybe.none();
@@ -144,6 +148,7 @@ var Maybe;
   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)();
   Maybe2.map = (f) => (data) => (0, Maybe2.isSome)(data) ? (0, Maybe2.some)(f(data.value)) : data;
@@ -1198,6 +1203,7 @@ var RemoteData;
   RemoteData2.recover = (fallback) => (data) => (0, RemoteData2.isFailure)(data) ? fallback(data.error) : data;
   RemoteData2.toMaybe = (data) => (0, RemoteData2.isSuccess)(data) ? Maybe.some(data.value) : Maybe.none();
   RemoteData2.toResult = (onNotReady) => (data) => (0, RemoteData2.isSuccess)(data) ? Result.ok(data.value) : Result.err((0, RemoteData2.isFailure)(data) ? data.error : onNotReady());
+  RemoteData2.fromResult = (data) => Result.isOk(data) ? (0, RemoteData2.success)(data.value) : (0, RemoteData2.failure)(data.error);
 })(RemoteData || (RemoteData = {}));
 
 // src/Core/Task.ts
@@ -1407,6 +1413,7 @@ var TaskResult;
   )(data);
   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);
 })(TaskResult || (TaskResult = {}));
 
 // src/Core/Validation.ts

package/dist/core.mjs

@@ -15,13 +15,13 @@ import {
   These,
   Tuple,
   Validation
-} from "./chunk-UFQE2J63.mjs";
+} from "./chunk-NTISCH7Z.mjs";
 import {
   Deferred,
   Maybe,
   Result,
   Task
-} from "./chunk-2DPG2RDB.mjs";
+} from "./chunk-Z3DYYR43.mjs";
 export {
   Deferred,
   Lens,

package/dist/index.d.mts

@@ -1,5 +1,5 @@
 export { and, compose, constFalse, constNull, constTrue, constUndefined, constVoid, constant, converge, curry, curry3, curry4, flip, flow, identity, juxt, memoize, memoizeWeak, not, on, once, or, pipe, tap, uncurry, uncurry3, uncurry4 } from './composition.mjs';
-export { D as Deferred, E as Err, M as Maybe, N as None, O as Ok, R as Result, S as Some, T as Task } from './Task-CT8iwwuB.mjs';
+export { D as Deferred, E as Err, M as Maybe, N as None, O as Ok, R as Result, S as Some, T as Task } from './Task-BoqaFsUR.mjs';
 export { Failure, Invalid, Lens, Loading, Logged, NotAsked, Op, Optional, Predicate, Reader, Refinement, RemoteData, Resource, State, Success, TaskMaybe, TaskResult, TaskValidation, These, TheseBoth, TheseFirst, TheseSecond, Tuple, Valid, Validation } from './core.mjs';
 export { Brand } from './types.mjs';
 export { N as NonEmptyList, i as isNonEmptyList } from './NonEmptyList-BlGFjor5.mjs';

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 export { and, compose, constFalse, constNull, constTrue, constUndefined, constVoid, constant, converge, curry, curry3, curry4, flip, flow, identity, juxt, memoize, memoizeWeak, not, on, once, or, pipe, tap, uncurry, uncurry3, uncurry4 } from './composition.js';
-export { D as Deferred, E as Err, M as Maybe, N as None, O as Ok, R as Result, S as Some, T as Task } from './Task-GSGtQO1m.js';
+export { D as Deferred, E as Err, M as Maybe, N as None, O as Ok, R as Result, S as Some, T as Task } from './Task-7brqoQrb.js';
 export { Failure, Invalid, Lens, Loading, Logged, NotAsked, Op, Optional, Predicate, Reader, Refinement, RemoteData, Resource, State, Success, TaskMaybe, TaskResult, TaskValidation, These, TheseBoth, TheseFirst, TheseSecond, Tuple, Valid, Validation } from './core.js';
 export { Brand } from './types.js';
 export { N as NonEmptyList, i as isNonEmptyList } from './NonEmptyList-BlGFjor5.js';

package/dist/index.js

@@ -371,6 +371,10 @@ var Result;
     if ((0, Result2.isOk)(data)) f(data.value);
     return data;
   };
+  Result2.tapError = (f) => (data) => {
+    if ((0, Result2.isErr)(data)) f(data.error);
+    return data;
+  };
   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.toMaybe = (data) => (0, Result2.isOk)(data) ? Maybe.some(data.value) : Maybe.none();
@@ -389,6 +393,7 @@ var Maybe;
   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)();
   Maybe2.map = (f) => (data) => (0, Maybe2.isSome)(data) ? (0, Maybe2.some)(f(data.value)) : data;
@@ -1443,6 +1448,7 @@ var RemoteData;
   RemoteData2.recover = (fallback) => (data) => (0, RemoteData2.isFailure)(data) ? fallback(data.error) : data;
   RemoteData2.toMaybe = (data) => (0, RemoteData2.isSuccess)(data) ? Maybe.some(data.value) : Maybe.none();
   RemoteData2.toResult = (onNotReady) => (data) => (0, RemoteData2.isSuccess)(data) ? Result.ok(data.value) : Result.err((0, RemoteData2.isFailure)(data) ? data.error : onNotReady());
+  RemoteData2.fromResult = (data) => Result.isOk(data) ? (0, RemoteData2.success)(data.value) : (0, RemoteData2.failure)(data.error);
 })(RemoteData || (RemoteData = {}));
 
 // src/Core/Task.ts
@@ -1652,6 +1658,7 @@ var TaskResult;
   )(data);
   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);
 })(TaskResult || (TaskResult = {}));
 
 // src/Core/Validation.ts
@@ -1870,6 +1877,14 @@ var Arr;
     }
     return result;
   };
+  Arr2.filterMap = (f) => (data) => {
+    const result = [];
+    for (let i = 0; i < data.length; i++) {
+      const mapped = f(data[i]);
+      if (mapped.kind === "Some") result.push(mapped.value);
+    }
+    return result;
+  };
   Arr2.partition = (predicate) => (data) => {
     const pass = [];
     const fail = [];
@@ -2298,6 +2313,8 @@ var Str;
   Str2.split = (separator) => (s) => s.split(separator);
   Str2.trim = (s) => s.trim();
   Str2.includes = (substring) => (s) => s.includes(substring);
+  Str2.replace = (pattern, replacement) => (s) => s.replace(pattern, replacement);
+  Str2.replaceAll = (pattern, replacement) => (s) => s.replaceAll(pattern, replacement);
   Str2.startsWith = (prefix) => (s) => s.startsWith(prefix);
   Str2.endsWith = (suffix) => (s) => s.endsWith(suffix);
   Str2.toUpperCase = (s) => s.toUpperCase();

package/dist/index.mjs

@@ -44,7 +44,7 @@ import {
   These,
   Tuple,
   Validation
-} from "./chunk-UFQE2J63.mjs";
+} from "./chunk-NTISCH7Z.mjs";
 import {
   Arr,
   Dict,
@@ -52,13 +52,13 @@ import {
   Rec,
   Str,
   Uniq
-} from "./chunk-C3Z56PCR.mjs";
+} from "./chunk-6H373E63.mjs";
 import {
   Deferred,
   Maybe,
   Result,
   Task
-} from "./chunk-2DPG2RDB.mjs";
+} from "./chunk-Z3DYYR43.mjs";
 import {
   Brand
 } from "./chunk-BYWKZLHM.mjs";

package/dist/utils.d.mts

@@ -1,4 +1,4 @@
-import { M as Maybe, R as Result, T as Task } from './Task-CT8iwwuB.mjs';
+import { M as Maybe, R as Result, T as Task } from './Task-BoqaFsUR.mjs';
 import { N as NonEmptyList } from './NonEmptyList-BlGFjor5.mjs';
 
 /**
@@ -102,6 +102,21 @@ declare namespace Arr {
      * ```
      */
     const filter: <A>(predicate: (a: A) => boolean) => (data: readonly A[]) => readonly A[];
+    /**
+     * Maps each element to a Maybe and collects only the Some values.
+     * Combines map and filter in a single pass.
+     *
+     * @example
+     * ```ts
+     * const parseNum = (s: string): Maybe<number> => {
+     *   const n = Number(s);
+     *   return isNaN(n) ? Maybe.none() : Maybe.some(n);
+     * };
+     *
+     * pipe(["1", "abc", "3"], Arr.filterMap(parseNum)); // [1, 3]
+     * ```
+     */
+    const filterMap: <A, B>(f: (a: A) => Maybe<B>) => (data: readonly A[]) => readonly B[];
     /**
      * Splits an array into two groups based on a predicate.
      * First group contains elements that satisfy the predicate,
@@ -1041,6 +1056,26 @@ declare namespace Str {
      * ```
      */
     const includes: (substring: string) => (s: string) => boolean;
+    /**
+     * Replaces the first occurrence of a pattern in a string. Data-last: use in `pipe`.
+     *
+     * @example
+     * ```ts
+     * pipe("foo foo foo", Str.replace("foo", "bar")); // "bar foo foo"
+     * pipe("Hello World", Str.replace(/world/i, "Earth")); // "Hello Earth"
+     * ```
+     */
+    const replace: (pattern: string | RegExp, replacement: string) => (s: string) => string;
+    /**
+     * Replaces all occurrences of a pattern in a string. Data-last: use in `pipe`.
+     *
+     * @example
+     * ```ts
+     * pipe("foo foo foo", Str.replaceAll("foo", "bar")); // "bar bar bar"
+     * pipe("aAbBaA", Str.replaceAll(/a/gi, "x")); // "xxBBxx"
+     * ```
+     */
+    const replaceAll: (pattern: string | RegExp, replacement: string) => (s: string) => string;
     /**
      * Returns `true` when the string starts with the given prefix.
      *

package/dist/utils.d.ts

@@ -1,4 +1,4 @@
-import { M as Maybe, R as Result, T as Task } from './Task-GSGtQO1m.js';
+import { M as Maybe, R as Result, T as Task } from './Task-7brqoQrb.js';
 import { N as NonEmptyList } from './NonEmptyList-BlGFjor5.js';
 
 /**
@@ -102,6 +102,21 @@ declare namespace Arr {
      * ```
      */
     const filter: <A>(predicate: (a: A) => boolean) => (data: readonly A[]) => readonly A[];
+    /**
+     * Maps each element to a Maybe and collects only the Some values.
+     * Combines map and filter in a single pass.
+     *
+     * @example
+     * ```ts
+     * const parseNum = (s: string): Maybe<number> => {
+     *   const n = Number(s);
+     *   return isNaN(n) ? Maybe.none() : Maybe.some(n);
+     * };
+     *
+     * pipe(["1", "abc", "3"], Arr.filterMap(parseNum)); // [1, 3]
+     * ```
+     */
+    const filterMap: <A, B>(f: (a: A) => Maybe<B>) => (data: readonly A[]) => readonly B[];
     /**
      * Splits an array into two groups based on a predicate.
      * First group contains elements that satisfy the predicate,
@@ -1041,6 +1056,26 @@ declare namespace Str {
      * ```
      */
     const includes: (substring: string) => (s: string) => boolean;
+    /**
+     * Replaces the first occurrence of a pattern in a string. Data-last: use in `pipe`.
+     *
+     * @example
+     * ```ts
+     * pipe("foo foo foo", Str.replace("foo", "bar")); // "bar foo foo"
+     * pipe("Hello World", Str.replace(/world/i, "Earth")); // "Hello Earth"
+     * ```
+     */
+    const replace: (pattern: string | RegExp, replacement: string) => (s: string) => string;
+    /**
+     * Replaces all occurrences of a pattern in a string. Data-last: use in `pipe`.
+     *
+     * @example
+     * ```ts
+     * pipe("foo foo foo", Str.replaceAll("foo", "bar")); // "bar bar bar"
+     * pipe("aAbBaA", Str.replaceAll(/a/gi, "x")); // "xxBBxx"
+     * ```
+     */
+    const replaceAll: (pattern: string | RegExp, replacement: string) => (s: string) => string;
     /**
      * Returns `true` when the string starts with the given prefix.
      *

package/dist/utils.js

@@ -63,6 +63,10 @@ var Result;
     if ((0, Result2.isOk)(data)) f(data.value);
     return data;
   };
+  Result2.tapError = (f) => (data) => {
+    if ((0, Result2.isErr)(data)) f(data.error);
+    return data;
+  };
   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.toMaybe = (data) => (0, Result2.isOk)(data) ? Maybe.some(data.value) : Maybe.none();
@@ -81,6 +85,7 @@ var Maybe;
   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)();
   Maybe2.map = (f) => (data) => (0, Maybe2.isSome)(data) ? (0, Maybe2.some)(f(data.value)) : data;
@@ -231,6 +236,14 @@ var Arr;
     }
     return result;
   };
+  Arr2.filterMap = (f) => (data) => {
+    const result = [];
+    for (let i = 0; i < data.length; i++) {
+      const mapped = f(data[i]);
+      if (mapped.kind === "Some") result.push(mapped.value);
+    }
+    return result;
+  };
   Arr2.partition = (predicate) => (data) => {
     const pass = [];
     const fail = [];
@@ -659,6 +672,8 @@ var Str;
   Str2.split = (separator) => (s) => s.split(separator);
   Str2.trim = (s) => s.trim();
   Str2.includes = (substring) => (s) => s.includes(substring);
+  Str2.replace = (pattern, replacement) => (s) => s.replace(pattern, replacement);
+  Str2.replaceAll = (pattern, replacement) => (s) => s.replaceAll(pattern, replacement);
   Str2.startsWith = (prefix) => (s) => s.startsWith(prefix);
   Str2.endsWith = (suffix) => (s) => s.endsWith(suffix);
   Str2.toUpperCase = (s) => s.toUpperCase();

package/dist/utils.mjs

@@ -5,8 +5,8 @@ import {
   Rec,
   Str,
   Uniq
-} from "./chunk-C3Z56PCR.mjs";
-import "./chunk-2DPG2RDB.mjs";
+} from "./chunk-6H373E63.mjs";
+import "./chunk-Z3DYYR43.mjs";
 import "./chunk-DBIC62UV.mjs";
 export {
   Arr,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@nlozgachev/pipelined",
-	"version": "0.24.0",
+	"version": "0.26.0",
 	"description": "Opinionated functional abstractions for TypeScript",
 	"license": "BSD-3-Clause",
 	"homepage": "https://pipelined.lozgachev.dev",