@nlozgachev/pipelined 0.56.0 → 0.58.0

package/dist/{Validation-DCqWoCC2.d.cts → Validation-DC3uUizM.d.cts}

@@ -1266,6 +1266,22 @@ declare namespace TaskResult {
      * The fallback can produce a different success type, widening the result to `Task.Result<E, A | B>`.
      */
     const recover: <E, B>(fallback: (e: E) => TaskResult<E, B>) => <A>(data: TaskResult<E, A>) => TaskResult<E, A | B>;
+    /**
+     * 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 `Task.Result<E, A | B>`.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   fetchTask,
+     *   Task.Result.recoverUnless(
+     *     (e) => e === "fatal",
+     *     () => Task.Result.ok("fallback")
+     *   )
+     * );
+     * ```
+     */
+    const recoverUnless: <E, B>(isBlocked: (e: E) => boolean, fallback: (e: E) => TaskResult<E, B>) => <A>(data: TaskResult<E, A>) => TaskResult<E, A | B>;
     /**
      * Returns the success value or a default value if the Task.Result is an error.
      * The default can be a different type, widening the result to `Task<A | B>`.
@@ -1501,6 +1517,28 @@ declare namespace TaskValidation {
          */
         const Result: <E, A>(result: Result<E, A>) => TaskValidation<E, A>;
     }
+    namespace to {
+        /**
+         * Converts a `Task.Validation` to a `Task.Result`, combining accumulated errors using `combineErrors`.
+         * `Passed(a)` becomes `Ok(a)`; `Failed(errors)` becomes `Err(combineErrors(errors))`.
+         *
+         * @example
+         * ```ts
+         * Task.Validation.to.Result((errors) => errors.join(", "))(validationTask);
+         * ```
+         */
+        const Result: <E1, E2, A>(combineErrors: (errors: NonEmptyArr<E1>) => E2) => (data: TaskValidation<E1, A>) => TaskResult<E2, A>;
+        /**
+         * Converts a `Task.Validation` to a `Task.Maybe`.
+         * `Passed(a)` becomes `Some(a)`; `Failed(errors)` becomes `None` (errors are discarded).
+         *
+         * @example
+         * ```ts
+         * Task.Validation.to.Maybe(validationTask);
+         * ```
+         */
+        const Maybe: <E, A>(data: TaskValidation<E, A>) => TaskMaybe<A>;
+    }
     /**
      * Creates a Task.Validation from a Promise-returning function.
      * Catches any errors and transforms them using the onError function.
@@ -1578,6 +1616,22 @@ declare namespace TaskValidation {
      * The fallback can produce a different success type, widening the result to `Task.Validation<E, A | B>`.
      */
     const recover: <E, B>(fallback: (errors: NonEmptyArr<E>) => TaskValidation<E, B>) => <A>(data: TaskValidation<E, A>) => TaskValidation<E, A | B>;
+    /**
+     * Recovers from a Failed state unless the predicate `isBlocked` returns true for the accumulated errors.
+     * The fallback receives the accumulated errors and can produce a different success type, widening the result to `Task.Validation<E, A | B>`.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   validationTask,
+     *   Task.Validation.recoverUnless(
+     *     (errors) => errors.includes("fatal"),
+     *     (errors) => Task.Validation.passed("fallback")
+     *   )
+     * );
+     * ```
+     */
+    const recoverUnless: <E, B>(isBlocked: (errors: NonEmptyArr<E>) => boolean, fallback: (errors: NonEmptyArr<E>) => TaskValidation<E, B>) => <A>(data: TaskValidation<E, A>) => TaskValidation<E, A | B>;
     /**
      * Runs two Task.Validations concurrently and combines their results into a tuple.
      * If both are Passed, returns Passed with both values. If either fails, accumulates

package/dist/{Validation-t0k4ic-S.d.ts → Validation-DZLizBZ0.d.ts}

@@ -1266,6 +1266,22 @@ declare namespace TaskResult {
      * The fallback can produce a different success type, widening the result to `Task.Result<E, A | B>`.
      */
     const recover: <E, B>(fallback: (e: E) => TaskResult<E, B>) => <A>(data: TaskResult<E, A>) => TaskResult<E, A | B>;
+    /**
+     * 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 `Task.Result<E, A | B>`.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   fetchTask,
+     *   Task.Result.recoverUnless(
+     *     (e) => e === "fatal",
+     *     () => Task.Result.ok("fallback")
+     *   )
+     * );
+     * ```
+     */
+    const recoverUnless: <E, B>(isBlocked: (e: E) => boolean, fallback: (e: E) => TaskResult<E, B>) => <A>(data: TaskResult<E, A>) => TaskResult<E, A | B>;
     /**
      * Returns the success value or a default value if the Task.Result is an error.
      * The default can be a different type, widening the result to `Task<A | B>`.
@@ -1501,6 +1517,28 @@ declare namespace TaskValidation {
          */
         const Result: <E, A>(result: Result<E, A>) => TaskValidation<E, A>;
     }
+    namespace to {
+        /**
+         * Converts a `Task.Validation` to a `Task.Result`, combining accumulated errors using `combineErrors`.
+         * `Passed(a)` becomes `Ok(a)`; `Failed(errors)` becomes `Err(combineErrors(errors))`.
+         *
+         * @example
+         * ```ts
+         * Task.Validation.to.Result((errors) => errors.join(", "))(validationTask);
+         * ```
+         */
+        const Result: <E1, E2, A>(combineErrors: (errors: NonEmptyArr<E1>) => E2) => (data: TaskValidation<E1, A>) => TaskResult<E2, A>;
+        /**
+         * Converts a `Task.Validation` to a `Task.Maybe`.
+         * `Passed(a)` becomes `Some(a)`; `Failed(errors)` becomes `None` (errors are discarded).
+         *
+         * @example
+         * ```ts
+         * Task.Validation.to.Maybe(validationTask);
+         * ```
+         */
+        const Maybe: <E, A>(data: TaskValidation<E, A>) => TaskMaybe<A>;
+    }
     /**
      * Creates a Task.Validation from a Promise-returning function.
      * Catches any errors and transforms them using the onError function.
@@ -1578,6 +1616,22 @@ declare namespace TaskValidation {
      * The fallback can produce a different success type, widening the result to `Task.Validation<E, A | B>`.
      */
     const recover: <E, B>(fallback: (errors: NonEmptyArr<E>) => TaskValidation<E, B>) => <A>(data: TaskValidation<E, A>) => TaskValidation<E, A | B>;
