@nlozgachev/pipelined 0.53.0 → 0.55.0

package/dist/{InternalTypes-CDiDBAY4.d.mts → InternalTypes-DuK_XpTi.d.cts}

@@ -1,4 +1,4 @@
-import { D as Duration } from './Duration-B8joKzro.mjs';
+import { D as Duration } from './Duration-B8joKzro.cjs';
 
 declare const _deferred: unique symbol;
 /**

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

@@ -1,6 +1,6 @@
-import { h as WithKind, o as WithValue, e as WithError, a as NonEmptyArr, T as Thenable, D as Deferred, f as WithErrors } from './InternalTypes-CDiDBAY4.mjs';
-import { D as Duration } from './Duration-B8joKzro.mjs';
-import { RetryPolicy } from './types.mjs';
+import { h as WithKind, o as WithValue, e as WithError, a as NonEmptyArr, T as Thenable, D as Deferred, f as WithErrors } from './InternalTypes-DuK_XpTi.cjs';
+import { D as Duration } from './Duration-B8joKzro.cjs';
+import { RetryPolicy } from './types.cjs';
 
 /**
  * A function that checks whether two values of type `A` are equal.
@@ -325,7 +325,7 @@ declare namespace Maybe {
      * pipe(Maybe.make.none<string>(), Maybe.getOrElse(() => null)); // null — typed as string | null
      * ```
      */
-    const getOrElse: <A, B>(defaultValue: () => B) => (data: Maybe<A>) => A | B;
+    const getOrElse: <B>(defaultValue: () => B) => <A>(data: Maybe<A>) => A | B;
     /**
      * Executes a side effect on the value without changing the Maybe.
      * Useful for logging or debugging.
@@ -361,7 +361,7 @@ declare namespace Maybe {
      * pipe(Maybe.make.some(10), Maybe.recover(() => Maybe.make.some(42))); // Some(10)
      * ```
      */
