@nlozgachev/pipelined 0.27.0 → 0.29.0

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

@@ -107,15 +107,15 @@ type WithMinInterval = {
 };
 
 type Ok<A> = WithKind<"Ok"> & WithValue<A>;
-type Err<E> = WithKind<"Error"> & WithError<E>;
+type Error<E> = WithKind<"Error"> & WithError<E>;
 /**
- * Result represents a value that can be one of two types: a success (Ok) or a failure (Err).
+ * Result represents a value that can be one of two types: a success (Ok) or a failure (Error).
  * Use Result when an operation can fail with a meaningful error value.
  *
  * @example
  * ```ts
  * const divide = (a: number, b: number): Result<string, number> =>
- *   b === 0 ? Result.err("Division by zero") : Result.ok(a / b);
+ *   b === 0 ? Result.error("Division by zero") : Result.ok(a / b);
  *
  * pipe(
  *   divide(10, 2),
@@ -124,7 +124,7 @@ type Err<E> = WithKind<"Error"> & WithError<E>;
  * ); // 10
  * ```
  */
-type Result<E, A> = Ok<A> | Err<E>;
+type Result<E, A> = Ok<A> | Error<E>;
 declare namespace Result {
     /**
      * Creates a successful Result with the given value.
@@ -133,15 +133,15 @@ declare namespace Result {
     /**
      * Creates a failed Result with the given error.
      */
-    const err: <E>(error: E) => Err<E>;
+    const error: <E>(e: E) => Error<E>;
     /**
      * Type guard that checks if an Result is Ok.
      */
     const isOk: <E, A>(data: Result<E, A>) => data is Ok<A>;
     /**
-     * Type guard that checks if an Result is Err.
+     * Type guard that checks if an Result is Error.
      */
-    const isErr: <E, A>(data: Result<E, A>) => data is Err<E>;
+    const isError: <E, A>(data: Result<E, A>) => data is Error<E>;
     /**
      * Creates an Result from a function that may throw.
      * Catches any errors and transforms them using the onError function.
@@ -162,7 +162,7 @@ declare namespace Result {
      * @example
      * ```ts
      * pipe(Result.ok(5), Result.map(n => n * 2)); // Ok(10)
-     * pipe(Result.err("error"), Result.map(n => n * 2)); // Err("error")
+     * pipe(Result.error("error"), Result.map(n => n * 2)); // Error("error")
      * ```
      */
     const map: <E, A, B>(f: (a: A) => B) => (data: Result<E, A>) => Result<E, B>;
@@ -171,7 +171,7 @@ declare namespace Result {
      *
      * @example
      * ```ts
-     * pipe(Result.err("oops"), Result.mapError(e => e.toUpperCase())); // Err("OOPS")
+     * pipe(Result.error("oops"), Result.mapError(e => e.toUpperCase())); // Error("OOPS")
      * ```
      */
     const mapError: <E, F, A>(f: (e: E) => F) => (data: Result<E, A>) => Result<F, A>;
@@ -182,10 +182,10 @@ declare namespace Result {
      * @example
      * ```ts
      * const validatePositive = (n: number): Result<string, number> =>
-     *   n > 0 ? Result.ok(n) : Result.err("Must be positive");
+     *   n > 0 ? Result.ok(n) : Result.error("Must be positive");
      *
      * pipe(Result.ok(5), Result.chain(validatePositive)); // Ok(5)
-     * pipe(Result.ok(-1), Result.chain(validatePositive)); // Err("Must be positive")
+     * pipe(Result.ok(-1), Result.chain(validatePositive)); // Error("Must be positive")
      * ```
      */
     const chain: <E, A, B>(f: (a: A) => Result<E, B>) => (data: Result<E, A>) => Result<E, B>;
@@ -230,8 +230,8 @@ declare namespace Result {
      * @example
      * ```ts
      * pipe(Result.ok(5), Result.getOrElse(() => 0)); // 5
-     * pipe(Result.err("error"), Result.getOrElse(() => 0)); // 0
-     * pipe(Result.err("error"), Result.getOrElse(() => null)); // null — typed as number | null
+     * pipe(Result.error("error"), Result.getOrElse(() => 0)); // 0
+     * pipe(Result.error("error"), Result.getOrElse(() => null)); // null — typed as number | null
      * ```
      */
     const getOrElse: <E, A, B>(defaultValue: () => B) => (data: Result<E, A>) => A | B;
@@ -256,7 +256,7 @@ declare namespace Result {
      * @example
      * ```ts
      * pipe(
-     *   Result.err("not found"),
+     *   Result.error("not found"),
      *   Result.tapError(e => console.error("validation failed:", e)),
      *   Result.chain(save),
      * )
@@ -270,8 +270,8 @@ declare namespace Result {
      * @example
      * ```ts
      * pipe(5, Result.fromPredicate(n => n > 0, n => `${n} is not positive`));  // Ok(5)
-     * pipe(-1, Result.fromPredicate(n => n > 0, n => `${n} is not positive`)); // Err("-1 is not positive")
-     * pipe("", Result.fromPredicate(s => s.length > 0, () => "empty string")); // Err("empty string")
+     * pipe(-1, Result.fromPredicate(n => n > 0, n => `${n} is not positive`)); // Error("-1 is not positive")
+     * pipe("", Result.fromPredicate(s => s.length > 0, () => "empty string")); // Error("empty string")
      * ```
      */
     const fromPredicate: <E, A>(pred: (a: A) => boolean, onFalse: (a: A) => E) => (a: A) => Result<E, A>;
@@ -281,10 +281,18 @@ declare namespace Result {
      */
     const recover: <E, A, B>(fallback: (e: E) => Result<E, B>) => (data: Result<E, A>) => Result<E, A | B>;
     /**
-     * Recovers from an error unless it matches the blocked error.
+     * Recovers from an error unless the predicate `isBlocked` returns true for that error.
      * The fallback can produce a different success type, widening the result to `Result<E, A | B>`.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   Result.error(new Error("not found")),
+     *   Result.recoverUnless(e => e.message === "fatal", () => Result.ok(0))
+     * ); // Ok(0)
+     * ```
      */
-    const recoverUnless: <E, A, B>(blockedErr: E, fallback: () => Result<E, B>) => (data: Result<E, A>) => Result<E, A | B>;
+    const recoverUnless: <E, A, B>(isBlocked: (e: E) => boolean, fallback: () => Result<E, B>) => (data: Result<E, A>) => Result<E, A | B>;
     /**
      * Converts a Result to an Maybe.
      * Ok becomes Some, Err becomes None (the error is discarded).
@@ -292,7 +300,7 @@ declare namespace Result {
      * @example
      * ```ts
      * Result.toMaybe(Result.ok(42)); // Some(42)
-     * Result.toMaybe(Result.err("oops")); // None
+     * Result.toMaybe(Result.error("oops")); // None
      * ```
      */
     const toMaybe: <E, A>(data: Result<E, A>) => Maybe<A>;
@@ -367,11 +375,6 @@ declare namespace Maybe {
      * Extracts the value from a Maybe, returning undefined if None.
      */
     const toUndefined: <A>(data: Maybe<A>) => A | undefined;
-    /**
-     * Creates a Maybe from a possibly undefined value.
-     * Returns None if undefined, Some otherwise.
-     */
-    const fromUndefined: <A>(value: A | undefined) => Maybe<A>;
     /**
      * Creates a Maybe from a predicate applied to a value.
      * Returns Some if the predicate passes, None otherwise.
@@ -411,7 +414,7 @@ declare namespace Maybe {
      * @example
      * ```ts
      * Maybe.fromResult(Result.ok(42)); // Some(42)
-     * Maybe.fromResult(Result.err("oops")); // None
+     * Maybe.fromResult(Result.error("oops")); // None
      * ```
      */
     const fromResult: <E, A>(data: Result<E, A>) => Maybe<A>;
@@ -703,10 +706,12 @@ declare namespace Task {
     const repeat: (options: {
         times: number;
         delay?: number;
-    }) => <A>(task: Task<A>) => Task<A[]>;
+    }) => <A>(task: Task<A>) => Task<readonly A[]>;
     /**
      * Runs a Task repeatedly until the result satisfies a predicate, returning that result.
      * An optional delay (ms) can be inserted between runs.
+     * An optional `maxAttempts` cap stops the loop after N calls — the last value is returned
+     * regardless of whether the predicate was satisfied.
      *
      * @example
      * ```ts
@@ -719,6 +724,7 @@ declare namespace Task {
     const repeatUntil: <A>(options: {
         when: (a: A) => boolean;
         delay?: number;
+        maxAttempts?: number;
     }) => (task: Task<A>) => Task<A>;
     /**
      * Resolves with the value of the first Task to complete. All Tasks start
@@ -767,9 +773,12 @@ declare namespace Task {
      */
     const timeout: <E>(ms: number, onTimeout: () => E) => <A>(task: Task<A>) => Task<Result<E, A>>;
     /**
-     * Creates a Task paired with an `abort` handle. When `abort()` is called the
-     * `AbortSignal` passed to the factory is fired, cancelling any in-flight
-     * operation (e.g. a `fetch`) immediately.
+     * Creates a Task paired with an `abort` handle. Calling `abort()` cancels the
+     * current in-flight call immediately. Unlike a one-shot abort, calling `task()`
+     * again after `abort()` starts a fresh call with a new signal.
+     *
+     * Each invocation of `task()` automatically cancels the previous in-flight call,
+     * making it safe to call repeatedly (e.g. on user input) without leaking promises.
      *
      * If an outer signal is also present (passed at the call site), aborting it
      * propagates into the internal controller.
@@ -788,6 +797,19 @@ declare namespace Task {
         task: Task<A>;
         abort: () => void;
     };
+    /**
+     * Executes a task with an optional signal. Use as a terminal step in a `pipe` chain.
+     *
+     * @example
+     * ```ts
+     * const name = await pipe(
+     *     fetchConfig,
+     *     Task.map(config => config.name),
+     *     Task.run(),
+     * );
+     * ```
+     */
+    const run: (signal?: AbortSignal) => <A>(task: Task<A>) => Promise<A>;
 }
 
-export { Deferred as D, type Err as E, Maybe as M, type None as N, type Ok as O, Result as R, type Some as S, Task as T, type WithValue as W, type WithLog as a, type WithKind as b, type WithError as c, type RetryOptions as d, type TimeoutOptions as e, type WithTimeout as f, type WithMinInterval as g, type WithCooldown as h, type WithConcurrency as i, type WithSize as j, type WithMs as k, type WithN as l, type WithErrors as m, type WithFirst as n, type WithSecond as o };
+export { Deferred as D, type Error as E, Maybe as M, type None as N, type Ok as O, Result as R, type Some as S, Task as T, type WithValue as W, type WithLog as a, type WithKind as b, type WithError as c, type RetryOptions as d, type TimeoutOptions as e, type WithTimeout as f, type WithMinInterval as g, type WithCooldown as h, type WithConcurrency as i, type WithSize as j, type WithMs as k, type WithN as l, type WithErrors as m, type WithFirst as n, type WithSecond as o };

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

@@ -3,7 +3,7 @@ import {
   Maybe,
   Result,
   Task
-} from "./chunk-HHCRWQYN.mjs";
+} from "./chunk-SDGDJ7CU.mjs";
 import {
   isNonEmptyList
 } from "./chunk-DBIC62UV.mjs";
@@ -166,7 +166,7 @@ var Arr;
     const result = [];
     for (const a of data) {
       const r = await Deferred.toPromise(f(a)());
-      if (Result.isErr(r)) return r;
+      if (Result.isError(r)) return r;
       result.push(r.value);
     }
     return Result.ok(result);
@@ -307,6 +307,14 @@ var Dict;
     }
     return result;
   };
+  Dict2.filterMap = (f) => (m) => {
+    const result = new globalThis.Map();
+    for (const [key, value] of m) {
+      const mapped = f(value);
+      if (mapped.kind === "Some") result.set(key, mapped.value);
+    }
+    return result;
+  };
   Dict2.union = (other) => (m) => {
     const result = new globalThis.Map(m);
     for (const [k, v] of other) {
@@ -367,13 +375,13 @@ var Num;
   Num2.add = (b) => (a) => a + b;
   Num2.subtract = (b) => (a) => a - b;
   Num2.multiply = (b) => (a) => a * b;
-  Num2.divide = (b) => (a) => a / b;
+  Num2.divide = (b) => (a) => b === 0 ? Maybe.none() : Maybe.some(a / b);
   Num2.abs = (n) => Math.abs(n);
   Num2.negate = (n) => -n;
   Num2.round = (n) => Math.round(n);
   Num2.floor = (n) => Math.floor(n);
   Num2.ceil = (n) => Math.ceil(n);
-  Num2.remainder = (divisor) => (n) => n % divisor;
+  Num2.remainder = (divisor) => (n) => divisor === 0 ? Maybe.none() : Maybe.some(n % divisor);
 })(Num || (Num = {}));
 
 // src/Utils/Rec.ts

package/dist/{chunk-YYVONF5X.mjs → chunk-PV7JOUKL.mjs}

@@ -3,7 +3,7 @@ import {
   Maybe,
   Result,
   Task
-} from "./chunk-HHCRWQYN.mjs";
+} from "./chunk-SDGDJ7CU.mjs";
 
 // src/Core/Lens.ts
 var Lens;