+    /**
+     * Recovers from a Failed state unless the predicate `isBlocked` returns true for the accumulated errors.
+     * The fallback receives the accumulated errors and can produce a different success type, widening the result to `Task.Validation<E, A | B>`.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   validationTask,
+     *   Task.Validation.recoverUnless(
+     *     (errors) => errors.includes("fatal"),
+     *     (errors) => Task.Validation.passed("fallback")
+     *   )
+     * );
+     * ```
+     */
+    const recoverUnless: <E, B>(isBlocked: (errors: NonEmptyArr<E>) => boolean, fallback: (errors: NonEmptyArr<E>) => TaskValidation<E, B>) => <A>(data: TaskValidation<E, A>) => TaskValidation<E, A | B>;
     /**
      * Runs two Task.Validations concurrently and combines their results into a tuple.
      * If both are Passed, returns Passed with both values. If either fails, accumulates

package/dist/{chunk-EJX32LRO.js → chunk-FVWJMPQI.js}

@@ -3,7 +3,7 @@ import {
   Maybe,
   Result,
   isNonEmptyArr
-} from "./chunk-K7HHEACE.js";
+} from "./chunk-VYHAA4KO.js";
 
 // src/Data/Arr.ts
 var ArrMaybe;

package/dist/{chunk-K7HHEACE.js → chunk-VYHAA4KO.js}

@@ -1402,6 +1402,34 @@ var Ordering;
   };
 })(Ordering || (Ordering = {}));
 
+// src/Core/Pair.ts
+var Pair;
+((Pair2) => {
+  let from;
+  ((from2) => {
+    from2.pair = (first2, second2) => [first2, second2];
+    from2.array = (arr) => arr;
+  })(from = Pair2.from || (Pair2.from = {}));
+  Pair2.first = (p) => p[0];
+  Pair2.second = (p) => p[1];
+  Pair2.mapFirst = (f) => (p) => [f(p[0]), p[1]];
+  Pair2.mapSecond = (f) => (p) => [p[0], f(p[1])];
+  Pair2.mapBoth = (onFirst, onSecond) => (p) => [
+    onFirst(p[0]),
+    onSecond(p[1])
+  ];
+  Pair2.fold = (f) => (p) => f(p[0], p[1]);
+  Pair2.swap = (p) => [p[1], p[0]];
+  let to;
+  ((to2) => {
+    to2.Array = (p) => [...p];
+  })(to = Pair2.to || (Pair2.to = {}));
+  Pair2.tap = (f) => (p) => {
+    f(p[0], p[1]);
+    return p;
+  };
+})(Pair || (Pair = {}));
+
 // src/Core/Predicate.ts
 var Predicate;
 ((Predicate2) => {
@@ -1951,6 +1979,9 @@ var TaskResult;
   TaskResult2.recover = (fallback) => (data) => Task.chain(
     (result) => Result.is.err(result) ? fallback(result.error) : Task.resolve(result)
   )(data);
+  TaskResult2.recoverUnless = (isBlocked, fallback) => (data) => Task.chain(
+    (result) => Result.is.err(result) && !isBlocked(result.error) ? 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);
@@ -2061,6 +2092,11 @@ var TaskValidation;
     );
     from2.Result = (result) => Task.resolve(Validation.from.Result(result));
   })(from = TaskValidation2.from || (TaskValidation2.from = {}));
+  let to;
+  ((to2) => {
+    to2.Result = (combineErrors) => (data) => Task.map(Validation.to.Result(combineErrors))(data);
+    to2.Maybe = (data) => Task.map(Validation.to.Maybe)(data);
+  })(to = TaskValidation2.to || (TaskValidation2.to = {}));
   TaskValidation2.tryCatch = (f, options) => (signal) => Deferred.from.Promise(
     globalThis.Promise.resolve().then(async () => f(signal)).then(Validation.make.passed).catch(
       (error) => Validation.make.failed(options.onError(error))
@@ -2079,6 +2115,9 @@ var TaskValidation;
   TaskValidation2.recover = (fallback) => (data) => Task.chain(
     (validation) => Validation.is.passed(validation) ? Task.resolve(validation) : fallback(validation.errors)
   )(data);
+  TaskValidation2.recoverUnless = (isBlocked, fallback) => (data) => Task.chain(
+    (validation) => Validation.is.passed(validation) ? Task.resolve(validation) : isBlocked(validation.errors) ? Task.resolve(validation) : fallback(validation.errors)
+  )(data);
   TaskValidation2.product = (first, second) => (signal) => Deferred.from.Promise(
     Promise.all([Deferred.to.Promise(first(signal)), Deferred.to.Promise(second(signal))]).then(
       ([va, vb]) => Validation.product(va, vb)
@@ -2449,34 +2488,6 @@ var These;
   };
 })(These || (These = {}));
 
-// src/Core/Tuple.ts
-var Tuple;
-((Tuple2) => {
-  let from;
-  ((from2) => {
-    from2.pair = (first2, second2) => [first2, second2];
-    from2.array = (arr) => arr;
-  })(from = Tuple2.from || (Tuple2.from = {}));
-  Tuple2.first = (tuple) => tuple[0];
-  Tuple2.second = (tuple) => tuple[1];
-  Tuple2.mapFirst = (f) => (tuple) => [f(tuple[0]), tuple[1]];
-  Tuple2.mapSecond = (f) => (tuple) => [tuple[0], f(tuple[1])];
-  Tuple2.mapBoth = (onFirst, onSecond) => (tuple) => [
-    onFirst(tuple[0]),
-    onSecond(tuple[1])
-  ];
-  Tuple2.fold = (f) => (tuple) => f(tuple[0], tuple[1]);
-  Tuple2.swap = (tuple) => [tuple[1], tuple[0]];
-  let to;
-  ((to2) => {
-    to2.Array = (tuple) => [...tuple];
-  })(to = Tuple2.to || (Tuple2.to = {}));
-  Tuple2.tap = (f) => (tuple) => {
-    f(tuple[0], tuple[1]);
-    return tuple;
-  };
-})(Tuple || (Tuple = {}));
-
 // src/Core/Validation.ts
 var Validation;
 ((Validation2) => {
@@ -2594,6 +2605,7 @@ export {
   Op,
   Optional,
   Ordering,
+  Pair,
   Predicate,
   Reader,
   Refinement,
@@ -2605,6 +2617,5 @@ export {
   isNonEmptyArr,
   Task,
   These,
-  Tuple,
   Validation
 };

package/dist/core.cjs

@@ -30,6 +30,7 @@ __export(Core_exports, {
   Op: () => Op,
   Optional: () => Optional,
   Ordering: () => Ordering,
+  Pair: () => Pair,
   Predicate: () => Predicate,
   Reader: () => Reader,
   Refinement: () => Refinement,
@@ -40,7 +41,6 @@ __export(Core_exports, {
   Stream: () => Stream,
   Task: () => Task,
   These: () => These,
-  Tuple: () => Tuple,
   Validation: () => Validation
 });
 module.exports = __toCommonJS(Core_exports);
@@ -1473,6 +1473,34 @@ var Ordering;
   };
 })(Ordering || (Ordering = {}));
 
+// src/Core/Pair.ts
+var Pair;
+((Pair2) => {
+  let from;
+  ((from2) => {
+    from2.pair = (first2, second2) => [first2, second2];
+    from2.array = (arr) => arr;
+  })(from = Pair2.from || (Pair2.from = {}));
+  Pair2.first = (p) => p[0];
+  Pair2.second = (p) => p[1];
+  Pair2.mapFirst = (f) => (p) => [f(p[0]), p[1]];
+  Pair2.mapSecond = (f) => (p) => [p[0], f(p[1])];
+  Pair2.mapBoth = (onFirst, onSecond) => (p) => [
+    onFirst(p[0]),
+    onSecond(p[1])
+  ];
+  Pair2.fold = (f) => (p) => f(p[0], p[1]);
+  Pair2.swap = (p) => [p[1], p[0]];
+  let to;
+  ((to2) => {
+    to2.Array = (p) => [...p];
+  })(to = Pair2.to || (Pair2.to = {}));
+  Pair2.tap = (f) => (p) => {
+    f(p[0], p[1]);
+    return p;
+  };
+})(Pair || (Pair = {}));
+
 // src/Core/Predicate.ts
 var Predicate;
 ((Predicate2) => {
@@ -2022,6 +2050,9 @@ var TaskResult;
   TaskResult2.recover = (fallback) => (data) => Task.chain(
     (result) => Result.is.err(result) ? fallback(result.error) : Task.resolve(result)
   )(data);
+  TaskResult2.recoverUnless = (isBlocked, fallback) => (data) => Task.chain(
+    (result) => Result.is.err(result) && !isBlocked(result.error) ? 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);
@@ -2132,6 +2163,11 @@ var TaskValidation;
     );
     from2.Result = (result) => Task.resolve(Validation.from.Result(result));
   })(from = TaskValidation2.from || (TaskValidation2.from = {}));
+  let to;
+  ((to2) => {
+    to2.Result = (combineErrors) => (data) => Task.map(Validation.to.Result(combineErrors))(data);
+    to2.Maybe = (data) => Task.map(Validation.to.Maybe)(data);
+  })(to = TaskValidation2.to || (TaskValidation2.to = {}));
   TaskValidation2.tryCatch = (f, options) => (signal) => Deferred.from.Promise(
     globalThis.Promise.resolve().then(async () => f(signal)).then(Validation.make.passed).catch(
       (error) => Validation.make.failed(options.onError(error))
@@ -2150,6 +2186,9 @@ var TaskValidation;
   TaskValidation2.recover = (fallback) => (data) => Task.chain(
     (validation) => Validation.is.passed(validation) ? Task.resolve(validation) : fallback(validation.errors)
   )(data);
+  TaskValidation2.recoverUnless = (isBlocked, fallback) => (data) => Task.chain(
+    (validation) => Validation.is.passed(validation) ? Task.resolve(validation) : isBlocked(validation.errors) ? Task.resolve(validation) : fallback(validation.errors)
+  )(data);
   TaskValidation2.product = (first, second) => (signal) => Deferred.from.Promise(
     Promise.all([Deferred.to.Promise(first(signal)), Deferred.to.Promise(second(signal))]).then(
       ([va, vb]) => Validation.product(va, vb)
@@ -2520,34 +2559,6 @@ var These;
   };
 })(These || (These = {}));
 
-// src/Core/Tuple.ts
-var Tuple;
-((Tuple2) => {
-  let from;
-  ((from2) => {
-    from2.pair = (first2, second2) => [first2, second2];
-    from2.array = (arr) => arr;
-  })(from = Tuple2.from || (Tuple2.from = {}));
-  Tuple2.first = (tuple) => tuple[0];
-  Tuple2.second = (tuple) => tuple[1];
-  Tuple2.mapFirst = (f) => (tuple) => [f(tuple[0]), tuple[1]];
-  Tuple2.mapSecond = (f) => (tuple) => [tuple[0], f(tuple[1])];
-  Tuple2.mapBoth = (onFirst, onSecond) => (tuple) => [
-    onFirst(tuple[0]),
-    onSecond(tuple[1])
-  ];
-  Tuple2.fold = (f) => (tuple) => f(tuple[0], tuple[1]);
-  Tuple2.swap = (tuple) => [tuple[1], tuple[0]];
-  let to;
-  ((to2) => {
-    to2.Array = (tuple) => [...tuple];
-  })(to = Tuple2.to || (Tuple2.to = {}));
-  Tuple2.tap = (f) => (tuple) => {
-    f(tuple[0], tuple[1]);
-    return tuple;
-  };
-})(Tuple || (Tuple = {}));
-
 // src/Core/Validation.ts
 var Validation;
 ((Validation2) => {
@@ -2665,6 +2676,7 @@ var Validation;
   Op,
   Optional,
   Ordering,
+  Pair,
   Predicate,
   Reader,
   Refinement,
@@ -2675,6 +2687,5 @@ var Validation;
   Stream,
   Task,
   These,
-  Tuple,
   Validation
 });

package/dist/core.d.cts

@@ -1,5 +1,5 @@
-import { M as Maybe, R as Result, T as Task } from './Validation-DCqWoCC2.cjs';
-export { E as Equality, a as Err, F as Failed, N as None, O as Ok, b as Ordering, P as Passed, S as Some, V as Validation } from './Validation-DCqWoCC2.cjs';
+import { M as Maybe, R as Result, T as Task } from './Validation-DC3uUizM.cjs';
+export { E as Equality, a as Err, F as Failed, N as None, O as Ok, b as Ordering, P as Passed, S as Some, V as Validation } from './Validation-DC3uUizM.cjs';
 import { o as WithValue, i as WithLog, D as Deferred, h as WithKind, e as WithError, R as RetryOptions, b as TimeoutOptions, n as WithTimeout, j as WithMinInterval, c as WithCooldown, W as WithConcurrency, m as WithSize, d as WithDuration, k as WithN, g as WithFirst, l as WithSecond } from './InternalTypes-DuK_XpTi.cjs';
 import { D as Duration } from './Duration-B8joKzro.cjs';
 import './types.cjs';
@@ -1327,6 +1327,148 @@ declare namespace Optional {
     const andThenLens: <A, B>(inner: Lens<A, B>) => <S>(outer: Optional<S, A>) => Optional<S, B>;
 }
 
+/**
+ * Pair<A, B> represents a pair of two values that are always both present.
+ * It is a typed alias for `readonly [A, B]`.
+ *
+ * Use Pair when two values always travel together through a pipeline and you
+ * want to transform either or both sides without destructuring.
+ *
+ * @example
+ * ```ts
+ * import { Pair } from "@nlozgachev/pipelined/core";
+ * import { pipe } from "@nlozgachev/pipelined/composition";
+ *
+ * const entry = Pair.from.pair("alice", 42);
+ *
+ * pipe(
+ *   entry,
+ *   Pair.mapFirst((name) => name.toUpperCase()),
+ *   Pair.mapSecond((score) => score * 2),
+ *   Pair.fold((name, score) => `${name}: ${score}`),
+ * ); // "ALICE: 84"
+ * ```
+ */
+type Pair<A, B> = readonly [A, B];
+declare namespace Pair {
+    namespace from {
+        /**
+         * Creates a Pair from two values.
+         *
+         * @example
+         * ```ts
+         * Pair.from.pair("Paris", 2_161_000); // ["Paris", 2161000]
+         * ```
+         */
+        const pair: <A, B>(first: A, second: B) => Pair<A, B>;
+        /**
+         * Creates a Pair from a two-element array.
+         *
+         * @example
+         * ```ts
+         * Pair.from.array(["Paris", 2_161_000] as const); // ["Paris", 2161000]
+         * ```
+         */
+        const array: <A, B>(arr: readonly [A, B]) => Pair<A, B>;
+    }
+    /**
+     * Returns the first value from the pair.
+     *
+     * @example
+     * ```ts
+     * Pair.first(Pair.from.pair("Paris", 2_161_000)); // "Paris"
+     * ```
+     */
+    const first: <A, B>(p: Pair<A, B>) => A;
+    /**
+     * Returns the second value from the pair.
+     *
+     * @example
+     * ```ts
+     * Pair.second(Pair.from.pair("Paris", 2_161_000)); // 2161000
+     * ```
+     */
+    const second: <A, B>(p: Pair<A, B>) => B;
+    /**
+     * Transforms the first value, leaving the second unchanged.
+     *
+     * @example
+     * ```ts
+     * pipe(Pair.from.pair("alice", 42), Pair.mapFirst((s) => s.toUpperCase())); // ["ALICE", 42]
+     * ```
+     */
+    const mapFirst: <A, C>(f: (a: A) => C) => <B>(p: Pair<A, B>) => Pair<C, B>;
+    /**
+     * Transforms the second value, leaving the first unchanged.
+     *
+     * @example
+     * ```ts
+     * pipe(Pair.from.pair("alice", 42), Pair.mapSecond((n) => n * 2)); // ["alice", 84]
+     * ```
+     */
+    const mapSecond: <B, D>(f: (b: B) => D) => <A>(p: Pair<A, B>) => Pair<A, D>;
+    /**
+     * Transforms both values independently in a single step.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   Pair.from.pair("alice", 42),
+     *   Pair.mapBoth(
+     *     (name) => name.toUpperCase(),
+     *     (score) => score * 2,
+     *   ),
+     * ); // ["ALICE", 84]
+     * ```
+     */
+    const mapBoth: <A, C, B, D>(onFirst: (a: A) => C, onSecond: (b: B) => D) => (p: Pair<A, B>) => Pair<C, D>;
+    /**
+     * Applies a binary function to both values, collapsing the pair into a single value.
+     * Useful as the final step when consuming a pair in a pipeline.
+     *
+     * @example
+     * ```ts
+     * pipe(Pair.from.pair("Alice", 100), Pair.fold((name, score) => `${name}: ${score}`));
+     * // "Alice: 100"
+     * ```
+     */
+    const fold: <A, B, C>(f: (a: A, b: B) => C) => (p: Pair<A, B>) => C;
+    /**
+     * Swaps the two values: `[A, B]` becomes `[B, A]`.
+     *
+     * @example
+     * ```ts
+     * Pair.swap(Pair.from.pair("key", 1)); // [1, "key"]
+     * ```
+     */
+    const swap: <A, B>(p: Pair<A, B>) => Pair<B, A>;
+    namespace to {
+        /**
+         * Converts the pair to a heterogeneous readonly array `readonly (A | B)[]`.
+         *
+         * @example
+         * ```ts
+         * Pair.to.Array(Pair.from.pair("hello", 42)); // ["hello", 42]
+         * ```
+         */
+        const Array: <A, B>(p: Pair<A, B>) => readonly (A | B)[];
+    }
+    /**
+     * Runs a side effect with both values without changing the pair.
+     * Useful for logging or debugging in the middle of a pipeline.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   Pair.from.pair("Paris", 2_161_000),
+     *   Pair.tap((city, pop) => console.log(`${city}: ${pop}`)),
+     *   Pair.mapSecond((n) => n / 1_000_000),
+     * ); // logs "Paris: 2161000", returns ["Paris", 2.161]
+     * ```
+     */
+    const tap: <A, B>(f: (a: A, b: B) => void) => (p: Pair<A, B>) => Pair<A, B>;
+}
+
 /**
  * A boolean-valued function over a type `A`.
  *
@@ -2877,146 +3019,4 @@ declare namespace These {
     const swap: <A, B>(data: These<A, B>) => These<B, A>;
 }
 
-/**
- * Tuple<A, B> represents a pair of two values that are always both present.
- * It is a typed alias for `readonly [A, B]`.
- *
- * Use Tuple when two values always travel together through a pipeline and you
- * want to transform either or both sides without destructuring.
- *
- * @example
- * ```ts
- * import { Tuple } from "@nlozgachev/pipelined/core";
- * import { pipe } from "@nlozgachev/pipelined/composition";
- *
- * const entry = Tuple.from.pair("alice", 42);
- *
- * pipe(
- *   entry,
- *   Tuple.mapFirst((name) => name.toUpperCase()),
- *   Tuple.mapSecond((score) => score * 2),
- *   Tuple.fold((name, score) => `${name}: ${score}`),
- * ); // "ALICE: 84"
- * ```
- */
-type Tuple<A, B> = readonly [A, B];
-declare namespace Tuple {
-    namespace from {
-        /**
-         * Creates a pair from two values.
-         *
-         * @example
-         * ```ts
-         * Tuple.from.pair("Paris", 2_161_000); // ["Paris", 2161000]
-         * ```
-         */
-        const pair: <A, B>(first: A, second: B) => Tuple<A, B>;
-        /**
-         * Creates a Tuple from a two-element array.
-         *
-         * @example
-         * ```ts
-         * Tuple.from.array(["Paris", 2_161_000] as const); // ["Paris", 2161000]
-         * ```
-         */
-        const array: <A, B>(arr: readonly [A, B]) => Tuple<A, B>;
-    }
-    /**
-     * Returns the first value from the pair.
-     *
-     * @example
-     * ```ts
-     * Tuple.first(Tuple.from.pair("Paris", 2_161_000)); // "Paris"
-     * ```
-     */
-    const first: <A, B>(tuple: Tuple<A, B>) => A;
-    /**
-     * Returns the second value from the pair.
-     *
-     * @example
-     * ```ts
-     * Tuple.second(Tuple.from.pair("Paris", 2_161_000)); // 2161000
-     * ```
-     */
-    const second: <A, B>(tuple: Tuple<A, B>) => B;
-    /**
-     * Transforms the first value, leaving the second unchanged.
-     *
-     * @example
-     * ```ts
-     * pipe(Tuple.from.pair("alice", 42), Tuple.mapFirst((s) => s.toUpperCase())); // ["ALICE", 42]
-     * ```
-     */
-    const mapFirst: <A, C>(f: (a: A) => C) => <B>(tuple: Tuple<A, B>) => Tuple<C, B>;
-    /**
-     * Transforms the second value, leaving the first unchanged.
-     *
-     * @example
-     * ```ts
-     * pipe(Tuple.from.pair("alice", 42), Tuple.mapSecond((n) => n * 2)); // ["alice", 84]
-     * ```
-     */
-    const mapSecond: <B, D>(f: (b: B) => D) => <A>(tuple: Tuple<A, B>) => Tuple<A, D>;
-    /**
-     * Transforms both values independently in a single step.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   Tuple.from.pair("alice", 42),
-     *   Tuple.mapBoth(
-     *     (name) => name.toUpperCase(),
-     *     (score) => score * 2,
-     *   ),
-     * ); // ["ALICE", 84]
-     * ```
-     */
-    const mapBoth: <A, C, B, D>(onFirst: (a: A) => C, onSecond: (b: B) => D) => (tuple: Tuple<A, B>) => Tuple<C, D>;
-    /**
-     * Applies a binary function to both values, collapsing the pair into a single value.
-     * Useful as the final step when consuming a pair in a pipeline.
-     *
-     * @example
-     * ```ts
-     * pipe(Tuple.from.pair("Alice", 100), Tuple.fold((name, score) => `${name}: ${score}`));
-     * // "Alice: 100"
-     * ```
-     */
-    const fold: <A, B, C>(f: (a: A, b: B) => C) => (tuple: Tuple<A, B>) => C;
-    /**
-     * Swaps the two values: `[A, B]` becomes `[B, A]`.
-     *
-     * @example
-     * ```ts
-     * Tuple.swap(Tuple.from.pair("key", 1)); // [1, "key"]
-     * ```
-     */
-    const swap: <A, B>(tuple: Tuple<A, B>) => Tuple<B, A>;
-    namespace to {
-        /**
-         * Converts the pair to a heterogeneous readonly array `readonly (A | B)[]`.
-         *
-         * @example
-         * ```ts
-         * Tuple.to.Array(Tuple.from.pair("hello", 42)); // ["hello", 42]
-         * ```
-         */
-        const Array: <A, B>(tuple: Tuple<A, B>) => readonly (A | B)[];
-    }
-    /**
-     * Runs a side effect with both values without changing the pair.
-     * Useful for logging or debugging in the middle of a pipeline.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   Tuple.from.pair("Paris", 2_161_000),
-     *   Tuple.tap((city, pop) => console.log(`${city}: ${pop}`)),
-     *   Tuple.mapSecond((n) => n / 1_000_000),
-     * ); // logs "Paris: 2161000", returns ["Paris", 2.161]
-     * ```
-     */
-    const tap: <A, B>(f: (a: A, b: B) => void) => (tuple: Tuple<A, B>) => Tuple<A, B>;
-}
-
-export { Combinable, Deferred, type Failure, Lazy, Lens, type Loading, Logged, Maybe, type NotAsked, Op, Optional, Predicate, Reader, Refinement, RemoteData, Resource, Result, State, Stream, type Success, Task, These, type TheseBoth, type TheseFirst, type TheseSecond, Tuple };
+export { Combinable, Deferred, type Failure, Lazy, Lens, type Loading, Logged, Maybe, type NotAsked, Op, Optional, Pair, Predicate, Reader, Refinement, RemoteData, Resource, Result, State, Stream, type Success, Task, These, type TheseBoth, type TheseFirst, type TheseSecond };

