@nlozgachev/pipelined 0.32.0 → 0.33.0

package/dist/{Task-CjYKLeTY.d.ts → Task-5na0QzS4.d.mts}

@@ -1,4 +1,4 @@
-import { N as NonEmptyList } from './NonEmptyList-BlGFjor5.js';
+import { NonEmptyList, Duration } from './types.mjs';
 
 type WithKind<K extends string> = {
     readonly kind: K;
@@ -223,6 +223,44 @@ declare namespace Result {
      * ```
      */
     const fromPredicate: <E, A>(pred: (a: A) => boolean, onFalse: (a: A) => E) => (a: A) => Result<E, A>;
+    /**
+     * Creates a Result from a nullable value.
+     * Returns Ok if the value is not null or undefined, error from onNull otherwise.
+     *
+     * @example
+     * ```ts
+     * pipe(null, Result.fromNullable(() => "is null")); // Error("is null")
+     * pipe(42, Result.fromNullable(() => "is null"));   // Ok(42)
+     * ```
+     */
+    const fromNullable: <E>(onNull: () => E) => <A>(value: A | null | undefined) => Result<E, A>;
+    /**
+     * Creates a Result from a Maybe.
+     * Some becomes Ok, None becomes error from onNone.
+     *
+     * @example
+     * ```ts
+     * pipe(Maybe.none(), Result.fromMaybe(() => "is none")); // Error("is none")
+     * pipe(Maybe.some(42), Result.fromMaybe(() => "is none")); // Ok(42)
+     * ```
+     */
+    const fromMaybe: <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.fromThrowable(
+     *   (s: string) => JSON.parse(s),
+     *   (e) => new Error(`Parse error: ${e}`)
+     * );
+     *
+     * safeParse('{"a":1}'); // Ok({ a: 1 })
+     * safeParse('invalid');  // Error(Error)
+     * ```
+     */
+    const fromThrowable: <Args extends readonly unknown[], A, E>(f: (...args: Args) => A, onError: (e: unknown) => E) => (...args: Args) => Result<E, A>;
     /**
      * 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>`.
@@ -844,37 +882,37 @@ declare namespace Task {
      */
     const all: <T extends readonly Task<unknown>[]>(tasks: T) => Task<{ [K in keyof T]: T[K] extends Task<infer A> ? A : never; }>;
     /**
-     * Delays the execution of a Task by the specified milliseconds.
+     * Delays the execution of a Task by the specified milliseconds or duration.
      * Useful for debouncing or rate limiting.
      *
      * @example
      * ```ts
      * pipe(
      *   Task.resolve(42),
-     *   Task.delay(1000)
+     *   Task.delay(Duration.seconds(1))
      * )(); // Resolves after 1 second
      * ```
      */
-    const delay: (ms: number) => <A>(data: Task<A>) => Task<A>;
+    const delay: (ms: number | Duration) => <A>(data: Task<A>) => Task<A>;
     /**
      * Runs a Task a fixed number of times sequentially, collecting all results into an array.
-     * An optional delay (ms) can be inserted between runs.
+     * An optional delay (ms or Duration) can be inserted between runs.
      *
      * @example
      * ```ts
      * pipe(
      *   pollSensor,
-     *   Task.repeat({ times: 5, delay: 1000 })
+     *   Task.repeat({ times: 5, delay: Duration.seconds(1) })
      * )(); // Task<Reading[]> — 5 readings, one per second
      * ```
      */
     const repeat: (options: {
         times: number;
-        delay?: number;
+        delay?: number | Duration;
     }) => <A>(task: Task<A>) => Task<readonly A[]>;
     /**
      * Runs a Task repeatedly until the result satisfies a predicate, returning that result.
-     * An optional delay (ms) can be inserted between runs.
+     * An optional delay (ms or Duration) can be inserted between runs.
      * An optional `maxAttempts` cap stops the loop after N calls — the last value is returned
      * regardless of whether the predicate was satisfied.
      *
@@ -882,18 +920,19 @@ declare namespace Task {
      * ```ts
      * pipe(
      *   checkStatus,
-     *   Task.repeatUntil({ when: (s) => s === "ready", delay: 500 })
+     *   Task.repeatUntil({ when: (s) => s === "ready", delay: Duration.milliseconds(500) })
      * )(); // polls every 500ms until status is "ready"
      * ```
      */
     const repeatUntil: <A>(options: {
         when: (a: A) => boolean;
-        delay?: number;
+        delay?: number | Duration;
         maxAttempts?: number;
     }) => (task: Task<A>) => Task<A>;
     /**
      * Resolves with the value of the first Task to complete. All Tasks start
-     * immediately; the rest are abandoned once one resolves.
+     * immediately. When one resolves, the other tasks are cancelled (aborted)
+     * downstream.
      *
      * @example
      * ```ts
@@ -904,6 +943,17 @@ declare namespace Task {
      * ```
      */
     const race: <A>(tasks: ReadonlyArray<Task<A>>) => Task<A>;
+    /**
+     * Runs an array of Tasks concurrently and collects their results in an array.
+     * Forward-propagates the call site's AbortSignal to all subtasks concurrently.
+     *
+     * @example
+     * ```ts
+     * Task.sequence([loadConfig, detectLocale, loadTheme])();
+     * // Deferred<[Config, string, Theme]>
+     * ```
+     */
+    const sequence: <A>(tasks: ReadonlyArray<Task<A>>) => Task<ReadonlyArray<A>>;
     /**
      * Runs an array of Tasks one at a time in order, collecting all results.
      * Each Task starts only after the previous one resolves.
@@ -931,12 +981,12 @@ declare namespace Task {
      * ```ts
      * pipe(
      *   heavyComputation,
-     *   Task.timeout(5000, () => "timed out"),
+     *   Task.timeout(Duration.seconds(5), () => "timed out"),
      *   TaskResult.chain(processResult)
      * );
      * ```
      */
-    const timeout: <E>(ms: number, onTimeout: () => E) => <A>(task: Task<A>) => Task<Result<E, A>>;
+    const timeout: <E>(ms: number | Duration, onTimeout: () => E) => <A>(task: Task<A>) => Task<Result<E, A>>;
     /**
      * Creates a Task paired with an `abort` handle. Calling `abort()` cancels the
      * current in-flight call immediately. Unlike a one-shot abort, calling `task()`

package/dist/{Task-CJZfcOkO.d.mts → Task-DeiWgoeJ.d.ts}

@@ -1,4 +1,4 @@
-import { N as NonEmptyList } from './NonEmptyList-BlGFjor5.mjs';
+import { NonEmptyList, Duration } from './types.js';
 
 type WithKind<K extends string> = {
     readonly kind: K;
@@ -223,6 +223,44 @@ declare namespace Result {
      * ```
      */
     const fromPredicate: <E, A>(pred: (a: A) => boolean, onFalse: (a: A) => E) => (a: A) => Result<E, A>;
+    /**
+     * Creates a Result from a nullable value.
+     * Returns Ok if the value is not null or undefined, error from onNull otherwise.
+     *
+     * @example
+     * ```ts
+     * pipe(null, Result.fromNullable(() => "is null")); // Error("is null")
+     * pipe(42, Result.fromNullable(() => "is null"));   // Ok(42)
+     * ```
+     */
+    const fromNullable: <E>(onNull: () => E) => <A>(value: A | null | undefined) => Result<E, A>;
+    /**
+     * Creates a Result from a Maybe.
+     * Some becomes Ok, None becomes error from onNone.
+     *
+     * @example
+     * ```ts
+     * pipe(Maybe.none(), Result.fromMaybe(() => "is none")); // Error("is none")
+     * pipe(Maybe.some(42), Result.fromMaybe(() => "is none")); // Ok(42)
+     * ```
+     */
+    const fromMaybe: <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.fromThrowable(
+     *   (s: string) => JSON.parse(s),
+     *   (e) => new Error(`Parse error: ${e}`)
+     * );
+     *
+     * safeParse('{"a":1}'); // Ok({ a: 1 })
+     * safeParse('invalid');  // Error(Error)
+     * ```
+     */
+    const fromThrowable: <Args extends readonly unknown[], A, E>(f: (...args: Args) => A, onError: (e: unknown) => E) => (...args: Args) => Result<E, A>;
     /**
      * 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>`.
@@ -844,37 +882,37 @@ declare namespace Task {
      */
     const all: <T extends readonly Task<unknown>[]>(tasks: T) => Task<{ [K in keyof T]: T[K] extends Task<infer A> ? A : never; }>;
     /**
-     * Delays the execution of a Task by the specified milliseconds.
+     * Delays the execution of a Task by the specified milliseconds or duration.
      * Useful for debouncing or rate limiting.
      *
      * @example
      * ```ts
      * pipe(
      *   Task.resolve(42),
-     *   Task.delay(1000)
+     *   Task.delay(Duration.seconds(1))
      * )(); // Resolves after 1 second
      * ```
      */
-    const delay: (ms: number) => <A>(data: Task<A>) => Task<A>;
+    const delay: (ms: number | Duration) => <A>(data: Task<A>) => Task<A>;
     /**
      * Runs a Task a fixed number of times sequentially, collecting all results into an array.
-     * An optional delay (ms) can be inserted between runs.
+     * An optional delay (ms or Duration) can be inserted between runs.
      *
      * @example
      * ```ts
      * pipe(
      *   pollSensor,
-     *   Task.repeat({ times: 5, delay: 1000 })
+     *   Task.repeat({ times: 5, delay: Duration.seconds(1) })
      * )(); // Task<Reading[]> — 5 readings, one per second
      * ```
      */
     const repeat: (options: {
         times: number;
-        delay?: number;
+        delay?: number | Duration;
     }) => <A>(task: Task<A>) => Task<readonly A[]>;
     /**
      * Runs a Task repeatedly until the result satisfies a predicate, returning that result.
-     * An optional delay (ms) can be inserted between runs.
+     * An optional delay (ms or Duration) can be inserted between runs.
      * An optional `maxAttempts` cap stops the loop after N calls — the last value is returned
      * regardless of whether the predicate was satisfied.
      *
@@ -882,18 +920,19 @@ declare namespace Task {
      * ```ts
      * pipe(
      *   checkStatus,
-     *   Task.repeatUntil({ when: (s) => s === "ready", delay: 500 })
+     *   Task.repeatUntil({ when: (s) => s === "ready", delay: Duration.milliseconds(500) })
      * )(); // polls every 500ms until status is "ready"
      * ```
      */
     const repeatUntil: <A>(options: {
         when: (a: A) => boolean;
-        delay?: number;
+        delay?: number | Duration;
         maxAttempts?: number;
     }) => (task: Task<A>) => Task<A>;
     /**
      * Resolves with the value of the first Task to complete. All Tasks start
-     * immediately; the rest are abandoned once one resolves.
+     * immediately. When one resolves, the other tasks are cancelled (aborted)
+     * downstream.
      *
      * @example
      * ```ts
@@ -904,6 +943,17 @@ declare namespace Task {
      * ```
      */
     const race: <A>(tasks: ReadonlyArray<Task<A>>) => Task<A>;
+    /**
+     * Runs an array of Tasks concurrently and collects their results in an array.
+     * Forward-propagates the call site's AbortSignal to all subtasks concurrently.
+     *
+     * @example
+     * ```ts
+     * Task.sequence([loadConfig, detectLocale, loadTheme])();
+     * // Deferred<[Config, string, Theme]>
+     * ```
+     */
+    const sequence: <A>(tasks: ReadonlyArray<Task<A>>) => Task<ReadonlyArray<A>>;
     /**
      * Runs an array of Tasks one at a time in order, collecting all results.
      * Each Task starts only after the previous one resolves.
@@ -931,12 +981,12 @@ declare namespace Task {
      * ```ts
      * pipe(
      *   heavyComputation,
-     *   Task.timeout(5000, () => "timed out"),
+     *   Task.timeout(Duration.seconds(5), () => "timed out"),
      *   TaskResult.chain(processResult)
      * );
      * ```
      */
-    const timeout: <E>(ms: number, onTimeout: () => E) => <A>(task: Task<A>) => Task<Result<E, A>>;
+    const timeout: <E>(ms: number | Duration, onTimeout: () => E) => <A>(task: Task<A>) => Task<Result<E, A>>;
     /**
      * Creates a Task paired with an `abort` handle. Calling `abort()` cancels the
      * current in-flight call immediately. Unlike a one-shot abort, calling `task()`

package/dist/{chunk-L3NC44SN.mjs → chunk-FZX4MTRI.mjs}

@@ -3,7 +3,7 @@ import {
   Maybe,
   Result,
   Task
-} from "./chunk-TK5ZCGP2.mjs";
+} from "./chunk-GSTKY7MF.mjs";
 
 // src/Core/Combinable.ts
 var Combinable;
@@ -1331,6 +1331,8 @@ var TaskMaybe;
   TaskMaybe2.some = (value) => Task.resolve(Maybe.some(value));
   TaskMaybe2.none = () => Task.resolve(Maybe.none());
   TaskMaybe2.fromMaybe = (option) => Task.resolve(option);
+  TaskMaybe2.fromNullable = (value) => Task.resolve(Maybe.fromNullable(value));
+  TaskMaybe2.fromResult = (result) => Task.resolve(Result.toMaybe(result));
   TaskMaybe2.fromTask = (task) => Task.map(Maybe.some)(task);
   TaskMaybe2.tryCatch = (f) => Task.from(
     (signal) => f(signal).then(Maybe.some).catch(() => Maybe.none())
@@ -1356,6 +1358,12 @@ var TaskResult;
 ((TaskResult2) => {
   TaskResult2.ok = (value) => Task.resolve(Result.ok(value));
   TaskResult2.err = (error) => Task.resolve(Result.error(error));
+  TaskResult2.fromNullable = (onNull) => (value) => Task.resolve(value === null || value === void 0 ? Result.error(onNull()) : Result.ok(value));
+  TaskResult2.fromMaybe = (onNone) => (maybe) => Task.resolve(Maybe.isNone(maybe) ? Result.error(onNone()) : Result.ok(maybe.value));
+  TaskResult2.fromResult = (result) => Task.resolve(result);
+  TaskResult2.fromThrowable = (f, onError) => (...args) => Task.from(
+    () => f(...args).then(Result.ok).catch((e) => Result.error(onError(e)))
+  );
   TaskResult2.tryCatch = (f, onError) => Task.from(
     (signal) => f(signal).then(Result.ok).catch((e) => Result.error(onError(e)))
   );
@@ -1401,6 +1409,8 @@ var Validation;
   Validation2.isValid = (data) => data.kind === "Valid";
   Validation2.isInvalid = (data) => data.kind === "Invalid";
   Validation2.fromPredicate = (pred, onFalse) => (a) => pred(a) ? (0, Validation2.valid)(a) : (0, Validation2.invalid)(onFalse(a));
+  Validation2.fromNullable = (onNull) => (value) => value === null || value === void 0 ? (0, Validation2.invalid)(onNull()) : (0, Validation2.valid)(value);
+  Validation2.fromMaybe = (onNone) => (maybe) => Maybe.isNone(maybe) ? (0, Validation2.invalid)(onNone()) : (0, Validation2.valid)(maybe.value);
   Validation2.map = (f) => (data) => (0, Validation2.isValid)(data) ? (0, Validation2.valid)(f(data.value)) : data;
   Validation2.ap = (arg) => (data) => {
     if ((0, Validation2.isValid)(data) && (0, Validation2.isValid)(arg)) return (0, Validation2.valid)(data.value(arg.value));
@@ -1452,6 +1462,9 @@ var TaskValidation;
   TaskValidation2.invalid = (error) => Task.resolve(Validation.invalid(error));
   TaskValidation2.invalidAll = (errors) => Task.resolve(Validation.invalidAll(errors));
   TaskValidation2.fromValidation = (validation) => Task.resolve(validation);
+  TaskValidation2.fromNullable = (onNull) => (value) => Task.resolve(value === null || value === void 0 ? Validation.invalid(onNull()) : Validation.valid(value));
+  TaskValidation2.fromMaybe = (onNone) => (maybe) => Task.resolve(Maybe.isNone(maybe) ? Validation.invalid(onNone()) : Validation.valid(maybe.value));
+  TaskValidation2.fromResult = (result) => Task.resolve(Validation.fromResult(result));
   TaskValidation2.tryCatch = (f, onError) => Task.from(
     (signal) => f(signal).then(Validation.valid).catch((e) => Validation.invalid(onError(e)))
   );

package/dist/{chunk-TK5ZCGP2.mjs → chunk-GSTKY7MF.mjs}

@@ -1,3 +1,7 @@
+import {
+  Duration
+} from "./chunk-VWVPHDZO.mjs";
+
 // src/Core/Maybe.ts
 var _none = { kind: "None" };
 var Maybe;
@@ -55,6 +59,15 @@ var Result;
     return data;
   };
   Result2.fromPredicate = (pred, onFalse) => (a) => pred(a) ? (0, Result2.ok)(a) : (0, Result2.error)(onFalse(a));
+  Result2.fromNullable = (onNull) => (value) => value === null || value === void 0 ? (0, Result2.error)(onNull()) : (0, Result2.ok)(value);
+  Result2.fromMaybe = (onNone) => (maybe) => Maybe.isNone(maybe) ? (0, Result2.error)(onNone()) : (0, Result2.ok)(maybe.value);
+  Result2.fromThrowable = (f, onError) => (...args) => {
+    try {
+      return (0, Result2.ok)(f(...args));
+    } catch (e) {
+      return (0, Result2.error)(onError(e));
+    }
+  };
   Result2.recover = (fallback) => (data) => (0, Result2.isOk)(data) ? data : fallback(data.error);
   Result2.recoverUnless = (isBlocked, fallback) => (data) => (0, Result2.isError)(data) && !isBlocked(data.error) ? fallback() : data;
   Result2.toMaybe = (data) => (0, Result2.isOk)(data) ? Maybe.some(data.value) : Maybe.none();
@@ -73,6 +86,7 @@ var Deferred;
 
 // src/Core/Task.ts
 var toPromise = (task, signal) => Deferred.toPromise(task(signal));
+var getMs = (ms) => typeof ms === "number" ? ms : Duration.toMilliseconds(ms);
 var Task;
 ((Task2) => {
   Task2.resolve = (value) => () => Deferred.fromPromise(Promise.resolve(value));
@@ -113,7 +127,7 @@ var Task;
       timerId = setTimeout(() => {
         signal?.removeEventListener("abort", onAbort);
         resolve2(toPromise(data, signal));
-      }, ms);
+      }, getMs(ms));
     })
   );
   Task2.repeat = (options) => (task) => (0, Task2.from)((signal) => {
@@ -136,7 +150,7 @@ var Task;
         timerId = setTimeout(() => {
           signal?.removeEventListener("abort", onAbort);
           r();
-        }, ms || 0);
+        }, getMs(ms || 0));
       });
     };
     const run2 = (left) => {
@@ -169,7 +183,7 @@ var Task;
         timerId = setTimeout(() => {
           signal?.removeEventListener("abort", onAbort);
           r();
-        }, ms || 0);
+        }, getMs(ms || 0));
       });
     };
     const run2 = (attempt, lastValue) => {
@@ -185,7 +199,39 @@ var Task;
     };
     return run2(1);
   });
-  Task2.race = (tasks) => (0, Task2.from)((signal) => Promise.race(tasks.map((t) => toPromise(t, signal))));
+  Task2.race = (tasks) => {
+    if (tasks.length === 0) {
+      return () => Deferred.fromPromise(new Promise(() => {
+      }));
+    }
+    return (0, Task2.from)((outerSignal) => {
+      const controllers = tasks.map(() => new AbortController());
+      const onOuterAbort = () => {
+        for (const ctrl of controllers) ctrl.abort();
+      };
+      if (outerSignal) {
+        if (outerSignal.aborted) {
+          onOuterAbort();
+        } else {
+          outerSignal.addEventListener("abort", onOuterAbort, { once: true });
+        }
+      }
+      const promises = tasks.map((task, idx) => {
+        const ctrl = controllers[idx];
+        return toPromise(task, ctrl.signal).then((result) => {
+          for (let i = 0; i < controllers.length; i++) {
+            if (i !== idx) {
+              controllers[i].abort();
+            }
+          }
+          outerSignal?.removeEventListener("abort", onOuterAbort);
+          return result;
+        });
+      });
+      return Promise.race(promises);
+    });
+  };
+  Task2.sequence = (tasks) => (0, Task2.from)((signal) => Promise.all(tasks.map((t) => toPromise(t, signal))));
   Task2.sequential = (tasks) => (0, Task2.from)(async (signal) => {
     const results = [];
     for (const task of tasks) {
@@ -226,7 +272,7 @@ var Task;
           controller.abort();
           cleanUp();
           resolve2(Result.error(onTimeout()));
-        }, ms);
+        }, getMs(ms));
       })
     ]);
   });

package/dist/chunk-VWVPHDZO.mjs

@@ -0,0 +1,29 @@
+// src/Types/Brand.ts
+var Brand;
+((Brand2) => {
+  Brand2.wrap = () => (value) => value;
+  Brand2.unwrap = (branded) => branded;
+})(Brand || (Brand = {}));
+
+// src/Types/Duration.ts
+var Duration;
+((Duration2) => {
+  const wrap = Brand.wrap();
+  Duration2.milliseconds = (ms) => wrap(ms);
+  Duration2.seconds = (s) => wrap(s * 1e3);
+  Duration2.minutes = (m) => wrap(m * 60 * 1e3);
+  Duration2.hours = (h) => wrap(h * 60 * 60 * 1e3);
+  Duration2.days = (d) => wrap(d * 24 * 60 * 60 * 1e3);
+  Duration2.toMilliseconds = (d) => Brand.unwrap(d);
+  Duration2.toSeconds = (d) => Brand.unwrap(d) / 1e3;
+  Duration2.toMinutes = (d) => Brand.unwrap(d) / (60 * 1e3);
+  Duration2.toHours = (d) => Brand.unwrap(d) / (60 * 60 * 1e3);
+  Duration2.toDays = (d) => Brand.unwrap(d) / (24 * 60 * 60 * 1e3);
+  Duration2.add = (other) => (self) => wrap(Brand.unwrap(self) + Brand.unwrap(other));
+  Duration2.subtract = (other) => (self) => wrap(Brand.unwrap(self) - Brand.unwrap(other));
+})(Duration || (Duration = {}));
+
+export {
+  Brand,
+  Duration
+};

package/dist/{chunk-EHQFUWZW.mjs → chunk-W53ZYTLX.mjs}

@@ -3,7 +3,7 @@ import {
   Maybe,
   Result,
   Task
-} from "./chunk-TK5ZCGP2.mjs";
+} from "./chunk-GSTKY7MF.mjs";
 import {
   isNonEmptyList
 } from "./chunk-DBIC62UV.mjs";
@@ -65,6 +65,40 @@ var Arr;
     }
     return [pass, fail];
   };
+  Arr2.compact = (data) => {
+    const result = [];
+    for (const item of data) {
+      if (item.kind === "Some") {
+        result.push(item.value);
+      }
+    }
+    return result;
+  };
+  Arr2.separate = (data) => {
+    const errors = [];
+    const successes = [];
+    for (const item of data) {
+      if (item.kind === "Ok") {
+        successes.push(item.value);
+      } else {
+        errors.push(item.error);
+      }
+    }
+    return [errors, successes];
+  };
+  Arr2.partitionMap = (f) => (data) => {
+    const errors = [];
+    const successes = [];
+    for (const item of data) {
+      const mapped = f(item);
+      if (mapped.kind === "Ok") {
+        successes.push(mapped.value);
+      } else {
+        errors.push(mapped.error);
+      }
+    }
+    return [errors, successes];
+  };
   Arr2.groupBy = (f) => (data) => {
     const result = {};
     for (const a of data) {
@@ -596,6 +630,13 @@ var Str;
       return isNaN(n) ? Maybe.none() : Maybe.some(n);
     }
   };
+  Str2.parseJson = (s) => {
+    try {
+      return Result.ok(JSON.parse(s));
+    } catch (e) {
+      return Result.error(e);
+    }
+  };
 })(Str || (Str = {}));
 
 // src/Utils/Uniq.ts

package/dist/core.d.mts

@@ -1,6 +1,6 @@
-import { M as Maybe, W as WithValue, c as WithLog, D as Deferred, R as Result, d as WithKind, e as WithError, f as RetryOptions, g as TimeoutOptions, h as WithTimeout, i as WithMinInterval, j as WithCooldown, k as WithConcurrency, l as WithSize, m as WithMs, n as WithN, T as Task, o as WithErrors, p as WithFirst, q as WithSecond } from './Task-CJZfcOkO.mjs';
-export { E as Equality, a as Error, N as None, O as Ok, b as Ordering, S as Some } from './Task-CJZfcOkO.mjs';
-import { N as NonEmptyList } from './NonEmptyList-BlGFjor5.mjs';
+import { M as Maybe, W as WithValue, c as WithLog, D as Deferred, R as Result, d as WithKind, e as WithError, f as RetryOptions, g as TimeoutOptions, h as WithTimeout, i as WithMinInterval, j as WithCooldown, k as WithConcurrency, l as WithSize, m as WithMs, n as WithN, T as Task, o as WithErrors, p as WithFirst, q as WithSecond } from './Task-5na0QzS4.mjs';
+export { E as Equality, a as Error, N as None, O as Ok, b as Ordering, S as Some } from './Task-5na0QzS4.mjs';
+import { NonEmptyList } from './types.mjs';
 
 /**
  * A type that can combine two values of type `A` into one, with a neutral starting value.
@@ -1984,6 +1984,25 @@ declare namespace TaskResult {
      * Creates a failed TaskResult with the given error.
      */
     const err: <E, A>(error: E) => TaskResult<E, A>;
+    /**
+     * Creates a TaskResult from a nullable value.
+     * Returns Ok if the value is not null or undefined, error from onNull otherwise.
+     */
+    const fromNullable: <E>(onNull: () => E) => <A>(value: A | null | undefined) => TaskResult<E, A>;
+    /**
+     * Creates a TaskResult from a Maybe.
+     * Some becomes Ok, None becomes error from onNone.
+     */
+    const fromMaybe: <E>(onNone: () => E) => <A>(maybe: Maybe<A>) => TaskResult<E, A>;
+    /**
+     * Lifts a Result into a TaskResult.
+     */
+    const fromResult: <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 TaskResult.
+     */
+    const fromThrowable: <Args extends readonly unknown[], A, E>(f: (...args: Args) => Promise<A>, onError: (e: unknown) => E) => (...args: Args) => TaskResult<E, A>;
     /**
      * Creates a TaskResult from a function that may throw.
      * Catches any errors and transforms them using the onError function.
@@ -2392,6 +2411,16 @@ declare namespace TaskMaybe {
      * Lifts an Option into a TaskMaybe.
      */
     const fromMaybe: <A>(option: Maybe<A>) => TaskMaybe<A>;
+    /**
+     * Creates a TaskMaybe from a nullable value.
+     * Returns Some if the value is not null or undefined, None otherwise.
+     */
+    const fromNullable: <A>(value: A | null | undefined) => TaskMaybe<A>;
+    /**
+     * Creates a TaskMaybe from a Result.
+     * Ok becomes Some, Error becomes None (the error value is discarded).
+     */
+    const fromResult: <E, A>(result: Result<E, A>) => TaskMaybe<A>;
     /**
      * Lifts a Task into a TaskMaybe by wrapping its result in Some.
      */
@@ -2561,6 +2590,30 @@ declare namespace Validation {
      * ```
      */
     const fromPredicate: <E, A>(pred: (a: A) => boolean, onFalse: (a: A) => E) => (a: A) => Validation<E, A>;
+    /**
+     * Creates a Validation from a nullable value.
+     * If the value is null or undefined, returns Invalid with the error from onNull.
+     * Otherwise, returns Valid.
+     *
+     * @example
+     * ```ts
+     * pipe(null, Validation.fromNullable(() => "is null")); // Invalid(["is null"])
+     * pipe(42, Validation.fromNullable(() => "is null"));   // Valid(42)
+     * ```
+     */
+    const fromNullable: <E>(onNull: () => E) => <A>(value: A | null | undefined) => Validation<E, A>;
+    /**
+     * Creates a Validation from a Maybe.
+     * If the Maybe is None, returns Invalid with the error from onNone.
+     * Otherwise, returns Valid.
+     *
+     * @example
+     * ```ts
+     * pipe(Maybe.none(), Validation.fromMaybe(() => "is none")); // Invalid(["is none"])
+     * pipe(Maybe.some(42), Validation.fromMaybe(() => "is none")); // Valid(42)
+     * ```
+     */
+    const fromMaybe: <E>(onNone: () => E) => <A>(maybe: Maybe<A>) => Validation<E, A>;
     /**
      * Transforms the success value inside a Validation.
      *
@@ -2794,6 +2847,22 @@ declare namespace TaskValidation {
      * Lifts a Validation into a TaskValidation.
      */
     const fromValidation: <E, A>(validation: Validation<E, A>) => TaskValidation<E, A>;
+    /**
+     * Creates a TaskValidation from a nullable value.
+     * If the value is null or undefined, returns Invalid with the error from onNull.
+     * Otherwise, returns Valid.
+     */
+    const fromNullable: <E>(onNull: () => E) => <A>(value: A | null | undefined) => TaskValidation<E, A>;
+    /**
+     * Creates a TaskValidation from a Maybe.
+     * Some becomes Valid, None becomes Invalid with the error from onNone.
+     */
+    const fromMaybe: <E>(onNone: () => E) => <A>(maybe: Maybe<A>) => TaskValidation<E, A>;
+    /**
+     * Creates a TaskValidation from a Result.
+     * Ok becomes Valid, Error(e) becomes Invalid([e]).
+     */
+    const fromResult: <E, A>(result: Result<E, A>) => TaskValidation<E, A>;
     /**
      * Creates a TaskValidation from a Promise-returning function.
      * Catches any errors and transforms them using the onError function.