@@ -55,14 +55,14 @@ var Logged;
 })(Logged || (Logged = {}));
 
 // src/internal/Op.util.ts
-var _abortedNil = { kind: "Nil", reason: "aborted" };
-var _droppedNil = { kind: "Nil", reason: "dropped" };
-var _replacedNil = { kind: "Nil", reason: "replaced" };
-var _evictedNil = { kind: "Nil", reason: "evicted" };
+var _abortedNil = { kind: "OpNil", reason: "aborted" };
+var _droppedNil = { kind: "OpNil", reason: "dropped" };
+var _replacedNil = { kind: "OpNil", reason: "replaced" };
+var _evictedNil = { kind: "OpNil", reason: "evicted" };
 var _idle = { kind: "Idle" };
 var _pending = { kind: "Pending" };
-var ok = (value) => ({ kind: "Ok", value });
-var err = (error) => ({ kind: "Err", error });
+var ok = (value) => ({ kind: "OpOk", value });
+var err = (error) => ({ kind: "OpError", error });
 var cancellableWait = (ms, signal) => {
   if (ms <= 0) return Promise.resolve();
   return new Promise((resolve) => {
@@ -185,6 +185,12 @@ var makeRestartable = (op, minInterval, retryOptions, timeoutOptions) => {
       subscribers.add(cb);
       if (currentState.kind !== "Idle") cb(currentState);
       return () => subscribers.delete(cb);
+    },
+    reset: () => emit(_idle),
+    poll: (input, { interval }) => {
+      void run(input);
+      const id = setInterval(() => void run(input), interval);
+      return () => clearInterval(id);
     }
   };
 };
@@ -249,6 +255,12 @@ var makeExclusive = (op, cooldown, retryOptions, timeoutOptions) => {
       subscribers.add(cb);
       if (currentState.kind !== "Idle") cb(currentState);
       return () => subscribers.delete(cb);
+    },
+    reset: () => emit(_idle),
+    poll: (input, { interval }) => {
+      void run(input);
+      const id = setInterval(() => void run(input), interval);
+      return () => clearInterval(id);
     }
   };
 };