package/dist/core.d.ts

@@ -1,5 +1,5 @@
-import { M as Maybe, R as Result, T as Task } from './Validation-t0k4ic-S.js';
-export { E as Equality, a as Err, F as Failed, N as None, O as Ok, b as Ordering, P as Passed, S as Some, V as Validation } from './Validation-t0k4ic-S.js';
+import { M as Maybe, R as Result, T as Task } from './Validation-DZLizBZ0.js';
+export { E as Equality, a as Err, F as Failed, N as None, O as Ok, b as Ordering, P as Passed, S as Some, V as Validation } from './Validation-DZLizBZ0.js';
 import { o as WithValue, i as WithLog, D as Deferred, h as WithKind, e as WithError, R as RetryOptions, b as TimeoutOptions, n as WithTimeout, j as WithMinInterval, c as WithCooldown, W as WithConcurrency, m as WithSize, d as WithDuration, k as WithN, g as WithFirst, l as WithSecond } from './InternalTypes-LdhLQx3N.js';
 import { D as Duration } from './Duration-B8joKzro.js';
 import './types.js';
@@ -1327,6 +1327,148 @@ declare namespace Optional {
     const andThenLens: <A, B>(inner: Lens<A, B>) => <S>(outer: Optional<S, A>) => Optional<S, B>;
 }
 
