@nlozgachev/pipelined 0.62.0 → 0.63.0

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

@@ -1,5 +1,5 @@
-import { h as WithKind, o as WithValue, e as WithError, a as NonEmptyArr, T as Thenable, D as Deferred, f as WithErrors } from './InternalTypes-LdhLQx3N.js';
-import { D as Duration } from './Duration-B8joKzro.js';
+import { h as WithKind, o as WithValue, e as WithError, a as NonEmptyArr, T as Thenable, D as Deferred, f as WithErrors } from './InternalTypes-CCXa8Kvr.js';
+import { D as Duration } from './Duration-DeyxG6VQ.js';
 import { RetryPolicy } from './types.js';
 
 /**
@@ -16,7 +16,7 @@ import { RetryPolicy } from './types.js';
  * ```
  */
 type Equality<A> = (a: A, b: A) => boolean;
-declare namespace Equality {
+declare const Equality: {
     /**
      * Equality for strings. Case-sensitive.
      *
@@ -26,7 +26,7 @@ declare namespace Equality {
      * Equality.string("hello", "Hello"); // false
      * ```
      */
-    const string: Equality<string>;
+    string: Equality<string>;
     /**
      * Equality for numbers. Uses strict equality.
      *
@@ -35,7 +35,7 @@ declare namespace Equality {
      * Equality.number(42, 42); // true
      * ```
      */
-    const number: Equality<number>;
+    number: Equality<number>;
     /**
      * Equality for booleans.
      *
@@ -44,7 +44,7 @@ declare namespace Equality {
      * Equality.boolean(true, true); // true
      * ```
      */
-    const boolean: Equality<boolean>;
+    boolean: Equality<boolean>;
     /**
      * Equality for `Date` values. Compares by numeric time value.
      *
@@ -53,7 +53,7 @@ declare namespace Equality {
      * Equality.date(new Date("2024-01-01"), new Date("2024-01-01")); // true
      * ```
      */
-    const date: Equality<Date>;
+    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`.
@@ -63,7 +63,7 @@ declare namespace Equality {
      * Equality.array(Equality.number)([1, 2, 3], [1, 2, 3]); // true
      * ```
      */
-    const array: <A>(eq: Equality<A>) => Equality<readonly A[]>;
+    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))`.
@@ -75,7 +75,7 @@ declare namespace Equality {
      * byId({ id: "p1", price: 9 }, { id: "p1", price: 12 }); // true
      * ```
      */