@@ -348,6 +360,12 @@ var makeQueue = (op, maxSize, overflow, concurrency, dedupe, retryOptions, timeo
       subscribers.add(cb);
       if (currentState.kind !== "Idle") cb(currentState);
       return () => subscribers.delete(cb);
+    },
+    reset: () => emit(_idle),
+    poll: (input, { interval }) => {
+      void run(input);
+      const id = setInterval(() => void run(input), interval);
+      return () => clearInterval(id);
     }
   };
 };
@@ -418,6 +436,12 @@ var makeBuffered = (op, size, retryOptions, timeoutOptions) => {
       subscribers.add(cb);
       if (currentState.kind !== "Idle") cb(currentState);
       return () => subscribers.delete(cb);
+    },
+    reset: () => emit(_idle),
+    poll: (input, { interval }) => {
+      void run(input);
+      const id = setInterval(() => void run(input), interval);
+      return () => clearInterval(id);
     }
   };
 };
@@ -540,6 +564,12 @@ var makeDebounced = (op, ms, leading, maxWait, retryOptions, timeoutOptions) =>
       subscribers.add(cb);
       if (currentState.kind !== "Idle") cb(currentState);
       return () => subscribers.delete(cb);
+    },
+    reset: () => emit(_idle),
+    poll: (input, { interval }) => {
+      void run(input);
+      const id = setInterval(() => void run(input), interval);
+      return () => clearInterval(id);
     }
   };
 };