+/**
+ * Pair<A, B> represents a pair of two values that are always both present.
+ * It is a typed alias for `readonly [A, B]`.
+ *
+ * Use Pair when two values always travel together through a pipeline and you
+ * want to transform either or both sides without destructuring.
+ *
+ * @example
+ * ```ts
+ * import { Pair } from "@nlozgachev/pipelined/core";
+ * import { pipe } from "@nlozgachev/pipelined/composition";
+ *
+ * const entry = Pair.from.pair("alice", 42);
+ *
+ * pipe(
+ *   entry,
+ *   Pair.mapFirst((name) => name.toUpperCase()),
+ *   Pair.mapSecond((score) => score * 2),
+ *   Pair.fold((name, score) => `${name}: ${score}`),
+ * ); // "ALICE: 84"
+ * ```
+ */
+type Pair<A, B> = readonly [A, B];
+declare namespace Pair {
+    namespace from {
+        /**
+         * Creates a Pair from two values.
+         *
+         * @example
+         * ```ts
+         * Pair.from.pair("Paris", 2_161_000); // ["Paris", 2161000]
+         * ```
+         */
+        const pair: <A, B>(first: A, second: B) => Pair<A, B>;
+        /**
+         * Creates a Pair from a two-element array.
+         *
+         * @example
+         * ```ts
+         * Pair.from.array(["Paris", 2_161_000] as const); // ["Paris", 2161000]
+         * ```
+         */
+        const array: <A, B>(arr: readonly [A, B]) => Pair<A, B>;
+    }
+    /**
+     * Returns the first value from the pair.
+     *
+     * @example
+     * ```ts
+     * Pair.first(Pair.from.pair("Paris", 2_161_000)); // "Paris"
+     * ```
+     */
+    const first: <A, B>(p: Pair<A, B>) => A;
+    /**
+     * Returns the second value from the pair.
+     *
+     * @example
+     * ```ts
+     * Pair.second(Pair.from.pair("Paris", 2_161_000)); // 2161000
+     * ```
+     */
+    const second: <A, B>(p: Pair<A, B>) => B;
+    /**
+     * Transforms the first value, leaving the second unchanged.
+     *
+     * @example
+     * ```ts
+     * pipe(Pair.from.pair("alice", 42), Pair.mapFirst((s) => s.toUpperCase())); // ["ALICE", 42]
+     * ```
+     */
+    const mapFirst: <A, C>(f: (a: A) => C) => <B>(p: Pair<A, B>) => Pair<C, B>;
+    /**
+     * Transforms the second value, leaving the first unchanged.
+     *
+     * @example
+     * ```ts
+     * pipe(Pair.from.pair("alice", 42), Pair.mapSecond((n) => n * 2)); // ["alice", 84]
+     * ```
+     */
+    const mapSecond: <B, D>(f: (b: B) => D) => <A>(p: Pair<A, B>) => Pair<A, D>;
+    /**
+     * Transforms both values independently in a single step.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   Pair.from.pair("alice", 42),
+     *   Pair.mapBoth(
+     *     (name) => name.toUpperCase(),
+     *     (score) => score * 2,
+     *   ),
+     * ); // ["ALICE", 84]
+     * ```
+     */
+    const mapBoth: <A, C, B, D>(onFirst: (a: A) => C, onSecond: (b: B) => D) => (p: Pair<A, B>) => Pair<C, D>;
+    /**
+     * Applies a binary function to both values, collapsing the pair into a single value.
+     * Useful as the final step when consuming a pair in a pipeline.
+     *
+     * @example
+     * ```ts
+     * pipe(Pair.from.pair("Alice", 100), Pair.fold((name, score) => `${name}: ${score}`));
+     * // "Alice: 100"
+     * ```
+     */
+    const fold: <A, B, C>(f: (a: A, b: B) => C) => (p: Pair<A, B>) => C;
+    /**
+     * Swaps the two values: `[A, B]` becomes `[B, A]`.
+     *
+     * @example
+     * ```ts
+     * Pair.swap(Pair.from.pair("key", 1)); // [1, "key"]
+     * ```
+     */
+    const swap: <A, B>(p: Pair<A, B>) => Pair<B, A>;
+    namespace to {
+        /**
+         * Converts the pair to a heterogeneous readonly array `readonly (A | B)[]`.
+         *
+         * @example
+         * ```ts
+         * Pair.to.Array(Pair.from.pair("hello", 42)); // ["hello", 42]
+         * ```
+         */
+        const Array: <A, B>(p: Pair<A, B>) => readonly (A | B)[];
+    }
+    /**
+     * Runs a side effect with both values without changing the pair.
+     * Useful for logging or debugging in the middle of a pipeline.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   Pair.from.pair("Paris", 2_161_000),
+     *   Pair.tap((city, pop) => console.log(`${city}: ${pop}`)),
+     *   Pair.mapSecond((n) => n / 1_000_000),
+     * ); // logs "Paris: 2161000", returns ["Paris", 2.161]
+     * ```
+     */
+    const tap: <A, B>(f: (a: A, b: B) => void) => (p: Pair<A, B>) => Pair<A, B>;
+}
+
 /**
  * A boolean-valued function over a type `A`.
  *
@@ -2877,146 +3019,4 @@ declare namespace These {
     const swap: <A, B>(data: These<A, B>) => These<B, A>;
 }
 
-/**
- * Tuple<A, B> represents a pair of two values that are always both present.
- * It is a typed alias for `readonly [A, B]`.
- *
- * Use Tuple when two values always travel together through a pipeline and you
- * want to transform either or both sides without destructuring.
- *
- * @example
- * ```ts
- * import { Tuple } from "@nlozgachev/pipelined/core";
- * import { pipe } from "@nlozgachev/pipelined/composition";
- *
- * const entry = Tuple.from.pair("alice", 42);
- *
- * pipe(
- *   entry,
- *   Tuple.mapFirst((name) => name.toUpperCase()),
- *   Tuple.mapSecond((score) => score * 2),
- *   Tuple.fold((name, score) => `${name}: ${score}`),
- * ); // "ALICE: 84"
- * ```
- */
-type Tuple<A, B> = readonly [A, B];
-declare namespace Tuple {
-    namespace from {
-        /**
-         * Creates a pair from two values.
-         *
-         * @example
-         * ```ts
-         * Tuple.from.pair("Paris", 2_161_000); // ["Paris", 2161000]
-         * ```
-         */
-        const pair: <A, B>(first: A, second: B) => Tuple<A, B>;
-        /**
-         * Creates a Tuple from a two-element array.
-         *
-         * @example
-         * ```ts
-         * Tuple.from.array(["Paris", 2_161_000] as const); // ["Paris", 2161000]
-         * ```
-         */
-        const array: <A, B>(arr: readonly [A, B]) => Tuple<A, B>;
-    }
-    /**
-     * Returns the first value from the pair.
-     *
-     * @example
-     * ```ts
-     * Tuple.first(Tuple.from.pair("Paris", 2_161_000)); // "Paris"
-     * ```
-     */
-    const first: <A, B>(tuple: Tuple<A, B>) => A;
-    /**
-     * Returns the second value from the pair.
-     *
-     * @example
-     * ```ts
-     * Tuple.second(Tuple.from.pair("Paris", 2_161_000)); // 2161000
-     * ```
-     */
-    const second: <A, B>(tuple: Tuple<A, B>) => B;
-    /**
-     * Transforms the first value, leaving the second unchanged.
-     *
-     * @example
-     * ```ts
-     * pipe(Tuple.from.pair("alice", 42), Tuple.mapFirst((s) => s.toUpperCase())); // ["ALICE", 42]
-     * ```
-     */
-    const mapFirst: <A, C>(f: (a: A) => C) => <B>(tuple: Tuple<A, B>) => Tuple<C, B>;
-    /**
-     * Transforms the second value, leaving the first unchanged.
-     *
-     * @example
-     * ```ts
-     * pipe(Tuple.from.pair("alice", 42), Tuple.mapSecond((n) => n * 2)); // ["alice", 84]
-     * ```
-     */
-    const mapSecond: <B, D>(f: (b: B) => D) => <A>(tuple: Tuple<A, B>) => Tuple<A, D>;
-    /**
-     * Transforms both values independently in a single step.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   Tuple.from.pair("alice", 42),
-     *   Tuple.mapBoth(
-     *     (name) => name.toUpperCase(),
-     *     (score) => score * 2,
-     *   ),
-     * ); // ["ALICE", 84]
-     * ```
-     */
-    const mapBoth: <A, C, B, D>(onFirst: (a: A) => C, onSecond: (b: B) => D) => (tuple: Tuple<A, B>) => Tuple<C, D>;
-    /**
-     * Applies a binary function to both values, collapsing the pair into a single value.
-     * Useful as the final step when consuming a pair in a pipeline.
-     *
-     * @example
-     * ```ts
-     * pipe(Tuple.from.pair("Alice", 100), Tuple.fold((name, score) => `${name}: ${score}`));
-     * // "Alice: 100"
-     * ```
-     */
-    const fold: <A, B, C>(f: (a: A, b: B) => C) => (tuple: Tuple<A, B>) => C;
-    /**
-     * Swaps the two values: `[A, B]` becomes `[B, A]`.
-     *
-     * @example
-     * ```ts
-     * Tuple.swap(Tuple.from.pair("key", 1)); // [1, "key"]
-     * ```
-     */
-    const swap: <A, B>(tuple: Tuple<A, B>) => Tuple<B, A>;
-    namespace to {
-        /**
-         * Converts the pair to a heterogeneous readonly array `readonly (A | B)[]`.
-         *
-         * @example
-         * ```ts
-         * Tuple.to.Array(Tuple.from.pair("hello", 42)); // ["hello", 42]
-         * ```
-         */
-        const Array: <A, B>(tuple: Tuple<A, B>) => readonly (A | B)[];
-    }
-    /**
-     * Runs a side effect with both values without changing the pair.
-     * Useful for logging or debugging in the middle of a pipeline.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   Tuple.from.pair("Paris", 2_161_000),
-     *   Tuple.tap((city, pop) => console.log(`${city}: ${pop}`)),
-     *   Tuple.mapSecond((n) => n / 1_000_000),
-     * ); // logs "Paris: 2161000", returns ["Paris", 2.161]
-     * ```
-     */
-    const tap: <A, B>(f: (a: A, b: B) => void) => (tuple: Tuple<A, B>) => Tuple<A, B>;
-}
-
-export { Combinable, Deferred, type Failure, Lazy, Lens, type Loading, Logged, Maybe, type NotAsked, Op, Optional, Predicate, Reader, Refinement, RemoteData, Resource, Result, State, Stream, type Success, Task, These, type TheseBoth, type TheseFirst, type TheseSecond, Tuple };
+export { Combinable, Deferred, type Failure, Lazy, Lens, type Loading, Logged, Maybe, type NotAsked, Op, Optional, Pair, Predicate, Reader, Refinement, RemoteData, Resource, Result, State, Stream, type Success, Task, These, type TheseBoth, type TheseFirst, type TheseSecond };