-    const recover: <A, B>(fallback: () => Maybe<B>) => (data: Maybe<A>) => Maybe<A | B>;
+    const recover: <B>(fallback: () => Maybe<B>) => <A>(data: Maybe<A>) => Maybe<A | B>;
     /**
      * Applies a function wrapped in a Maybe to a value wrapped in a Maybe.
      *
@@ -595,13 +595,16 @@ declare namespace Result {
      * Creates a Result from a function that may throw.
      * Catches any errors and transforms them using the onError function.
      *
+    /**
+     * Creates a Result from a synchronous thunk that may throw.
+     * Catches any errors and transforms them using the `onError` function.
+     *
      * @example
      * ```ts
-     * const parseJson = (s: string): Result<string, unknown> =>
-     *   Result.tryCatch(
-     *     () => JSON.parse(s),
-     *     { onError: (e) => `Parse error: ${e}` }
-     *   );
+     * const result = Result.tryCatch(
+     *   () => JSON.parse(rawString),
+     *   { onError: (e) => `Parse error: ${e}` }
+     * );
      * ```
      */
     const tryCatch: <E, A>(f: () => A, options: {
@@ -685,7 +688,7 @@ declare namespace Result {
      * pipe(Result.make.err("error"), Result.getOrElse(() => null)); // null — typed as number | null
      * ```
      */
-    const getOrElse: <E, A, B>(defaultValue: () => B) => (data: Result<E, A>) => A | B;
+    const getOrElse: <B>(defaultValue: () => B) => <E, A>(data: Result<E, A>) => A | B;
     /**
      * Executes a side effect on the success value without changing the Result.
      * Useful for logging or debugging.
@@ -749,24 +752,6 @@ declare namespace Result {
          * ```
          */
         const Maybe: <E>(onNone: () => E) => <A>(maybe: Maybe<A>) => Result<E, A>;
-        /**
-         * Wraps a throwing function of any arguments, returning a new function
-         * that catches errors and returns a Result.
-         *
-         * @example
-         * ```ts
-         * const safeParse = Result.from.throwable(
-         *   (s: string) => JSON.parse(s),
-         *   { onError: (e) => new Error(`Parse error: ${e}`) }
-         * );
-         *
-         * safeParse('{"a":1}'); // Ok({ a: 1 })
-         * safeParse('invalid');  // Err(Error)
-         * ```
-         */
-        const throwable: <Args extends readonly unknown[], A, E>(f: (...args: Args) => A, options: {
-            onError: (e: unknown) => E;
-        }) => (...args: Args) => Result<E, A>;
         /**
          * Converts a `Validation` to a `Result`, combining accumulated errors using `combineErrors`.
          * `Passed(a)` becomes `Ok(a)`; `Failed(errors)` becomes `Err(combineErrors(errors))`.
@@ -782,7 +767,7 @@ declare namespace Result {
      * Recovers from an error by providing a fallback Result.
      * The fallback can produce a different success type, widening the result to `Result<E, A | B>`.
      */
-    const recover: <E, A, B>(fallback: (e: E) => Result<E, B>) => (data: Result<E, A>) => Result<E, A | B>;
+    const recover: <E, B>(fallback: (e: E) => Result<E, B>) => <A>(data: Result<E, A>) => Result<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 `Result<E, A | B>`.
@@ -795,7 +780,7 @@ declare namespace Result {
      * ); // Ok(0)
      * ```
      */
-    const recoverUnless: <E, A, B>(isBlocked: (e: E) => boolean, fallback: () => Result<E, B>) => (data: Result<E, A>) => Result<E, A | B>;
+    const recoverUnless: <E, B>(isBlocked: (e: E) => boolean, fallback: () => Result<E, B>) => <A>(data: Result<E, A>) => Result<E, A | B>;
     namespace to {
         /**
          * Converts a Result to a Maybe.
@@ -1062,7 +1047,7 @@ declare namespace TaskMaybe {
      * Returns the value or a default if the Task.Maybe resolves to None.
      * The default can be a different type, widening the result to `Task<A | B>`.
      */
-    const getOrElse: <A, B>(defaultValue: () => B) => (data: TaskMaybe<A>) => Task<A | B>;
+    const getOrElse: <B>(defaultValue: () => B) => <A>(data: TaskMaybe<A>) => Task<A | B>;
     /**
      * Executes a side effect on the value without changing the Task.Maybe.
      * Useful for logging or debugging.
@@ -1118,7 +1103,7 @@ declare namespace TaskMaybe {
      * ); // Task.Maybe(42)
      * ```
      */
-    const recover: <A, B>(fallback: () => TaskMaybe<B>) => (data: TaskMaybe<A>) => TaskMaybe<A | B>;
+    const recover: <B>(fallback: () => TaskMaybe<B>) => <A>(data: TaskMaybe<A>) => TaskMaybe<A | B>;
     /**
      * Combines a record of Task.Maybes into a single Task.Maybe of a record.
      * Evaluates fields in parallel and returns None if any task resolves to None.
@@ -1159,7 +1144,7 @@ declare namespace TaskResult {
          * const res = await task(); // Ok(42)
          * ```
          */
-        const ok: <E, A>(value: A) => TaskResult<E, A>;
+        const ok: <E = never, A = unknown>(value: A) => TaskResult<E, A>;
         /**
          * Creates a failed Task.Result with the given error.
          *
@@ -1169,10 +1154,10 @@ declare namespace TaskResult {
          * const res = await task(); // Err("failed")
          * ```
          */
-        const err: <E, A>(error: E) => TaskResult<E, A>;
+        const err: <E, A = never>(error: E) => TaskResult<E, A>;
     }
-    const ok: <E, A>(value: A) => TaskResult<E, A>;
-    const err: <E, A>(error: E) => TaskResult<E, A>;
+    const ok: <E = never, A = unknown>(value: A) => TaskResult<E, A>;
+    const err: <E, A = never>(error: E) => TaskResult<E, A>;
     namespace from {
         /**
          * Creates a Task.Result from a nullable value.
@@ -1204,14 +1189,15 @@ declare namespace TaskResult {
          * Task.Result.from.Result(Result.make.ok(42)); // resolves to Ok(42)
          * ```
          */
-        const Result: <E, A>(result: Result<E, A>) => TaskResult<E, A>;
         /**
-         * Wraps a Promise-returning function of any arguments, returning a new function
-         * that catches rejections and returns a Task.Result.
+         * Lifts a Result into a Task.Result.
+         *
+         * @example
+         * ```ts
+         * Task.Result.from.Result(Result.make.ok(42)); // resolves to Ok(42)
+         * ```
          */
-        const throwable: <Args extends readonly unknown[], A, E>(f: (...args: Args) => Promise<A>, options: {
-            onError: (e: unknown) => E;
-        }) => (...args: Args) => TaskResult<E, A>;
+        const Result: <E, A>(result: Result<E, A>) => TaskResult<E, A>;
     }
     namespace to {
         /**
@@ -1226,21 +1212,20 @@ declare namespace TaskResult {
         const Maybe: <E, A>(data: TaskResult<E, A>) => TaskMaybe<A>;
     }
     /**
-     * Creates a Task.Result from a function that may throw.
-     * Catches any errors and transforms them using the onError function.
-     * The factory optionally receives an `AbortSignal` forwarded from the call site.
+     * Creates a Task.Result from a Promise-returning thunk that may throw or reject.
+     * Catches any errors and transforms them using the `onError` function into an `Err`.
+     * The thunk optionally receives an `AbortSignal` forwarded from the call site.
      *
      * @example
      * ```ts
-     * const fetchUser = (id: string): Task.Result<string, User> =>
-     *   Task.Result.tryCatch(
-     *     (signal) => fetch(`/users/${id}`, { signal }).then(r => r.json()),
-     *     { onError: String }
-     *   );
+     * const loadUser = Task.Result.tryCatch(
+     *   (signal) => userStore.get("u_123", { signal }),
+     *   { onError: (e) => new DbError(e) }
+     * );
      * ```
      */
     const tryCatch: <E, A>(f: (signal?: AbortSignal) => Thenable<A>, options: {
-        onError: (e: unknown) => E;
+        onError: (error: unknown) => E;
     }) => TaskResult<E, A>;
     /**
      * Transforms the success value inside a Task.Result.
@@ -1270,12 +1255,12 @@ declare namespace TaskResult {
      * Recovers from an error by providing a fallback Task.Result.
      * The fallback can produce a different success type, widening the result to `Task.Result<E, A | B>`.
      */
-    const recover: <E, A, B>(fallback: (e: E) => TaskResult<E, B>) => (data: TaskResult<E, A>) => TaskResult<E, A | B>;
+    const recover: <E, B>(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>`.
      */
-    const getOrElse: <E, A, B>(defaultValue: () => B) => (data: TaskResult<E, A>) => Task<A | B>;
+    const getOrElse: <B>(defaultValue: () => B) => <E, A>(data: TaskResult<E, A>) => Task<A | B>;
     /**
      * Executes a side effect on the success value without changing the Task.Result.
      * Useful for logging or debugging.
@@ -1436,7 +1421,7 @@ declare namespace TaskValidation {
          * const res = await task(); // Passed(42)
          * ```
          */
-        const passed: <E, A>(value: A) => TaskValidation<E, A>;
+        const passed: <E = never, A = unknown>(value: A) => TaskValidation<E, A>;
         /**
          * Creates a failed Task.Validation with a single error.
          *
@@ -1446,7 +1431,7 @@ declare namespace TaskValidation {
          * const res = await task(); // Failed(["invalid"])
          * ```
          */
-        const failed: <E, A>(error: E) => TaskValidation<E, A>;
+        const failed: <E, A = never>(error: E) => TaskValidation<E, A>;
         /**
          * Creates a failed Task.Validation from multiple errors.
          *
@@ -1456,11 +1441,11 @@ declare namespace TaskValidation {
          * const res = await task(); // Failed(["err1", "err2"])
          * ```
          */
-        const failedAll: <E, A>(errors: NonEmptyArr<E>) => TaskValidation<E, A>;
+        const failedAll: <E, A = never>(errors: NonEmptyArr<E>) => TaskValidation<E, A>;
     }
-    const passed: <E, A>(value: A) => TaskValidation<E, A>;
-    const failed: <E, A>(error: E) => TaskValidation<E, A>;
-    const failedAll: <E, A>(errors: NonEmptyArr<E>) => TaskValidation<E, A>;
+    const passed: <E = never, A = unknown>(value: A) => TaskValidation<E, A>;
+    const failed: <E, A = never>(error: E) => TaskValidation<E, A>;
+    const failedAll: <E, A = never>(errors: NonEmptyArr<E>) => TaskValidation<E, A>;
     namespace from {
         /**
          * Lifts a Validation into a Task.Validation.
@@ -1510,17 +1495,22 @@ declare namespace TaskValidation {
      * Creates a Task.Validation from a Promise-returning function.
      * Catches any errors and transforms them using the onError function.
      * The factory optionally receives an `AbortSignal` forwarded from the call site.
+    /**
+     * Creates a Task.Validation from a Promise-returning thunk that may throw or reject.
+     * Catches any errors and transforms them using the `onError` function into a Failed validation.
+     * The thunk optionally receives an `AbortSignal` forwarded from the call site.
      *
      * @example
      * ```ts
-     * const fetchUser = (id: string): Task.Validation<string, User> =>
-     *   Task.Validation.tryCatch(
-     *     (signal) => fetch(`/users/${id}`, { signal }).then(r => r.json()),
-     *     e => `Failed to fetch user: ${e}`
-     *   );
+     * const loadConfig = Task.Validation.tryCatch(
+     *   (signal) => configStore.get("default", { signal }),
+     *   { onError: (e) => `Failed to load config: ${e}` }
+     * );
      * ```
      */
-    const tryCatch: <E, A>(f: (signal?: AbortSignal) => Thenable<A>, onError: (e: unknown) => E) => TaskValidation<E, A>;
+    const tryCatch: <E, A>(f: (signal?: AbortSignal) => Thenable<A>, options: {
+        onError: (error: unknown) => E;
+    }) => TaskValidation<E, A>;
     /**
      * Transforms the success value inside a Task.Validation.
      */
@@ -1566,7 +1556,7 @@ declare namespace TaskValidation {
      * Returns the success value or a default value if the Task.Validation is failed.
      * The default can be a different type, widening the result to `Task<A | B>`.
      */
-    const getOrElse: <E, A, B>(defaultValue: () => B) => (data: TaskValidation<E, A>) => Task<A | B>;
+    const getOrElse: <B>(defaultValue: () => B) => <E, A>(data: TaskValidation<E, A>) => Task<A | B>;
     /**
      * Executes a side effect on the success value without changing the Task.Validation.
      * Useful for logging or debugging.
@@ -1577,7 +1567,7 @@ declare namespace TaskValidation {
      * The fallback receives the accumulated error list so callers can inspect which errors occurred.
      * The fallback can produce a different success type, widening the result to `Task.Validation<E, A | B>`.
      */
-    const recover: <E, A, B>(fallback: (errors: NonEmptyArr<E>) => TaskValidation<E, B>) => (data: TaskValidation<E, A>) => TaskValidation<E, A | B>;
+    const recover: <E, B>(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
@@ -1701,16 +1691,6 @@ declare namespace Task {
      */
     const resolve: <A>(value: A) => Task<A>;
     namespace from {
-        /**
-         * Creates a Task from a function that returns a Promise.
-         * The factory optionally receives an `AbortSignal` forwarded from the call site.
-         *
-         * @example
-         * ```ts
-         * const getTimestamp = Task.from.Promise(() => Promise.resolve(Date.now()));
-         * ```
-         */
-        const Promise: <A>(f: (signal?: AbortSignal) => Thenable<A>) => Task<A>;
         /**
          * Creates a Task from a lazy synchronous thunk.
          * Unlike `Task.resolve(f())`, `from.sync` does not evaluate `f` until the Task is called.
@@ -1723,6 +1703,21 @@ declare namespace Task {
          */
         const sync: <A>(f: () => A) => Task<A>;
     }
+    /**
+     * Wraps a Promise-returning thunk that may throw or reject,
+     * trapping errors with a fallback function and returning a guaranteed `Task<A>`.
+     *
+     * @example
+     * ```ts
+     * const loadConfig = Task.tryCatch(
+     *   () => configStore.get("default"),
+     *   { onError: () => DEFAULT_CONFIG }
+     * );
+     * ```
+     */
+    const tryCatch: <A>(f: (signal?: AbortSignal) => globalThis.Promise<A>, options: {
+        onError: (error: unknown) => A;
+    }) => Task<A>;
     /**
      * Transforms the value inside a Task.
      *
@@ -1845,8 +1840,8 @@ declare namespace Task {
      *
      * @example
      * ```ts
-     * const fast = Task.from.Promise(() => new Promise<string>(r => setTimeout(() => r("fast"), 10)));
-     * const slow = Task.from.Promise(() => new Promise<string>(r => setTimeout(() => r("slow"), 200)));
+     * const fast = Task.resolve("fast");
+     * const slow = Task.delay(Duration.milliseconds(200))(Task.resolve("slow"));
      *
      * await Task.race([fast, slow])(); // "fast"
      * ```
@@ -1870,10 +1865,7 @@ declare namespace Task {
      * @example
      * ```ts
      * let log: number[] = [];
-     * const makeTask = (n: number) => Task.from.Promise(() => {
-     *   log.push(n);
-     *   return Promise.resolve(n);
-     * });
+     * const makeTask = (n: number) => Task.resolve(n);
      *
      * await Task.sequential([makeTask(1), makeTask(2), makeTask(3)])();
      * // log = [1, 2, 3] — tasks ran in order
@@ -2089,16 +2081,15 @@ declare namespace Validation {
         const failed: <E, A>(data: Validation<E, A>) => data is Failed<E>;
     }
     /**
-     * Creates a Validation from a function that may throw.
-     * Catches any errors and transforms them using the onError function into a Failed validation.
+     * Creates a Validation from a synchronous thunk that may throw.
+     * Catches any errors and transforms them using the `onError` function into a Failed validation.
      *
      * @example
      * ```ts
-     * const parseJson = (s: string): Validation<string, unknown> =>
-     *   Validation.tryCatch(
-     *     () => JSON.parse(s),
-     *     { onError: (e) => `Parse error: ${e}` }
-     *   );
+     * const result = Validation.tryCatch(
+     *   () => JSON.parse(rawString),
+     *   { onError: (e) => `Parse error: ${e}` }
+     * );
      * ```
      */
     const tryCatch: <E, A>(f: () => A, options: {
@@ -2255,7 +2246,7 @@ declare namespace Validation {
      * pipe(Validation.make.failed("oops"), Validation.getOrElse(() => null)); // null — typed as number | null
      * ```
      */
-    const getOrElse: <E, A, B>(defaultValue: () => B) => (data: Validation<E, A>) => A | B;
+    const getOrElse: <B>(defaultValue: () => B) => <E, A>(data: Validation<E, A>) => A | B;
     /**
      * Executes a side effect on the success value without changing the Validation.
      *
@@ -2288,7 +2279,7 @@ declare namespace Validation {
      * The fallback receives the accumulated error list so callers can inspect which errors occurred.
      * The fallback can produce a different success type, widening the result to `Validation<E, A | B>`.
      */
-    const recover: <E, A, B>(fallback: (errors: NonEmptyArr<E>) => Validation<E, B>) => (data: Validation<E, A>) => Validation<E, A | B>;
+    const recover: <E, B>(fallback: (errors: NonEmptyArr<E>) => Validation<E, B>) => <A>(data: Validation<E, A>) => Validation<E, A | B>;
     /**
      * Recovers from a Failed state unless `isBlocked` returns true for any of the accumulated errors.
      * The fallback can produce a different success type, widening the result to `Validation<E, A | B>`.
@@ -2301,7 +2292,7 @@ declare namespace Validation {
      * ); // Passed(0)
      * ```
      */
-    const recoverUnless: <E, A, B>(isBlocked: (e: E) => boolean, fallback: () => Validation<E, B>) => (data: Validation<E, A>) => Validation<E, A | B>;
+    const recoverUnless: <E, B>(isBlocked: (e: E) => boolean, fallback: () => Validation<E, B>) => <A>(data: Validation<E, A>) => Validation<E, A | B>;
     namespace to {
         /**
          * Converts a Validation to a Result.