@@ -632,6 +662,12 @@ var makeThrottled = (op, ms, trailing, retryOptions, timeoutOptions) => {
       subscribers.add(cb);
       if (currentState.kind !== "Idle") cb(currentState);
       return () => subscribers.delete(cb);
+    },
+    reset: () => emit(_idle),
+    poll: (input, { interval }) => {
+      void run(input);
+      const id = setInterval(() => void run(input), interval);
+      return () => clearInterval(id);
     }
   };
 };
@@ -713,6 +749,12 @@ var makeConcurrent = (op, n, overflow, retryOptions, timeoutOptions) => {
       subscribers.add(cb);
       if (currentState.kind !== "Idle") cb(currentState);
       return () => subscribers.delete(cb);
+    },
+    reset: () => emit(_idle),
+    poll: (input, { interval }) => {
+      void run(input);
+      const id = setInterval(() => void run(input), interval);
+      return () => clearInterval(id);
     }
   };
 };
@@ -789,6 +831,15 @@ var makeKeyed = (op, keyFn, perKey, timeoutOptions) => {
       subscribers.add(cb);
       if (stateMap.size > 0) cb(new Map(stateMap));
       return () => subscribers.delete(cb);
+    },
+    reset: () => {
+      stateMap.clear();
+      emitSnapshot();
+    },
+    poll: (input, { interval }) => {
+      void run(input);
+      const id = setInterval(() => void run(input), interval);
+      return () => clearInterval(id);
     }
   };
 };