package/dist/core.js

@@ -9,6 +9,7 @@ import {
   Op,
   Optional,
   Ordering,
+  Pair,
   Predicate,
   Reader,
   Refinement,
@@ -19,9 +20,8 @@ import {
   Stream,
   Task,
   These,
-  Tuple,
   Validation
-} from "./chunk-K7HHEACE.js";
+} from "./chunk-VYHAA4KO.js";
 import "./chunk-OIIOGDHK.js";
 export {
   Combinable,
@@ -34,6 +34,7 @@ export {
   Op,
   Optional,
   Ordering,
+  Pair,
   Predicate,
   Reader,
   Refinement,
@@ -44,6 +45,5 @@ export {
   Stream,
   Task,
   These,
-  Tuple,
   Validation
 };

package/dist/data.d.cts

@@ -1,5 +1,5 @@
 import { a as NonEmptyArr, N as NonEmpty } from './InternalTypes-DuK_XpTi.cjs';
-import { M as Maybe, R as Result, E as Equality, b as Ordering, T as Task } from './Validation-DCqWoCC2.cjs';
+import { M as Maybe, R as Result, E as Equality, b as Ordering, T as Task } from './Validation-DC3uUizM.cjs';
 import { B as Brand } from './Duration-B8joKzro.cjs';
 import './types.cjs';
 

package/dist/data.d.ts

@@ -1,5 +1,5 @@
 import { a as NonEmptyArr, N as NonEmpty } from './InternalTypes-LdhLQx3N.js';
-import { M as Maybe, R as Result, E as Equality, b as Ordering, T as Task } from './Validation-t0k4ic-S.js';
+import { M as Maybe, R as Result, E as Equality, b as Ordering, T as Task } from './Validation-DZLizBZ0.js';
 import { B as Brand } from './Duration-B8joKzro.js';
 import './types.js';
 

package/dist/data.js

@@ -7,8 +7,8 @@ import {
   Rec,
   Str,
   Uniq
-} from "./chunk-EJX32LRO.js";
-import "./chunk-K7HHEACE.js";
+} from "./chunk-FVWJMPQI.js";
+import "./chunk-VYHAA4KO.js";
 import "./chunk-OIIOGDHK.js";
 export {
   Arr,

package/dist/index.cjs

@@ -37,6 +37,7 @@ __export(src_exports, {
   Op: () => Op,
   Optional: () => Optional,
   Ordering: () => Ordering,
+  Pair: () => Pair,
   Predicate: () => Predicate,
   Reader: () => Reader,
   Rec: () => Rec,
@@ -50,7 +51,6 @@ __export(src_exports, {
   Stream: () => Stream,
   Task: () => Task,
   These: () => These,
-  Tuple: () => Tuple,
   Uniq: () => Uniq,
   Validation: () => Validation,
   and: () => and,
@@ -1955,6 +1955,34 @@ var Ordering;
   };
 })(Ordering || (Ordering = {}));
 
+// src/Core/Pair.ts
+var Pair;
+((Pair2) => {
+  let from;
+  ((from2) => {
+    from2.pair = (first2, second2) => [first2, second2];
+    from2.array = (arr) => arr;
+  })(from = Pair2.from || (Pair2.from = {}));
+  Pair2.first = (p) => p[0];
+  Pair2.second = (p) => p[1];
+  Pair2.mapFirst = (f) => (p) => [f(p[0]), p[1]];
+  Pair2.mapSecond = (f) => (p) => [p[0], f(p[1])];
+  Pair2.mapBoth = (onFirst, onSecond) => (p) => [
+    onFirst(p[0]),
+    onSecond(p[1])
+  ];
+  Pair2.fold = (f) => (p) => f(p[0], p[1]);
+  Pair2.swap = (p) => [p[1], p[0]];
+  let to;
+  ((to2) => {
+    to2.Array = (p) => [...p];
+  })(to = Pair2.to || (Pair2.to = {}));
+  Pair2.tap = (f) => (p) => {
+    f(p[0], p[1]);
+    return p;
+  };
+})(Pair || (Pair = {}));
+
 // src/Core/Predicate.ts
 var Predicate;
 ((Predicate2) => {
@@ -2504,6 +2532,9 @@ var TaskResult;
   TaskResult2.recover = (fallback) => (data) => Task.chain(
     (result) => Result.is.err(result) ? fallback(result.error) : Task.resolve(result)
   )(data);
+  TaskResult2.recoverUnless = (isBlocked, fallback) => (data) => Task.chain(
+    (result) => Result.is.err(result) && !isBlocked(result.error) ? 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);
@@ -2614,6 +2645,11 @@ var TaskValidation;
     );
     from2.Result = (result) => Task.resolve(Validation.from.Result(result));
   })(from = TaskValidation2.from || (TaskValidation2.from = {}));
+  let to;
+  ((to2) => {
+    to2.Result = (combineErrors) => (data) => Task.map(Validation.to.Result(combineErrors))(data);
+    to2.Maybe = (data) => Task.map(Validation.to.Maybe)(data);
+  })(to = TaskValidation2.to || (TaskValidation2.to = {}));
   TaskValidation2.tryCatch = (f, options) => (signal) => Deferred.from.Promise(
     globalThis.Promise.resolve().then(async () => f(signal)).then(Validation.make.passed).catch(
       (error) => Validation.make.failed(options.onError(error))
@@ -2632,6 +2668,9 @@ var TaskValidation;
   TaskValidation2.recover = (fallback) => (data) => Task.chain(
     (validation) => Validation.is.passed(validation) ? Task.resolve(validation) : fallback(validation.errors)
   )(data);
+  TaskValidation2.recoverUnless = (isBlocked, fallback) => (data) => Task.chain(
+    (validation) => Validation.is.passed(validation) ? Task.resolve(validation) : isBlocked(validation.errors) ? Task.resolve(validation) : fallback(validation.errors)
+  )(data);
   TaskValidation2.product = (first, second) => (signal) => Deferred.from.Promise(
     Promise.all([Deferred.to.Promise(first(signal)), Deferred.to.Promise(second(signal))]).then(
       ([va, vb]) => Validation.product(va, vb)
@@ -3002,34 +3041,6 @@ var These;
   };
 })(These || (These = {}));
 
-// src/Core/Tuple.ts
-var Tuple;
-((Tuple2) => {
-  let from;
-  ((from2) => {
-    from2.pair = (first2, second2) => [first2, second2];
-    from2.array = (arr) => arr;
-  })(from = Tuple2.from || (Tuple2.from = {}));
-  Tuple2.first = (tuple2) => tuple2[0];
-  Tuple2.second = (tuple2) => tuple2[1];
-  Tuple2.mapFirst = (f) => (tuple2) => [f(tuple2[0]), tuple2[1]];
-  Tuple2.mapSecond = (f) => (tuple2) => [tuple2[0], f(tuple2[1])];
-  Tuple2.mapBoth = (onFirst, onSecond) => (tuple2) => [
-    onFirst(tuple2[0]),
-    onSecond(tuple2[1])
-  ];
-  Tuple2.fold = (f) => (tuple2) => f(tuple2[0], tuple2[1]);
-  Tuple2.swap = (tuple2) => [tuple2[1], tuple2[0]];
-  let to;
-  ((to2) => {
-    to2.Array = (tuple2) => [...tuple2];
-  })(to = Tuple2.to || (Tuple2.to = {}));
-  Tuple2.tap = (f) => (tuple2) => {
-    f(tuple2[0], tuple2[1]);
-    return tuple2;
-  };
-})(Tuple || (Tuple = {}));
-
 // src/Core/Validation.ts
 var Validation;
 ((Validation2) => {
@@ -4461,6 +4472,7 @@ var Uniq;
   Op,
   Optional,
   Ordering,
+  Pair,
   Predicate,
   Reader,
   Rec,
@@ -4474,7 +4486,6 @@ var Uniq;
   Stream,
   Task,
   These,
-  Tuple,
   Uniq,
   Validation,
   and,

package/dist/index.d.cts

@@ -1,7 +1,7 @@
 export { and, compose, constFalse, constNull, constTrue, constUndefined, constVoid, constant, converge, curry, curry3, curry4, defaultTo, flip, flow, identity, juxt, memoize, memoizeWeak, not, on, once, or, pipe, tap, tuple, uncurry, uncurry3, uncurry4, untuple } from './composition.cjs';
-export { Combinable, Failure, Lazy, Lens, Loading, Logged, NotAsked, Op, Optional, Predicate, Reader, Refinement, RemoteData, Resource, State, Stream, Success, These, TheseBoth, TheseFirst, TheseSecond, Tuple } from './core.cjs';
+export { Combinable, Failure, Lazy, Lens, Loading, Logged, NotAsked, Op, Optional, Pair, Predicate, Reader, Refinement, RemoteData, Resource, State, Stream, Success, These, TheseBoth, TheseFirst, TheseSecond } from './core.cjs';
 export { D as Deferred } from './InternalTypes-DuK_XpTi.cjs';
-export { E as Equality, a as Err, F as Failed, M as Maybe, N as None, O as Ok, b as Ordering, P as Passed, R as Result, S as Some, T as Task, V as Validation } from './Validation-DCqWoCC2.cjs';
+export { E as Equality, a as Err, F as Failed, M as Maybe, N as None, O as Ok, b as Ordering, P as Passed, R as Result, S as Some, T as Task, V as Validation } from './Validation-DC3uUizM.cjs';
 export { Arr, BigNum, Dict, Json, NonEmptyMap, NonEmptyRecord, NonEmptySet, NonEmptyString, Num, Rec, Str, Uniq } from './data.cjs';
 export { B as Brand, D as Duration } from './Duration-B8joKzro.cjs';
 export { RetryPolicy } from './types.cjs';

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 export { and, compose, constFalse, constNull, constTrue, constUndefined, constVoid, constant, converge, curry, curry3, curry4, defaultTo, flip, flow, identity, juxt, memoize, memoizeWeak, not, on, once, or, pipe, tap, tuple, uncurry, uncurry3, uncurry4, untuple } from './composition.js';
-export { Combinable, Failure, Lazy, Lens, Loading, Logged, NotAsked, Op, Optional, Predicate, Reader, Refinement, RemoteData, Resource, State, Stream, Success, These, TheseBoth, TheseFirst, TheseSecond, Tuple } from './core.js';
+export { Combinable, Failure, Lazy, Lens, Loading, Logged, NotAsked, Op, Optional, Pair, Predicate, Reader, Refinement, RemoteData, Resource, State, Stream, Success, These, TheseBoth, TheseFirst, TheseSecond } from './core.js';
 export { D as Deferred } from './InternalTypes-LdhLQx3N.js';
-export { E as Equality, a as Err, F as Failed, M as Maybe, N as None, O as Ok, b as Ordering, P as Passed, R as Result, S as Some, T as Task, V as Validation } from './Validation-t0k4ic-S.js';
+export { E as Equality, a as Err, F as Failed, M as Maybe, N as None, O as Ok, b as Ordering, P as Passed, R as Result, S as Some, T as Task, V as Validation } from './Validation-DZLizBZ0.js';
 export { Arr, BigNum, Dict, Json, NonEmptyMap, NonEmptyRecord, NonEmptySet, NonEmptyString, Num, Rec, Str, Uniq } from './data.js';
 export { B as Brand, D as Duration } from './Duration-B8joKzro.js';
 export { RetryPolicy } from './types.js';

package/dist/index.js

@@ -39,7 +39,7 @@ import {
   Rec,
   Str,
   Uniq
-} from "./chunk-EJX32LRO.js";
+} from "./chunk-FVWJMPQI.js";
 import {
   Combinable,
   Deferred,
@@ -51,6 +51,7 @@ import {
   Op,
   Optional,
   Ordering,
+  Pair,
   Predicate,
   Reader,
   Refinement,
@@ -61,9 +62,8 @@ import {
   Stream,
   Task,
   These,
-  Tuple,
   Validation
-} from "./chunk-K7HHEACE.js";
+} from "./chunk-VYHAA4KO.js";
 import {
   Brand,
   Duration,
@@ -87,6 +87,7 @@ export {
   Op,
   Optional,
   Ordering,
+  Pair,
   Predicate,
   Reader,
   Rec,
@@ -100,7 +101,6 @@ export {
   Stream,
   Task,
   These,
-  Tuple,
   Uniq,
   Validation,
   and,

package/package.json

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