-    const by: <A, B>(f: (b: B) => A) => (eq: Equality<A>) => Equality<B>;
+    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.
@@ -86,7 +86,7 @@ declare namespace Equality {
      * exact(userA, userB); // true only if name AND role match
      * ```
      */
-    const and: <A>(eq2: Equality<A>) => (eq1: Equality<A>) => Equality<A>;
+    and: <A>(eq2: Equality<A>) => (eq1: Equality<A>) => Equality<A>;
     /**
      * Derives deep equality for a record from field-level `Equality` checkers.
      *
@@ -98,7 +98,7 @@ declare namespace Equality {
      * });
      * ```
      */
-    const struct: <R extends Record<string, unknown>>(fields: { [K in keyof R]: Equality<R[K]>; }) => Equality<R>;
+    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.
      *
@@ -108,8 +108,8 @@ declare namespace Equality {
      * pairEq(["a", 1], ["a", 1]); // true
      * ```
      */
-    const tuple: <T extends readonly unknown[]>(...equalities: { [K in keyof T]: Equality<T[K]>; }) => Equality<T>;
-}
+    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">;
@@ -129,8 +129,8 @@ type None = WithKind<"None">;
  * ```
  */
 type Maybe<T> = Some<T> | None;
-declare namespace Maybe {
-    namespace make {
+declare const Maybe: {
+    make: {
         /**
          * Creates a Some containing the given value.
          *
@@ -139,7 +139,7 @@ declare namespace Maybe {
          * Maybe.make.some(42); // Some(42)
          * ```
          */
-        const some: <A>(value: A) => Some<A>;
+        some: <A>(value: A) => Some<A>;
         /**
          * Creates a None (empty Maybe).
          *
@@ -148,9 +148,9 @@ declare namespace Maybe {
          * Maybe.make.none(); // None
          * ```
          */
-        const none: () => None;
-    }
-    namespace is {
+        none: () => None;
+    };
+    is: {
         /**
          * Type guard that checks if a Maybe is Some.
          *
@@ -162,7 +162,7 @@ declare namespace Maybe {
          * }
          * ```
          */
-        const some: <A>(data: Maybe<A>) => data is Some<A>;
+        some: <A>(data: Maybe<A>) => data is Some<A>;
         /**
          * Type guard that checks if a Maybe is None.
          *
@@ -174,9 +174,9 @@ declare namespace Maybe {
          * }
          * ```
          */
-        const none: <A>(data: Maybe<A>) => data is None;
-    }
-    namespace to {
+        none: <A>(data: Maybe<A>) => data is None;
+    };
+    to: {
         /**
          * Extracts the value from a Maybe, returning null if None.
          *
@@ -186,7 +186,7 @@ declare namespace Maybe {
          * Maybe.to.nullable(Maybe.make.none());   // null
          * ```
          */
-        const nullable: <A>(data: Maybe<A>) => A | null;
+        nullable: <A>(data: Maybe<A>) => A | null;
         /**
          * Extracts the value from a Maybe, returning undefined if None.
          *
@@ -196,7 +196,7 @@ declare namespace Maybe {
          * Maybe.to.undefined(Maybe.make.none());   // undefined
          * ```
          */
-        const undefined: <A>(data: Maybe<A>) => A | undefined;
+        undefined: <A>(data: Maybe<A>) => A | undefined;
         /**
          * Converts a Maybe to a Result.
          * Some becomes Ok, None becomes Err with the provided error.
@@ -214,9 +214,9 @@ declare namespace Maybe {
          * ); // Err("Value was missing")
          * ```
          */
-        const Result: <E>(onNone: () => E) => <A>(data: Maybe<A>) => Result<E, A>;
-    }
-    namespace from {
+        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.
@@ -227,7 +227,7 @@ declare namespace Maybe {
          * Maybe.from.nullable(42); // Some(42)
          * ```
          */
-        const nullable: <A>(value: A | null | undefined) => Maybe<A>;
+        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.
@@ -241,7 +241,7 @@ declare namespace Maybe {
          * pipe("", Maybe.from.Predicate((s: string) => s.length > 0));      // None
          * ```
          */
-        const Predicate: <A>(pred: (a: A) => boolean) => (a: A) => Maybe<A>;
+        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).
@@ -252,8 +252,8 @@ declare namespace Maybe {
          * Maybe.from.Result(Result.make.err("oops")); // None
          * ```
          */
-        const Result: <E, A>(data: Result<E, A>) => Maybe<A>;
-    }
+        Result: <E, A>(data: Result<E, A>) => Maybe<A>;
+    };
     /**
      * Transforms the value inside a Maybe if it exists.
      *
@@ -263,7 +263,7 @@ declare namespace Maybe {
      * pipe(Maybe.make.none(), Maybe.map(n => n * 2)); // None
      * ```
      */
-    const map: <A, B>(f: (a: A) => B) => (data: Maybe<A>) => Maybe<B>;
+    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.
@@ -279,7 +279,7 @@ declare namespace Maybe {
      * pipe(Maybe.make.some("abc"), Maybe.chain(parseNumber)); // None
      * ```
      */
-    const chain: <A, B>(f: (a: A) => Maybe<B>) => (data: Maybe<A>) => Maybe<B>;
+    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.
      *
@@ -294,7 +294,7 @@ declare namespace Maybe {
      * ); // "Value: 5"
      * ```
      */
-    const fold: <A, B>(onNone: () => B, onSome: (a: A) => B) => (data: Maybe<A>) => B;
+    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.
      *
@@ -309,7 +309,7 @@ declare namespace Maybe {
      * );
      * ```
      */
-    const match: <A, B>(cases: {
+    match: <A, B>(cases: {
         none: () => B;
         some: (a: A) => B;
     }) => (data: Maybe<A>) => B;
@@ -325,7 +325,7 @@ declare namespace Maybe {
      * pipe(Maybe.make.none<string>(), Maybe.getOrElse(() => null)); // null — typed as string | null
      * ```
      */
-    const getOrElse: <B>(defaultValue: () => B) => <A>(data: Maybe<A>) => A | B;
+    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.
@@ -339,7 +339,7 @@ declare namespace Maybe {
      * );
      * ```
      */
-    const tap: <A>(f: (a: A) => void) => (data: Maybe<A>) => Maybe<A>;
+    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.
@@ -350,7 +350,7 @@ declare namespace Maybe {
      * pipe(Maybe.make.some(2), Maybe.filter(n => n > 3)); // None
      * ```
      */
-    const filter: <A>(predicate: (a: A) => boolean) => (data: Maybe<A>) => Maybe<A>;
+    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>`.
@@ -361,7 +361,7 @@ declare namespace Maybe {
      * pipe(Maybe.make.some(10), Maybe.recover(() => Maybe.make.some(42))); // Some(10)
      * ```
      */
-    const recover: <B>(fallback: () => Maybe<B>) => <A>(data: Maybe<A>) => Maybe<A | B>;
+    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.
      *
@@ -375,7 +375,7 @@ declare namespace Maybe {
      * ); // Some(8)
      * ```
      */
-    const ap: <A>(arg: Maybe<A>) => <B>(data: Maybe<(a: A) => B>) => Maybe<B>;
+    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.
@@ -385,7 +385,7 @@ declare namespace Maybe {
      * pipe(Maybe.make.some(42), Maybe.bindTo("value")); // Some({ value: 42 })
      * ```
      */
-    const bindTo: <K extends string>(key: K) => <A>(data: Maybe<A>) => Maybe<{ [P in K]: A; }>;
+    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.
      *
@@ -397,7 +397,7 @@ declare namespace Maybe {
      * ); // Some({ a: 1, b: 2 })
      * ```
      */
-    const bind: <K extends string, A, B>(key: K, f: (a: A) => Maybe<B>) => (data: Maybe<A>) => Maybe<A & { [P in K]: B; }>;
+    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.
@@ -410,7 +410,7 @@ declare namespace Maybe {
      * }); // Some({ name: "Alice", age: 30 })
      * ```
      */
-    const struct: <R extends Record<string, any>>(fields: { [K in keyof R]: Maybe<R[K]>; }) => Maybe<R>;
+    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)`.
@@ -422,8 +422,8 @@ declare namespace Maybe {
      * Maybe.transposeResult(Maybe.make.none());                     // Ok(None)
      * ```
      */
-    const transposeResult: <E, A>(data: Maybe<Result<E, A>>) => Result<E, Maybe<A>>;
-}
+    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
@@ -442,7 +442,7 @@ declare namespace Maybe {
  * ```
  */
 type Ordering<A> = (a: A, b: A) => number;
-declare namespace Ordering {
+declare const Ordering: {
     /**
      * Alphabetical ordering for strings.
      *
@@ -451,7 +451,7 @@ declare namespace Ordering {
      * Ordering.string("apple", "banana"); // negative
      * ```
      */
-    const string: Ordering<string>;
+    string: Ordering<string>;
     /**
      * Numeric ordering. Equivalent to `(a, b) => a - b`.
      *
@@ -460,7 +460,7 @@ declare namespace Ordering {
      * pipe([3, 1, 2], Arr.sortWith(Ordering.number)); // [1, 2, 3]
      * ```
      */
-    const number: Ordering<number>;
+    number: Ordering<number>;
     /**
      * Ordering for `Date` values by numeric time value.
      *
@@ -469,7 +469,7 @@ declare namespace Ordering {
      * pipe(dates, Arr.sortWith(Ordering.date)); // earliest first
      * ```
      */
-    const date: Ordering<Date>;
+    date: Ordering<Date>;
     /**
      * Flips the direction of an ordering.
      *
@@ -478,7 +478,7 @@ declare namespace Ordering {
      * pipe([3, 1, 2], Arr.sortWith(Ordering.reverse(Ordering.number))); // [3, 2, 1]
      * ```
      */
-    const reverse: <A>(ord: Ordering<A>) => Ordering<A>;
+    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.
@@ -488,7 +488,7 @@ declare namespace Ordering {
      * const byDeptThenSalary = pipe(byDept, Ordering.thenBy(bySalary));
      * ```
      */
-    const thenBy: <A>(ord2: Ordering<A>) => (ord1: Ordering<A>) => Ordering<A>;
+    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))`.
@@ -500,7 +500,7 @@ declare namespace Ordering {
      * pipe(products, Arr.sortWith(byPrice));
      * ```
      */
-    const by: <A, B>(f: (b: B) => A) => (ord: Ordering<A>) => Ordering<B>;
+    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.
@@ -512,7 +512,7 @@ declare namespace Ordering {
      * const sortUsers = Ordering.byFields([byName, byAge]);
      * ```
      */
-    const byFields: <A>(orderings: ReadonlyArray<Ordering<A>>) => Ordering<A>;
+    byFields: <A>(orderings: ReadonlyArray<Ordering<A>>) => Ordering<A>;
     /**
      * Derives a lexicographical tuple ordering from positional `Ordering` comparators.
      *
@@ -522,8 +522,8 @@ declare namespace Ordering {
      * pairOrd(["a", 1], ["a", 2]); // negative
      * ```
      */
-    const tuple: <T extends readonly unknown[]>(...orderings: { [K in keyof T]: Ordering<T[K]>; }) => Ordering<T>;
-}
+    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>;
@@ -544,8 +544,8 @@ type Err<E> = WithKind<"Err"> & WithError<E>;
  * ```
  */
 type Result<E, A> = Ok<A> | Err<E>;
-declare namespace Result {
-    namespace make {
+declare const Result: {
+    make: {
         /**
          * Creates a successful Result with the given value.
          *
@@ -554,7 +554,7 @@ declare namespace Result {
          * Result.make.ok(42); // Ok(42)
          * ```
          */
-        const ok: <A>(value: A) => Ok<A>;
+        ok: <A>(value: A) => Ok<A>;
         /**
          * Creates a failed Result with the given error.
          *
@@ -563,9 +563,9 @@ declare namespace Result {
          * Result.make.err("Error message"); // Err("Error message")
          * ```
          */
-        const err: <E>(e: E) => Err<E>;
-    }
-    namespace is {
+        err: <E>(e: E) => Err<E>;
+    };
+    is: {
         /**
          * Type guard that checks if a Result is Ok.
          *
@@ -577,7 +577,7 @@ declare namespace Result {
          * }
          * ```
          */
-        const ok: <E, A>(data: Result<E, A>) => data is Ok<A>;
+        ok: <E, A>(data: Result<E, A>) => data is Ok<A>;
         /**
          * Type guard that checks if a Result is Err.
          *
@@ -589,12 +589,8 @@ declare namespace Result {
          * }
          * ```
          */
-        const err: <E, A>(data: Result<E, A>) => data is Err<E>;
-    }
-    /**
-     * Creates a Result from a function that may throw.
-     * Catches any errors and transforms them using the onError function.
-     *
+        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.
@@ -607,7 +603,7 @@ declare namespace Result {
      * );
      * ```
      */
-    const tryCatch: <E, A>(f: () => A, options: {
+    tryCatch: <E, A>(f: () => A, options: {
         onError: (e: unknown) => E;
     }) => Result<E, A>;
     /**
@@ -619,7 +615,7 @@ declare namespace Result {
      * pipe(Result.make.err("error"), Result.map(n => n * 2)); // Err("error")
      * ```
      */
-    const map: <E, A, B>(f: (a: A) => B) => (data: Result<E, A>) => Result<E, B>;
+    map: <E, A, B>(f: (a: A) => B) => (data: Result<E, A>) => Result<E, B>;
     /**
      * Transforms the error value inside a Result.
      *
@@ -628,7 +624,7 @@ declare namespace Result {
      * pipe(Result.make.err("oops"), Result.mapError(e => e.toUpperCase())); // Err("OOPS")
      * ```
      */
-    const mapError: <E, F, A>(f: (e: E) => F) => (data: Result<E, A>) => Result<F, A>;
+    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.
@@ -642,7 +638,7 @@ declare namespace Result {
      * pipe(Result.make.ok(-1), Result.chain(validatePositive)); // Err("Must be positive")
      * ```
      */
-    const chain: <E2, A, B>(f: (a: A) => Result<E2, B>) => <E1 = never>(data: Result<E1, A>) => Result<E1 | E2, B>;
+    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.
      *
@@ -657,7 +653,7 @@ declare namespace Result {
      * ); // "Value: 5"
      * ```
      */
-    const fold: <E, A, B>(onErr: (e: E) => B, onOk: (a: A) => B) => (data: Result<E, A>) => B;
+    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.
      *
@@ -672,7 +668,7 @@ declare namespace Result {
      * );
      * ```
      */
-    const match: <E, A, B>(cases: {
+    match: <E, A, B>(cases: {
         ok: (a: A) => B;
         err: (e: E) => B;
     }) => (data: Result<E, A>) => B;
@@ -688,7 +684,7 @@ declare namespace Result {
      * pipe(Result.make.err("error"), Result.getOrElse(() => null)); // null — typed as number | null
      * ```
      */
-    const getOrElse: <B>(defaultValue: () => B) => <E, A>(data: Result<E, A>) => A | B;
+    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.
@@ -702,7 +698,7 @@ declare namespace Result {
      * );
      * ```
      */
-    const tap: <E, A>(f: (a: A) => void) => (data: Result<E, A>) => Result<E, A>;
+    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.
@@ -716,8 +712,8 @@ declare namespace Result {
      * )
      * ```
      */
-    const tapError: <E, A>(f: (e: E) => void) => (data: Result<E, A>) => Result<E, A>;
-    namespace from {
+    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.
@@ -729,7 +725,7 @@ declare namespace Result {
          * pipe("", Result.from.Predicate(s => s.length > 0, () => "empty string")); // Err("empty string")
          * ```
          */
-        const Predicate: <E, A>(pred: (a: A) => boolean, onFalse: (a: A) => E) => (a: A) => Result<E, A>;
+        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.
@@ -740,7 +736,7 @@ declare namespace Result {
          * pipe(42, Result.from.nullable(() => "is null"));   // Ok(42)
          * ```
          */
-        const nullable: <E>(onNull: () => E) => <A>(value: A | null | undefined) => Result<E, A>;
+        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.
@@ -751,7 +747,7 @@ declare namespace Result {
          * pipe(Maybe.make.some(42), Result.from.Maybe(() => "is none")); // Ok(42)
          * ```
          */
-        const Maybe: <E>(onNone: () => E) => <A>(maybe: Maybe<A>) => Result<E, A>;
+        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))`.
@@ -761,13 +757,13 @@ declare namespace Result {
          * Result.from.Validation((errors) => errors.join(", "))(Validation.make.failed("error1")); // Err("error1")
          * ```
          */
-        const Validation: <E1, E2, A>(combineErrors: (errors: NonEmptyArr<E1>) => E2) => (val: Validation<E1, A>) => Result<E2, A>;
-    }
+        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>`.
      */
-    const recover: <E, B>(fallback: (e: E) => Result<E, B>) => <A>(data: Result<E, A>) => 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>`.
@@ -780,8 +776,8 @@ declare namespace Result {
      * ); // Ok(0)
      * ```
      */
-    const recoverUnless: <E, B>(isBlocked: (e: E) => boolean, fallback: () => Result<E, B>) => <A>(data: Result<E, A>) => Result<E, A | B>;
-    namespace to {
+    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).
@@ -792,7 +788,7 @@ declare namespace Result {
          * Result.to.Maybe(Result.make.err("oops")); // None
          * ```
          */
-        const Maybe: <E, A>(data: Result<E, A>) => Maybe<A>;
+        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])`.
          *
@@ -802,8 +798,8 @@ declare namespace Result {
          * Result.to.Validation(Result.make.err("bad")); // Failed(["bad"])
          * ```
          */
-        const Validation: <E, A>(data: Result<E, A>) => Validation<E, A>;
-    }
+        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))`.
@@ -815,7 +811,7 @@ declare namespace Result {
      * Result.transposeMaybe(Result.make.err("error"));           // Some(Err("error"))
      * ```
      */
-    const transposeMaybe: <E, A>(data: Result<E, Maybe<A>>) => Maybe<Result<E, A>>;
+    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.
      *
@@ -829,7 +825,7 @@ declare namespace Result {
      * ); // Ok(8)
      * ```
      */
-    const ap: <E, A>(arg: Result<E, A>) => <B>(data: Result<E, (a: A) => B>) => Result<E, B>;
+    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.
@@ -839,7 +835,7 @@ declare namespace Result {
      * pipe(Result.make.ok(42), Result.bindTo("value")); // Ok({ value: 42 })
      * ```
      */
-    const bindTo: <K extends string>(key: K) => <E, A>(data: Result<E, A>) => Result<E, { [P in K]: A; }>;
+    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.
      *
@@ -851,7 +847,7 @@ declare namespace Result {
      * ); // Ok({ a: 1, b: 2 })
      * ```
      */
-    const 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; }>;
+    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.
@@ -864,7 +860,7 @@ declare namespace Result {
      * }); // Ok({ name: "Alice", age: 30 })
      * ```
      */
-    const struct: <E, R extends Record<string, any>>(fields: { [K in keyof R]: Result<E, R[K]>; }) => Result<E, R>;
+    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.
      *
@@ -876,7 +872,7 @@ declare namespace Result {
      * ); // Err("Age 15 is below 18")
      * ```
      */
-    const ensure: <A, E2>(predicate: (a: A) => boolean, onFail: (a: A) => E2) => <E1 = never>(data: Result<E1, A>) => Result<E1 | E2, A>;
+    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.
@@ -892,8 +888,8 @@ declare namespace Result {
      * ); // Ok(10)
      * ```
      */
-    const bimap: <E1, E2, A, B>(onErr: (e: E1) => E2, onOk: (a: A) => B) => (data: Result<E1, A>) => Result<E2, B>;
-}
+    bimap: <E1, E2, A, B>(onErr: (e: E1) => E2, onOk: (a: A) => B) => (data: Result<E1, A>) => Result<E2, B>;
+};
 
 /**
  * TaskMaybe represents a lazy, infallible async operation that resolves to a `Maybe<A>`.
@@ -910,7 +906,7 @@ declare namespace Result {
  * ```
  */
 type TaskMaybe<A> = Task<Maybe<A>>;
-declare namespace TaskMaybe {
+declare const TaskMaybe: {
     /**
      * Wraps a value in a Some inside a Task.
      *
@@ -920,7 +916,7 @@ declare namespace TaskMaybe {
      * const res = await task(); // Some(42)
      * ```
      */
-    namespace make {
+    make: {
         /**
          * Creates a Task.Maybe that resolves to Some(value).
          *
@@ -930,7 +926,7 @@ declare namespace TaskMaybe {
          * const res = await task(); // Some(42)
          * ```
          */
-        const some: <A>(value: A) => TaskMaybe<A>;
+        some: <A>(value: A) => TaskMaybe<A>;
         /**
          * Creates a Task.Maybe that resolves to None.
          *
@@ -940,11 +936,11 @@ declare namespace TaskMaybe {
          * const res = await task(); // None
          * ```
          */
-        const none: <A = never>() => TaskMaybe<A>;
-    }
-    const some: <A>(value: A) => TaskMaybe<A>;
-    const none: <A = never>() => TaskMaybe<A>;
-    namespace from {
+        none: <A = never>() => TaskMaybe<A>;
+    };
+    some: <A>(value: A) => TaskMaybe<A>;
+    none: <A = never>() => TaskMaybe<A>;
+    from: {
         /**
          * Lifts a Maybe into a Task.Maybe.
          *
@@ -953,7 +949,7 @@ declare namespace TaskMaybe {
          * Task.Maybe.from.Maybe(Maybe.make.some(42));
          * ```
          */
-        const Maybe: <A>(option: Maybe<A>) => TaskMaybe<A>;
+        Maybe: <A>(option: Maybe<A>) => TaskMaybe<A>;
         /**
          * Creates a Task.Maybe from a nullable value.
          * Returns Some if the value is not null or undefined, None otherwise.
@@ -964,7 +960,7 @@ declare namespace TaskMaybe {
          * Task.Maybe.from.nullable(null); // resolves to None
          * ```
          */
-        const nullable: <A>(value: A | null | undefined) => TaskMaybe<A>;
+        nullable: <A>(value: A | null | undefined) => TaskMaybe<A>;
         /**
          * Creates a Task.Maybe from a Result.
          * Ok becomes Some, Error becomes None (the error value is discarded).
@@ -975,7 +971,7 @@ declare namespace TaskMaybe {
          * Task.Maybe.from.Result(Result.make.err("e")); // resolves to None
          * ```
          */
-        const Result: <E, A>(result: Result<E, A>) => TaskMaybe<A>;
+        Result: <E, A>(result: Result<E, A>) => TaskMaybe<A>;
         /**
          * Lifts a Task into a Task.Maybe by wrapping its result in Some.
          *
@@ -984,8 +980,8 @@ declare namespace TaskMaybe {
          * Task.Maybe.from.Task(Task.resolve(42)); // resolves to Some(42)
          * ```
          */
-        const Task: <A>(task: Task<A>) => TaskMaybe<A>;
-    }
+        Task: <A>(task: Task<A>) => TaskMaybe<A>;
+    };
     /**
      * Creates a Task.Maybe from a Promise-returning function.
      * Returns Some if the promise resolves, None if it rejects.
@@ -998,11 +994,11 @@ declare namespace TaskMaybe {
      * );
      * ```
      */
-    const tryCatch: <A>(f: (signal?: AbortSignal) => Thenable<A>) => TaskMaybe<A>;
+    tryCatch: <A>(f: (signal?: AbortSignal) => Thenable<A>) => TaskMaybe<A>;
     /**
      * Transforms the value inside a Task.Maybe.
      */
-    const map: <A, B>(f: (a: A) => B) => (data: TaskMaybe<A>) => TaskMaybe<B>;
+    map: <A, B>(f: (a: A) => B) => (data: TaskMaybe<A>) => TaskMaybe<B>;
     /**
      * Chains Task.Maybe computations. If the first resolves to Some, passes the
      * value to f. If the first resolves to None, propagates None.
@@ -1015,16 +1011,16 @@ declare namespace TaskMaybe {
      * )();
      * ```
      */
-    const chain: <A, B>(f: (a: A) => TaskMaybe<B>) => (data: TaskMaybe<A>) => TaskMaybe<B>;
+    chain: <A, B>(f: (a: A) => TaskMaybe<B>) => (data: TaskMaybe<A>) => TaskMaybe<B>;
     /**
      * Applies a function wrapped in a Task.Maybe to a value wrapped in a Task.Maybe.
      * Both Tasks run in parallel.
      */
-    const ap: <A>(arg: TaskMaybe<A>) => <B>(data: TaskMaybe<(a: A) => B>) => TaskMaybe<B>;
+    ap: <A>(arg: TaskMaybe<A>) => <B>(data: TaskMaybe<(a: A) => B>) => TaskMaybe<B>;
     /**
      * Extracts a value from a Task.Maybe by providing handlers for both cases.
      */
-    const fold: <A, B>(onNone: () => B, onSome: (a: A) => B) => (data: TaskMaybe<A>) => Task<B>;
+    fold: <A, B>(onNone: () => B, onSome: (a: A) => B) => (data: TaskMaybe<A>) => Task<B>;
     /**
      * Pattern matches on a Task.Maybe, returning a Task of the result.
      *
@@ -1039,7 +1035,7 @@ declare namespace TaskMaybe {
      * )();
      * ```
      */
-    const match: <A, B>(cases: {
+    match: <A, B>(cases: {
         none: () => B;
         some: (a: A) => B;
     }) => (data: TaskMaybe<A>) => Task<B>;
@@ -1047,17 +1043,17 @@ declare namespace TaskMaybe {
      * Returns the value or a default if the Task.Maybe resolves to None.
      * The default can be a different type, widening the result to `Task<A | B>`.
      */
-    const getOrElse: <B>(defaultValue: () => B) => <A>(data: TaskMaybe<A>) => Task<A | B>;
+    getOrElse: <B>(defaultValue: () => B) => <A>(data: TaskMaybe<A>) => Task<A | B>;
     /**
      * Executes a side effect on the value without changing the Task.Maybe.
      * Useful for logging or debugging.
      */
-    const tap: <A>(f: (a: A) => void) => (data: TaskMaybe<A>) => TaskMaybe<A>;
+    tap: <A>(f: (a: A) => void) => (data: TaskMaybe<A>) => TaskMaybe<A>;
     /**
      * Filters the value inside a Task.Maybe. Returns None if the predicate fails.
      */
-    const filter: <A>(predicate: (a: A) => boolean) => (data: TaskMaybe<A>) => TaskMaybe<A>;
-    namespace to {
+    filter: <A>(predicate: (a: A) => boolean) => (data: TaskMaybe<A>) => TaskMaybe<A>;
+    to: {
         /**
          * Converts a Task.Maybe to a Task.Result, using onNone to produce the error value.
          *
@@ -1069,8 +1065,8 @@ declare namespace TaskMaybe {
          * );
          * ```
          */
-        const Result: <E>(onNone: () => E) => <A>(data: TaskMaybe<A>) => Task.Result<E, A>;
-    }
+        Result: <E>(onNone: () => E) => <A>(data: TaskMaybe<A>) => Task.Result<E, A>;
+    };
     /**
      * Lifts a Task.Maybe value into an accumulator object.
      *
@@ -1079,7 +1075,7 @@ declare namespace TaskMaybe {
      * pipe(Task.Maybe.some(42), Task.Maybe.bindTo("value")); // Task.Maybe({ value: 42 })
      * ```
      */
-    const bindTo: <K extends string>(key: K) => <A>(data: TaskMaybe<A>) => TaskMaybe<{ [P in K]: A; }>;
+    bindTo: <K extends string>(key: K) => <A>(data: TaskMaybe<A>) => TaskMaybe<{ [P in K]: A; }>;
     /**
      * Evaluates a new Task.Maybe using the current accumulator and attaches the output to a new key.
      *
@@ -1091,7 +1087,7 @@ declare namespace TaskMaybe {
      * ); // Task.Maybe({ a: 1, b: 2 })
      * ```
      */
-    const bind: <K extends string, A, B>(key: K, f: (a: A) => TaskMaybe<B>) => (data: TaskMaybe<A>) => TaskMaybe<A & { [P in K]: B; }>;
+    bind: <K extends string, A, B>(key: K, f: (a: A) => TaskMaybe<B>) => (data: TaskMaybe<A>) => TaskMaybe<A & { [P in K]: B; }>;
     /**
      * Recovers from a None state by providing a fallback Task.Maybe.
      *
@@ -1103,7 +1099,7 @@ declare namespace TaskMaybe {
      * ); // Task.Maybe(42)
      * ```
      */
-    const recover: <B>(fallback: () => TaskMaybe<B>) => <A>(data: TaskMaybe<A>) => TaskMaybe<A | B>;
+    recover: <B>(fallback: () => TaskMaybe<B>) => <A>(data: TaskMaybe<A>) => TaskMaybe<A | B>;
     /**
      * Combines a record of Task.Maybes into a single Task.Maybe of a record.
      * Evaluates fields in parallel and returns None if any task resolves to None.
@@ -1116,7 +1112,7 @@ declare namespace TaskMaybe {
      * }); // Task.Maybe({ name: "Alice", age: 30 })
      * ```
      */
-    const struct: <R extends Record<string, any>>(fields: { [K in keyof R]: TaskMaybe<R[K]>; }) => TaskMaybe<R>;
+    struct: <R extends Record<string, any>>(fields: { [K in keyof R]: TaskMaybe<R[K]>; }) => TaskMaybe<R>;
     /**
      * Creates a memoized version of a Task.Maybe. The task is executed at most once on first call,
      * and its resolved Maybe is cached for all subsequent calls.
@@ -1126,8 +1122,8 @@ declare namespace TaskMaybe {
      * const loadUser = Task.Maybe.memoize(fetchUserMaybeTask);
      * ```
      */
-    const memoize: <A>(task: TaskMaybe<A>) => TaskMaybe<A>;
-}
+    memoize: <A>(task: TaskMaybe<A>) => TaskMaybe<A>;
+};
 
 /**
  * A Task that can fail with an error of type E or succeed with a value of type A.
@@ -1143,8 +1139,8 @@ declare namespace TaskMaybe {
  * ```
  */
 type TaskResult<E, A> = Task<Result<E, A>>;
-declare namespace TaskResult {
-    namespace make {
+declare const TaskResult: {
+    make: {
         /**
          * Wraps a value in a successful Task.Result.
          *
@@ -1154,7 +1150,7 @@ declare namespace TaskResult {
          * const res = await task(); // Ok(42)
          * ```
          */
-        const ok: <E = never, A = unknown>(value: A) => TaskResult<E, A>;
+        ok: <E = never, A = unknown>(value: A) => TaskResult<E, A>;
         /**
          * Creates a failed Task.Result with the given error.
          *
@@ -1164,11 +1160,11 @@ declare namespace TaskResult {
          * const res = await task(); // Err("failed")
          * ```
          */
-        const err: <E, A = never>(error: E) => TaskResult<E, A>;
-    }
-    const ok: <E = never, A = unknown>(value: A) => TaskResult<E, A>;
-    const err: <E, A = never>(error: E) => TaskResult<E, A>;
-    namespace from {
+        err: <E, A = never>(error: E) => TaskResult<E, A>;
+    };
+    ok: <E = never, A = unknown>(value: A) => TaskResult<E, A>;
+    err: <E, A = never>(error: E) => TaskResult<E, A>;
+    from: {
         /**
          * Creates a Task.Result from a nullable value.
          * Returns Ok if the value is not null or undefined, err from onNull otherwise.
@@ -1179,7 +1175,7 @@ declare namespace TaskResult {
          * Task.Result.from.nullable(() => "missing")(null); // resolves to Err("missing")
          * ```
          */
-        const nullable: <E>(onNull: () => E) => <A>(value: A | null | undefined) => TaskResult<E, A>;
+        nullable: <E>(onNull: () => E) => <A>(value: A | null | undefined) => TaskResult<E, A>;
         /**
          * Creates a Task.Result from a Maybe.
          * Some becomes Ok, None becomes err from onNone.
@@ -1190,15 +1186,7 @@ declare namespace TaskResult {
          * Task.Result.from.Maybe(() => "empty")(Maybe.make.none());   // resolves to Err("empty")
          * ```
          */
-        const Maybe: <E>(onNone: () => E) => <A>(maybe: Maybe<A>) => TaskResult<E, A>;
-        /**
-         * Lifts a Result into a Task.Result.
-         *
-         * @example
-         * ```ts
-         * Task.Result.from.Result(Result.make.ok(42)); // resolves to Ok(42)
-         * ```
-         */
+        Maybe: <E>(onNone: () => E) => <A>(maybe: Maybe<A>) => TaskResult<E, A>;
         /**
          * Lifts a Result into a Task.Result.
          *
@@ -1207,9 +1195,9 @@ declare namespace TaskResult {
          * Task.Result.from.Result(Result.make.ok(42)); // resolves to Ok(42)
          * ```
          */
-        const Result: <E, A>(result: Result<E, A>) => TaskResult<E, A>;
-    }
-    namespace to {
+        Result: <E, A>(result: Result<E, A>) => TaskResult<E, A>;
+    };
+    to: {
         /**
          * Converts a Task.Result to a Task.Maybe, dropping the error value on Err.
          *
@@ -1219,8 +1207,8 @@ declare namespace TaskResult {
          * const taskMaybe = pipe(taskResult, Task.Result.to.Maybe);
          * ```
          */
-        const Maybe: <E, A>(data: TaskResult<E, A>) => TaskMaybe<A>;
-    }
+        Maybe: <E, A>(data: TaskResult<E, A>) => TaskMaybe<A>;
+    };
     /**
      * Creates a Task.Result from a Promise-returning thunk that may throw or reject.
      * Catches any errors and transforms them using the `onError` function into an `Err`.
@@ -1234,30 +1222,30 @@ declare namespace TaskResult {
      * );
      * ```
      */
-    const tryCatch: <E, A>(f: (signal?: AbortSignal) => Thenable<A>, options: {
+    tryCatch: <E, A>(f: (signal?: AbortSignal) => Thenable<A>, options: {
         onError: (error: unknown) => E;
     }) => TaskResult<E, A>;
     /**
      * Transforms the success value inside a Task.Result.
      */
-    const map: <E, A, B>(f: (a: A) => B) => (data: TaskResult<E, A>) => TaskResult<E, B>;
+    map: <E, A, B>(f: (a: A) => B) => (data: TaskResult<E, A>) => TaskResult<E, B>;
     /**
      * Transforms the error value inside a Task.Result.
      */
-    const mapError: <E, F, A>(f: (e: E) => F) => (data: TaskResult<E, A>) => TaskResult<F, A>;
+    mapError: <E, F, A>(f: (e: E) => F) => (data: TaskResult<E, A>) => TaskResult<F, A>;
     /**
      * Chains Task.Result computations. If the first succeeds, passes the value to f.
      * If the first fails, propagates the error.
      */
-    const chain: <E2, A, B>(f: (a: A) => TaskResult<E2, B>) => <E1 = never>(data: TaskResult<E1, A>) => TaskResult<E1 | E2, B>;
+    chain: <E2, A, B>(f: (a: A) => TaskResult<E2, B>) => <E1 = never>(data: TaskResult<E1, A>) => TaskResult<E1 | E2, B>;
     /**
      * Extracts the value from a Task.Result by providing handlers for both cases.
      */
-    const fold: <E, A, B>(onErr: (e: E) => B, onOk: (a: A) => B) => (data: TaskResult<E, A>) => Task<B>;
+    fold: <E, A, B>(onErr: (e: E) => B, onOk: (a: A) => B) => (data: TaskResult<E, A>) => Task<B>;
     /**
      * Pattern matches on a Task.Result, returning a Task of the result.
      */
-    const match: <E, A, B>(cases: {
+    match: <E, A, B>(cases: {
         err: (e: E) => B;
         ok: (a: A) => B;
     }) => (data: TaskResult<E, A>) => Task<B>;
@@ -1265,7 +1253,7 @@ declare namespace TaskResult {
      * Recovers from an error by providing a fallback Task.Result.
      * The fallback can produce a different success type, widening the result to `Task.Result<E, A | B>`.
      */
-    const recover: <E, B>(fallback: (e: E) => TaskResult<E, B>) => <A>(data: TaskResult<E, A>) => TaskResult<E, A | B>;
+    recover: <E, B>(fallback: (e: E) => TaskResult<E, B>) => <A>(data: TaskResult<E, A>) => TaskResult<E, A | B>;
     /**
      * Recovers from an error unless the predicate `isBlocked` returns true for that error.
      * The fallback can produce a different success type, widening the result to `Task.Result<E, A | B>`.
@@ -1281,17 +1269,17 @@ declare namespace TaskResult {
      * );
      * ```
      */
-    const recoverUnless: <E, B>(isBlocked: (e: E) => boolean, fallback: (e: E) => TaskResult<E, B>) => <A>(data: TaskResult<E, A>) => TaskResult<E, A | B>;
+    recoverUnless: <E, B>(isBlocked: (e: E) => boolean, fallback: (e: E) => TaskResult<E, B>) => <A>(data: TaskResult<E, A>) => TaskResult<E, A | B>;
     /**
      * Returns the success value or a default value if the Task.Result is an error.
      * The default can be a different type, widening the result to `Task<A | B>`.
      */
-    const getOrElse: <B>(defaultValue: () => B) => <E, A>(data: TaskResult<E, A>) => Task<A | B>;
+    getOrElse: <B>(defaultValue: () => B) => <E, A>(data: TaskResult<E, A>) => Task<A | B>;
     /**
      * Executes a side effect on the success value without changing the Task.Result.
      * Useful for logging or debugging.
      */
-    const tap: <E, A>(f: (a: A) => void) => (data: TaskResult<E, A>) => TaskResult<E, A>;
+    tap: <E, A>(f: (a: A) => void) => (data: TaskResult<E, A>) => TaskResult<E, A>;
     /**
      * Executes a side effect on the error value without changing the Task.Result.
      * Useful for logging or reporting async errors.
@@ -1305,12 +1293,12 @@ declare namespace TaskResult {
      * )
      * ```
      */
-    const tapError: <E, A>(f: (e: E) => void) => (data: TaskResult<E, A>) => TaskResult<E, A>;
+    tapError: <E, A>(f: (e: E) => void) => (data: TaskResult<E, A>) => TaskResult<E, A>;
     /**
      * Applies a function wrapped in a Task.Result to a value wrapped in a Task.Result.
      * Both Tasks run in parallel.
      */
-    const ap: <E, A>(arg: TaskResult<E, A>) => <B>(data: TaskResult<E, (a: A) => B>) => TaskResult<E, B>;
+    ap: <E, A>(arg: TaskResult<E, A>) => <B>(data: TaskResult<E, (a: A) => B>) => TaskResult<E, B>;
     /**
      * Executes a `Task.Result` with an optional signal, returning `Promise<Result<E, A>>`.
      * Use as a terminal step in a `pipe` chain.
@@ -1326,7 +1314,7 @@ declare namespace TaskResult {
      * if (Result.is.ok(result)) render(result.value);
      * ```
      */
-    const run: (signal?: AbortSignal) => <E, A>(task: TaskResult<E, A>) => Deferred<Result<E, A>>;
+    run: (signal?: AbortSignal) => <E, A>(task: TaskResult<E, A>) => Deferred<Result<E, A>>;
     /**
      * Converts a Task.Result value into an object containing a single property.
      * Initiates the pipeline accumulator record.
@@ -1336,7 +1324,7 @@ declare namespace TaskResult {
      * pipe(Task.Result.ok(42), Task.Result.bindTo("value")); // Task.Result({ value: 42 })
      * ```
      */
-    const bindTo: <K extends string>(key: K) => <E, A>(data: TaskResult<E, A>) => TaskResult<E, { [P in K]: A; }>;
+    bindTo: <K extends string>(key: K) => <E, A>(data: TaskResult<E, A>) => TaskResult<E, { [P in K]: A; }>;
     /**
      * Evaluates a new Task.Result using the current accumulator and attaches the output to a new key.
      *
@@ -1348,7 +1336,7 @@ declare namespace TaskResult {
      * ); // Task.Result({ a: 1, b: 2 })
      * ```
      */
-    const bind: <K extends string, E, A, B>(key: K, f: (a: A) => TaskResult<E, B>) => (data: TaskResult<E, A>) => TaskResult<E, A & { [P in K]: B; }>;
+    bind: <K extends string, E, A, B>(key: K, f: (a: A) => TaskResult<E, B>) => (data: TaskResult<E, A>) => TaskResult<E, A & { [P in K]: B; }>;
     /**
      * Combines a record of Task.Results into a single Task.Result of a record.
      * Evaluates all tasks in parallel, forwarding the AbortSignal down to each sub-task.
@@ -1362,7 +1350,7 @@ declare namespace TaskResult {
      * }); // Task.Result({ name: "Alice", age: 30 })
      * ```
      */
-    const struct: <E, R extends Record<string, any>>(fields: { [K in keyof R]: TaskResult<E, R[K]>; }) => TaskResult<E, R>;
+    struct: <E, R extends Record<string, any>>(fields: { [K in keyof R]: TaskResult<E, R[K]>; }) => TaskResult<E, R>;
     /**
      * Retries a fallible Task.Result according to a RetryPolicy.
      * If the task succeeds, returns Ok immediately.
@@ -1374,7 +1362,7 @@ declare namespace TaskResult {
      * const retryableFetch = pipe(fetchData, Task.Result.retry(policy));
      * ```
      */
-    const retry: (policy: RetryPolicy) => <E, A>(task: TaskResult<E, A>) => TaskResult<E, A>;
+    retry: (policy: RetryPolicy) => <E, A>(task: TaskResult<E, A>) => TaskResult<E, A>;
     /**
      * Creates a memoized version of a Task.Result. The task is executed at most once on first call,
      * and its resolved Result is cached for all subsequent calls.
@@ -1384,7 +1372,7 @@ declare namespace TaskResult {
      * const loadConfig = Task.Result.memoize(fetchConfigTask);
      * ```
      */
-    const memoize: <E, A>(task: TaskResult<E, A>) => TaskResult<E, A>;
+    memoize: <E, A>(task: TaskResult<E, A>) => TaskResult<E, A>;
     /**
      * Times out a fallible task, resolving to `Err(onTimeout())` if the duration elapses
      * before the task completes.
@@ -1397,7 +1385,7 @@ declare namespace TaskResult {
      * );
      * ```
      */
-    const timeout: <E2>(options: {
+    timeout: <E2>(options: {
         duration: Duration;
         onTimeout: () => E2;
     }) => <E1 = never, A = unknown>(task: TaskResult<E1, A>) => TaskResult<E1 | E2, A>;
@@ -1411,8 +1399,8 @@ declare namespace TaskResult {
      * // [Ok(val1), Err(err2), Ok(val3)]
      * ```
      */
-    const allSettled: <E, A>(tasks: ReadonlyArray<TaskResult<E, A>>) => Task<ReadonlyArray<Result<E, A>>>;
-}
+    allSettled: <E, A>(tasks: ReadonlyArray<TaskResult<E, A>>) => Task<ReadonlyArray<Result<E, A>>>;
+};
 
 /**
  * A Task that resolves to a Validation — combining async operations with
@@ -1436,8 +1424,8 @@ declare namespace TaskResult {
  * ```
  */
 type TaskValidation<E, A> = Task<Validation<E, A>>;
-declare namespace TaskValidation {
-    namespace make {
+declare const TaskValidation: {
+    make: {
         /**
          * Wraps a value in a passed Task.Validation.
          *
@@ -1447,7 +1435,7 @@ declare namespace TaskValidation {
          * const res = await task(); // Passed(42)
          * ```
          */
-        const passed: <E = never, A = unknown>(value: A) => TaskValidation<E, A>;
+        passed: <E = never, A = unknown>(value: A) => TaskValidation<E, A>;
         /**
          * Creates a failed Task.Validation with a single error.
          *
@@ -1457,7 +1445,7 @@ declare namespace TaskValidation {
          * const res = await task(); // Failed(["invalid"])
          * ```
          */
-        const failed: <E, A = never>(error: E) => TaskValidation<E, A>;
+        failed: <E, A = never>(error: E) => TaskValidation<E, A>;
         /**
          * Creates a failed Task.Validation from multiple errors.
          *
@@ -1467,12 +1455,12 @@ declare namespace TaskValidation {
          * const res = await task(); // Failed(["err1", "err2"])
          * ```
          */
-        const failedAll: <E, A = never>(errors: NonEmptyArr<E>) => TaskValidation<E, A>;
-    }
-    const passed: <E = never, A = unknown>(value: A) => TaskValidation<E, A>;
-    const failed: <E, A = never>(error: E) => TaskValidation<E, A>;
-    const failedAll: <E, A = never>(errors: NonEmptyArr<E>) => TaskValidation<E, A>;
-    namespace from {
+        failedAll: <E, A = never>(errors: NonEmptyArr<E>) => TaskValidation<E, A>;
+    };
+    passed: <E = never, A = unknown>(value: A) => TaskValidation<E, A>;
+    failed: <E, A = never>(error: E) => TaskValidation<E, A>;
+    failedAll: <E, A = never>(errors: NonEmptyArr<E>) => TaskValidation<E, A>;
+    from: {
         /**
          * Lifts a Validation into a Task.Validation.
          *
@@ -1481,7 +1469,7 @@ declare namespace TaskValidation {
          * Task.Validation.from.Validation(Validation.make.passed(42));
          * ```
          */
-        const Validation: <E, A>(validation: Validation<E, A>) => TaskValidation<E, A>;
+        Validation: <E, A>(validation: Validation<E, A>) => TaskValidation<E, A>;
         /**
          * Creates a Task.Validation from a nullable value.
          * If the value is null or undefined, returns Failed with the error from onNull.
@@ -1493,7 +1481,7 @@ declare namespace TaskValidation {
          * Task.Validation.from.nullable(() => "missing")(null); // resolves to Failed(["missing"])
          * ```
          */
-        const nullable: <E>(onNull: () => E) => <A>(value: A | null | undefined) => TaskValidation<E, A>;
+        nullable: <E>(onNull: () => E) => <A>(value: A | null | undefined) => TaskValidation<E, A>;
         /**
          * Creates a Task.Validation from a Maybe.
          * Some becomes Passed, None becomes Failed with the error from onNone.
@@ -1504,7 +1492,7 @@ declare namespace TaskValidation {
          * Task.Validation.from.Maybe(() => "empty")(Maybe.make.none());   // resolves to Failed(["empty"])
          * ```
          */
-        const Maybe: <E>(onNone: () => E) => <A>(maybe: Maybe<A>) => TaskValidation<E, A>;
+        Maybe: <E>(onNone: () => E) => <A>(maybe: Maybe<A>) => TaskValidation<E, A>;
         /**
          * Creates a Task.Validation from a Result.
          * Ok becomes Passed, Err(e) becomes Failed([e]).
@@ -1515,9 +1503,9 @@ declare namespace TaskValidation {
          * Task.Validation.from.Result(Result.make.err("bad")); // resolves to Failed(["bad"])
          * ```
          */
-        const Result: <E, A>(result: Result<E, A>) => TaskValidation<E, A>;
-    }
-    namespace to {
+        Result: <E, A>(result: Result<E, A>) => TaskValidation<E, A>;
+    };
+    to: {
         /**
          * Converts a `Task.Validation` to a `Task.Result`, combining accumulated errors using `combineErrors`.
          * `Passed(a)` becomes `Ok(a)`; `Failed(errors)` becomes `Err(combineErrors(errors))`.
@@ -1527,7 +1515,7 @@ declare namespace TaskValidation {
          * Task.Validation.to.Result((errors) => errors.join(", "))(validationTask);
          * ```
          */
-        const Result: <E1, E2, A>(combineErrors: (errors: NonEmptyArr<E1>) => E2) => (data: TaskValidation<E1, A>) => TaskResult<E2, A>;
+        Result: <E1, E2, A>(combineErrors: (errors: NonEmptyArr<E1>) => E2) => (data: TaskValidation<E1, A>) => TaskResult<E2, A>;
         /**
          * Converts a `Task.Validation` to a `Task.Maybe`.
          * `Passed(a)` becomes `Some(a)`; `Failed(errors)` becomes `None` (errors are discarded).
@@ -1537,12 +1525,8 @@ declare namespace TaskValidation {
          * Task.Validation.to.Maybe(validationTask);
          * ```
          */
-        const Maybe: <E, A>(data: TaskValidation<E, A>) => TaskMaybe<A>;
-    }
-    /**
-     * Creates a Task.Validation from a Promise-returning function.
-     * Catches any errors and transforms them using the onError function.
-     * The factory optionally receives an `AbortSignal` forwarded from the call site.
+        Maybe: <E, A>(data: TaskValidation<E, A>) => TaskMaybe<A>;
+    };
     /**
      * Creates a Task.Validation from a Promise-returning thunk that may throw or reject.
      * Catches any errors and transforms them using the `onError` function into a Failed validation.
@@ -1556,13 +1540,13 @@ declare namespace TaskValidation {
      * );
      * ```
      */
-    const tryCatch: <E, A>(f: (signal?: AbortSignal) => Thenable<A>, options: {
+    tryCatch: <E, A>(f: (signal?: AbortSignal) => Thenable<A>, options: {
         onError: (error: unknown) => E;
     }) => TaskValidation<E, A>;
     /**
      * Transforms the success value inside a Task.Validation.
      */
-    const map: <E, A, B>(f: (a: A) => B) => (data: TaskValidation<E, A>) => TaskValidation<E, B>;
+    map: <E, A, B>(f: (a: A) => B) => (data: TaskValidation<E, A>) => TaskValidation<E, B>;
     /**
      * Applies a function wrapped in a Task.Validation to a value wrapped in a
      * Task.Validation. Both Tasks run in parallel and errors from both sides
@@ -1577,11 +1561,11 @@ declare namespace TaskValidation {
      * )();
      * ```
      */
-    const ap: <E, A>(arg: TaskValidation<E, A>) => <B>(data: TaskValidation<E, (a: A) => B>) => TaskValidation<E, B>;
+    ap: <E, A>(arg: TaskValidation<E, A>) => <B>(data: TaskValidation<E, (a: A) => B>) => TaskValidation<E, B>;
     /**
      * Extracts a value from a Task.Validation by providing handlers for both cases.
      */
-    const fold: <E, A, B>(onFailed: (errors: NonEmptyArr<E>) => B, onPassed: (a: A) => B) => (data: TaskValidation<E, A>) => Task<B>;
+    fold: <E, A, B>(onFailed: (errors: NonEmptyArr<E>) => B, onPassed: (a: A) => B) => (data: TaskValidation<E, A>) => Task<B>;
     /**
      * Pattern matches on a Task.Validation, returning a Task of the result.
      *
@@ -1596,7 +1580,7 @@ declare namespace TaskValidation {
      * )();
      * ```
      */
-    const match: <E, A, B>(cases: {
+    match: <E, A, B>(cases: {
         passed: (a: A) => B;
         failed: (errors: NonEmptyArr<E>) => B;
     }) => (data: TaskValidation<E, A>) => Task<B>;
@@ -1604,18 +1588,18 @@ declare namespace TaskValidation {
      * Returns the success value or a default value if the Task.Validation is failed.
      * The default can be a different type, widening the result to `Task<A | B>`.
      */
-    const getOrElse: <B>(defaultValue: () => B) => <E, A>(data: TaskValidation<E, A>) => Task<A | B>;
+    getOrElse: <B>(defaultValue: () => B) => <E, A>(data: TaskValidation<E, A>) => Task<A | B>;
     /**
      * Executes a side effect on the success value without changing the Task.Validation.
      * Useful for logging or debugging.
      */
-    const tap: <E, A>(f: (a: A) => void) => (data: TaskValidation<E, A>) => TaskValidation<E, A>;
+    tap: <E, A>(f: (a: A) => void) => (data: TaskValidation<E, A>) => TaskValidation<E, A>;
     /**
      * Recovers from a Failed state by providing a fallback Task.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 `Task.Validation<E, A | B>`.
      */
-    const recover: <E, B>(fallback: (errors: NonEmptyArr<E>) => TaskValidation<E, B>) => <A>(data: TaskValidation<E, A>) => TaskValidation<E, A | B>;
+    recover: <E, B>(fallback: (errors: NonEmptyArr<E>) => TaskValidation<E, B>) => <A>(data: TaskValidation<E, A>) => TaskValidation<E, A | B>;
     /**
      * Recovers from a Failed state unless the predicate `isBlocked` returns true for the accumulated errors.
      * The fallback receives the accumulated errors and can produce a different success type, widening the result to `Task.Validation<E, A | B>`.
@@ -1631,7 +1615,7 @@ declare namespace TaskValidation {
      * );
      * ```
      */
-    const recoverUnless: <E, B>(isBlocked: (errors: NonEmptyArr<E>) => boolean, fallback: (errors: NonEmptyArr<E>) => TaskValidation<E, B>) => <A>(data: TaskValidation<E, A>) => TaskValidation<E, A | B>;
+    recoverUnless: <E, B>(isBlocked: (errors: NonEmptyArr<E>) => boolean, fallback: (errors: NonEmptyArr<E>) => TaskValidation<E, B>) => <A>(data: TaskValidation<E, A>) => TaskValidation<E, A | B>;
     /**
      * Runs two Task.Validations concurrently and combines their results into a tuple.
      * If both are Passed, returns Passed with both values. If either fails, accumulates
@@ -1645,7 +1629,7 @@ declare namespace TaskValidation {
      * )(); // Passed(["Alice", 30]) or Failed([...errors])
      * ```
      */
-    const product: <E, A, B>(first: TaskValidation<E, A>, second: TaskValidation<E, B>) => TaskValidation<E, readonly [A, B]>;
+    product: <E, A, B>(first: TaskValidation<E, A>, second: TaskValidation<E, B>) => TaskValidation<E, readonly [A, B]>;
     /**
      * Runs all Task.Validations concurrently and collects results.
      * If all are Passed, returns Passed with all values as an array.
@@ -1660,7 +1644,7 @@ declare namespace TaskValidation {
      * ])(); // Passed([name, email, age]) or Failed([...all errors])
      * ```
      */
-    const productAll: <E, A>(data: NonEmptyArr<TaskValidation<E, A>>) => TaskValidation<E, readonly A[]>;
+    productAll: <E, A>(data: NonEmptyArr<TaskValidation<E, A>>) => TaskValidation<E, readonly A[]>;
     /**
      * Transforms all accumulated errors inside a Task.Validation.
      *
@@ -1672,7 +1656,7 @@ declare namespace TaskValidation {
      * ); // Task.Validation(Failed(["OOPS"]))
      * ```
      */
-    const mapError: <E, F, A>(f: (e: E) => F) => (data: TaskValidation<E, A>) => TaskValidation<F, A>;
+    mapError: <E, F, A>(f: (e: E) => F) => (data: TaskValidation<E, A>) => TaskValidation<F, A>;
     /**
      * Executes a side effect on the accumulated errors without changing the Task.Validation.
      *
@@ -1684,7 +1668,7 @@ declare namespace TaskValidation {
      * );
      * ```
      */
-    const tapError: <E, A>(f: (errors: NonEmptyArr<E>) => void) => (data: TaskValidation<E, A>) => TaskValidation<E, A>;
+    tapError: <E, A>(f: (errors: NonEmptyArr<E>) => void) => (data: TaskValidation<E, A>) => TaskValidation<E, A>;
     /**
      * Combines a record of Task.Validations into a single Task.Validation of a record.
      * Evaluates fields in parallel and accumulates all validation errors.
@@ -1697,7 +1681,7 @@ declare namespace TaskValidation {
      * }); // Task.Validation({ name: "Alice", age: 30 })
      * ```
      */
-    const struct: <E, R extends Record<string, any>>(fields: { [K in keyof R]: TaskValidation<E, R[K]>; }) => TaskValidation<E, R>;
+    struct: <E, R extends Record<string, any>>(fields: { [K in keyof R]: TaskValidation<E, R[K]>; }) => TaskValidation<E, R>;
     /**
      * Creates a memoized version of a Task.Validation. The task is executed at most once on first call,
      * and its resolved Validation is cached for all subsequent calls.
@@ -1707,8 +1691,8 @@ declare namespace TaskValidation {
      * const validate = Task.Validation.memoize(validateFormTask);
      * ```
      */
-    const memoize: <E, A>(task: TaskValidation<E, A>) => TaskValidation<E, A>;
-}
+    memoize: <E, A>(task: TaskValidation<E, A>) => TaskValidation<E, A>;
+};
 
 /**
  * A lazy async computation that always resolves.
@@ -1753,7 +1737,7 @@ declare namespace TaskValidation {
  * ```
  */
 type Task<A> = (signal?: AbortSignal) => Deferred<A>;
-declare namespace Task {
+declare const Task: {
     /**
      * Creates a Task that immediately resolves to the given value.
      *
@@ -1763,8 +1747,8 @@ declare namespace Task {
      * const value = await task(); // 42
      * ```
      */
-    const resolve: <A>(value: A) => Task<A>;
-    namespace from {
+    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.
@@ -1775,8 +1759,8 @@ declare namespace Task {
          * const ts = await t(); // called here, every time
          * ```
          */
-        const sync: <A>(f: () => A) => Task<A>;
-    }
+        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>`.
@@ -1789,7 +1773,7 @@ declare namespace Task {
      * );
      * ```
      */
-    const tryCatch: <A>(f: (signal?: AbortSignal) => globalThis.Promise<A>, options: {
+    tryCatch: <A>(f: (signal?: AbortSignal) => globalThis.Promise<A>, options: {
         onError: (error: unknown) => A;
     }) => Task<A>;
     /**
@@ -1803,7 +1787,7 @@ declare namespace Task {
      * )(); // Deferred<10>
      * ```
      */
-    const map: <A, B>(f: (a: A) => B) => (data: Task<A>) => Task<B>;
+    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.
      *
@@ -1819,7 +1803,7 @@ declare namespace Task {
      * )(); // Deferred<Preferences>
      * ```
      */
-    const chain: <A, B>(f: (a: A) => Task<B>) => (data: Task<A>) => Task<B>;
+    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.
@@ -1834,7 +1818,7 @@ declare namespace Task {
      * )(); // Deferred<8>
      * ```
      */
-    const ap: <A>(arg: Task<A>) => <B>(data: Task<(a: A) => B>) => Task<B>;
+    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.
@@ -1848,7 +1832,7 @@ declare namespace Task {
      * );
      * ```
      */
-    const tap: <A>(f: (a: A) => void) => (data: Task<A>) => Task<A>;
+    tap: <A>(f: (a: A) => void) => (data: Task<A>) => Task<A>;
     /**
      * Runs multiple Tasks in parallel and collects their results.
      *
@@ -1858,7 +1842,7 @@ declare namespace Task {
      * // Deferred<[Config, string, Theme]>
      * ```
      */
-    const all: <T extends readonly Task<unknown>[]>(tasks: T) => Task<{ [K in keyof T]: T[K] extends Task<infer A> ? A : never; }>;
+    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.
@@ -1871,7 +1855,7 @@ declare namespace Task {
      * )(); // Resolves after 1 second
      * ```
      */
-    const delay: (duration: Duration) => <A>(data: Task<A>) => Task<A>;
+    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.
@@ -1884,7 +1868,7 @@ declare namespace Task {
      * )(); // Task<Reading[]> — 5 readings, one per second
      * ```
      */
-    const repeat: (options: {
+    repeat: (options: {
         times: number;
         delay?: Duration;
     }) => <A>(task: Task<A>) => Task<readonly A[]>;
@@ -1902,7 +1886,7 @@ declare namespace Task {
      * )(); // polls every 500ms until status is "ready"
      * ```
      */
-    const repeatUntil: <A>(options: {
+    repeatUntil: <A>(options: {
         when: (a: A) => boolean;
         delay?: Duration;
         maxAttempts?: number;
@@ -1920,7 +1904,7 @@ declare namespace Task {
      * await Task.race([fast, slow])(); // "fast"
      * ```
      */
-    const race: <A>(tasks: ReadonlyArray<Task<A>>) => Task<A>;
+    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.
@@ -1931,7 +1915,7 @@ declare namespace Task {
      * // Deferred<[Config, string, Theme]>
      * ```
      */
-    const sequence: <A>(tasks: ReadonlyArray<Task<A>>) => Task<ReadonlyArray<A>>;
+    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.
@@ -1945,7 +1929,7 @@ declare namespace Task {
      * // log = [1, 2, 3] — tasks ran in order
      * ```
      */
-    const sequential: <A>(tasks: ReadonlyArray<Task<A>>) => Task<ReadonlyArray<A>>;
+    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
@@ -1961,7 +1945,7 @@ declare namespace Task {
      * );
      * ```
      */
-    const timeout: <E>(options: {
+    timeout: <E>(options: {
         duration: Duration;
         onTimeout: () => E;
     }) => <A>(task: Task<A>) => Task<Result<E, A>>;
@@ -1986,7 +1970,7 @@ declare namespace Task {
      * await poll();
      * ```
      */
-    const abortable: <A>(factory: (signal: AbortSignal) => Thenable<A>) => {
+    abortable: <A>(factory: (signal: AbortSignal) => Thenable<A>) => {
         task: Task<A>;
         abort: () => void;
     };
@@ -2002,7 +1986,7 @@ declare namespace Task {
      * );
      * ```
      */
-    const run: (signal?: AbortSignal) => <A>(task: Task<A>) => Deferred<A>;
+    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.
@@ -2012,7 +1996,7 @@ declare namespace Task {
      * pipe(Task.resolve(42), Task.bindTo("value")); // Task({ value: 42 })
      * ```
      */
-    const bindTo: <K extends string>(key: K) => <A>(data: Task<A>) => Task<{ [P in K]: A; }>;
+    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.
      *
@@ -2024,7 +2008,7 @@ declare namespace Task {
      * ); // Task({ a: 1, b: 2 })
      * ```
      */
-    const bind: <K extends string, A, B>(key: K, f: (a: A) => Task<B>) => (data: Task<A>) => Task<A & { [P in K]: B; }>;
+    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.
@@ -2036,7 +2020,7 @@ declare namespace Task {
      * const token2 = await loadToken(); // returns cached token immediately
      * ```
      */
-    const memoize: <A>(task: Task<A>) => Task<A>;
+    memoize: <A>(task: Task<A>) => Task<A>;
     /**
      * Monitors progress of a Task by calling `onProgress(0)` before execution and `onProgress(1)` upon completion.
      *
@@ -2048,10 +2032,7 @@ declare namespace Task {
      * );
      * ```
      */
-    const withProgress: <A>(onProgress: (ratio: number) => void) => (task: Task<A>) => Task<A>;
-    type LabeledTask<L extends string, A> = Task<A> & {
-        readonly label: L;
-    };
+    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.
      *
@@ -2061,17 +2042,141 @@ declare namespace Task {
      * console.log(labeledTask.label); // "readUser"
      * ```
      */
-    const withLabel: <L extends string>(label: L) => <A>(task: Task<A>) => LabeledTask<L, A>;
+    withLabel: <L extends string>(label: L) => <A>(task: Task<A>) => Task.LabeledTask<L, A>;
+    Maybe: {
+        make: {
+            some: <A>(value: A) => TaskMaybe<A>;
+            none: <A = never>() => TaskMaybe<A>;
+        };
+        some: <A>(value: A) => TaskMaybe<A>;
+        none: <A = never>() => TaskMaybe<A>;
+        from: {
+            Maybe: <A>(option: Maybe<A>) => TaskMaybe<A>;
+            nullable: <A>(value: A | null | undefined) => TaskMaybe<A>;
+            Result: <E, A>(result: Result<E, A>) => TaskMaybe<A>;
+            Task: <A>(task: Task<A>) => TaskMaybe<A>;
+        };
+        tryCatch: <A>(f: (signal?: AbortSignal) => Thenable<A>) => TaskMaybe<A>;
+        map: <A, B>(f: (a: A) => B) => (data: TaskMaybe<A>) => TaskMaybe<B>;
+        chain: <A, B>(f: (a: A) => TaskMaybe<B>) => (data: TaskMaybe<A>) => TaskMaybe<B>;
+        ap: <A>(arg: TaskMaybe<A>) => <// Deferred<10>
+        B>(data: TaskMaybe<(a: A) => B>) => TaskMaybe<B>;
+        fold: <A, B>(onNone: () => B, onSome: (a: A) => B) => (data: TaskMaybe<A>) => Task<B>;
+        match: <A, B>(cases: {
+            none: () => B;
+            some: (a: A) => B;
+        }) => (data: TaskMaybe<A>) => Task<B>;
+        getOrElse: <B>(defaultValue: () => B) => <A>(data: TaskMaybe<A>) => Task<A | B>;
+        tap: <A>(f: (a: A) => void) => (data: TaskMaybe<A>) => TaskMaybe<A>;
+        filter: <A>(predicate: (a: A) => boolean) => (data: TaskMaybe<A>) => TaskMaybe<A>;
+        to: {
+            Result: <E>(onNone: () => E) => <A>(data: TaskMaybe<A>) => Task.Result<E, A>;
+        };
+        bindTo: <K extends string>(key: K) => <A>(data: TaskMaybe<A>) => TaskMaybe<{ [P in K]: A; }>;
+        bind: <K extends string, A, B>(key: K, f: (a: A) => TaskMaybe<B>) => (data: TaskMaybe<A>) => TaskMaybe<A & { [P in K]: B; }>;
+        recover: <B>(fallback: () => TaskMaybe<B>) => <A>(data: TaskMaybe<A>) => TaskMaybe<A | B>;
+        struct: <R extends Record<string, any>>(fields: { [K in keyof R]: TaskMaybe<R[K]>; }) => TaskMaybe<R>;
+        memoize: <A>(task: TaskMaybe<A>) => TaskMaybe<A>;
+    };
+    Result: {
+        make: {
+            ok: <E = never, A = unknown>(value: A) => TaskResult<E, A>;
+            err: <E, A = never>(error: E) => TaskResult<E, A>;
+        };
+        ok: <E = never, A = unknown>(value: A) => TaskResult<E, A>;
+        err: <E, A = never>(error: E) => TaskResult<E, A>;
+        from: {
+            nullable: <E>(onNull: () => E) => <A>(value: A | null | undefined) => TaskResult<E, A>;
+            Maybe: <E>(onNone: () => E) => <A>(maybe: Maybe<A>) => TaskResult<E, A>;
+            Result: <E, A>(result: Result<E, A>) => TaskResult<E, A>;
+        };
+        to: {
+            Maybe: <E, A>(data: TaskResult<E, A>) => TaskMaybe<A>;
+        };
+        tryCatch: <E, A>(f: (signal?: AbortSignal) => Thenable<A>, options: {
+            onError: (error: unknown) => E;
+        }) => TaskResult<E, A>;
+        map: <E, A, B>(f: (a: A) => B) => (data: TaskResult<E, A>) => TaskResult<E, B>;
+        mapError: <E, F, A>(f: (e: E) => F) => (data: TaskResult<E, A>) => TaskResult<F, A>;
+        chain: <E2, A, B>(f: (a: A) => TaskResult<E2, B>) => <E1 = never>(data: TaskResult<E1, A>) => TaskResult<E1 | E2, B>;
+        fold: <E, A, B>(onErr: (e: E) => B, onOk: (a: A) => B) => (data: TaskResult<E, A>) => Task<B>;
+        match: <E, A, B>(cases: {
+            err: (e: E) => B;
+            ok: (a: A) => B;
+        }) => (data: TaskResult<E, A>) => Task<B>;
+        recover: <E, B>(fallback: (e: E) => TaskResult<E, B>) => <A>(data: TaskResult<E, A>) => TaskResult<E, A | B>;
+        recoverUnless: <E, B>(isBlocked: (e: E) => boolean, fallback: (e: E) => TaskResult<E, B>) => <A>(data: TaskResult<E, A>) => TaskResult<E, A | B>;
+        getOrElse: <B>(defaultValue: () => B) => <E, A>(// oxlint-disable-next-line prefer-const
+        data: TaskResult<E, A>) => Task<A | B>;
+        tap: <E, A>(f: (a: A) => void) => (data: TaskResult<E, A>) => TaskResult<E, A>;
+        tapError: <E, A>(f: (e: E) => void) => (data: TaskResult<E, A>) => TaskResult<E, A>;
+        ap: <E, A>(arg: TaskResult<E, A>) => <B>(data: TaskResult<E, (a: A) => B>) => TaskResult<E, B>;
+        run: (signal?: AbortSignal) => <E, A>(task: TaskResult<E, A>) => Deferred<Result<E, A>>;
+        bindTo: <K extends string>(key: K) => <E, A>(data: TaskResult<E, A>) => TaskResult<E, { [P in K]: A; }>;
+        bind: <K extends string, E, A, B>(key: K, f: (a: A) => TaskResult<E, B>) => (data: TaskResult<E, A>) => TaskResult<E, A & { [P in K]: B; }>;
+        struct: <E, R extends Record<string, any>>(fields: { [K in keyof R]: TaskResult<E, R[K]>; }) => TaskResult<E, R>;
+        retry: (policy: RetryPolicy) => <E, A>(task: TaskResult<E, A>) => TaskResult<E, A>;
+        memoize: <E, A>(task: TaskResult<E, A>) => TaskResult<E, A>;
+        timeout: <E2>(options: {
+            duration: Duration;
+            onTimeout: () => E2;
+        }) => <E1 = never, A = unknown>(task: TaskResult<E1, A>) => TaskResult<E1 | E2, A>;
+        allSettled: <E, A>(tasks: ReadonlyArray<TaskResult<E, A>>) => Task<ReadonlyArray<Result<E, A>>>;
+    };
+    Validation: {
+        make: {
+            passed: <E = never, A = unknown>(value: A) => TaskValidation<E, A>;
+            failed: <E, A = never>(error: E) => TaskValidation<E, A>;
+            failedAll: <E, A = never>(errors: NonEmptyArr<E>) => TaskValidation<E, A>;
+        };
+        passed: <E = never, A = unknown>(value: A) => TaskValidation<E, A>;
+        failed: <E, A = never>(error: E) => TaskValidation<E, A>;
+        failedAll: <E, A = never>(errors: NonEmptyArr<E>) => TaskValidation<E, A>;
+        from: {
+            Validation: <E, A>(validation: Validation<E, A>) => TaskValidation<E, A>;
+            nullable: <E>(onNull: () => E) => <A>(value: A | null | undefined) => TaskValidation<E, A>;
+            Maybe: <E>(onNone: () => E) => <A>(maybe: Maybe<A>) => TaskValidation<E, A>;
+            Result: <E, A>(result: Result<E, A>) => TaskValidation<E, A>;
+        };
+        to: {
+            Result: <E1, E2, A>(combineErrors: (errors: NonEmptyArr<E1>) => E2) => (data: TaskValidation<E1, A>) => TaskResult<E2, A>;
+            Maybe: <E, A>(data: TaskValidation<E, A>) => TaskMaybe<A>;
+        };
+        tryCatch: <E, A>(f: (signal?: AbortSignal) => Thenable<A>, options: {
+            onError: (error: unknown) => E;
+        }) => TaskValidation<E, A>;
+        map: <E, A, B>(f: (a: A) => B) => (data: TaskValidation<E, A>) => TaskValidation<E, B>;
+        ap: <E, A>(arg: TaskValidation<E, A>) => <B>(data: TaskValidation<E, (a: A) => B>) => TaskValidation<E, B>;
+        fold: <E, A, B>(onFailed: (errors: NonEmptyArr<E>) => B, onPassed: (a: A) => B) => (data: TaskValidation<E, A>) => Task<B>;
+        match: <E, A, B>(cases: {
+            passed: (a: A) => B;
+            failed: (errors: NonEmptyArr<E>) => B;
+        }) => (data: TaskValidation<E, A>) => Task<B>;
+        getOrElse: <B>(defaultValue: () => B) => <E, A>(data: TaskValidation<E, A>) => Task<A | B>;
+        tap: <E, A>(f: (a: A) => void) => (data: TaskValidation<E, A>) => TaskValidation<E, A>;
+        recover: <E, B>(fallback: (errors: NonEmptyArr<E>) => TaskValidation<E, B>) => <A>(data: TaskValidation<E, A>) => TaskValidation<E, A | B>;
+        recoverUnless: <E, B>(isBlocked: (errors: NonEmptyArr<E>) => boolean, fallback: (errors: NonEmptyArr<E>) => TaskValidation<E, B>) => <A>(data: TaskValidation<E, A>) => TaskValidation<E, A | B>;
+        product: <E, A, B>(first: TaskValidation<E, A>, second: TaskValidation<E, B>) => TaskValidation<E, readonly [A, B]>;
+        productAll: <E, A>(data: NonEmptyArr<TaskValidation<E, A>>) => TaskValidation<E, readonly A[]>;
+        mapError: <E, F, A>(f: (e: E) => F) => (data: TaskValidation<E, A>) => TaskValidation<F, A>;
+        tapError: <E, A>(f: (errors: NonEmptyArr<E>) => void) => (data: TaskValidation<E, A>) => TaskValidation<E, A>;
+        struct: <E, R extends Record<string, any>>(fields: { [K in keyof R]: TaskValidation<E, R[K]>; }) => TaskValidation<E, R>;
+        memoize: <E, A>(task: TaskValidation<E, A>) => TaskValidation<E, A>;
+    };
+};
+declare namespace Task {
+    type LabeledTask<L extends string, A> = Task<A> & {
+        readonly label: L;
+    };
     type Maybe<A> = TaskMaybe<A>;
-    const Maybe: typeof TaskMaybe;
     type Result<E, A> = TaskResult<E, A>;
-    const Result: typeof TaskResult;
     type Validation<E, A> = TaskValidation<E, A>;
-    const Validation: typeof TaskValidation;
 }
 
 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.
@@ -2098,8 +2203,8 @@ type Failed<E> = WithKind<"Failed"> & WithErrors<E>;
  * ```
  */
 type Validation<E, A> = Passed<A> | Failed<E>;
-declare namespace Validation {
-    namespace make {
+declare const Validation: {
+    make: {
         /**
          * Wraps a value in a passed Validation.
          *
@@ -2108,7 +2213,7 @@ declare namespace Validation {
          * Validation.make.passed(42); // Passed(42)
          * ```
          */
-        const passed: <E, A>(value: A) => Validation<E, A>;
+        passed: <E, A>(value: A) => Validation<E, A>;
         /**
          * Creates a failed Validation from a single error.
          *
@@ -2117,7 +2222,7 @@ declare namespace Validation {
          * Validation.make.failed("Invalid input");
          * ```
          */
-        const failed: <E>(error: E) => Failed<E>;
+        failed: <E>(error: E) => Failed<E>;
         /**
          * Creates a failed Validation from multiple errors.
          *
@@ -2126,9 +2231,9 @@ declare namespace Validation {
          * Validation.make.failedAll(["Invalid input"]);
          * ```
          */
-        const failedAll: <E>(errors: NonEmptyArr<E>) => Failed<E>;
-    }
-    namespace is {
+        failedAll: <E>(errors: NonEmptyArr<E>) => Failed<E>;
+    };
+    is: {
         /**
          * Type guard that checks if a Validation is passed.
          *
@@ -2140,7 +2245,7 @@ declare namespace Validation {
          * }
          * ```
          */
-        const passed: <E, A>(data: Validation<E, A>) => data is Passed<A>;
+        passed: <E, A>(data: Validation<E, A>) => data is Passed<A>;
         /**
          * Type guard that checks if a Validation is failed.
          *
@@ -2152,8 +2257,8 @@ declare namespace Validation {
          * }
          * ```
          */
-        const failed: <E, A>(data: Validation<E, A>) => data is Failed<E>;
-    }
+        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.
@@ -2166,10 +2271,10 @@ declare namespace Validation {
      * );
      * ```
      */
-    const tryCatch: <E, A>(f: () => A, options: {
+    tryCatch: <E, A>(f: () => A, options: {
         onError: (e: unknown) => E;
     }) => Validation<E, A>;
-    namespace from {
+    from: {
         /**
          * Creates a Validation from a predicate applied to a value.
          * Returns Passed if the predicate passes, Failed from `onFalse` otherwise.
@@ -2185,7 +2290,7 @@ declare namespace Validation {
          * validateName("");      // Failed(["Name is required"])
          * ```
          */
-        const Predicate: <E, A>(pred: (a: A) => boolean, onFalse: (a: A) => E) => (a: A) => Validation<E, A>;
+        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.
@@ -2197,7 +2302,7 @@ declare namespace Validation {
          * pipe(42, Validation.from.nullable(() => "is null"));   // Passed(42)
          * ```
          */
-        const nullable: <E>(onNull: () => E) => <A>(value: A | null | undefined) => Validation<E, A>;
+        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.
@@ -2209,7 +2314,7 @@ declare namespace Validation {
          * pipe(Maybe.make.some(42), Validation.from.Maybe(() => "is none")); // Passed(42)
          * ```
          */
-        const Maybe: <E>(onNone: () => E) => <A>(maybe: Maybe<A>) => Validation<E, A>;
+        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])`.
          *
@@ -2222,8 +2327,8 @@ declare namespace Validation {
          * Validation.from.Result(Result.make.err("bad"));   // Failed(["bad"])
          * ```
          */
-        const Result: <E, A>(data: Result<E, A>) => Validation<E, A>;
-    }
+        Result: <E, A>(data: Result<E, A>) => Validation<E, A>;
+    };
     /**
      * Transforms the success value inside a Validation.
      *
@@ -2233,7 +2338,7 @@ declare namespace Validation {
      * pipe(Validation.make.failed("oops"), Validation.map(n => n * 2)); // Failed(["oops"])
      * ```
      */
-    const map: <A, B>(f: (a: A) => B) => <E>(data: Validation<E, A>) => Validation<E, B>;
+    map: <A, B>(f: (a: A) => B) => <E>(data: Validation<E, A>) => Validation<E, B>;
     /**
      * Transforms the error list inside a Validation.
      *
@@ -2242,7 +2347,7 @@ declare namespace Validation {
      * pipe(Validation.make.failed("oops"), Validation.mapError(e => e.toUpperCase())); // Failed(["OOPS"])
      * ```
      */
-    const mapError: <E, F, A>(f: (e: E) => F) => (data: Validation<E, A>) => Validation<F, A>;
+    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.
@@ -2263,7 +2368,7 @@ declare namespace Validation {
      * ); // Failed(["bad a", "bad b"])
      * ```
      */
-    const ap: <E, A>(arg: Validation<E, A>) => <B>(data: Validation<E, (a: A) => B>) => Validation<E, 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.
@@ -2275,7 +2380,7 @@ declare namespace Validation {
      * pipe(fnVal, Validation.apCustom(concat)(argVal));
      * ```
      */
-    const 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>;
+    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.
      *
@@ -2290,7 +2395,7 @@ declare namespace Validation {
      * );
      * ```
      */
-    const fold: <E, A, B>(onFailed: (errors: NonEmptyArr<E>) => B, onPassed: (a: A) => B) => (data: Validation<E, A>) => B;
+    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.
      *
@@ -2305,7 +2410,7 @@ declare namespace Validation {
      * );
      * ```
      */
-    const match: <E, A, B>(cases: {
+    match: <E, A, B>(cases: {
         passed: (a: A) => B;
         failed: (errors: NonEmptyArr<E>) => B;
     }) => (data: Validation<E, A>) => B;
@@ -2320,7 +2425,7 @@ declare namespace Validation {
      * pipe(Validation.make.failed("oops"), Validation.getOrElse(() => null)); // null — typed as number | null
      * ```
      */
-    const getOrElse: <B>(defaultValue: () => B) => <E, A>(data: Validation<E, A>) => A | B;
+    getOrElse: <B>(defaultValue: () => B) => <E, A>(data: Validation<E, A>) => A | B;
     /**
      * Executes a side effect on the success value without changing the Validation.
      *
@@ -2333,7 +2438,7 @@ declare namespace Validation {
      * );
      * ```
      */
-    const tap: <E, A>(f: (a: A) => void) => (data: Validation<E, A>) => Validation<E, A>;
+    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.
@@ -2347,13 +2452,13 @@ declare namespace Validation {
      * );
      * ```
      */
-    const tapError: <E, A>(f: (errors: NonEmptyArr<E>) => void) => (data: Validation<E, A>) => Validation<E, A>;
+    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>`.
      */
-    const recover: <E, B>(fallback: (errors: NonEmptyArr<E>) => Validation<E, B>) => <A>(data: Validation<E, A>) => 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>`.
@@ -2366,8 +2471,8 @@ declare namespace Validation {
      * ); // Passed(0)
      * ```
      */
-    const recoverUnless: <E, B>(isBlocked: (e: E) => boolean, fallback: () => Validation<E, B>) => <A>(data: Validation<E, A>) => Validation<E, A | B>;
-    namespace to {
+    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.
@@ -2381,8 +2486,7 @@ declare namespace Validation {
          * pipe(Validation.make.failed("oops"), Validation.to.Result(errors => errors.join(", "))); // Err("oops")
          * ```
          */
-        function Result<E1, E2, A>(combineErrors: (errors: NonEmptyArr<E1>) => E2): (val: Validation<E1, A>) => Result<E2, A>;
-        function Result<E, A>(data: Validation<E, A>): Result<NonEmptyArr<E>, A>;
+        Result: typeof toResult;
         /**
          * Converts a Validation to a Maybe. `Passed` becomes `Some`; `Failed` becomes `None`
          * (errors are discarded).
@@ -2393,8 +2497,8 @@ declare namespace Validation {
          * Validation.to.Maybe(Validation.make.failed("bad"));  // None
          * ```
          */
-        const Maybe: <E, A>(data: Validation<E, A>) => Maybe<A>;
-    }
+        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.
@@ -2413,7 +2517,7 @@ declare namespace Validation {
      * ); // Failed(["Name required", "Age must be >= 0"])
      * ```
      */
-    const product: <E, A, B>(first: Validation<E, A>, second: Validation<E, B>) => Validation<E, readonly [A, B]>;
+    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.
@@ -2429,7 +2533,7 @@ declare namespace Validation {
      * // Passed([name, email, age]) or Failed([...all errors])
      * ```
      */
-    const productAll: <E, A>(data: NonEmptyArr<Validation<E, A>>) => Validation<E, readonly A[]>;
+    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.
@@ -2447,7 +2551,7 @@ declare namespace Validation {
      * }); // Failed(["Name required", "Age must be >= 0"])
      * ```
      */
-    const struct: <E, R extends Record<string, any>>(fields: { [K in keyof R]: Validation<E, R[K]>; }) => Validation<E, R>;
-}
+    struct: <E, R extends Record<string, any>>(fields: { [K in keyof R]: Validation<E, R[K]>; }) => Validation<E, R>;
+};
 
 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 };