@nlozgachev/pipelined 0.64.0 → 0.65.0

package/dist/Task-C_goFYQ1.d.cts

@@ -1,1748 +0,0 @@
-import { h as WithKind, o as WithValue, e as WithError, a as NonEmptyArr, f as WithErrors, D as Deferred, T as Thenable } from './InternalTypes-GFn4RTwD.cjs';
-import { D as Duration } from './Duration-DeyxG6VQ.cjs';
-import { RetryPolicy } from './types.cjs';
-
-/**
- * A function that checks whether two values of type `A` are equal.
- * Use built-in instances (`Equality.string`, `Equality.number`, etc.) as starting points,
- * then adapt them with `Equality.by` and combine them with `Equality.and`.
- *
- * @example
- * ```ts
- * type User = { id: string; name: string };
- * const byId = pipe(Equality.string, Equality.by((u: User) => u.id));
- *
- * pipe(users, Arr.uniqWith(byId));
- * ```
- */
-type Equality<A> = (a: A, b: A) => boolean;
-declare const Equality: {
-    /**
-     * Equality for strings. Case-sensitive.
-     *
-     * @example
-     * ```ts
-     * Equality.string("hello", "hello"); // true
-     * Equality.string("hello", "Hello"); // false
-     * ```
-     */
-    string: Equality<string>;
-    /**
-     * Equality for numbers. Uses strict equality.
-     *
-     * @example
-     * ```ts
-     * Equality.number(42, 42); // true
-     * ```
-     */
-    number: Equality<number>;
-    /**
-     * Equality for booleans.
-     *
-     * @example
-     * ```ts
-     * Equality.boolean(true, true); // true
-     * ```
-     */
-    boolean: Equality<boolean>;
-    /**
-     * Equality for `Date` values. Compares by numeric time value.
-     *
-     * @example
-     * ```ts
-     * Equality.date(new Date("2024-01-01"), new Date("2024-01-01")); // true
-     * ```
-     */
-    date: Equality<Date>;
-    /**
-     * Lifts an element equality into an array equality. Two arrays are equal if they have the
-     * same length and every element pair is equal under `eq`.
-     *
-     * @example
-     * ```ts
-     * Equality.array(Equality.number)([1, 2, 3], [1, 2, 3]); // true
-     * ```
-     */
-    array: <A>(eq: Equality<A>) => Equality<readonly A[]>;
-    /**
-     * Adapts an equality for type `A` into an equality for type `B` by extracting a field.
-     * Read as "equality by this field": `pipe(Equality.string, Equality.by(u => u.name))`.
-     *
-     * @example
-     * ```ts
-     * type Product = { id: string; price: number };
-     * const byId = pipe(Equality.string, Equality.by((p: Product) => p.id));
-     * byId({ id: "p1", price: 9 }, { id: "p1", price: 12 }); // true
-     * ```
-     */
-    by: <A, B>(f: (b: B) => A) => (eq: Equality<A>) => Equality<B>;
-    /**
-     * Combines two equalities with logical AND. Both must pass for two values to be considered equal.
-     * Data-last: the first equality is the data being piped.
-     *
-     * @example
-     * ```ts
-     * const exact = pipe(byName, Equality.and(byRole));
-     * exact(userA, userB); // true only if name AND role match
-     * ```
-     */
-    and: <A>(eq2: Equality<A>) => (eq1: Equality<A>) => Equality<A>;
-    /**
-     * Derives deep equality for a record from field-level `Equality` checkers.
-     *
-     * @example
-     * ```ts
-     * const userEq = Equality.struct({
-     *   id: Equality.string,
-     *   age: Equality.number,
-     * });
-     * ```
-     */
-    struct: <R extends Record<string, unknown>>(fields: { [K in keyof R]: Equality<R[K]>; }) => Equality<R>;
-    /**
-     * Derives element-wise equality for a tuple from positional `Equality` checkers.
-     *
-     * @example
-     * ```ts
-     * const pairEq = Equality.tuple(Equality.string, Equality.number);
-     * pairEq(["a", 1], ["a", 1]); // true
-     * ```
-     */
-    tuple: <T extends readonly unknown[]>(...equalities: { [K in keyof T]: Equality<T[K]>; }) => Equality<T>;
-};
-
-type Some<A> = WithKind<"Some"> & WithValue<A>;
-type None = WithKind<"None">;
-/**
- * Maybe represents an optional value: every Maybe is either Some (contains a value) or None (empty).
- * Use Maybe instead of null/undefined to make optionality explicit and composable.
- *
- * @example
- * ```ts
- * const user = { name: "Alice", email: Maybe.make.some("alice@example.com") };
- *
- * pipe(
- *   user.email,
- *   Maybe.map(email => email.toUpperCase()),
- *   Maybe.getOrElse(() => "NO EMAIL")
- * ); // "ALICE@EXAMPLE.COM"
- * ```
- */
-type Maybe<T> = Some<T> | None;
-declare const Maybe: {
-    make: {
-        /**
-         * Creates a Some containing the given value.
-         *
-         * @example
-         * ```ts
-         * Maybe.make.some(42); // Some(42)
-         * ```
-         */
-        some: <A>(value: A) => Some<A>;
-        /**
-         * Creates a None (empty Maybe).
-         *
-         * @example
-         * ```ts
-         * Maybe.make.none(); // None
-         * ```
-         */
-        none: () => None;
-    };
-    is: {
-        /**
-         * Type guard that checks if a Maybe is Some.
-         *
-         * @example
-         * ```ts
-         * const value = Maybe.make.some(42);
-         * if (Maybe.is.some(value)) {
-         *   console.log(value.value); // 42
-         * }
-         * ```
-         */
-        some: <A>(data: Maybe<A>) => data is Some<A>;
-        /**
-         * Type guard that checks if a Maybe is None.
-         *
-         * @example
-         * ```ts
-         * const value = Maybe.make.none();
-         * if (Maybe.is.none(value)) {
-         *   console.log("No value present");
-         * }
-         * ```
-         */
-        none: <A>(data: Maybe<A>) => data is None;
-    };
-    to: {
-        /**
-         * Extracts the value from a Maybe, returning null if None.
-         *
-         * @example
-         * ```ts
-         * Maybe.to.nullable(Maybe.make.some(42)); // 42
-         * Maybe.to.nullable(Maybe.make.none());   // null
-         * ```
-         */
-        nullable: <A>(data: Maybe<A>) => A | null;
-        /**
-         * Extracts the value from a Maybe, returning undefined if None.
-         *
-         * @example
-         * ```ts
-         * Maybe.to.undefined(Maybe.make.some(42)); // 42
-         * Maybe.to.undefined(Maybe.make.none());   // undefined
-         * ```
-         */
-        undefined: <A>(data: Maybe<A>) => A | undefined;
-        /**
-         * Converts a Maybe to a Result.
-         * Some becomes Ok, None becomes Err with the provided error.
-         *
-         * @example
-         * ```ts
-         * pipe(
-         *   Maybe.make.some(42),
-         *   Maybe.to.Result(() => "Value was missing")
-         * ); // Ok(42)
-         *
-         * pipe(
-         *   Maybe.make.none(),
-         *   Maybe.to.Result(() => "Value was missing")
-         * ); // Err("Value was missing")
-         * ```
-         */
-        Result: <E>(onNone: () => E) => <A>(data: Maybe<A>) => Result<E, A>;
-    };
-    from: {
-        /**
-         * Creates a Maybe from a nullable value.
-         * Returns None if the value is null or undefined, Some otherwise.
-         *
-         * @example
-         * ```ts
-         * Maybe.from.nullable(null); // None
-         * Maybe.from.nullable(42); // Some(42)
-         * ```
-         */
-        nullable: <A>(value: A | null | undefined) => Maybe<A>;
-        /**
-         * Creates a Maybe from a predicate applied to a value.
-         * Returns Some if the predicate passes, None otherwise.
-         *
-         * @example
-         * ```ts
-         * Maybe.from.Predicate((n: number) => n >= 18)(21); // Some(21)
-         * Maybe.from.Predicate((n: number) => n >= 18)(15); // None
-         *
-         * pipe("hello", Maybe.from.Predicate((s: string) => s.length > 0)); // Some("hello")
-         * pipe("", Maybe.from.Predicate((s: string) => s.length > 0));      // None
-         * ```
-         */
-        Predicate: <A>(pred: (a: A) => boolean) => (a: A) => Maybe<A>;
-        /**
-         * Creates a Maybe from a Result.
-         * Ok becomes Some, Err becomes None (the error is discarded).
-         *
-         * @example
-         * ```ts
-         * Maybe.from.Result(Result.make.ok(42)); // Some(42)
-         * Maybe.from.Result(Result.make.err("oops")); // None
-         * ```
-         */
-        Result: <E, A>(data: Result<E, A>) => Maybe<A>;
-    };
-    /**
-     * Transforms the value inside a Maybe if it exists.
-     *
-     * @example
-     * ```ts
-     * pipe(Maybe.make.some(5), Maybe.map(n => n * 2)); // Some(10)
-     * pipe(Maybe.make.none(), Maybe.map(n => n * 2)); // None
-     * ```
-     */
-    map: <A, B>(f: (a: A) => B) => (data: Maybe<A>) => Maybe<B>;
-    /**
-     * Chains Maybe computations. If the first is Some, passes the value to f.
-     * If the first is None, propagates None.
-     *
-     * @example
-     * ```ts
-     * const parseNumber = (s: string): Maybe<number> => {
-     *   const n = parseInt(s, 10);
-     *   return isNaN(n) ? Maybe.make.none() : Maybe.make.some(n);
-     * };
-     *
-     * pipe(Maybe.make.some("42"), Maybe.chain(parseNumber)); // Some(42)
-     * pipe(Maybe.make.some("abc"), Maybe.chain(parseNumber)); // None
-     * ```
-     */
-    chain: <A, B>(f: (a: A) => Maybe<B>) => (data: Maybe<A>) => Maybe<B>;
-    /**
-     * Extracts the value from a Maybe by providing handlers for both cases.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   Maybe.make.some(5),
-     *   Maybe.fold(
-     *     () => "No value",
-     *     n => `Value: ${n}`
-     *   )
-     * ); // "Value: 5"
-     * ```
-     */
-    fold: <A, B>(onNone: () => B, onSome: (a: A) => B) => (data: Maybe<A>) => B;
-    /**
-     * Pattern matches on a Maybe, returning the result of the matching case.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   optionUser,
-     *   Maybe.match({
-     *     some: user => `Hello, ${user.name}`,
-     *     none: () => "Hello, stranger"
-     *   })
-     * );
-     * ```
-     */
-    match: <A, B>(cases: {
-        none: () => B;
-        some: (a: A) => B;
-    }) => (data: Maybe<A>) => B;
-    /**
-     * Returns the value inside a Maybe, or a default value if None.
-     * The default is a thunk `() => B` — evaluated only when the Maybe is None.
-     * The default can be a different type, widening the result to `A | B`.
-     *
-     * @example
-     * ```ts
-     * pipe(Maybe.make.some(5), Maybe.getOrElse(() => 0)); // 5
-     * pipe(Maybe.make.none(), Maybe.getOrElse(() => 0)); // 0
-     * pipe(Maybe.make.none<string>(), Maybe.getOrElse(() => null)); // null — typed as string | null
-     * ```
-     */
-    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.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   Maybe.make.some(5),
-     *   Maybe.tap(n => console.log("Value:", n)),
-     *   Maybe.map(n => n * 2)
-     * );
-     * ```
-     */
-    tap: <A>(f: (a: A) => void) => (data: Maybe<A>) => Maybe<A>;
-    /**
-     * Filters a Maybe based on a predicate.
-     * Returns None if the predicate returns false or if the Maybe is already None.
-     *
-     * @example
-     * ```ts
-     * pipe(Maybe.make.some(5), Maybe.filter(n => n > 3)); // Some(5)
-     * pipe(Maybe.make.some(2), Maybe.filter(n => n > 3)); // None
-     * ```
-     */
-    filter: <A>(predicate: (a: A) => boolean) => (data: Maybe<A>) => Maybe<A>;
-    /**
-     * Recovers from a None by providing a fallback Maybe.
-     * The fallback can produce a different type, widening the result to `Maybe<A | B>`.
-     *
-     * @example
-     * ```ts
-     * pipe(Maybe.make.none(), Maybe.recover(() => Maybe.make.some(42))); // Some(42)
-     * pipe(Maybe.make.some(10), Maybe.recover(() => Maybe.make.some(42))); // Some(10)
-     * ```
-     */
-    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.
-     *
-     * @example
-     * ```ts
-     * const add = (a: number) => (b: number) => a + b;
-     * pipe(
-     *   Maybe.make.some(add),
-     *   Maybe.ap(Maybe.make.some(5)),
-     *   Maybe.ap(Maybe.make.some(3))
-     * ); // Some(8)
-     * ```
-     */
-    ap: <A>(arg: Maybe<A>) => <B>(data: Maybe<(a: A) => B>) => Maybe<B>;
-    /**
-     * Converts a Maybe value into an object containing a single property.
-     * Initiates the pipeline accumulator record.
-     *
-     * @example
-     * ```ts
-     * pipe(Maybe.make.some(42), Maybe.bindTo("value")); // Some({ value: 42 })
-     * ```
-     */
-    bindTo: <K extends string>(key: K) => <A>(data: Maybe<A>) => Maybe<{ [P in K]: A; }>;
-    /**
-     * Evaluates a new Maybe using the current accumulator and attaches the output to a new key.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   Maybe.make.some({ a: 1 }),
-     *   Maybe.bind("b", ({ a }) => Maybe.make.some(a + 1))
-     * ); // Some({ a: 1, b: 2 })
-     * ```
-     */
-    bind: <K extends string, A, B>(key: K, f: (a: A) => Maybe<B>) => (data: Maybe<A>) => Maybe<A & { [P in K]: B; }>;
-    /**
-     * Combines a record of Maybes into a single Maybe of a record.
-     * Evaluates fields in key order and short-circuits on the first None.
-     *
-     * @example
-     * ```ts
-     * Maybe.struct({
-     *   name: Maybe.make.some("Alice"),
-     *   age: Maybe.make.some(30)
-     * }); // Some({ name: "Alice", age: 30 })
-     * ```
-     */
-    struct: <R extends Record<string, any>>(fields: { [K in keyof R]: Maybe<R[K]>; }) => Maybe<R>;
-    /**
-     * Swaps the outer `Maybe` and inner `Result` context.
-     * `Some(Ok(a))` becomes `Ok(Some(a))`, `Some(Err(e))` becomes `Err(e)`, and `None` becomes `Ok(None)`.
-     *
-     * @example
-     * ```ts
-     * Maybe.transposeResult(Maybe.make.some(Result.make.ok(42)));  // Ok(Some(42))
-     * Maybe.transposeResult(Maybe.make.some(Result.make.err("e"))); // Err("e")
-     * Maybe.transposeResult(Maybe.make.none());                     // Ok(None)
-     * ```
-     */
-    transposeResult: <E, A>(data: Maybe<Result<E, A>>) => Result<E, Maybe<A>>;
-};
-
-/**
- * A function that orders two values of type `A`. Returns a negative number when `a` comes before
- * `b`, a positive number when `a` comes after `b`, and `0` when they are equal.
- *
- * Compatible with `Array.prototype.sort` and `Arr.sortWith`.
- *
- * @example
- * ```ts
- * type Employee = { name: string; salary: number };
- *
- * const byName   = pipe(Ordering.string, Ordering.by((e: Employee) => e.name));
- * const bySalary = pipe(Ordering.number, Ordering.by((e: Employee) => e.salary));
- *
- * pipe(employees, Arr.sortWith(pipe(byName, Ordering.thenBy(bySalary))));
- * ```
- */
-type Ordering<A> = (a: A, b: A) => number;
-declare const Ordering: {
-    /**
-     * Alphabetical ordering for strings.
-     *
-     * @example
-     * ```ts
-     * Ordering.string("apple", "banana"); // negative
-     * ```
-     */
-    string: Ordering<string>;
-    /**
-     * Numeric ordering. Equivalent to `(a, b) => a - b`.
-     *
-     * @example
-     * ```ts
-     * pipe([3, 1, 2], Arr.sortWith(Ordering.number)); // [1, 2, 3]
-     * ```
-     */
-    number: Ordering<number>;
-    /**
-     * Ordering for `Date` values by numeric time value.
-     *
-     * @example
-     * ```ts
-     * pipe(dates, Arr.sortWith(Ordering.date)); // earliest first
-     * ```
-     */
-    date: Ordering<Date>;
-    /**
-     * Flips the direction of an ordering.
-     *
-     * @example
-     * ```ts
-     * pipe([3, 1, 2], Arr.sortWith(Ordering.reverse(Ordering.number))); // [3, 2, 1]
-     * ```
-     */
-    reverse: <A>(ord: Ordering<A>) => Ordering<A>;
-    /**
-     * Chains two orderings: the second is used only when the first returns `0`.
-     * Data-last: the first ordering is the data being piped.
-     *
-     * @example
-     * ```ts
-     * const byDeptThenSalary = pipe(byDept, Ordering.thenBy(bySalary));
-     * ```
-     */
-    thenBy: <A>(ord2: Ordering<A>) => (ord1: Ordering<A>) => Ordering<A>;
-    /**
-     * Adapts an ordering for type `A` into an ordering for type `B` by extracting a field.
-     * Read as "ordering by this field": `pipe(Ordering.number, Ordering.by(p => p.price))`.
-     *
-     * @example
-     * ```ts
-     * type Product = { name: string; price: number };
-     * const byPrice = pipe(Ordering.number, Ordering.by((p: Product) => p.price));
-     * pipe(products, Arr.sortWith(byPrice));
-     * ```
-     */
-    by: <A, B>(f: (b: B) => A) => (ord: Ordering<A>) => Ordering<B>;
-    /**
-     * Combines a list of orderings into a single composite comparator.
-     * Evaluates each ordering in sequence until a non-zero comparison result is found.
-     *
-     * @example
-     * ```ts
-     * const byName = pipe(Ordering.string, Ordering.by((u: User) => u.name));
-     * const byAge  = pipe(Ordering.number, Ordering.by((u: User) => u.age));
-     * const sortUsers = Ordering.byFields([byName, byAge]);
-     * ```
-     */
-    byFields: <A>(orderings: ReadonlyArray<Ordering<A>>) => Ordering<A>;
-    /**
-     * Derives a lexicographical tuple ordering from positional `Ordering` comparators.
-     *
-     * @example
-     * ```ts
-     * const pairOrd = Ordering.tuple(Ordering.string, Ordering.number);
-     * pairOrd(["a", 1], ["a", 2]); // negative
-     * ```
-     */
-    tuple: <T extends readonly unknown[]>(...orderings: { [K in keyof T]: Ordering<T[K]>; }) => Ordering<T>;
-};
-
-type Ok<A> = WithKind<"Ok"> & WithValue<A>;
-type Err<E> = WithKind<"Err"> & WithError<E>;
-/**
- * Result represents a value that can be one of two types: a success (Ok) or a failure (Err).
- * Use Result when an operation can fail with a meaningful error value.
- *
- * @example
- * ```ts
- * const divide = (a: number, b: number): Result<string, number> =>
- *   b === 0 ? Result.make.err("Division by zero") : Result.make.ok(a / b);
- *
- * pipe(
- *   divide(10, 2),
- *   Result.map(n => n * 2),
- *   Result.getOrElse(() => 0)
- * ); // 10
- * ```
- */
-type Result<E, A> = Ok<A> | Err<E>;
-declare const Result: {
-    make: {
-        /**
-         * Creates a successful Result with the given value.
-         *
-         * @example
-         * ```ts
-         * Result.make.ok(42); // Ok(42)
-         * ```
-         */
-        ok: <A>(value: A) => Ok<A>;
-        /**
-         * Creates a failed Result with the given error.
-         *
-         * @example
-         * ```ts
-         * Result.make.err("Error message"); // Err("Error message")
-         * ```
-         */
-        err: <E>(e: E) => Err<E>;
-    };
-    is: {
-        /**
-         * Type guard that checks if a Result is Ok.
-         *
-         * @example
-         * ```ts
-         * const res = Result.make.ok(42);
-         * if (Result.is.ok(res)) {
-         *   console.log(res.value); // 42
-         * }
-         * ```
-         */
-        ok: <E, A>(data: Result<E, A>) => data is Ok<A>;
-        /**
-         * Type guard that checks if a Result is Err.
-         *
-         * @example
-         * ```ts
-         * const res = Result.make.err("failed");
-         * if (Result.is.err(res)) {
-         *   console.log(res.error); // "failed"
-         * }
-         * ```
-         */
-        err: <E, A>(data: Result<E, A>) => data is Err<E>;
-    };
-    /**
-     * Creates a Result from a synchronous thunk that may throw.
-     * Catches any errors and transforms them using the `onError` function.
-     *
-     * @example
-     * ```ts
-     * const result = Result.tryCatch(
-     *   () => JSON.parse(rawString),
-     *   { onError: (e) => `Parse error: ${e}` }
-     * );
-     * ```
-     */
-    tryCatch: <E, A>(f: () => A, options: {
-        onError: (e: unknown) => E;
-    }) => Result<E, A>;
-    /**
-     * Transforms the success value inside a Result.
-     *
-     * @example
-     * ```ts
-     * pipe(Result.make.ok(5), Result.map(n => n * 2)); // Ok(10)
-     * pipe(Result.make.err("error"), Result.map(n => n * 2)); // Err("error")
-     * ```
-     */
-    map: <E, A, B>(f: (a: A) => B) => (data: Result<E, A>) => Result<E, B>;
-    /**
-     * Transforms the error value inside a Result.
-     *
-     * @example
-     * ```ts
-     * pipe(Result.make.err("oops"), Result.mapError(e => e.toUpperCase())); // Err("OOPS")
-     * ```
-     */
-    mapError: <E, F, A>(f: (e: E) => F) => (data: Result<E, A>) => Result<F, A>;
-    /**
-     * Chains Result computations. If the first is Ok, passes the value to f.
-     * If the first is Err, propagates the error.
-     *
-     * @example
-     * ```ts
-     * const validatePositive = (n: number): Result<string, number> =>
-     *   n > 0 ? Result.make.ok(n) : Result.make.err("Must be positive");
-     *
-     * pipe(Result.make.ok(5), Result.chain(validatePositive)); // Ok(5)
-     * pipe(Result.make.ok(-1), Result.chain(validatePositive)); // Err("Must be positive")
-     * ```
-     */
-    chain: <E2, A, B>(f: (a: A) => Result<E2, B>) => <E1 = never>(data: Result<E1, A>) => Result<E1 | E2, B>;
-    /**
-     * Extracts the value from a Result by providing handlers for both cases.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   Result.make.ok(5),
-     *   Result.fold(
-     *     e => `Error: ${e}`,
-     *     n => `Value: ${n}`
-     *   )
-     * ); // "Value: 5"
-     * ```
-     */
-    fold: <E, A, B>(onErr: (e: E) => B, onOk: (a: A) => B) => (data: Result<E, A>) => B;
-    /**
-     * Pattern matches on a Result, returning the result of the matching case.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   result,
-     *   Result.match({
-     *     ok: value => `Got ${value}`,
-     *     err: error => `Failed: ${error}`
-     *   })
-     * );
-     * ```
-     */
-    match: <E, A, B>(cases: {
-        ok: (a: A) => B;
-        err: (e: E) => B;
-    }) => (data: Result<E, A>) => B;
-    /**
-     * Returns the success value or a default value if the Result is an error.
-     * The default is a thunk `() => B` — evaluated only when the Result is Err.
-     * The default can be a different type, widening the result to `A | B`.
-     *
-     * @example
-     * ```ts
-     * pipe(Result.make.ok(5), Result.getOrElse(() => 0)); // 5
-     * pipe(Result.make.err("error"), Result.getOrElse(() => 0)); // 0
-     * pipe(Result.make.err("error"), Result.getOrElse(() => null)); // null — typed as number | null
-     * ```
-     */
-    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.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   Result.make.ok(5),
-     *   Result.tap(n => console.log("Value:", n)),
-     *   Result.map(n => n * 2)
-     * );
-     * ```
-     */
-    tap: <E, A>(f: (a: A) => void) => (data: Result<E, A>) => Result<E, A>;
-    /**
-     * Executes a side effect on the error value without changing the Result.
-     * Useful for logging or reporting errors.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   Result.make.err("not found"),
-     *   Result.tapError(e => console.error("validation failed:", e)),
-     *   Result.chain(save),
-     * )
-     * ```
-     */
-    tapError: <E, A>(f: (e: E) => void) => (data: Result<E, A>) => Result<E, A>;
-    from: {
-        /**
-         * Creates a Result from a predicate applied to a value.
-         * Returns Ok if the predicate passes, Err from onFalse otherwise.
-         *
-         * @example
-         * ```ts
-         * pipe(5, Result.from.Predicate(n => n > 0, n => `${n} is not positive`));  // Ok(5)
-         * pipe(-1, Result.from.Predicate(n => n > 0, n => `${n} is not positive`)); // Err("-1 is not positive")
-         * pipe("", Result.from.Predicate(s => s.length > 0, () => "empty string")); // Err("empty string")
-         * ```
-         */
-        Predicate: <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.from.nullable(() => "is null")); // Err("is null")
-         * pipe(42, Result.from.nullable(() => "is null"));   // Ok(42)
-         * ```
-         */
-        nullable: <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.make.none(), Result.from.Maybe(() => "is none")); // Err("is none")
-         * pipe(Maybe.make.some(42), Result.from.Maybe(() => "is none")); // Ok(42)
-         * ```
-         */
-        Maybe: <E>(onNone: () => E) => <A>(maybe: Maybe<A>) => 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))`.
-         *
-         * @example
-         * ```ts
-         * Result.from.Validation((errors) => errors.join(", "))(Validation.make.failed("error1")); // Err("error1")
-         * ```
-         */
-        Validation: <E1, E2, A>(combineErrors: (errors: NonEmptyArr<E1>) => E2) => (val: Validation<E1, A>) => Result<E2, 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>`.
-     */
-    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>`.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   Result.make.err(new Error("not found")),
-     *   Result.recoverUnless(e => e.message === "fatal", () => Result.make.ok(0))
-     * ); // Ok(0)
-     * ```
-     */
-    recoverUnless: <E, B>(isBlocked: (e: E) => boolean, fallback: () => Result<E, B>) => <A>(data: Result<E, A>) => Result<E, A | B>;
-    to: {
-        /**
-         * Converts a Result to a Maybe.
-         * Ok becomes Some, Err becomes None (the error is discarded).
-         *
-         * @example
-         * ```ts
-         * Result.to.Maybe(Result.make.ok(42)); // Some(42)
-         * Result.to.Maybe(Result.make.err("oops")); // None
-         * ```
-         */
-        Maybe: <E, A>(data: Result<E, A>) => Maybe<A>;
-        /**
-         * Converts a `Result` to a `Validation`. `Ok(a)` becomes `Passed(a)`; `Err(e)` becomes `Failed([e])`.
-         *
-         * @example
-         * ```ts
-         * Result.to.Validation(Result.make.ok(42));     // Passed(42)
-         * Result.to.Validation(Result.make.err("bad")); // Failed(["bad"])
-         * ```
-         */
-        Validation: <E, A>(data: Result<E, A>) => Validation<E, A>;
-    };
-    /**
-     * Swaps the outer `Result` and inner `Maybe` context.
-     * `Ok(Some(a))` becomes `Some(Ok(a))`, `Ok(None)` becomes `None`, and `Err(e)` becomes `Some(Err(e))`.
-     *
-     * @example
-     * ```ts
-     * Result.transposeMaybe(Result.make.ok(Maybe.make.some(42))); // Some(Ok(42))
-     * Result.transposeMaybe(Result.make.ok(Maybe.make.none()));   // None
-     * Result.transposeMaybe(Result.make.err("error"));           // Some(Err("error"))
-     * ```
-     */
-    transposeMaybe: <E, A>(data: Result<E, Maybe<A>>) => Maybe<Result<E, A>>;
-    /**
-     * Applies a function wrapped in a Result to a value wrapped in a Result.
-     *
-     * @example
-     * ```ts
-     * const add = (a: number) => (b: number) => a + b;
-     * pipe(
-     *   Result.make.ok(add),
-     *   Result.ap(Result.make.ok(5)),
-     *   Result.ap(Result.make.ok(3))
-     * ); // Ok(8)
-     * ```
-     */
-    ap: <E, A>(arg: Result<E, A>) => <B>(data: Result<E, (a: A) => B>) => Result<E, B>;
-    /**
-     * Converts a Result value into an object containing a single property.
-     * Initiates the pipeline accumulator record.
-     *
-     * @example
-     * ```ts
-     * pipe(Result.make.ok(42), Result.bindTo("value")); // Ok({ value: 42 })
-     * ```
-     */
-    bindTo: <K extends string>(key: K) => <E, A>(data: Result<E, A>) => Result<E, { [P in K]: A; }>;
-    /**
-     * Evaluates a new Result using the current accumulator and attaches the output to a new key.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   Result.make.ok({ a: 1 }),
-     *   Result.bind("b", ({ a }) => Result.make.ok(a + 1))
-     * ); // Ok({ a: 1, b: 2 })
-     * ```
-     */
-    bind: <K extends string, E, A, B>(key: K, f: (a: A) => Result<E, B>) => (data: Result<E, A>) => Result<E, A & { [P in K]: B; }>;
-    /**
-     * Combines a record of Results into a single Result of a record.
-     * Evaluates fields in key order and short-circuits on the first failure.
-     *
-     * @example
-     * ```ts
-     * Result.struct({
-     *   name: Result.make.ok("Alice"),
-     *   age: Result.make.ok(30)
-     * }); // Ok({ name: "Alice", age: 30 })
-     * ```
-     */
-    struct: <E, R extends Record<string, any>>(fields: { [K in keyof R]: Result<E, R[K]>; }) => Result<E, R>;
-    /**
-     * Narrows an `Ok` value with a predicate, converting to `Err(onFail(a))` if the predicate returns false.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   Result.make.ok(15),
-     *   Result.ensure((n) => n >= 18, (n) => `Age ${n} is below 18`)
-     * ); // Err("Age 15 is below 18")
-     * ```
-     */
-    ensure: <A, E2>(predicate: (a: A) => boolean, onFail: (a: A) => E2) => <E1 = never>(data: Result<E1, A>) => Result<E1 | E2, A>;
-    /**
-     * Transforms both branches of a Result simultaneously.
-     * Applies `onErr` to `Err` values and `onOk` to `Ok` values.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   Result.make.ok(5),
-     *   Result.bimap(
-     *     (e) => `Error: ${e}`,
-     *     (n) => n * 2
-     *   )
-     * ); // Ok(10)
-     * ```
-     */
-    bimap: <E1, E2, A, B>(onErr: (e: E1) => E2, onOk: (a: A) => B) => (data: Result<E1, A>) => Result<E2, B>;
-};
-
-type Passed<A> = WithKind<"Passed"> & WithValue<A>;
-type Failed<E> = WithKind<"Failed"> & WithErrors<E>;
-declare function toResult<E1, E2, A>(combineErrors: (errors: NonEmptyArr<E1>) => E2): (val: Validation<E1, A>) => Result<E2, A>;
-declare function toResult<E, A>(data: Validation<E, A>): Result<NonEmptyArr<E>, A>;
-/**
- * Validation represents a value that is either passed with a success value,
- * or failed with accumulated errors.
- * Unlike Result, Validation can accumulate multiple errors instead of short-circuiting.
- *
- * Use Validation when you need to collect all errors (e.g., form validation).
- * Use Result when you want to fail fast on the first error.
- *
- * @example
- * ```ts
- * const validateName = (name: string): Validation<string, string> =>
- *   name.length > 0 ? Validation.make.passed(name) : Validation.make.failed("Name is required");
- *
- * const validateAge = (age: number): Validation<string, number> =>
- *   age >= 0 ? Validation.make.passed(age) : Validation.make.failed("Age must be positive");
- *
- * // Accumulates all errors using ap
- * pipe(
- *   Validation.make.passed((name: string) => (age: number) => ({ name, age })),
- *   Validation.ap(validateName("")),
- *   Validation.ap(validateAge(-1))
- * );
- * // Failed(["Name is required", "Age must be positive"])
- * ```
- */
-type Validation<E, A> = Passed<A> | Failed<E>;
-declare const Validation: {
-    make: {
-        /**
-         * Wraps a value in a passed Validation.
-         *
-         * @example
-         * ```ts
-         * Validation.make.passed(42); // Passed(42)
-         * ```
-         */
-        passed: <E, A>(value: A) => Validation<E, A>;
-        /**
-         * Creates a failed Validation from a single error.
-         *
-         * @example
-         * ```ts
-         * Validation.make.failed("Invalid input");
-         * ```
-         */
-        failed: <E>(error: E) => Failed<E>;
-        /**
-         * Creates a failed Validation from multiple errors.
-         *
-         * @example
-         * ```ts
-         * Validation.make.failedAll(["Invalid input"]);
-         * ```
-         */
-        failedAll: <E>(errors: NonEmptyArr<E>) => Failed<E>;
-    };
-    is: {
-        /**
-         * Type guard that checks if a Validation is passed.
-         *
-         * @example
-         * ```ts
-         * const v = Validation.make.passed(42);
-         * if (Validation.is.passed(v)) {
-         *   console.log(v.value); // 42
-         * }
-         * ```
-         */
-        passed: <E, A>(data: Validation<E, A>) => data is Passed<A>;
-        /**
-         * Type guard that checks if a Validation is failed.
-         *
-         * @example
-         * ```ts
-         * const v = Validation.make.failed("invalid");
-         * if (Validation.is.failed(v)) {
-         *   console.log(v.errors); // ["invalid"]
-         * }
-         * ```
-         */
-        failed: <E, A>(data: Validation<E, A>) => data is Failed<E>;
-    };
-    /**
-     * 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 result = Validation.tryCatch(
-     *   () => JSON.parse(rawString),
-     *   { onError: (e) => `Parse error: ${e}` }
-     * );
-     * ```
-     */
-    tryCatch: <E, A>(f: () => A, options: {
-        onError: (e: unknown) => E;
-    }) => Validation<E, A>;
-    from: {
-        /**
-         * Creates a Validation from a predicate applied to a value.
-         * Returns Passed if the predicate passes, Failed from `onFalse` otherwise.
-         *
-         * @example
-         * ```ts
-         * const validateName = Validation.from.Predicate(
-         *   (s: string) => s.length > 0,
-         *   () => "Name is required"
-         * );
-         *
-         * validateName("Alice"); // Passed("Alice")
-         * validateName("");      // Failed(["Name is required"])
-         * ```
-         */
-        Predicate: <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 Failed with the error from onNull.
-         * Otherwise, returns Passed.
-         *
-         * @example
-         * ```ts
-         * pipe(null, Validation.from.nullable(() => "is null")); // Failed(["is null"])
-         * pipe(42, Validation.from.nullable(() => "is null"));   // Passed(42)
-         * ```
-         */
-        nullable: <E>(onNull: () => E) => <A>(value: A | null | undefined) => Validation<E, A>;
-        /**
-         * Creates a Validation from a Maybe.
-         * If the Maybe is None, returns Failed with the error from onNone.
-         * Otherwise, returns Passed.
-         *
-         * @example
-         * ```ts
-         * pipe(Maybe.make.none(), Validation.from.Maybe(() => "is none")); // Failed(["is none"])
-         * pipe(Maybe.make.some(42), Validation.from.Maybe(() => "is none")); // Passed(42)
-         * ```
-         */
-        Maybe: <E>(onNone: () => E) => <A>(maybe: Maybe<A>) => Validation<E, A>;
-        /**
-         * Converts a `Result` to a `Validation`. `Ok` becomes `Passed`; `Err(e)` becomes `Failed([e])`.
-         *
-         * Useful when bridging from error-short-circuiting `Result` pipelines into
-         * error-accumulating `Validation` pipelines.
-         *
-         * @example
-         * ```ts
-         * Validation.from.Result(Result.make.ok(42));       // Passed(42)
-         * Validation.from.Result(Result.make.err("bad"));   // Failed(["bad"])
-         * ```
-         */
-        Result: <E, A>(data: Result<E, A>) => Validation<E, A>;
-    };
-    /**
-     * Transforms the success value inside a Validation.
-     *
-     * @example
-     * ```ts
-     * pipe(Validation.make.passed(5), Validation.map(n => n * 2)); // Passed(10)
-     * pipe(Validation.make.failed("oops"), Validation.map(n => n * 2)); // Failed(["oops"])
-     * ```
-     */
-    map: <A, B>(f: (a: A) => B) => <E>(data: Validation<E, A>) => Validation<E, B>;
-    /**
-     * Transforms the error list inside a Validation.
-     *
-     * @example
-     * ```ts
-     * pipe(Validation.make.failed("oops"), Validation.mapError(e => e.toUpperCase())); // Failed(["OOPS"])
-     * ```
-     */
-    mapError: <E, F, A>(f: (e: E) => F) => (data: Validation<E, A>) => Validation<F, A>;
-    /**
-     * Applies a function wrapped in a Validation to a value wrapped in a Validation.
-     * Accumulates errors from both sides.
-     *
-     * @example
-     * ```ts
-     * const add = (a: number) => (b: number) => a + b;
-     * pipe(
-     *   Validation.make.passed(add),
-     *   Validation.ap(Validation.make.passed(5)),
-     *   Validation.ap(Validation.make.passed(3))
-     * ); // Passed(8)
-     *
-     * pipe(
-     *   Validation.make.passed(add),
-     *   Validation.ap(Validation.make.failed<string>("bad a")),
-     *   Validation.ap(Validation.make.failed<string>("bad b"))
-     * ); // Failed(["bad a", "bad b"])
-     * ```
-     */
-    ap: <E, A>(arg: Validation<E, A>) => <B>(data: Validation<E, (a: A) => B>) => Validation<E, B>;
-    /**
-     * Applies a function wrapped in a Validation to a value wrapped in a Validation,
-     * using a custom error concatenator function when both sides fail.
-     *
-     * @example
-     * ```ts
-     * const concat = (e1: NonEmptyArr<string>, e2: NonEmptyArr<string>): NonEmptyArr<string> =>
-     *   [...e1, ...e2];
-     * pipe(fnVal, Validation.apCustom(concat)(argVal));
-     * ```
-     */
-    apCustom: <E1, E2, E3>(concat: (e1: NonEmptyArr<E1>, e2: NonEmptyArr<E2>) => NonEmptyArr<E3>) => <A>(arg: Validation<E2, A>) => <B>(data: Validation<E1, (a: A) => B>) => Validation<E3, B>;
-    /**
-     * Extracts the value from a Validation by providing handlers for both cases.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   Validation.make.passed(42),
-     *   Validation.fold(
-     *     errors => `Errors: ${errors.join(", ")}`,
-     *     value => `Value: ${value}`
-     *   )
-     * );
-     * ```
-     */
-    fold: <E, A, B>(onFailed: (errors: NonEmptyArr<E>) => B, onPassed: (a: A) => B) => (data: Validation<E, A>) => B;
-    /**
-     * Pattern matches on a Validation, returning the result of the matching case.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   validation,
-     *   Validation.match({
-     *     passed: value => `Got ${value}`,
-     *     failed: errors => `Failed: ${errors.join(", ")}`
-     *   })
-     * );
-     * ```
-     */
-    match: <E, A, B>(cases: {
-        passed: (a: A) => B;
-        failed: (errors: NonEmptyArr<E>) => B;
-    }) => (data: Validation<E, A>) => B;
-    /**
-     * Returns the success value or a default value if the Validation is failed.
-     * The default can be a different type, widening the result to `A | B`.
-     *
-     * @example
-     * ```ts
-     * pipe(Validation.make.passed(5), Validation.getOrElse(() => 0)); // 5
-     * pipe(Validation.make.failed("oops"), Validation.getOrElse(() => 0)); // 0
-     * pipe(Validation.make.failed("oops"), Validation.getOrElse(() => null)); // null — typed as number | null
-     * ```
-     */
-    getOrElse: <B>(defaultValue: () => B) => <E, A>(data: Validation<E, A>) => A | B;
-    /**
-     * Executes a side effect on the success value without changing the Validation.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   Validation.make.passed(5),
-     *   Validation.tap(n => console.log("Value:", n)),
-     *   Validation.map(n => n * 2)
-     * );
-     * ```
-     */
-    tap: <E, A>(f: (a: A) => void) => (data: Validation<E, A>) => Validation<E, A>;
-    /**
-     * Executes a side effect on the accumulated errors without changing the Validation.
-     * Useful for logging or reporting validation failures.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   Validation.make.failed("Name required"),
-     *   Validation.tapError(errors => console.error("validation failed:", errors)),
-     *   Validation.map(toUser)
-     * );
-     * ```
-     */
-    tapError: <E, A>(f: (errors: NonEmptyArr<E>) => void) => (data: Validation<E, A>) => Validation<E, A>;
-    /**
-     * Recovers from a Failed state by providing a fallback 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>`.
-     */
-    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>`.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   Validation.make.failed("field-error"),
-     *   Validation.recoverUnless(e => e === "fatal", () => Validation.make.passed(0))
-     * ); // Passed(0)
-     * ```
-     */
-    recoverUnless: <E, B>(isBlocked: (e: E) => boolean, fallback: () => Validation<E, B>) => <A>(data: Validation<E, A>) => Validation<E, A | B>;
-    to: {
-        /**
-         * Converts a Validation to a Result.
-         * Passed becomes Ok.
-         * Direct call converts Failed to Err with accumulated error list `NonEmptyArr<E>`.
-         * Curried call converts Failed to Err with combined error `E2` via `combineErrors`.
-         *
-         * @example
-         * ```ts
-         * Validation.to.Result(Validation.make.passed(42));        // Ok(42)
-         * Validation.to.Result(Validation.make.failed("oops"));  // Err(["oops"])
-         * pipe(Validation.make.failed("oops"), Validation.to.Result(errors => errors.join(", "))); // Err("oops")
-         * ```
-         */
-        Result: typeof toResult;
-        /**
-         * Converts a Validation to a Maybe. `Passed` becomes `Some`; `Failed` becomes `None`
-         * (errors are discarded).
-         *
-         * @example
-         * ```ts
-         * Validation.to.Maybe(Validation.make.passed(42));       // Some(42)
-         * Validation.to.Maybe(Validation.make.failed("bad"));  // None
-         * ```
-         */
-        Maybe: <E, A>(data: Validation<E, A>) => Maybe<A>;
-    };
-    /**
-     * Combines two independent Validation instances into a tuple.
-     * If both are Passed, returns Passed with both values as a tuple.
-     * If either is Failed, accumulates errors from both sides.
-     *
-     * @example
-     * ```ts
-     * Validation.product(
-     *   Validation.make.passed("alice"),
-     *   Validation.make.passed(30)
-     * ); // Passed(["alice", 30])
-     *
-     * Validation.product(
-     *   Validation.make.failed("Name required"),
-     *   Validation.make.failed("Age must be >= 0")
-     * ); // Failed(["Name required", "Age must be >= 0"])
-     * ```
-     */
-    product: <E, A, B>(first: Validation<E, A>, second: Validation<E, B>) => Validation<E, readonly [A, B]>;
-    /**
-     * Combines a non-empty list of Validation instances, accumulating all errors.
-     * If all are Passed, returns Passed with all values collected into an array.
-     * If any are Failed, returns Failed with all accumulated errors.
-     *
-     * @example
-     * ```ts
-     * Validation.productAll([
-     *   validateName(name),
-     *   validateEmail(email),
-     *   validateAge(age)
-     * ]);
-     * // Passed([name, email, age]) or Failed([...all errors])
-     * ```
-     */
-    productAll: <E, A>(data: NonEmptyArr<Validation<E, A>>) => Validation<E, readonly A[]>;
-    /**
-     * Combines a record of Validations into a single Validation of a record.
-     * Accumulates all failed branches' errors.
-     *
-     * @example
-     * ```ts
-     * Validation.struct({
-     *   name: Validation.make.passed("Alice"),
-     *   age: Validation.make.passed(30)
-     * }); // Passed({ name: "Alice", age: 30 })
-     *
-     * Validation.struct({
-     *   name: Validation.make.failed("Name required"),
-     *   age: Validation.make.failed("Age must be >= 0")
-     * }); // Failed(["Name required", "Age must be >= 0"])
-     * ```
-     */
-    struct: <E, R extends Record<string, any>>(fields: { [K in keyof R]: Validation<E, R[K]>; }) => Validation<E, R>;
-};
-
-type _CoreMaybe<A> = Maybe<A>;
-type _CoreResult<E, A> = Result<E, A>;
-type _CoreValidation<E, A> = Validation<E, A>;
-/**
- * A lazy async computation that always resolves.
- *
- * Two guarantees:
- * - **Lazy** — nothing starts until you call it.
- * - **Infallible** — it never rejects. If failure is possible, encode it in the
- *   return type using `Task.Result<E, A>` instead.
- *
- * An optional `AbortSignal` can be passed at the call site. Combinators like
- * `retry`, `pollUntil`, and `timeout` thread it automatically to every inner
- * operation. Existing tasks that ignore the signal continue to work unchanged.
- *
- * Calling a Task returns a `Deferred<A>` — a one-shot async value that supports
- * `await` but has no `.catch()`, `.finally()`, or chainable `.then()`.
- *
- * **Consuming a Task:**
- *
- * Use `await task()` to run it and get the value directly:
- * ```ts
- * const value: number = await task();
- * ```
- *
- * When you need an explicit `Promise<A>` (e.g. for a third-party API), convert
- * the `Deferred` with `Deferred.to.Promise`:
- * ```ts
- * const p: Promise<number> = Deferred.to.Promise(task());
- * ```
- *
- * @example
- * ```ts
- * const getTimestamp: Task<number> = Task.resolve(Date.now());
- *
- * // Nothing runs yet — getTimestamp is just a description
- * const formatted = pipe(
- *   getTimestamp,
- *   Task.map(ts => new Date(ts).toISOString())
- * );
- *
- * // Execute when ready
- * const result = await formatted();
- * ```
- */
-type Task<A> = (signal?: AbortSignal) => Deferred<A>;
-declare const Task: {
-    /**
-     * Creates a Task that immediately resolves to the given value.
-     *
-     * @example
-     * ```ts
-     * const task = Task.resolve(42);
-     * const value = await task(); // 42
-     * ```
-     */
-    resolve: <A>(value: A) => Task<A>;
-    from: {
-        /**
-         * Creates a Task from a lazy synchronous thunk.
-         * Unlike `Task.resolve(f())`, `from.sync` does not evaluate `f` until the Task is called.
-         *
-         * @example
-         * ```ts
-         * const t = Task.from.sync(() => Date.now()); // Date.now() not called yet
-         * const ts = await t(); // called here, every time
-         * ```
-         */
-        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 }
-     * );
-     * ```
-     */
-    tryCatch: <A>(f: (signal?: AbortSignal) => globalThis.Promise<A>, options: {
-        onError: (error: unknown) => A;
-    }) => Task<A>;
-    /**
-     * Transforms the value inside a Task.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   Task.resolve(5),
-     *   Task.map(n => n * 2)
-     * )(); // Deferred<10>
-     * ```
-     */
-    map: <A, B>(f: (a: A) => B) => (data: Task<A>) => Task<B>;
-    /**
-     * Chains Task computations. Passes the resolved value of the first Task to f.
-     *
-     * @example
-     * ```ts
-     * const readUserId: Task<string> = Task.resolve(session.userId);
-     * const loadPrefs = (id: string): Task<Preferences> =>
-     *   Task.resolve(prefsCache.get(id));
-     *
-     * pipe(
-     *   readUserId,
-     *   Task.chain(loadPrefs)
-     * )(); // Deferred<Preferences>
-     * ```
-     */
-    chain: <A, B>(f: (a: A) => Task<B>) => (data: Task<A>) => Task<B>;
-    /**
-     * Applies a function wrapped in a Task to a value wrapped in a Task.
-     * Both Tasks run in parallel.
-     *
-     * @example
-     * ```ts
-     * const add = (a: number) => (b: number) => a + b;
-     * pipe(
-     *   Task.resolve(add),
-     *   Task.ap(Task.resolve(5)),
-     *   Task.ap(Task.resolve(3))
-     * )(); // Deferred<8>
-     * ```
-     */
-    ap: <A>(arg: Task<A>) => <B>(data: Task<(a: A) => B>) => Task<B>;
-    /**
-     * Executes a side effect on the value without changing the Task.
-     * Useful for logging or debugging.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   loadConfig,
-     *   Task.tap(cfg => console.log("Config:", cfg)),
-     *   Task.map(buildReport)
-     * );
-     * ```
-     */
-    tap: <A>(f: (a: A) => void) => (data: Task<A>) => Task<A>;
-    /**
-     * Runs multiple Tasks in parallel and collects their results.
-     *
-     * @example
-     * ```ts
-     * Task.all([loadConfig, detectLocale, loadTheme])();
-     * // Deferred<[Config, string, Theme]>
-     * ```
-     */
-    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 duration.
-     * Useful for debouncing or rate limiting.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   Task.resolve(42),
-     *   Task.delay(Duration.seconds(1))
-     * )(); // Resolves after 1 second
-     * ```
-     */
-    delay: (duration: 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 duration can be inserted between runs.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   pollSensor,
-     *   Task.repeat({ times: 5, delay: Duration.seconds(1) })
-     * )(); // Task<Reading[]> — 5 readings, one per second
-     * ```
-     */
-    repeat: (options: {
-        times: number;
-        delay?: Duration;
-    }) => <A>(task: Task<A>) => Task<readonly A[]>;
-    /**
-     * Runs a Task repeatedly until the result satisfies a predicate, returning that result.
-     * An optional delay 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.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   checkStatus,
-     *   Task.repeatUntil({ when: (s) => s === "ready", delay: Duration.milliseconds(500) })
-     * )(); // polls every 500ms until status is "ready"
-     * ```
-     */
-    repeatUntil: <A>(options: {
-        when: (a: A) => boolean;
-        delay?: Duration;
-        maxAttempts?: number;
-    }) => (task: Task<A>) => Task<A>;
-    /**
-     * Resolves with the value of the first Task to complete. All Tasks start
-     * immediately. When one resolves, the other tasks are cancelled (aborted)
-     * downstream.
-     *
-     * @example
-     * ```ts
-     * const fast = Task.resolve("fast");
-     * const slow = Task.delay(Duration.milliseconds(200))(Task.resolve("slow"));
-     *
-     * await Task.race([fast, slow])(); // "fast"
-     * ```
-     */
-    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]>
-     * ```
-     */
-    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.
-     *
-     * @example
-     * ```ts
-     * let log: number[] = [];
-     * const makeTask = (n: number) => Task.resolve(n);
-     *
-     * await Task.sequential([makeTask(1), makeTask(2), makeTask(3)])();
-     * // log = [1, 2, 3] — tasks ran in order
-     * ```
-     */
-    sequential: <A>(tasks: ReadonlyArray<Task<A>>) => Task<ReadonlyArray<A>>;
-    /**
-     * Converts a `Task<A>` into a `Task<Result<E, A>>`, resolving to `Err` if the
-     * Task does not complete within the given duration. The inner Task receives an
-     * `AbortSignal` that fires when the deadline passes, so asynchronous operations
-     * that accept a signal are cancelled rather than left dangling.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   heavyComputation,
-     *   Task.timeout({ duration: Duration.seconds(5), onTimeout: () => "timed out" }),
-     *   Task.Result.chain(processResult)
-     * );
-     * ```
-     */
-    timeout: <E>(options: {
-        duration: 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()`
-     * again after `abort()` starts a fresh call with a new signal.
-     *
-     * Each invocation of `task()` automatically cancels the previous in-flight call,
-     * making it safe to call repeatedly (e.g. on user input) without leaking promises.
-     *
-     * If an outer signal is also present (passed at the call site), aborting it
-     * propagates into the internal controller.
-     *
-     * @example
-     * ```ts
-     * const { task: poll, abort } = Task.abortable(
-     *   (signal) => waitForEvent(bus, "ready", { signal }),
-     * );
-     *
-     * onUnmount(abort);
-     * await poll();
-     * ```
-     */
-    abortable: <A>(factory: (signal: AbortSignal) => Thenable<A>) => {
-        task: Task<A>;
-        abort: () => void;
-    };
-    /**
-     * Executes a task with an optional signal. Use as a terminal step in a `pipe` chain.
-     *
-     * @example
-     * ```ts
-     * const name = await pipe(
-     *     loadConfig,
-     *     Task.map(config => config.name),
-     *     Task.run(),
-     * );
-     * ```
-     */
-    run: (signal?: AbortSignal) => <A>(task: Task<A>) => Deferred<A>;
-    /**
-     * Converts a Task value into an object containing a single property.
-     * Initiates the pipeline accumulator record.
-     *
-     * @example
-     * ```ts
-     * pipe(Task.resolve(42), Task.bindTo("value")); // Task({ value: 42 })
-     * ```
-     */
-    bindTo: <K extends string>(key: K) => <A>(data: Task<A>) => Task<{ [P in K]: A; }>;
-    /**
-     * Evaluates a new Task using the current accumulator and attaches the output to a new key.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   Task.resolve({ a: 1 }),
-     *   Task.bind("b", ({ a }) => Task.resolve(a + 1))
-     * ); // Task({ a: 1, b: 2 })
-     * ```
-     */
-    bind: <K extends string, A, B>(key: K, f: (a: A) => Task<B>) => (data: Task<A>) => Task<A & { [P in K]: B; }>;
-    /**
-     * Creates a memoized version of a Task. The task is executed at most once on first call,
-     * and its resolved value is cached for all subsequent calls.
-     *
-     * @example
-     * ```ts
-     * const loadToken = Task.memoize(loadAuthToken);
-     * const token1 = await loadToken(); // loads token
-     * const token2 = await loadToken(); // returns cached token immediately
-     * ```
-     */
-    memoize: <A>(task: Task<A>) => Task<A>;
-    /**
-     * Monitors progress of a Task by calling `onProgress(0)` before execution and `onProgress(1)` upon completion.
-     *
-     * @example
-     * ```ts
-     * const taskWithProgress = pipe(
-     *   readTask,
-     *   Task.withProgress((ratio) => console.log(`Progress: ${ratio * 100}%`))
-     * );
-     * ```
-     */
-    withProgress: <A>(onProgress: (ratio: number) => void) => (task: Task<A>) => Task<A>;
-    /**
-     * Attaches a read-only `.label` property to a Task, preserving the literal string generic type for IDE tooltips.
-     *
-     * @example
-     * ```ts
-     * const labeledTask = pipe(readTask, Task.withLabel("readUser"));
-     * console.log(labeledTask.label); // "readUser"
-     * ```
-     */
-    withLabel: <L extends string>(label: L) => <A>(task: Task<A>) => Task.LabeledTask<L, A>;
-    Maybe: {
-        make: {
-            some: <A>(value: A) => Task.Maybe<A>;
-            none: <A = never>() => Task.Maybe<A>;
-        };
-        from: {
-            Maybe: <A>(option: Maybe<A>) => Task.Maybe<A>;
-            nullable: <A>(value: A | null | undefined) => Task.Maybe<A>;
-            Result: <E, A>(result: Result<E, A>) => Task.Maybe<A>;
-            Task: <A>(task: Task<A>) => Task.Maybe<A>;
-        };
-        tryCatch: <A>(f: (signal?: AbortSignal) => Thenable<A>) => Task.Maybe<A>;
-        map: <A, B>(f: (a: A) => B) => (data: Task.Maybe<A>) => Task.Maybe<B>;
-        chain: <A, B>(f: (a: A) => Task.Maybe<B>) => (data: Task.Maybe<A>) => Task.Maybe<B>;
-        ap: <A>(arg: Task.Maybe<A>) => <B>(data: Task.Maybe<(a: A) => B>) => Task.Maybe<B>;
-        fold: <A, B>(onNone: () => B, onSome: (a: A) => B) => (data: Task.Maybe<A>) => Task<B>;
-        match: <A, B>(cases: {
-            none: () => B;
-            some: (a: A) => B;
-        }) => (data: Task.Maybe<A>) => Task<B>;
-        getOrElse: <B>(defaultValue: () => B) => <A>(data: Task.Maybe<A>) => Task<A | B>;
-        tap: <A>(f: (a: A) => void) => (data: Task.Maybe<A>) => Task.Maybe<A>;
-        filter: <A>(predicate: (a: A) => boolean) => (data: Task.Maybe<A>) => Task.Maybe<A>;
-        to: {
-            Result: <E>(onNone: () => E) => <A>(data: Task.Maybe<A>) => Task.Result<E, A>;
-        };
-        bindTo: <K extends string>(key: K) => <A>(data: Task.Maybe<A>) => Task.Maybe<{ [P in K]: A; }>;
-        bind: <K extends string, A, B>(key: K, f: (a: A) => Task.Maybe<B>) => (data: Task.Maybe<A>) => Task.Maybe<A & { [P in K]: B; }>;
-        recover: <B>(fallback: () => Task.Maybe<B>) => <A>(data: Task.Maybe<A>) => Task.Maybe<A | B>;
-        struct: <R extends Record<string, any>>(fields: { [K in keyof R]: Task.Maybe<R[K]>; }) => Task.Maybe<R>;
-        memoize: <A>(task: Task.Maybe<A>) => Task.Maybe<A>;
-    };
-    Result: {
-        make: {
-            ok: <E = never, A = unknown>(value: A) => Task.Result<E, A>;
-            err: <E, A = never>(error: E) => Task.Result<E, A>;
-        };
-        from: {
-            nullable: <E>(onNull: () => E) => <A>(value: A | null | undefined) => Task.Result<E, A>;
-            Maybe: <E>(onNone: () => E) => <A>(maybe: Maybe<A>) => Task.Result<E, A>;
-            Result: <E, A>(result: Result<E, A>) => Task.Result<E, A>;
-        };
-        to: {
-            Maybe: <E, A>(data: Task.Result<E, A>) => Task.Maybe<A>;
-        };
-        tryCatch: <E, A>(f: (signal?: AbortSignal) => Thenable<A>, options: {
-            onError: (error: unknown) => E;
-        }) => Task.Result<E, A>;
-        map: <E, A, B>(f: (a: A) => B) => (data: Task.Result<E, A>) => Task.Result<E, B>;
-        mapError: <E, F, A>(f: (e: E) => F) => (data: Task.Result<E, A>) => Task.Result<F, A>;
-        chain: <E2, A, B>(f: (a: A) => Task.Result<E2, B>) => <E1 = never>(data: Task.Result<E1, A>) => Task.Result<E1 | E2, B>;
-        fold: <E, A, B>(onErr: (e: E) => B, onOk: (a: A) => B) => (data: Task.Result<E, A>) => Task<B>;
-        match: <E, A, B>(cases: {
-            err: (e: E) => B;
-            ok: (a: A) => B;
-        }) => (data: Task.Result<E, A>) => Task<B>;
-        recover: <E, B>(fallback: (e: E) => Task.Result<E, B>) => <A>(data: Task.Result<E, A>) => Task.Result<E, A | B>;
-        recoverUnless: <E, B>(isBlocked: (e: E) => boolean, fallback: (e: E) => Task.Result<E, B>) => <A>(data: Task.Result<E, A>) => Task.Result<E, A | B>;
-        getOrElse: <B>(defaultValue: () => B) => <E, A>(data: Task.Result<E, A>) => Task<A | B>;
-        tap: <E, A>(f: (a: A) => void) => (data: Task.Result<E, A>) => Task.Result<E, A>;
-        tapError: <E, A>(f: (e: E) => void) => (data: Task.Result<E, A>) => Task.Result<E, A>;
-        ap: <E, A>(arg: Task.Result<E, A>) => <B>(data: Task.Result<E, (a: A) => B>) => Task.Result<E, B>;
-        run: (signal?: AbortSignal) => <E, A>(task: Task.Result<E, A>) => Deferred<Result<E, A>>;
-        bindTo: <K extends string>(key: K) => <E, A>(data: Task.Result<E, A>) => Task.Result<E, { [P in K]: A; }>;
-        bind: <K extends string, E, A, B>(key: K, f: (a: A) => Task.Result<E, B>) => (data: Task.Result<E, A>) => Task.Result<E, A & { [P in K]: B; }>;
-        struct: <E, R extends Record<string, any>>(fields: { [K in keyof R]: Task.Result<E, R[K]>; }) => Task.Result<E, R>;
-        retry: (policy: RetryPolicy) => <E, A>(task: Task.Result<E, A>) => Task.Result<E, A>;
-        memoize: <E, A>(task: Task.Result<E, A>) => Task.Result<E, A>;
-        timeout: <E2>(options: {
-            duration: Duration;
-            onTimeout: () => E2;
-        }) => <E1 = never, A = unknown>(task: Task.Result<E1, A>) => Task.Result<E1 | E2, A>;
-        allSettled: <E, A>(tasks: ReadonlyArray<Task.Result<E, A>>) => Task<ReadonlyArray<Result<E, A>>>;
-    };
-    Validation: {
-        make: {
-            passed: <E = never, A = unknown>(value: A) => Task.Validation<E, A>;
-            failed: <E, A = never>(error: E) => Task.Validation<E, A>;
-            failedAll: <E, A = never>(errors: NonEmptyArr<E>) => Task.Validation<E, A>;
-        };
-        from: {
-            Validation: <E, A>(validation: Validation<E, A>) => Task.Validation<E, A>;
-            nullable: <E>(onNull: () => E) => <A>(value: A | null | undefined) => Task.Validation<E, A>;
-            Maybe: <E>(onNone: () => E) => <A>(maybe: Maybe<A>) => Task.Validation<E, A>;
-            Result: <E, A>(result: Result<E, A>) => Task.Validation<E, A>;
-        };
-        to: {
-            Result: <E1, E2, A>(combineErrors: (errors: NonEmptyArr<E1>) => E2) => (data: Task.Validation<E1, A>) => Task.Result<E2, A>;
-            Maybe: <E, A>(data: Task.Validation<E, A>) => Task.Maybe<A>;
-        };
-        tryCatch: <E, A>(f: (signal?: AbortSignal) => Thenable<A>, options: {
-            onError: (error: unknown) => E;
-        }) => Task.Validation<E, A>;
-        map: <E, A, B>(f: (a: A) => B) => (data: Task.Validation<E, A>) => Task.Validation<E, B>;
-        ap: <E, A>(arg: Task.Validation<E, A>) => <B>(data: Task.Validation<E, (a: A) => B>) => Task.Validation<E, B>;
-        fold: <E, A, B>(onFailed: (errors: NonEmptyArr<E>) => B, onPassed: (a: A) => B) => (data: Task.Validation<E, A>) => Task<B>;
-        match: <E, A, B>(cases: {
-            passed: (a: A) => B;
-            failed: (errors: NonEmptyArr<E>) => B;
-        }) => (data: Task.Validation<E, A>) => Task<B>;
-        getOrElse: <B>(defaultValue: () => B) => <E, A>(data: Task.Validation<E, A>) => Task<A | B>;
-        tap: <E, A>(f: (a: A) => void) => (data: Task.Validation<E, A>) => Task.Validation<E, A>;
-        recover: <E, B>(fallback: (errors: NonEmptyArr<E>) => Task.Validation<E, B>) => <A>(data: Task.Validation<E, A>) => Task.Validation<E, A | B>;
-        recoverUnless: <E, B>(isBlocked: (errors: NonEmptyArr<E>) => boolean, fallback: (errors: NonEmptyArr<E>) => Task.Validation<E, B>) => <A>(data: Task.Validation<E, A>) => Task.Validation<E, A | B>;
-        product: <E, A, B>(first: Task.Validation<E, A>, second: Task.Validation<E, B>) => Task.Validation<E, readonly [A, B]>;
-        productAll: <E, A>(data: NonEmptyArr<Task.Validation<E, A>>) => Task.Validation<E, readonly A[]>;
-        mapError: <E, F, A>(f: (e: E) => F) => (data: Task.Validation<E, A>) => Task.Validation<F, A>;
-        tapError: <E, A>(f: (errors: NonEmptyArr<E>) => void) => (data: Task.Validation<E, A>) => Task.Validation<E, A>;
-        struct: <E, R extends Record<string, any>>(fields: { [K in keyof R]: Task.Validation<E, R[K]>; }) => Task.Validation<E, R>;
-        memoize: <E, A>(task: Task.Validation<E, A>) => Task.Validation<E, A>;
-    };
-};
-declare namespace Task {
-    type LabeledTask<L extends string, A> = Task<A> & {
-        readonly label: L;
-    };
-    type Maybe<A> = Task<_CoreMaybe<A>>;
-    type Result<E, A> = Task<_CoreResult<E, A>>;
-    type Validation<E, A> = Task<_CoreValidation<E, A>>;
-}
-
-export { Equality as E, type Failed as F, Maybe as M, type None as N, type Ok as O, type Passed as P, Result as R, type Some as S, Task as T, Validation as V, type Err as a, Ordering as b };