@@ -843,6 +894,12 @@ var makeOnce = (op, retryOptions, timeoutOptions) => {
       subscribers.add(cb);
       if (currentState.kind !== "Idle") cb(currentState);
       return () => subscribers.delete(cb);
+    },
+    reset: () => emit(_idle),
+    poll: (input, { interval }) => {
+      void run(input);
+      const id = setInterval(() => void run(input), interval);
+      return () => clearInterval(id);
     }
   };
 };
@@ -850,44 +907,59 @@ var makeOnce = (op, retryOptions, timeoutOptions) => {
 // src/Core/Op.ts
 var Op;
 ((Op2) => {
-  Op2.nil = (reason) => ({ kind: "Nil", reason });
+  Op2.nil = (reason) => ({ kind: "OpNil", reason });
   Op2.create = (factory, onError) => ({
     _factory: (input, signal) => Deferred.fromPromise(
-      factory(signal)(input).then((value) => Result.ok(value)).catch((e) => signal.aborted ? null : Result.err(onError(e)))
+      factory(signal)(input).then((value) => Result.ok(value)).catch((e) => signal.aborted ? null : Result.error(onError(e)))
     )
   });
-  Op2.ok = (value) => ({ kind: "Ok", value });
-  Op2.err = (error) => ({ kind: "Err", error });
-  Op2.isOk = (outcome) => outcome.kind === "Ok";
-  Op2.isErr = (outcome) => outcome.kind === "Err";
-  Op2.isNil = (outcome) => outcome.kind === "Nil";
+  Op2.lift = (f) => (0, Op2.create)(
+    (signal) => (input) => f(input, signal),
+    (e) => e
+  );
+  Op2.ok = (value) => ({ kind: "OpOk", value });
+  Op2.error = (error2) => ({ kind: "OpError", error: error2 });
+  Op2.isIdle = (state) => state.kind === "Idle";
+  Op2.isPending = (state) => state.kind === "Pending";
+  Op2.isQueued = (state) => state.kind === "Queued";
+  Op2.isRetrying = (state) => state.kind === "Retrying";
+  Op2.isOk = (state) => state.kind === "OpOk";
+  Op2.isError = (state) => state.kind === "OpError";
+  Op2.isNil = (state) => state.kind === "OpNil";
   Op2.match = (cases) => (outcome) => {
-    if (outcome.kind === "Ok") return cases.ok(outcome.value);
-    if (outcome.kind === "Err") return cases.err(outcome.error);
+    if (outcome.kind === "OpOk") return cases.ok(outcome.value);
+    if (outcome.kind === "OpError") return cases.error(outcome.error);
     return cases.nil();
   };
-  Op2.fold = (onErr, onOk, onNil) => (outcome) => {
-    if (outcome.kind === "Ok") return onOk(outcome.value);
-    if (outcome.kind === "Err") return onErr(outcome.error);
+  Op2.fold = (onError, onOk, onNil) => (outcome) => {
+    if (outcome.kind === "OpOk") return onOk(outcome.value);
+    if (outcome.kind === "OpError") return onError(outcome.error);
     return onNil();
   };
-  Op2.getOrElse = (defaultValue) => (outcome) => outcome.kind === "Ok" ? outcome.value : defaultValue();
-  Op2.map = (f) => (outcome) => outcome.kind === "Ok" ? (0, Op2.ok)(f(outcome.value)) : outcome;
-  Op2.mapError = (f) => (outcome) => outcome.kind === "Err" ? (0, Op2.err)(f(outcome.error)) : outcome;
-  Op2.chain = (f) => (outcome) => outcome.kind === "Ok" ? f(outcome.value) : outcome;
+  Op2.getOrElse = (defaultValue) => (outcome) => outcome.kind === "OpOk" ? outcome.value : defaultValue();
+  Op2.map = (f) => (outcome) => outcome.kind === "OpOk" ? (0, Op2.ok)(f(outcome.value)) : outcome;
+  Op2.mapError = (f) => (outcome) => outcome.kind === "OpError" ? (0, Op2.error)(f(outcome.error)) : outcome;
+  Op2.chain = (f) => (outcome) => outcome.kind === "OpOk" ? f(outcome.value) : outcome;
   Op2.tap = (f) => (outcome) => {
-    if (outcome.kind === "Ok") f(outcome.value);
+    if (outcome.kind === "OpOk") f(outcome.value);
     return outcome;
   };
-  Op2.recover = (f) => (outcome) => outcome.kind === "Err" ? f(outcome.error) : outcome;
+  Op2.recover = (f) => (outcome) => outcome.kind === "OpError" ? f(outcome.error) : outcome;
   Op2.toResult = (onNil) => (outcome) => {
-    if (outcome.kind === "Ok") return Result.ok(outcome.value);
-    if (outcome.kind === "Err") return Result.err(outcome.error);
-    return Result.err(onNil());
+    if (outcome.kind === "OpOk") return Result.ok(outcome.value);
+    if (outcome.kind === "OpError") return Result.error(outcome.error);
+    return Result.error(onNil());
   };
-  Op2.toMaybe = (outcome) => outcome.kind === "Ok" ? Maybe.some(outcome.value) : Maybe.none();
+  Op2.toMaybe = (outcome) => outcome.kind === "OpOk" ? Maybe.some(outcome.value) : Maybe.none();
   Op2.all = (invocations) => Deferred.fromPromise(Promise.all(invocations.map(Deferred.toPromise)));
   Op2.race = (invocations) => Deferred.fromPromise(Promise.race(invocations.map(Deferred.toPromise)));
+  Op2.wire = (source, f) => source.subscribe((state) => {
+    if ((0, Op2.isOk)(state)) f(state.value);
+  });
+  Op2.wireAll = (...pairs) => {
+    const cleanups = pairs.map(([source, f]) => (0, Op2.wire)(source, f));
+    return () => cleanups.forEach((c) => c());
+  };
   function interpret(op, options) {
     const { strategy, retry: retryOptions, timeout: timeoutOptions } = options;
     switch (strategy) {
@@ -1026,7 +1098,7 @@ var Refinement;
   Refinement2.and = (second) => (first) => (a) => first(a) && second(a);
   Refinement2.or = (second) => (first) => (a) => first(a) || second(a);
   Refinement2.toFilter = (r) => (a) => r(a) ? Maybe.some(a) : Maybe.none();
-  Refinement2.toResult = (r, onFail) => (a) => r(a) ? Result.ok(a) : Result.err(onFail(a));
+  Refinement2.toResult = (r, onFail) => (a) => r(a) ? Result.ok(a) : Result.error(onFail(a));
 })(Refinement || (Refinement = {}));
 
 // src/Core/RemoteData.ts
@@ -1089,11 +1161,16 @@ var RemoteData;
     if ((0, RemoteData2.isSuccess)(data)) f(data.value);
     return data;
   };
+  RemoteData2.tapError = (f) => (data) => {
+    if ((0, RemoteData2.isFailure)(data)) f(data.error);
+    return data;
+  };
   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.toResult = (onNotReady) => (data) => (0, RemoteData2.isSuccess)(data) ? Result.ok(data.value) : Result.error((0, RemoteData2.isFailure)(data) ? data.error : onNotReady());
   RemoteData2.fromResult = (data) => Result.isOk(data) ? (0, RemoteData2.success)(data.value) : (0, RemoteData2.failure)(data.error);
   RemoteData2.fromMaybe = (onNone) => (data) => Maybe.isSome(data) ? (0, RemoteData2.success)(data.value) : (0, RemoteData2.failure)(onNone());
+  RemoteData2.filter = (pred, onFalse) => (data) => (0, RemoteData2.isSuccess)(data) ? pred(data.value) ? data : (0, RemoteData2.failure)(onFalse(data.value)) : data;
 })(RemoteData || (RemoteData = {}));
 
 // src/Core/Resource.ts
@@ -1106,7 +1183,7 @@ var Resource;
   });
   Resource2.use = (f) => (resource) => Task.from(
     () => Deferred.toPromise(resource.acquire()).then(async (acquired) => {
-      if (Result.isErr(acquired)) return acquired;
+      if (Result.isError(acquired)) return acquired;
       const a = acquired.value;
       const usageResult = await Deferred.toPromise(f(a)());
       await Deferred.toPromise(resource.release(a)());
@@ -1116,10 +1193,10 @@ var Resource;
   Resource2.combine = (resourceA, resourceB) => ({
     acquire: Task.from(
       () => Deferred.toPromise(resourceA.acquire()).then(async (acquiredA) => {
-        if (Result.isErr(acquiredA)) return acquiredA;
+        if (Result.isError(acquiredA)) return acquiredA;
         const a = acquiredA.value;
         const acquiredB = await Deferred.toPromise(resourceB.acquire());
-        if (Result.isErr(acquiredB)) {
+        if (Result.isError(acquiredB)) {
           await Deferred.toPromise(resourceA.release(a)());
           return acquiredB;
         }
@@ -1191,23 +1268,26 @@ var TaskMaybe;
 var TaskResult;
 ((TaskResult2) => {
   TaskResult2.ok = (value) => Task.resolve(Result.ok(value));
-  TaskResult2.err = (error) => Task.resolve(Result.err(error));
+  TaskResult2.err = (error) => Task.resolve(Result.error(error));
   TaskResult2.tryCatch = (f, onError) => Task.from(
-    (signal) => f(signal).then(Result.ok).catch((e) => Result.err(onError(e)))
+    (signal) => f(signal).then(Result.ok).catch((e) => Result.error(onError(e)))
   );
   TaskResult2.map = (f) => (data) => Task.map(Result.map(f))(data);
   TaskResult2.mapError = (f) => (data) => Task.map(Result.mapError(f))(data);
-  TaskResult2.chain = (f) => (data) => Task.chain((result) => Result.isOk(result) ? f(result.value) : Task.resolve(Result.err(result.error)))(
+  TaskResult2.chain = (f) => (data) => Task.chain(
+    (result) => Result.isOk(result) ? f(result.value) : Task.resolve(Result.error(result.error))
+  )(
     data
   );
   TaskResult2.fold = (onErr, onOk) => (data) => Task.map(Result.fold(onErr, onOk))(data);
   TaskResult2.match = (cases) => (data) => Task.map(Result.match(cases))(data);
   TaskResult2.recover = (fallback) => (data) => Task.chain(
-    (result) => Result.isErr(result) ? fallback(result.error) : Task.resolve(result)
+    (result) => Result.isError(result) ? fallback(result.error) : Task.resolve(result)
   )(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);
+  TaskResult2.run = (signal) => (task) => Deferred.toPromise(task(signal));
 })(TaskResult || (TaskResult = {}));
 
 // src/Core/Validation.ts
@@ -1227,6 +1307,7 @@ var Validation;
   });
   Validation2.isValid = (data) => data.kind === "Valid";
   Validation2.isInvalid = (data) => data.kind === "Invalid";
+  Validation2.fromPredicate = (pred, onFalse) => (a) => pred(a) ? (0, Validation2.valid)(a) : (0, Validation2.invalid)(onFalse(a));
   Validation2.map = (f) => (data) => (0, Validation2.isValid)(data) ? (0, Validation2.valid)(f(data.value)) : data;
   Validation2.ap = (arg) => (data) => {
     if ((0, Validation2.isValid)(data) && (0, Validation2.isValid)(arg)) return (0, Validation2.valid)(data.value(arg.value));
@@ -1243,8 +1324,15 @@ var Validation;
     if ((0, Validation2.isValid)(data)) f(data.value);
     return data;
   };
+  Validation2.tapError = (f) => (data) => {
+    if ((0, Validation2.isInvalid)(data)) f(data.errors);
+    return data;
+  };
   Validation2.recover = (fallback) => (data) => (0, Validation2.isValid)(data) ? data : fallback(data.errors);
-  Validation2.recoverUnless = (blockedErrors, fallback) => (data) => (0, Validation2.isInvalid)(data) && !data.errors.some((err2) => blockedErrors.includes(err2)) ? fallback() : data;
+  Validation2.recoverUnless = (isBlocked, fallback) => (data) => (0, Validation2.isInvalid)(data) && !data.errors.some(isBlocked) ? fallback() : data;
+  Validation2.toResult = (data) => (0, Validation2.isValid)(data) ? Result.ok(data.value) : Result.error(data.errors);
+  Validation2.toMaybe = (data) => (0, Validation2.isValid)(data) ? Maybe.some(data.value) : Maybe.none();
+  Validation2.fromResult = (data) => data.kind === "Ok" ? (0, Validation2.valid)(data.value) : (0, Validation2.invalid)(data.error);
   Validation2.product = (first, second) => {
     if ((0, Validation2.isValid)(first) && (0, Validation2.isValid)(second)) return (0, Validation2.valid)([first.value, second.value]);
     const errors = [