@nlozgachev/pipelined 0.54.0 → 0.56.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-C5Qz1R0S.d.mts → Validation-DCqWoCC2.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.
@@ -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: {
@@ -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))`.
@@ -1132,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>;
 }
 
 /**
@@ -1159,7 +1154,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 +1164,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 +1199,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 +1222,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.
@@ -1436,7 +1431,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 +1441,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 +1451,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 +1505,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.
      */
@@ -1644,6 +1644,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>;
 }
 
 /**
@@ -1701,16 +1711,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 +1723,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 +1860,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 +1885,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 +2101,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: {

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

@@ -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: {
@@ -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))`.
@@ -1132,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>;
 }
 
 /**
@@ -1159,7 +1154,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 +1164,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 +1199,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 +1222,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.
@@ -1436,7 +1431,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 +1441,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 +1451,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 +1505,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.
      */
@@ -1644,6 +1644,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>;
 }
 
 /**
@@ -1701,16 +1711,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 +1723,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 +1860,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 +1885,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 +2101,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: {

package/dist/{chunk-L6GLADRU.mjs → chunk-EJX32LRO.js}

@@ -2,9 +2,8 @@ import {
   Deferred,
   Maybe,
   Result,
-  Task,
   isNonEmptyArr
-} from "./chunk-XFE3SQEE.mjs";
+} from "./chunk-K7HHEACE.js";
 
 // src/Data/Arr.ts
 var ArrMaybe;
@@ -41,7 +40,7 @@ var ArrResult;
 })(ArrResult || (ArrResult = {}));
 var ArrTaskResult;
 ((ArrTaskResult2) => {
-  ArrTaskResult2.traverse = (f) => (data) => Task.from.Promise(async () => {
+  ArrTaskResult2.traverse = (f) => (data) => () => Deferred.from.Promise((async () => {
     const result = [];
     for (const a of data) {
       const r = await Deferred.to.Promise(f(a)());
@@ -51,12 +50,12 @@ var ArrTaskResult;
       result.push(r.value);
     }
     return Result.make.ok(result);
-  });
+  })());
   ArrTaskResult2.sequence = (data) => (0, ArrTaskResult2.traverse)((a) => a)(data);
 })(ArrTaskResult || (ArrTaskResult = {}));
 var ArrTask;
 ((ArrTask2) => {
-  ArrTask2.traverse = (f) => (data) => Task.from.Promise(() => Promise.all(data.map((a) => Deferred.to.Promise(f(a)()))));
+  ArrTask2.traverse = (f) => (data) => () => Deferred.from.Promise(Promise.all(data.map((a) => Deferred.to.Promise(f(a)()))));
   ArrTask2.sequence = (data) => (0, ArrTask2.traverse)((a) => a)(data);
   ArrTask2.Result = ArrTaskResult;
 })(ArrTask || (ArrTask = {}));

package/dist/{chunk-5OFVS5UZ.mjs → chunk-JSG7SFXS.js}

@@ -1,6 +1,6 @@
 import {
   Duration
-} from "./chunk-DENXUTKL.mjs";
+} from "./chunk-OIIOGDHK.js";
 
 // src/Composition/compose.ts
 function compose(f0, f1, f2, f3, f4, f5, f6, f7, f8, f9) {