@nlozgachev/pipelined 0.55.0 → 0.57.0

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

@@ -1117,6 +1117,16 @@ declare namespace TaskMaybe {
      * ```
      */
     const struct: <R extends Record<string, any>>(fields: { [K in keyof R]: TaskMaybe<R[K]>; }) => TaskMaybe<R>;
+    /**
+     * Creates a memoized version of a Task.Maybe. The task is executed at most once on first call,
+     * and its resolved Maybe is cached for all subsequent calls.
+     *
+     * @example
+     * ```ts
+     * const loadUser = Task.Maybe.memoize(fetchUserMaybeTask);
+     * ```
+     */
+    const memoize: <A>(task: TaskMaybe<A>) => TaskMaybe<A>;
 }
 
 /**
@@ -1256,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>`.
@@ -1491,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.
@@ -1568,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
@@ -1634,6 +1698,16 @@ declare namespace TaskValidation {
      * ```
      */
     const struct: <E, R extends Record<string, any>>(fields: { [K in keyof R]: TaskValidation<E, R[K]>; }) => TaskValidation<E, R>;
+    /**
+     * Creates a memoized version of a Task.Validation. The task is executed at most once on first call,
+     * and its resolved Validation is cached for all subsequent calls.
+     *
+     * @example
+     * ```ts
+     * const validate = Task.Validation.memoize(validateFormTask);
+     * ```
+     */
+    const memoize: <E, A>(task: TaskValidation<E, A>) => TaskValidation<E, A>;
 }
 
 /**

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

@@ -1117,6 +1117,16 @@ declare namespace TaskMaybe {
      * ```
      */
     const struct: <R extends Record<string, any>>(fields: { [K in keyof R]: TaskMaybe<R[K]>; }) => TaskMaybe<R>;
+    /**
+     * Creates a memoized version of a Task.Maybe. The task is executed at most once on first call,
+     * and its resolved Maybe is cached for all subsequent calls.
+     *
+     * @example
+     * ```ts
+     * const loadUser = Task.Maybe.memoize(fetchUserMaybeTask);
+     * ```
+     */
+    const memoize: <A>(task: TaskMaybe<A>) => TaskMaybe<A>;
 }
 
 /**
@@ -1256,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>`.
@@ -1491,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.
@@ -1568,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
@@ -1634,6 +1698,16 @@ declare namespace TaskValidation {
      * ```
      */
     const struct: <E, R extends Record<string, any>>(fields: { [K in keyof R]: TaskValidation<E, R[K]>; }) => TaskValidation<E, R>;
+    /**
+     * Creates a memoized version of a Task.Validation. The task is executed at most once on first call,
+     * and its resolved Validation is cached for all subsequent calls.
+     *
+     * @example
+     * ```ts
+     * const validate = Task.Validation.memoize(validateFormTask);
+     * ```
+     */
+    const memoize: <E, A>(task: TaskValidation<E, A>) => TaskValidation<E, A>;
 }
 
 /**

package/dist/{chunk-NIE7VVZU.js → chunk-M4JSQLML.js}

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

package/dist/{chunk-MFJXL6J2.js → chunk-YMHKIN4I.js}

@@ -1913,6 +1913,7 @@ var TaskMaybe;
       return Maybe.make.some(record);
     });
   })());
+  TaskMaybe2.memoize = (task) => Task.memoize(task);
 })(TaskMaybe || (TaskMaybe = {}));
 
 // src/Core/TaskResult.ts
@@ -1950,6 +1951,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);
@@ -2060,6 +2064,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))
@@ -2078,6 +2087,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)
@@ -2108,6 +2120,7 @@ var TaskValidation;
       return isNonEmptyArr(errors) ? Validation.make.failedAll(errors) : Validation.make.passed(record);
     });
   })());
+  TaskValidation2.memoize = (task) => Task.memoize(task);
 })(TaskValidation || (TaskValidation = {}));
 
 // src/Core/Task.ts

package/dist/core.cjs

@@ -1984,6 +1984,7 @@ var TaskMaybe;
       return Maybe.make.some(record);
     });
   })());
+  TaskMaybe2.memoize = (task) => Task.memoize(task);
 })(TaskMaybe || (TaskMaybe = {}));
 
 // src/Core/TaskResult.ts
@@ -2021,6 +2022,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);
@@ -2131,6 +2135,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))
@@ -2149,6 +2158,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)
@@ -2179,6 +2191,7 @@ var TaskValidation;
       return isNonEmptyArr(errors) ? Validation.make.failedAll(errors) : Validation.make.passed(record);
     });
   })());
+  TaskValidation2.memoize = (task) => Task.memoize(task);
 })(TaskValidation || (TaskValidation = {}));
 
 // src/Core/Task.ts

package/dist/core.d.cts

@@ -1,5 +1,5 @@
-import { M as Maybe, R as Result, T as Task } from './Validation-CbU7Z-kj.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-CbU7Z-kj.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';

package/dist/core.d.ts

@@ -1,5 +1,5 @@
-import { M as Maybe, R as Result, T as Task } from './Validation-CmxZ3V4r.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-CmxZ3V4r.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';

package/dist/core.js

@@ -21,7 +21,7 @@ import {
   These,
   Tuple,
   Validation
-} from "./chunk-MFJXL6J2.js";
+} from "./chunk-YMHKIN4I.js";
 import "./chunk-OIIOGDHK.js";
 export {
   Combinable,

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-CbU7Z-kj.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-CmxZ3V4r.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-NIE7VVZU.js";
-import "./chunk-MFJXL6J2.js";
+} from "./chunk-M4JSQLML.js";
+import "./chunk-YMHKIN4I.js";
 import "./chunk-OIIOGDHK.js";
 export {
   Arr,

package/dist/index.cjs

@@ -2466,6 +2466,7 @@ var TaskMaybe;
       return Maybe.make.some(record);
     });
   })());
+  TaskMaybe2.memoize = (task) => Task.memoize(task);
 })(TaskMaybe || (TaskMaybe = {}));
 
 // src/Core/TaskResult.ts
@@ -2503,6 +2504,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);
@@ -2613,6 +2617,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))
@@ -2631,6 +2640,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)
@@ -2661,6 +2673,7 @@ var TaskValidation;
       return isNonEmptyArr(errors) ? Validation.make.failedAll(errors) : Validation.make.passed(record);
     });
   })());
+  TaskValidation2.memoize = (task) => Task.memoize(task);
 })(TaskValidation || (TaskValidation = {}));
 
 // src/Core/Task.ts

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 { 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-CbU7Z-kj.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 { 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-CmxZ3V4r.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-NIE7VVZU.js";
+} from "./chunk-M4JSQLML.js";
 import {
   Combinable,
   Deferred,
@@ -63,7 +63,7 @@ import {
   These,
   Tuple,
   Validation
-} from "./chunk-MFJXL6J2.js";
+} from "./chunk-YMHKIN4I.js";
 import {
   Brand,
   Duration,

package/package.json

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