@nlozgachev/pipelined 0.24.0 → 0.25.0

package/dist/{Task-GSGtQO1m.d.ts → Task-BbTMuIby.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>;
@@ -777,4 +739,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-C7M6gLYu.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>;
@@ -777,4 +739,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/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-C7M6gLYu.mjs';
+export { E as Err, N as None, O as Ok, S as Some } from './Task-C7M6gLYu.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>;
 }
 
 /**

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-BbTMuIby.js';
+export { E as Err, N as None, O as Ok, S as Some } from './Task-BbTMuIby.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>;
 }
 
 /**

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-C7M6gLYu.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-BbTMuIby.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/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-C7M6gLYu.mjs';
 import { N as NonEmptyList } from './NonEmptyList-BlGFjor5.mjs';
 
 /**

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-BbTMuIby.js';
 import { N as NonEmptyList } from './NonEmptyList-BlGFjor5.js';
 
 /**

package/package.json

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