@nlozgachev/pipelined 0.28.0 → 0.30.0

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 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-BZT0wedE.mjs';
-export { E as Err, N as None, O as Ok, S as Some } from './Task-BZT0wedE.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-BDcKwFAj.mjs';
+export { E as Error, N as None, O as Ok, S as Some } from './Task-BDcKwFAj.mjs';
 import { N as NonEmptyList } from './NonEmptyList-BlGFjor5.mjs';
 
 /** Keys of T for which undefined is assignable (i.e. optional fields). */
@@ -505,10 +505,10 @@ type InterpretResult<I, E, A, O> = [O] extends [{
  *
  * const manager = Op.interpret(fetchUser, { strategy: "restartable" });
  * manager.subscribe(state => {
- *   if (state.kind === "Pending") showSpinner();
- *   if (state.kind === "Ok")      render(state.value);
- *   if (state.kind === "Err")     showError(state.error);
- *   if (state.kind === "Nil")     resetUI();
+ *   if (Op.isPending(state)) showSpinner();
+ *   if (Op.isOk(state))      render(state.value);
+ *   if (Op.isError(state))   showError(state.error);
+ *   if (Op.isNil(state))     resetUI();
  * });
  * manager.run(userId);
  * ```
@@ -532,11 +532,11 @@ declare namespace Op {
      *   over a call that was already running; `"evicted"` — a newer `run()` took over
      *   a call that was waiting and had not yet started.
      */
-    type Outcome<E, A> = Ok<A> | Err<E> | Nil;
+    type Outcome<E, A> = Ok<A> | Error<E> | Nil;
     /** A successful outcome with a value. */
-    type Ok<A> = WithKind<"Ok"> & WithValue<A>;
+    type Ok<A> = WithKind<"OpOk"> & WithValue<A>;
     /** A failed outcome with a typed error. */
-    type Err<E> = WithKind<"Err"> & WithError<E>;
+    type Error<E> = WithKind<"OpError"> & WithError<E>;
     /**
      * An outcome that produced nothing. `reason` identifies why:
      * - `"aborted"` — `abort()` was called explicitly.
@@ -545,7 +545,7 @@ declare namespace Op {
      * - `"evicted"` — a newer invocation took a slot from a call that was waiting and
      *   had not yet started (buffered slot, debounce timer, throttle trailing slot).
      */
-    type Nil = WithKind<"Nil"> & {
+    type Nil = WithKind<"OpNil"> & {
         readonly reason: NilReason;
     };
     /** The reason a `Nil` outcome was produced. */
@@ -593,9 +593,9 @@ declare namespace Op {
      * const manager = Op.interpret(saveConfig, { strategy: "exclusive" });
      *
      * manager.subscribe(state => {
-     *   if (state.kind === "Pending") lockForm();
-     *   if (state.kind === "Ok")      toast("Saved");
-     *   if (state.kind === "Err")     toast(`Error: ${state.error.message}`);
+     *   if (Op.isPending(state)) lockForm();
+     *   if (Op.isOk(state))     toast("Saved");
+     *   if (Op.isError(state))  toast(`Error: ${state.error.message}`);
      * });
      *
      * // Fire and subscribe (subscriber pattern)
@@ -626,6 +626,15 @@ declare namespace Op {
          * The callback fires immediately with the current state if the manager is not idle.
          */
         subscribe: (cb: (state: S) => void) => () => void;
+        /** Returns state to Idle. Does not cancel any in-flight operation. */
+        reset: () => void;
+        /**
+         * Runs the input immediately, then every `interval` milliseconds.
+         * Returns a stop handle — call it to cancel future runs.
+         */
+        poll: (input: I, options: {
+            interval: number;
+        }) => () => void;
     };
     /**
      * A stateful manager that maintains independent per-key execution slots.
@@ -643,8 +652,8 @@ declare namespace Op {
      *
      * getUser.subscribe((map) => {
      *   for (const [id, state] of map) {
-     *     if (state.kind === "Pending") showSpinner(id);
-     *     if (state.kind === "Ok")      render(id, state.value);
+     *     if (Op.isPending(state)) showSpinner(id);
+     *     if (Op.isOk(state))     render(id, state.value);
      *   }
      * });
      *
@@ -668,63 +677,72 @@ declare namespace Op {
          * Fires immediately with the current map if any key is active.
          */
         subscribe: (cb: (state: ReadonlyMap<K, PerKeyS>) => void) => () => void;
+        /** Clears all per-key state and notifies subscribers. Does not cancel in-flight operations. */
+        reset: () => void;
+        /**
+         * Runs the input immediately, then every `interval` milliseconds.
+         * Returns a stop handle — call it to cancel future runs.
+         */
+        poll: (input: I, options: {
+            interval: number;
+        }) => () => void;
     };
     /** States reachable by a `once` manager (no retry). */
-    type OnceState<E, A> = Idle | Pending | Ok<A> | Err<E> | AbortedNil | DroppedNil;
+    type OnceState<E, A> = Idle | Pending | Ok<A> | Error<E> | AbortedNil | DroppedNil;
     /** States reachable by a `once` manager with retry configured. */
-    type RetryableOnceState<E, A> = Idle | Pending | Retrying<E> | Ok<A> | Err<E> | AbortedNil | DroppedNil;
+    type RetryableOnceState<E, A> = Idle | Pending | Retrying<E> | Ok<A> | Error<E> | AbortedNil | DroppedNil;
     /** States reachable by a `restartable` manager (no retry). */
-    type RestartableState<E, A> = Idle | Pending | Ok<A> | Err<E> | AbortedNil | ReplacedNil;
+    type RestartableState<E, A> = Idle | Pending | Ok<A> | Error<E> | AbortedNil | ReplacedNil;
     /** States reachable by a `restartable` manager with retry configured. */
-    type RetryableRestartableState<E, A> = Idle | Pending | Retrying<E> | Ok<A> | Err<E> | AbortedNil | ReplacedNil;
+    type RetryableRestartableState<E, A> = Idle | Pending | Retrying<E> | Ok<A> | Error<E> | AbortedNil | ReplacedNil;
     /** States reachable by an `exclusive` manager (no retry). */
-    type ExclusiveState<E, A> = Idle | Pending | Ok<A> | Err<E> | AbortedNil | DroppedNil;
+    type ExclusiveState<E, A> = Idle | Pending | Ok<A> | Error<E> | AbortedNil | DroppedNil;
     /** States reachable by an `exclusive` manager with retry configured. */
-    type RetryableExclusiveState<E, A> = Idle | Pending | Retrying<E> | Ok<A> | Err<E> | AbortedNil | DroppedNil;
+    type RetryableExclusiveState<E, A> = Idle | Pending | Retrying<E> | Ok<A> | Error<E> | AbortedNil | DroppedNil;
     /** States reachable by a `queue` manager (no retry, no overflow, no dedupe). */
-    type QueueState<E, A> = Idle | Pending | Queued | Ok<A> | Err<E> | AbortedNil;
+    type QueueState<E, A> = Idle | Pending | Queued | Ok<A> | Error<E> | AbortedNil;
     /** States reachable by a `queue` manager with retry (no overflow, no dedupe). */
-    type RetryableQueueState<E, A> = Idle | Pending | Queued | Retrying<E> | Ok<A> | Err<E> | AbortedNil;
+    type RetryableQueueState<E, A> = Idle | Pending | Queued | Retrying<E> | Ok<A> | Error<E> | AbortedNil;
     /** States reachable by a `queue` manager with `overflow:"drop"` or `dedupe` (no retry). */
-    type QueueDropState<E, A> = Idle | Pending | Queued | Ok<A> | Err<E> | AbortedNil | DroppedNil;
+    type QueueDropState<E, A> = Idle | Pending | Queued | Ok<A> | Error<E> | AbortedNil | DroppedNil;
     /** States reachable by a `queue` manager with `overflow:"drop"` or `dedupe`, with retry. */
-    type RetryableQueueDropState<E, A> = Idle | Pending | Queued | Retrying<E> | Ok<A> | Err<E> | AbortedNil | DroppedNil;
+    type RetryableQueueDropState<E, A> = Idle | Pending | Queued | Retrying<E> | Ok<A> | Error<E> | AbortedNil | DroppedNil;
     /** States reachable by a `queue` manager with `overflow:"replace-last"` and no `dedupe` (no retry). */
-    type QueueReplaceState<E, A> = Idle | Pending | Queued | Ok<A> | Err<E> | AbortedNil | EvictedNil;
+    type QueueReplaceState<E, A> = Idle | Pending | Queued | Ok<A> | Error<E> | AbortedNil | EvictedNil;
     /** States reachable by a `queue` manager with `overflow:"replace-last"` and no `dedupe`, with retry. */
-    type RetryableQueueReplaceState<E, A> = Idle | Pending | Queued | Retrying<E> | Ok<A> | Err<E> | AbortedNil | EvictedNil;
+    type RetryableQueueReplaceState<E, A> = Idle | Pending | Queued | Retrying<E> | Ok<A> | Error<E> | AbortedNil | EvictedNil;
     /** States reachable by a `queue` manager with `overflow:"replace-last"` AND `dedupe` (no retry). */
-    type QueueDropAndReplaceState<E, A> = Idle | Pending | Queued | Ok<A> | Err<E> | AbortedNil | DroppedNil | EvictedNil;
+    type QueueDropAndReplaceState<E, A> = Idle | Pending | Queued | Ok<A> | Error<E> | AbortedNil | DroppedNil | EvictedNil;
     /** States reachable by a `queue` manager with `overflow:"replace-last"` AND `dedupe`, with retry. */
-    type RetryableQueueDropAndReplaceState<E, A> = Idle | Pending | Queued | Retrying<E> | Ok<A> | Err<E> | AbortedNil | DroppedNil | EvictedNil;
+    type RetryableQueueDropAndReplaceState<E, A> = Idle | Pending | Queued | Retrying<E> | Ok<A> | Error<E> | AbortedNil | DroppedNil | EvictedNil;
     /** States reachable by a `buffered` manager (no retry). */
-    type BufferedState<E, A> = Idle | Pending | Queued | Ok<A> | Err<E> | AbortedNil | EvictedNil;
+    type BufferedState<E, A> = Idle | Pending | Queued | Ok<A> | Error<E> | AbortedNil | EvictedNil;
     /** States reachable by a `buffered` manager with retry configured. */
-    type RetryableBufferedState<E, A> = Idle | Pending | Queued | Retrying<E> | Ok<A> | Err<E> | AbortedNil | EvictedNil;
+    type RetryableBufferedState<E, A> = Idle | Pending | Queued | Retrying<E> | Ok<A> | Error<E> | AbortedNil | EvictedNil;
     /** States reachable by a `debounced` manager (no retry). */
-    type DebouncedState<E, A> = Idle | Pending | Ok<A> | Err<E> | AbortedNil | EvictedNil;
+    type DebouncedState<E, A> = Idle | Pending | Ok<A> | Error<E> | AbortedNil | EvictedNil;
     /** States reachable by a `debounced` manager with retry configured. */
-    type RetryableDebouncedState<E, A> = Idle | Pending | Retrying<E> | Ok<A> | Err<E> | AbortedNil | EvictedNil;
+    type RetryableDebouncedState<E, A> = Idle | Pending | Retrying<E> | Ok<A> | Error<E> | AbortedNil | EvictedNil;
     /** States reachable by a `throttled` manager (leading-only, no retry). */
-    type ThrottledState<E, A> = Idle | Pending | Ok<A> | Err<E> | AbortedNil | DroppedNil;
+    type ThrottledState<E, A> = Idle | Pending | Ok<A> | Error<E> | AbortedNil | DroppedNil;
     /** States reachable by a `throttled` manager (leading-only, with retry). */
-    type RetryableThrottledState<E, A> = Idle | Pending | Retrying<E> | Ok<A> | Err<E> | AbortedNil | DroppedNil;
+    type RetryableThrottledState<E, A> = Idle | Pending | Retrying<E> | Ok<A> | Error<E> | AbortedNil | DroppedNil;
     /** States reachable by a `throttled` manager with `trailing: true` (no retry). */
-    type ThrottledTrailingState<E, A> = Idle | Pending | Ok<A> | Err<E> | AbortedNil | EvictedNil;
+    type ThrottledTrailingState<E, A> = Idle | Pending | Ok<A> | Error<E> | AbortedNil | EvictedNil;
     /** States reachable by a `throttled` manager with `trailing: true` and retry. */
-    type RetryableThrottledTrailingState<E, A> = Idle | Pending | Retrying<E> | Ok<A> | Err<E> | AbortedNil | EvictedNil;
+    type RetryableThrottledTrailingState<E, A> = Idle | Pending | Retrying<E> | Ok<A> | Error<E> | AbortedNil | EvictedNil;
     /** States reachable by a `concurrent` manager with `overflow: "queue"` (no retry). */
-    type ConcurrentQueueState<E, A> = Idle | Pending | Queued | Ok<A> | Err<E> | AbortedNil;
+    type ConcurrentQueueState<E, A> = Idle | Pending | Queued | Ok<A> | Error<E> | AbortedNil;
     /** States reachable by a `concurrent` manager with `overflow: "queue"` and retry. */
-    type RetryableConcurrentQueueState<E, A> = Idle | Pending | Queued | Retrying<E> | Ok<A> | Err<E> | AbortedNil;
+    type RetryableConcurrentQueueState<E, A> = Idle | Pending | Queued | Retrying<E> | Ok<A> | Error<E> | AbortedNil;
     /** States reachable by a `concurrent` manager with `overflow: "drop"` (no retry). */
-    type ConcurrentDropState<E, A> = Idle | Pending | Ok<A> | Err<E> | AbortedNil | DroppedNil;
+    type ConcurrentDropState<E, A> = Idle | Pending | Ok<A> | Error<E> | AbortedNil | DroppedNil;
     /** States reachable by a `concurrent` manager with `overflow: "drop"` and retry. */
-    type RetryableConcurrentDropState<E, A> = Idle | Pending | Retrying<E> | Ok<A> | Err<E> | AbortedNil | DroppedNil;
+    type RetryableConcurrentDropState<E, A> = Idle | Pending | Retrying<E> | Ok<A> | Error<E> | AbortedNil | DroppedNil;
     /** Per-key state union for a `keyed` manager with `perKey: "exclusive"`. */
-    type KeyedExclusivePerKey<E, A> = Pending | Ok<A> | Err<E> | AbortedNil | DroppedNil;
+    type KeyedExclusivePerKey<E, A> = Pending | Ok<A> | Error<E> | AbortedNil | DroppedNil;
     /** Per-key state union for a `keyed` manager with `perKey: "restartable"`. */
-    type KeyedRestartablePerKey<E, A> = Pending | Ok<A> | Err<E> | AbortedNil | ReplacedNil;
+    type KeyedRestartablePerKey<E, A> = Pending | Ok<A> | Error<E> | AbortedNil | ReplacedNil;
     type RetryOptions<E> = RetryOptions<E>;
     type TimeoutOptions<E> = TimeoutOptions<E>;
     /**
@@ -732,10 +750,10 @@ declare namespace Op {
      *
      * @example
      * ```ts
-     * Op.nil("aborted");  // { kind: "Nil", reason: "aborted" }
-     * Op.nil("dropped");  // { kind: "Nil", reason: "dropped" }
-     * Op.nil("replaced"); // { kind: "Nil", reason: "replaced" }
-     * Op.nil("evicted");  // { kind: "Nil", reason: "evicted" }
+     * Op.nil("aborted");  // { kind: "OpNil", reason: "aborted" }
+     * Op.nil("dropped");  // { kind: "OpNil", reason: "dropped" }
+     * Op.nil("replaced"); // { kind: "OpNil", reason: "replaced" }
+     * Op.nil("evicted");  // { kind: "OpNil", reason: "evicted" }
      * ```
      */
     const nil: (reason: NilReason) => Nil;
@@ -778,12 +796,29 @@ declare namespace Op {
      * ```
      */
     const create: <E, A, I = void>(factory: (signal: AbortSignal) => (input: I) => Promise<A>, onError: (e: unknown) => E) => Op<I, E, A>;
+    /**
+     * Lifts a plain async function into an Op, treating all errors as `unknown`.
+     *
+     * Use this when you have a simple async function that doesn't need custom error mapping.
+     * The signal is passed so the operation can respect cancellation.
+     *
+     * @example
+     * ```ts
+     * const fetchUser = Op.lift((id: number, signal: AbortSignal) =>
+     *   fetch(`/api/users/${id}`, { signal }).then(r => r.json())
+     * );
+     * const manager = Op.interpret(fetchUser, { strategy: "restartable" });
+     * const outcome = await manager.run(42);
+     * if (Op.isOk(outcome)) console.log(outcome.value);
+     * ```
+     */
+    const lift: <I, A>(f: (input: I, signal: AbortSignal) => Promise<A>) => Op<I, unknown, A>;
     /**
      * Creates a successful Outcome.
      *
      * @example
      * ```ts
-     * Op.ok(42); // { kind: "Ok", value: 42 }
+     * Op.ok(42); // { kind: "OpOk", value: 42 }
      * ```
      */
     const ok: <A>(value: A) => Ok<A>;
@@ -792,37 +827,87 @@ declare namespace Op {
      *
      * @example
      * ```ts
-     * Op.err(new ApiError("not found")); // { kind: "Err", error: ApiError }
+     * Op.error(new ApiError("not found")); // { kind: "OpError", error: ApiError }
+     * ```
+     */
+    const error: <E>(error: E) => Error<E>;
+    /**
+     * Returns `true` if the state is `Idle`.
+     *
+     * @example
+     * ```ts
+     * manager.subscribe(state => {
+     *   if (Op.isIdle(state)) hideSpinner();
+     * });
+     * ```
+     */
+    const isIdle: <E, A>(state: State<E, A>) => state is Idle;
+    /**
+     * Returns `true` if the state is `Pending` (an operation is in-flight).
+     *
+     * @example
+     * ```ts
+     * manager.subscribe(state => {
+     *   if (Op.isPending(state)) showSpinner();
+     * });
      * ```
      */
-    const err: <E>(error: E) => Err<E>;
+    const isPending: <E, A>(state: State<E, A>) => state is Pending;
     /**
-     * Returns `true` if the Outcome is `Ok`.
+     * Returns `true` if the state is `Queued` (an invocation is waiting to run).
      *
      * @example
      * ```ts
-     * if (Op.isOk(outcome)) render(outcome.value);
+     * manager.subscribe(state => {
+     *   if (Op.isQueued(state)) showQueuePosition(state.position);
+     * });
+     * ```
+     */
+    const isQueued: <E, A>(state: State<E, A>) => state is Queued;
+    /**
+     * Returns `true` if the state is `Retrying`.
+     *
+     * @example
+     * ```ts
+     * manager.subscribe(state => {
+     *   if (Op.isRetrying(state)) showRetryBadge(state.attempt);
+     * });
+     * ```
+     */
+    const isRetrying: <E, A>(state: State<E, A>) => state is Retrying<E>;
+    /**
+     * Returns `true` if the state is `Ok` (the operation produced a value).
+     *
+     * @example
+     * ```ts
+     * manager.subscribe(state => {
+     *   if (Op.isOk(state)) render(state.value);
+     * });
      * ```
      */
-    const isOk: <E, A>(outcome: Outcome<E, A>) => outcome is Ok<A>;
+    const isOk: <E, A>(state: State<E, A>) => state is Ok<A>;
     /**
-     * Returns `true` if the Outcome is `Err`.
+     * Returns `true` if the state is `Error` (the operation failed with a typed error).
      *
      * @example
      * ```ts
-     * if (Op.isErr(outcome)) logger.error(outcome.error);
+     * manager.subscribe(state => {
+     *   if (Op.isError(state)) showError(state.error);
+     * });
      * ```
      */
-    const isErr: <E, A>(outcome: Outcome<E, A>) => outcome is Err<E>;
+    const isError: <E, A>(state: State<E, A>) => state is Error<E>;
     /**
-     * Returns `true` if the Outcome is `Nil`.
+     * Returns `true` if the state is `Nil` (the operation completed without a value or error).
      *
      * @example
      * ```ts
-     * if (Op.isNil(outcome)) resetUI();
+     * manager.subscribe(state => {
+     *   if (Op.isNil(state)) resetUI();
+     * });
      * ```
      */
-    const isNil: <E, A>(outcome: Outcome<E, A>) => outcome is Nil;
+    const isNil: <E, A>(state: State<E, A>) => state is Nil;
     /**
      * Pattern matches on an Outcome using named case handlers.
      *
@@ -830,19 +915,19 @@ declare namespace Op {
      * ```ts
      * Op.match({
      *   ok:  (user) => render(user),
-     *   err: (e)    => showError(e.message),
+     *   error: (e)    => showError(e.message),
      *   nil: ()     => resetUI(),
      * })(outcome);
      * ```
      */
     const match: <E, A, B>(cases: {
         ok: (a: A) => B;
-        err: (e: E) => B;
+        error: (e: E) => B;
         nil: () => B;
     }) => (outcome: Outcome<E, A>) => B;
     /**
      * Eliminates an Outcome with positional handlers.
-     * Order: `onErr`, `onOk`, `onNil` — mirrors `Result.fold` for the first two.
+     * Order: `onError`, `onOk`, `onNil` — mirrors `Result.fold` for the first two.
      *
      * @example
      * ```ts
@@ -853,7 +938,7 @@ declare namespace Op {
      * )(outcome);
      * ```
      */
-    const fold: <E, A, B>(onErr: (e: E) => B, onOk: (a: A) => B, onNil: () => B) => (outcome: Outcome<E, A>) => B;
+    const fold: <E, A, B>(onError: (e: E) => B, onOk: (a: A) => B, onNil: () => B) => (outcome: Outcome<E, A>) => B;
     /**
      * Returns the success value, or the result of `defaultValue()` for `Err` or `Nil`.
      *
@@ -888,7 +973,7 @@ declare namespace Op {
      * ```ts
      * pipe(
      *   outcome,
-     *   Op.chain(user => user.active ? Op.ok(user) : Op.err(new Error("inactive"))),
+     *   Op.chain(user => user.active ? Op.ok(user) : Op.error(new Error("inactive"))),
      * );
      * ```
      */
@@ -909,7 +994,7 @@ declare namespace Op {
      * ```ts
      * pipe(
      *   outcome,
-     *   Op.recover(e => e.isRetryable ? Op.ok(cachedValue) : Op.err(e)),
+     *   Op.recover(e => e.isRetryable ? Op.ok(cachedValue) : Op.error(e)),
      * );
      * ```
      */
@@ -952,6 +1037,37 @@ declare namespace Op {
      * ```
      */
     const race: <E, A>(invocations: ReadonlyArray<Deferred<Outcome<E, A>>>) => Deferred<Outcome<E, A>>;
+    /**
+     * Subscribes to a manager and calls a handler when the state reaches `OpOk`.
+     * Returns an unsubscribe function.
+     *
+     * @example
+     * ```ts
+     * const manager = Op.interpret(fetchUser, { strategy: "restartable" });
+     * const stop = Op.wire(manager, (user) => {
+     *   console.log("User loaded:", user.name);
+     * });
+     * manager.run(userId);
+     * // ... later
+     * stop(); // removes the subscription
+     * ```
+     */
+    const wire: <I, E, A, S extends State<E, A>>(source: Manager<I, E, A, S>, f: (a: A) => void) => () => void;
+    /**
+     * Wires multiple source-handler pairs, returning a combined cleanup function.
+     * When any source reaches `OpOk`, its corresponding handler is called.
+     *
+     * @example
+     * ```ts
+     * const stop = Op.wireAll(
+     *   [userManager, (u) => render(u)],
+     *   [settingsManager, (s) => applySettings(s)],
+     * );
+     * // ... later
+     * stop(); // removes all subscriptions
+     * ```
+     */
+    const wireAll: <I, E, A, S extends State<E, A>>(...pairs: Array<[Manager<I, E, A, S>, (a: A) => void]>) => () => void;
     /**
      * Attaches a concurrency strategy to an `Op`, returning a `Manager`.
      *
@@ -979,7 +1095,7 @@ declare namespace Op {
      * const getUser = Op.interpret(fetchUser, { strategy: "once" });
      * getUser.subscribe(state => {
      *   if (state.kind === "Pending") showSpinner();
-     *   if (state.kind === "Ok")      render(state.value);
+     *   if (state.kind === "OpOk")      render(state.value);
      * });
      * getUser.run(userId);
      *
@@ -1680,6 +1796,20 @@ declare namespace RemoteData {
      * ```
      */
     const fromMaybe: <E>(onNone: () => E) => <A>(data: Maybe<A>) => RemoteData<E, A>;
+    /**
+     * Filters a `Success` value. When the predicate passes, the value is kept. When it fails,
+     * `Success` becomes `Failure` using the error produced by `onFalse`. All other states pass through unchanged.
+     *
+     * @example
+     * ```ts
+     * RemoteData.filter(n => n > 0, n => `${n} is not a valid price`)(RemoteData.success(9.99));
+     * // Success(9.99)
+     * RemoteData.filter(n => n > 0, n => `${n} is not a valid price`)(RemoteData.success(-1));
+     * // Failure("-1 is not a valid price")
+     * RemoteData.filter(n => n > 0, () => "error")(RemoteData.loading()); // Loading
+     * ```
+     */
+    const filter: <E, A>(pred: (a: A) => boolean, onFalse: (a: A) => E) => (data: RemoteData<E, A>) => RemoteData<E, A>;
 }
 
 /**
@@ -1773,6 +1903,22 @@ declare namespace TaskResult {
      * ```
      */
     const tapError: <E, A>(f: (e: E) => void) => (data: TaskResult<E, A>) => TaskResult<E, A>;
+    /**
+     * Executes a `TaskResult` with an optional signal, returning `Promise<Result<E, A>>`.
+     * Use as a terminal step in a `pipe` chain.
+     *
+     * @example
+     * ```ts
+     * const controller = new AbortController();
+     * const result = await pipe(
+     *     fetchUser("42"),
+     *     TaskResult.chain(user => fetchPosts(user.id)),
+     *     TaskResult.run(controller.signal),
+     * );
+     * if (Result.isOk(result)) render(result.value);
+     * ```
+     */
+    const run: (signal?: AbortSignal) => <E, A>(task: TaskResult<E, A>) => Promise<Result<E, A>>;
 }
 
 /**
@@ -2393,6 +2539,30 @@ declare namespace Validation {
      * ```
      */
     const toResult: <E, A>(data: Validation<E, A>) => Result<NonEmptyList<E>, A>;
+    /**
+     * Converts a Validation to a Maybe. `Valid` becomes `Some`; `Invalid` becomes `None`
+     * (errors are discarded).
+     *
+     * @example
+     * ```ts
+     * Validation.toMaybe(Validation.valid(42));       // Some(42)
+     * Validation.toMaybe(Validation.invalid("bad"));  // None
+     * ```
+     */
+    const toMaybe: <E, A>(data: Validation<E, A>) => Maybe<A>;
+    /**
+     * Converts a `Result` to a `Validation`. `Ok` becomes `Valid`; `Err(e)` becomes `Invalid([e])`.
+     *
+     * Useful when bridging from error-short-circuiting `Result` pipelines into
+     * error-accumulating `Validation` pipelines.
+     *
+     * @example
+     * ```ts
+     * Validation.fromResult(Result.ok(42));       // Valid(42)
+     * Validation.fromResult(Result.error("bad"));   // Invalid(["bad"])
+     * ```
+     */
+    const fromResult: <E, A>(data: Result<E, A>) => Validation<E, A>;
     /**
      * Combines two independent Validation instances into a tuple.
      * If both are Valid, returns Valid with both values as a tuple.