@nlozgachev/pipelined 0.44.0 → 0.45.0

package/dist/{Validation-Dz70wtcG.d.mts → Validation-v38R0qH-.d.mts}

@@ -1,4 +1,4 @@
-import { g as WithKind, n as WithValue, d as WithError, T as Thenable, D as Deferred, N as NonEmptyArr, e as WithErrors } from './InternalTypes-BL23H8Qr.mjs';
+import { h as WithKind, o as WithValue, e as WithError, T as Thenable, D as Deferred, a as NonEmptyArr, f as WithErrors } from './InternalTypes-CLE7qlOc.mjs';
 import { Duration } from './types.mjs';
 
 /**
@@ -96,7 +96,7 @@ type None = WithKind<"None">;
  *
  * @example
  * ```ts
- * const user = { name: "Alice", email: Maybe.some("alice@example.com") };
+ * const user = { name: "Alice", email: Maybe.make.some("alice@example.com") };
  *
  * pipe(
  *   user.email,
@@ -107,91 +107,99 @@ type None = WithKind<"None">;
  */
 type Maybe<T> = Some<T> | None;
 declare namespace Maybe {
-    /**
-     * Creates a Some containing the given value.
-     */
-    const some: <A>(value: A) => Some<A>;
-    /**
-     * Type guard that checks if a Maybe is Some.
-     */
-    const isSome: <A>(data: Maybe<A>) => data is Some<A>;
-    /**
-     * Creates a None (empty Maybe).
-     */
-    const none: () => None;
-    /**
-     * Type guard that checks if a Maybe is None.
-     */
-    const isNone: <A>(data: Maybe<A>) => data is None;
-    /**
-     * Creates a Maybe from a nullable value.
-     * Returns None if the value is null or undefined, Some otherwise.
-     *
-     * @example
-     * ```ts
-     * Maybe.fromNullable(null); // None
-     * Maybe.fromNullable(42); // Some(42)
-     * ```
-     */
-    const fromNullable: <A>(value: A | null | undefined) => Maybe<A>;
-    /**
-     * Extracts the value from a Maybe, returning null if None.
-     */
-    const toNullable: <A>(data: Maybe<A>) => A | null;
-    /**
-     * Extracts the value from a Maybe, returning undefined if None.
-     */
-    const toUndefined: <A>(data: Maybe<A>) => A | undefined;
-    /**
-     * Creates a Maybe from a predicate applied to a value.
-     * Returns Some if the predicate passes, None otherwise.
-     *
-     * @example
-     * ```ts
-     * Maybe.fromPredicate((n: number) => n >= 18)(21); // Some(21)
-     * Maybe.fromPredicate((n: number) => n >= 18)(15); // None
-     *
-     * pipe("hello", Maybe.fromPredicate((s: string) => s.length > 0)); // Some("hello")
-     * pipe("", Maybe.fromPredicate((s: string) => s.length > 0));      // None
-     * ```
-     */
-    const fromPredicate: <A>(pred: (a: A) => boolean) => (a: A) => Maybe<A>;
-    /**
-     * Converts a Maybe to a Result.
-     * Some becomes Ok, None becomes Err with the provided error.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   Maybe.some(42),
-     *   Maybe.toResult(() => "Value was missing")
-     * ); // Ok(42)
-     *
-     * pipe(
-     *   Maybe.none(),
-     *   Maybe.toResult(() => "Value was missing")
-     * ); // Err("Value was missing")
-     * ```
-     */
-    const toResult: <E>(onNone: () => E) => <A>(data: Maybe<A>) => Result<E, A>;
-    /**
-     * Creates a Maybe from a Result.
-     * Ok becomes Some, Err becomes None (the error is discarded).
-     *
-     * @example
-     * ```ts
-     * Maybe.fromResult(Result.ok(42)); // Some(42)
-     * Maybe.fromResult(Result.err("oops")); // None
-     * ```
-     */
-    const fromResult: <E, A>(data: Result<E, A>) => Maybe<A>;
+    namespace make {
+        /**
+         * Creates a Some containing the given value.
+         */
+        const some: <A>(value: A) => Some<A>;
+        /**
+         * Creates a None (empty Maybe).
+         */
+        const none: () => None;
+    }
+    namespace is {
+        /**
+         * Type guard that checks if a Maybe is Some.
+         */
+        const some: <A>(data: Maybe<A>) => data is Some<A>;
+        /**
+         * Type guard that checks if a Maybe is None.
+         */
+        const none: <A>(data: Maybe<A>) => data is None;
+    }
+    namespace to {
+        /**
+         * Extracts the value from a Maybe, returning null if None.
+         */
+        const nullable: <A>(data: Maybe<A>) => A | null;
+        /**
+         * Extracts the value from a Maybe, returning undefined if None.
+         */
+        const 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")
+         * ```
+         */
+        const Result: <E>(onNone: () => E) => <A>(data: Maybe<A>) => Result<E, A>;
+    }
+    namespace 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)
+         * ```
+         */
+        const 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
+         * ```
+         */
+        const 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
+         * ```
+         */
+        const Result: <E, A>(data: Result<E, A>) => Maybe<A>;
+    }
     /**
      * Transforms the value inside a Maybe if it exists.
      *
      * @example
      * ```ts
-     * pipe(Maybe.some(5), Maybe.map(n => n * 2)); // Some(10)
-     * pipe(Maybe.none(), Maybe.map(n => n * 2)); // None
+     * pipe(Maybe.make.some(5), Maybe.map(n => n * 2)); // Some(10)
+     * pipe(Maybe.make.none(), Maybe.map(n => n * 2)); // None
      * ```
      */
     const map: <A, B>(f: (a: A) => B) => (data: Maybe<A>) => Maybe<B>;
@@ -203,11 +211,11 @@ declare namespace Maybe {
      * ```ts
      * const parseNumber = (s: string): Maybe<number> => {
      *   const n = parseInt(s, 10);
-     *   return isNaN(n) ? Maybe.none() : Maybe.some(n);
+     *   return isNaN(n) ? Maybe.make.none() : Maybe.make.some(n);
      * };
      *
-     * pipe(Maybe.some("42"), Maybe.chain(parseNumber)); // Some(42)
-     * pipe(Maybe.some("abc"), Maybe.chain(parseNumber)); // None
+     * pipe(Maybe.make.some("42"), Maybe.chain(parseNumber)); // Some(42)
+     * pipe(Maybe.make.some("abc"), Maybe.chain(parseNumber)); // None
      * ```
      */
     const chain: <A, B>(f: (a: A) => Maybe<B>) => (data: Maybe<A>) => Maybe<B>;
@@ -217,7 +225,7 @@ declare namespace Maybe {
      * @example
      * ```ts
      * pipe(
-     *   Maybe.some(5),
+     *   Maybe.make.some(5),
      *   Maybe.fold(
      *     () => "No value",
      *     n => `Value: ${n}`
@@ -251,9 +259,9 @@ declare namespace Maybe {
      *
      * @example
      * ```ts
-     * pipe(Maybe.some(5), Maybe.getOrElse(() => 0)); // 5
-     * pipe(Maybe.none(), Maybe.getOrElse(() => 0)); // 0
-     * pipe(Maybe.none<string>(), Maybe.getOrElse(() => null)); // null — typed as string | null
+     * 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
      * ```
      */
     const getOrElse: <A, B>(defaultValue: () => B) => (data: Maybe<A>) => A | B;
@@ -264,7 +272,7 @@ declare namespace Maybe {
      * @example
      * ```ts
      * pipe(
-     *   Maybe.some(5),
+     *   Maybe.make.some(5),
      *   Maybe.tap(n => console.log("Value:", n)),
      *   Maybe.map(n => n * 2)
      * );
@@ -277,8 +285,8 @@ declare namespace Maybe {
      *
      * @example
      * ```ts
-     * pipe(Maybe.some(5), Maybe.filter(n => n > 3)); // Some(5)
-     * pipe(Maybe.some(2), Maybe.filter(n => n > 3)); // None
+     * pipe(Maybe.make.some(5), Maybe.filter(n => n > 3)); // Some(5)
+     * pipe(Maybe.make.some(2), Maybe.filter(n => n > 3)); // None
      * ```
      */
     const filter: <A>(predicate: (a: A) => boolean) => (data: Maybe<A>) => Maybe<A>;
@@ -294,9 +302,9 @@ declare namespace Maybe {
      * ```ts
      * const add = (a: number) => (b: number) => a + b;
      * pipe(
-     *   Maybe.some(add),
-     *   Maybe.ap(Maybe.some(5)),
-     *   Maybe.ap(Maybe.some(3))
+     *   Maybe.make.some(add),
+     *   Maybe.ap(Maybe.make.some(5)),
+     *   Maybe.ap(Maybe.make.some(3))
      * ); // Some(8)
      * ```
      */
@@ -307,7 +315,7 @@ declare namespace Maybe {
      *
      * @example
      * ```ts
-     * pipe(Maybe.some(42), Maybe.bindTo("value")); // Some({ value: 42 })
+     * 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; }>;
@@ -317,8 +325,8 @@ declare namespace Maybe {
      * @example
      * ```ts
      * pipe(
-     *   Maybe.some({ a: 1 }),
-     *   Maybe.bind("b", ({ a }) => Maybe.some(a + 1))
+     *   Maybe.make.some({ a: 1 }),
+     *   Maybe.bind("b", ({ a }) => Maybe.make.some(a + 1))
      * ); // Some({ a: 1, b: 2 })
      * ```
      */
@@ -330,8 +338,8 @@ declare namespace Maybe {
      * @example
      * ```ts
      * Maybe.struct({
-     *   name: Maybe.some("Alice"),
-     *   age: Maybe.some(30)
+     *   name: Maybe.make.some("Alice"),
+     *   age: Maybe.make.some(30)
      * }); // Some({ name: "Alice", age: 30 })
      * ```
      */
@@ -425,7 +433,7 @@ type Err<E> = WithKind<"Err"> & WithError<E>;
  * @example
  * ```ts
  * const divide = (a: number, b: number): Result<string, number> =>
- *   b === 0 ? Result.err("Division by zero") : Result.ok(a / b);
+ *   b === 0 ? Result.make.err("Division by zero") : Result.make.ok(a / b);
  *
  * pipe(
  *   divide(10, 2),
@@ -436,22 +444,26 @@ type Err<E> = WithKind<"Err"> & WithError<E>;
  */
 type Result<E, A> = Ok<A> | Err<E>;
 declare namespace Result {
-    /**
-     * Creates a successful Result with the given value.
-     */
-    const ok: <A>(value: A) => Ok<A>;
-    /**
-     * Creates a failed Result with the given error.
-     */
-    const err: <E>(e: E) => Err<E>;
-    /**
-     * Type guard that checks if a Result is Ok.
-     */
-    const isOk: <E, A>(data: Result<E, A>) => data is Ok<A>;
-    /**
-     * Type guard that checks if a Result is Err.
-     */
-    const isErr: <E, A>(data: Result<E, A>) => data is Err<E>;
+    namespace make {
+        /**
+         * Creates a successful Result with the given value.
+         */
+        const ok: <A>(value: A) => Ok<A>;
+        /**
+         * Creates a failed Result with the given error.
+         */
+        const err: <E>(e: E) => Err<E>;
+    }
+    namespace is {
+        /**
+         * Type guard that checks if a Result is Ok.
+         */
+        const ok: <E, A>(data: Result<E, A>) => data is Ok<A>;
+        /**
+         * Type guard that checks if a Result is Err.
+         */
+        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.
@@ -471,8 +483,8 @@ declare namespace Result {
      *
      * @example
      * ```ts
-     * pipe(Result.ok(5), Result.map(n => n * 2)); // Ok(10)
-     * pipe(Result.err("error"), Result.map(n => n * 2)); // Err("error")
+     * pipe(Result.make.ok(5), Result.map(n => n * 2)); // Ok(10)
+     * 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>;
@@ -481,7 +493,7 @@ declare namespace Result {
      *
      * @example
      * ```ts
-     * pipe(Result.err("oops"), Result.mapError(e => e.toUpperCase())); // Err("OOPS")
+     * 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>;
@@ -492,10 +504,10 @@ declare namespace Result {
      * @example
      * ```ts
      * const validatePositive = (n: number): Result<string, number> =>
-     *   n > 0 ? Result.ok(n) : Result.err("Must be positive");
+     *   n > 0 ? Result.make.ok(n) : Result.make.err("Must be positive");
      *
-     * pipe(Result.ok(5), Result.chain(validatePositive)); // Ok(5)
-     * pipe(Result.ok(-1), Result.chain(validatePositive)); // 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")
      * ```
      */
     const chain: <E, A, B>(f: (a: A) => Result<E, B>) => (data: Result<E, A>) => Result<E, B>;
@@ -505,7 +517,7 @@ declare namespace Result {
      * @example
      * ```ts
      * pipe(
-     *   Result.ok(5),
+     *   Result.make.ok(5),
      *   Result.fold(
      *     e => `Error: ${e}`,
      *     n => `Value: ${n}`
@@ -539,9 +551,9 @@ declare namespace Result {
      *
      * @example
      * ```ts
-     * pipe(Result.ok(5), Result.getOrElse(() => 0)); // 5
-     * pipe(Result.err("error"), Result.getOrElse(() => 0)); // 0
-     * pipe(Result.err("error"), Result.getOrElse(() => null)); // null — typed as number | null
+     * 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
      * ```
      */
     const getOrElse: <E, A, B>(defaultValue: () => B) => (data: Result<E, A>) => A | B;
@@ -552,7 +564,7 @@ declare namespace Result {
      * @example
      * ```ts
      * pipe(
-     *   Result.ok(5),
+     *   Result.make.ok(5),
      *   Result.tap(n => console.log("Value:", n)),
      *   Result.map(n => n * 2)
      * );
@@ -566,63 +578,65 @@ declare namespace Result {
      * @example
      * ```ts
      * pipe(
-     *   Result.err("not found"),
+     *   Result.make.err("not found"),
      *   Result.tapError(e => console.error("validation failed:", e)),
      *   Result.chain(save),
      * )
      * ```
      */
     const tapError: <E, A>(f: (e: E) => void) => (data: Result<E, A>) => Result<E, A>;
-    /**
-     * 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.fromPredicate(n => n > 0, n => `${n} is not positive`));  // Ok(5)
-     * pipe(-1, Result.fromPredicate(n => n > 0, n => `${n} is not positive`)); // Err("-1 is not positive")
-     * pipe("", Result.fromPredicate(s => s.length > 0, () => "empty string")); // Err("empty string")
-     * ```
-     */
-    const fromPredicate: <E, A>(pred: (a: A) => boolean, onFalse: (a: A) => E) => (a: A) => Result<E, A>;
-    /**
-     * Creates a Result from a nullable value.
-     * Returns Ok if the value is not null or undefined, error from onNull otherwise.
-     *
-     * @example
-     * ```ts
-     * pipe(null, Result.fromNullable(() => "is null")); // Err("is null")
-     * pipe(42, Result.fromNullable(() => "is null"));   // Ok(42)
-     * ```
-     */
-    const fromNullable: <E>(onNull: () => E) => <A>(value: A | null | undefined) => Result<E, A>;
-    /**
-     * Creates a Result from a Maybe.
-     * Some becomes Ok, None becomes error from onNone.
-     *
-     * @example
-     * ```ts
-     * pipe(Maybe.none(), Result.fromMaybe(() => "is none")); // Err("is none")
-     * pipe(Maybe.some(42), Result.fromMaybe(() => "is none")); // Ok(42)
-     * ```
-     */
-    const fromMaybe: <E>(onNone: () => E) => <A>(maybe: Maybe<A>) => Result<E, A>;
-    /**
-     * Wraps a throwing function of any arguments, returning a new function
-     * that catches errors and returns a Result.
-     *
-     * @example
-     * ```ts
-     * const safeParse = Result.fromThrowable(
-     *   (s: string) => JSON.parse(s),
-     *   (e) => new Error(`Parse error: ${e}`)
-     * );
-     *
-     * safeParse('{"a":1}'); // Ok({ a: 1 })
-     * safeParse('invalid');  // Err(Error)
-     * ```
-     */
-    const fromThrowable: <Args extends readonly unknown[], A, E>(f: (...args: Args) => A, onError: (e: unknown) => E) => (...args: Args) => Result<E, A>;
+    namespace 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")
+         * ```
+         */
+        const 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)
+         * ```
+         */
+        const 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)
+         * ```
+         */
+        const Maybe: <E>(onNone: () => E) => <A>(maybe: Maybe<A>) => Result<E, A>;
+        /**
+         * Wraps a throwing function of any arguments, returning a new function
+         * that catches errors and returns a Result.
+         *
+         * @example
+         * ```ts
+         * const safeParse = Result.from.throwable(
+         *   (s: string) => JSON.parse(s),
+         *   (e) => new Error(`Parse error: ${e}`)
+         * );
+         *
+         * safeParse('{"a":1}'); // Ok({ a: 1 })
+         * safeParse('invalid');  // Err(Error)
+         * ```
+         */
+        const throwable: <Args extends readonly unknown[], A, E>(f: (...args: Args) => A, onError: (e: unknown) => E) => (...args: Args) => Result<E, A>;
+    }
     /**
      * Recovers from an error by providing a fallback Result.
      * The fallback can produce a different success type, widening the result to `Result<E, A | B>`.
@@ -635,23 +649,25 @@ declare namespace Result {
      * @example
      * ```ts
      * pipe(
-     *   Result.err(new Error("not found")),
-     *   Result.recoverUnless(e => e.message === "fatal", () => Result.ok(0))
+     *   Result.make.err(new Error("not found")),
+     *   Result.recoverUnless(e => e.message === "fatal", () => Result.make.ok(0))
      * ); // Ok(0)
      * ```
      */
     const recoverUnless: <E, A, B>(isBlocked: (e: E) => boolean, fallback: () => Result<E, B>) => (data: Result<E, A>) => Result<E, A | B>;
-    /**
-     * Converts a Result to a Maybe.
-     * Ok becomes Some, Err becomes None (the error is discarded).
-     *
-     * @example
-     * ```ts
-     * Result.toMaybe(Result.ok(42)); // Some(42)
-     * Result.toMaybe(Result.err("oops")); // None
-     * ```
-     */
-    const toMaybe: <E, A>(data: Result<E, A>) => Maybe<A>;
+    namespace 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
+         * ```
+         */
+        const Maybe: <E, A>(data: Result<E, A>) => Maybe<A>;
+    }
     /**
      * Applies a function wrapped in a Result to a value wrapped in a Result.
      *
@@ -659,9 +675,9 @@ declare namespace Result {
      * ```ts
      * const add = (a: number) => (b: number) => a + b;
      * pipe(
-     *   Result.ok(add),
-     *   Result.ap(Result.ok(5)),
-     *   Result.ap(Result.ok(3))
+     *   Result.make.ok(add),
+     *   Result.ap(Result.make.ok(5)),
+     *   Result.ap(Result.make.ok(3))
      * ); // Ok(8)
      * ```
      */
@@ -672,7 +688,7 @@ declare namespace Result {
      *
      * @example
      * ```ts
-     * pipe(Result.ok(42), Result.bindTo("value")); // Ok({ value: 42 })
+     * 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; }>;
@@ -682,8 +698,8 @@ declare namespace Result {
      * @example
      * ```ts
      * pipe(
-     *   Result.ok({ a: 1 }),
-     *   Result.bind("b", ({ a }) => Result.ok(a + 1))
+     *   Result.make.ok({ a: 1 }),
+     *   Result.bind("b", ({ a }) => Result.make.ok(a + 1))
      * ); // Ok({ a: 1, b: 2 })
      * ```
      */
@@ -695,8 +711,8 @@ declare namespace Result {
      * @example
      * ```ts
      * Result.struct({
-     *   name: Result.ok("Alice"),
-     *   age: Result.ok(30)
+     *   name: Result.make.ok("Alice"),
+     *   age: Result.make.ok(30)
      * }); // Ok({ name: "Alice", age: 30 })
      * ```
      */
@@ -704,19 +720,17 @@ declare namespace Result {
 }
 
 /**
- * A Task that resolves to an optional value.
- * Combines async operations with the Maybe type for values that may not exist.
+ * TaskMaybe represents a lazy, infallible async operation that resolves to a `Maybe<A>`.
+ * It is a type alias for `Task<Maybe<A>>`.
+ *
+ * Use Task.Maybe for async operations that can result in a missing value (e.g. database lookups).
  *
  * @example
  * ```ts
  * const findUser = (id: string): Task.Maybe<User> =>
- *   Task.Maybe.tryCatch(() => db.users.findById(id));
- *
- * pipe(
- *   findUser("123"),
- *   Task.Maybe.map(user => user.name),
- *   Task.Maybe.getOrElse(() => "Unknown")
- * )();
+ *   Task.Maybe.tryCatch((signal) =>
+ *     fetch(`/users/${id}`, { signal }).then(r => r.ok ? r.json() : null)
+ *   );
  * ```
  */
 type TaskMaybe<A> = Task<Maybe<A>>;
@@ -729,24 +743,26 @@ declare namespace TaskMaybe {
      * Creates a Task.Maybe that resolves to None.
      */
     const none: <A = never>() => TaskMaybe<A>;
-    /**
-     * Lifts an Option into a Task.Maybe.
-     */
-    const fromMaybe: <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.
-     */
-    const fromNullable: <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).
-     */
-    const fromResult: <E, A>(result: Result<E, A>) => TaskMaybe<A>;
-    /**
-     * Lifts a Task into a Task.Maybe by wrapping its result in Some.
-     */
-    const fromTask: <A>(task: Task<A>) => TaskMaybe<A>;
+    namespace from {
+        /**
+         * Lifts an Option into a Task.Maybe.
+         */
+        const 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.
+         */
+        const 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).
+         */
+        const Result: <E, A>(result: Result<E, A>) => TaskMaybe<A>;
+        /**
+         * Lifts a Task into a Task.Maybe by wrapping its result in Some.
+         */
+        const 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.
@@ -818,18 +834,20 @@ declare namespace TaskMaybe {
      * 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>;
-    /**
-     * Converts a Task.Maybe to a Task.Result, using onNone to produce the error value.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   findUser("123"),
-     *   Task.Maybe.toResult(() => "User not found")
-     * );
-     * ```
-     */
-    const toResult: <E>(onNone: () => E) => <A>(data: TaskMaybe<A>) => Task.Result<E, A>;
+    namespace to {
+        /**
+         * Converts a Task.Maybe to a Task.Result, using onNone to produce the error value.
+         *
+         * @example
+         * ```ts
+         * pipe(
+         *   findUser("123"),
+         *   Task.Maybe.to.Result(() => "User not found")
+         * );
+         * ```
+         */
+        const Result: <E>(onNone: () => E) => <A>(data: TaskMaybe<A>) => Task.Result<E, A>;
+    }
     /**
      * Lifts a Task.Maybe value into an accumulator object.
      *
@@ -901,25 +919,27 @@ declare namespace TaskResult {
      * Creates a failed Task.Result with the given error.
      */
     const err: <E, A>(error: E) => TaskResult<E, A>;
-    /**
-     * Creates a Task.Result from a nullable value.
-     * Returns Ok if the value is not null or undefined, err from onNull otherwise.
-     */
-    const fromNullable: <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.
-     */
-    const fromMaybe: <E>(onNone: () => E) => <A>(maybe: Maybe<A>) => TaskResult<E, A>;
-    /**
-     * Lifts a Result into a Task.Result.
-     */
-    const fromResult: <E, A>(result: Result<E, A>) => TaskResult<E, A>;
-    /**
-     * Wraps a Promise-returning function of any arguments, returning a new function
-     * that catches rejections and returns a Task.Result.
-     */
-    const fromThrowable: <Args extends readonly unknown[], A, E>(f: (...args: Args) => Promise<A>, onError: (e: unknown) => E) => (...args: Args) => TaskResult<E, A>;
+    namespace from {
+        /**
+         * Creates a Task.Result from a nullable value.
+         * Returns Ok if the value is not null or undefined, err from onNull otherwise.
+         */
+        const 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.
+         */
+        const Maybe: <E>(onNone: () => E) => <A>(maybe: Maybe<A>) => TaskResult<E, A>;
+        /**
+         * Lifts a Result into a Task.Result.
+         */
+        const Result: <E, A>(result: Result<E, A>) => TaskResult<E, A>;
+        /**
+         * Wraps a Promise-returning function of any arguments, returning a new function
+         * that catches rejections and returns a Task.Result.
+         */
+        const throwable: <Args extends readonly unknown[], A, E>(f: (...args: Args) => Promise<A>, onError: (e: unknown) => E) => (...args: Args) => TaskResult<E, A>;
+    }
     /**
      * Creates a Task.Result from a function that may throw.
      * Catches any errors and transforms them using the onError function.
@@ -1005,7 +1025,7 @@ declare namespace TaskResult {
      *     Task.Result.chain(user => fetchPosts(user.id)),
      *     Task.Result.run(controller.signal),
      * );
-     * if (Result.isOk(result)) render(result.value);
+     * if (Result.is.ok(result)) render(result.value);
      * ```
      */
     const run: (signal?: AbortSignal) => <E, A>(task: TaskResult<E, A>) => Deferred<Result<E, A>>;
@@ -1082,26 +1102,28 @@ declare namespace TaskValidation {
      * Creates a failed Task.Validation from multiple errors.
      */
     const failedAll: <E, A>(errors: NonEmptyArr<E>) => TaskValidation<E, A>;
-    /**
-     * Lifts a Validation into a Task.Validation.
-     */
-    const fromValidation: <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.
-     * Otherwise, returns Passed.
-     */
-    const fromNullable: <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.
-     */
-    const fromMaybe: <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]).
-     */
-    const fromResult: <E, A>(result: Result<E, A>) => TaskValidation<E, A>;
+    namespace from {
+        /**
+         * Lifts a Validation into a Task.Validation.
+         */
+        const 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.
+         * Otherwise, returns Passed.
+         */
+        const 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.
+         */
+        const 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]).
+         */
+        const Result: <E, A>(result: Result<E, A>) => TaskValidation<E, A>;
+    }
     /**
      * Creates a Task.Validation from a Promise-returning function.
      * Catches any errors and transforms them using the onError function.
@@ -1265,9 +1287,9 @@ declare namespace TaskValidation {
  * ```
  *
  * When you need an explicit `Promise<A>` (e.g. for a third-party API), convert
- * the `Deferred` with `Deferred.toPromise`:
+ * the `Deferred` with `Deferred.to.Promise`:
  * ```ts
- * const p: Promise<number> = Deferred.toPromise(task());
+ * const p: Promise<number> = Deferred.to.Promise(task());
  * ```
  *
  * @example
@@ -1296,27 +1318,29 @@ declare namespace Task {
      * ```
      */
     const resolve: <A>(value: A) => Task<A>;
-    /**
-     * Creates a Task from a function that returns a Promise.
-     * The factory optionally receives an `AbortSignal` forwarded from the call site.
-     *
-     * @example
-     * ```ts
-     * const getTimestamp = Task.from(() => Promise.resolve(Date.now()));
-     * ```
-     */
-    const from: <A>(f: (signal?: AbortSignal) => Thenable<A>) => Task<A>;
-    /**
-     * Creates a Task from a lazy synchronous thunk.
-     * Unlike `Task.resolve(f())`, `fromSync` does not evaluate `f` until the Task is called.
-     *
-     * @example
-     * ```ts
-     * const t = Task.fromSync(() => Date.now()); // Date.now() not called yet
-     * const ts = await t(); // called here, every time
-     * ```
-     */
-    const fromSync: <A>(f: () => A) => Task<A>;
+    namespace from {
+        /**
+         * Creates a Task from a function that returns a Promise.
+         * The factory optionally receives an `AbortSignal` forwarded from the call site.
+         *
+         * @example
+         * ```ts
+         * const getTimestamp = Task.from.Promise(() => Promise.resolve(Date.now()));
+         * ```
+         */
+        const Promise: <A>(f: (signal?: AbortSignal) => Thenable<A>) => Task<A>;
+        /**
+         * Creates a Task from a lazy synchronous thunk.
+         * Unlike `Task.resolve(f())`, `from.sync` does not evaluate `f` until the Task is called.
+         *
+         * @example
+         * ```ts
+         * const t = Task.from.sync(() => Date.now()); // Date.now() not called yet
+         * const ts = await t(); // called here, every time
+         * ```
+         */
+        const sync: <A>(f: () => A) => Task<A>;
+    }
     /**
      * Transforms the value inside a Task.
      *
@@ -1439,8 +1463,8 @@ declare namespace Task {
      *
      * @example
      * ```ts
-     * const fast = Task.from(() => new Promise<string>(r => setTimeout(() => r("fast"), 10)));
-     * const slow = Task.from(() => new Promise<string>(r => setTimeout(() => r("slow"), 200)));
+     * const fast = Task.from.Promise(() => new Promise<string>(r => setTimeout(() => r("fast"), 10)));
+     * const slow = Task.from.Promise(() => new Promise<string>(r => setTimeout(() => r("slow"), 200)));
      *
      * await Task.race([fast, slow])(); // "fast"
      * ```
@@ -1464,7 +1488,7 @@ declare namespace Task {
      * @example
      * ```ts
      * let log: number[] = [];
-     * const makeTask = (n: number) => Task.from(() => {
+     * const makeTask = (n: number) => Task.from.Promise(() => {
      *   log.push(n);
      *   return Promise.resolve(n);
      * });
@@ -1571,14 +1595,14 @@ type Failed<E> = WithKind<"Failed"> & WithErrors<E>;
  * @example
  * ```ts
  * const validateName = (name: string): Validation<string, string> =>
- *   name.length > 0 ? Validation.passed(name) : Validation.failed("Name is required");
+ *   name.length > 0 ? Validation.make.passed(name) : Validation.make.failed("Name is required");
  *
  * const validateAge = (age: number): Validation<string, number> =>
- *   age >= 0 ? Validation.passed(age) : Validation.failed("Age must be positive");
+ *   age >= 0 ? Validation.make.passed(age) : Validation.make.failed("Age must be positive");
  *
  * // Accumulates all errors using ap
  * pipe(
- *   Validation.passed((name: string) => (age: number) => ({ name, age })),
+ *   Validation.make.passed((name: string) => (age: number) => ({ name, age })),
  *   Validation.ap(validateName("")),
  *   Validation.ap(validateAge(-1))
  * );
@@ -1587,88 +1611,107 @@ type Failed<E> = WithKind<"Failed"> & WithErrors<E>;
  */
 type Validation<E, A> = Passed<A> | Failed<E>;
 declare namespace Validation {
-    /**
-     * Wraps a value in a passed Validation.
-     *
-     * @example
-     * ```ts
-     * Validation.passed(42); // Passed(42)
-     * ```
-     */
-    const passed: <E, A>(value: A) => Validation<E, A>;
-    /**
-     * Creates a failed Validation from a single error.
-     *
-     * @example
-     * ```ts
-     * Validation.failed("Invalid input");
-     * ```
-     */
-    const failed: <E>(error: E) => Failed<E>;
-    /**
-     * Creates a failed Validation from multiple errors.
-     *
-     * @example
-     * ```ts
-     * Validation.failedAll(["Invalid input"]);
-     * ```
-     */
-    const failedAll: <E>(errors: NonEmptyArr<E>) => Failed<E>;
-    /**
-     * Type guard that checks if a Validation is passed.
-     */
-    const isPassed: <E, A>(data: Validation<E, A>) => data is Passed<A>;
-    /**
-     * Type guard that checks if a Validation is failed.
-     */
-    const isFailed: <E, A>(data: Validation<E, A>) => data is Failed<E>;
-    /**
-     * 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.fromPredicate(
-     *   (s: string) => s.length > 0,
-     *   () => "Name is required"
-     * );
-     *
-     * validateName("Alice"); // Passed("Alice")
-     * validateName("");      // Failed(["Name is required"])
-     * ```
-     */
-    const fromPredicate: <E, A>(pred: (a: A) => boolean, onFalse: (a: A) => E) => (a: A) => Validation<E, A>;
-    /**
-     * Creates a Validation from a nullable value.
-     * If the value is null or undefined, returns Failed with the error from onNull.
-     * Otherwise, returns Passed.
-     *
-     * @example
-     * ```ts
-     * pipe(null, Validation.fromNullable(() => "is null")); // Failed(["is null"])
-     * pipe(42, Validation.fromNullable(() => "is null"));   // Passed(42)
-     * ```
-     */
-    const fromNullable: <E>(onNull: () => E) => <A>(value: A | null | undefined) => Validation<E, A>;
-    /**
-     * Creates a Validation from a Maybe.
-     * If the Maybe is None, returns Failed with the error from onNone.
-     * Otherwise, returns Passed.
-     *
-     * @example
-     * ```ts
-     * pipe(Maybe.none(), Validation.fromMaybe(() => "is none")); // Failed(["is none"])
-     * pipe(Maybe.some(42), Validation.fromMaybe(() => "is none")); // Passed(42)
-     * ```
-     */
-    const fromMaybe: <E>(onNone: () => E) => <A>(maybe: Maybe<A>) => Validation<E, A>;
+    namespace make {
+        /**
+         * Wraps a value in a passed Validation.
+         *
+         * @example
+         * ```ts
+         * Validation.make.passed(42); // Passed(42)
+         * ```
+         */
+        const passed: <E, A>(value: A) => Validation<E, A>;
+        /**
+         * Creates a failed Validation from a single error.
+         *
+         * @example
+         * ```ts
+         * Validation.make.failed("Invalid input");
+         * ```
+         */
+        const failed: <E>(error: E) => Failed<E>;
+        /**
+         * Creates a failed Validation from multiple errors.
+         *
+         * @example
+         * ```ts
+         * Validation.make.failedAll(["Invalid input"]);
+         * ```
+         */
+        const failedAll: <E>(errors: NonEmptyArr<E>) => Failed<E>;
+    }
+    namespace is {
+        /**
+         * Type guard that checks if a Validation is passed.
+         */
+        const passed: <E, A>(data: Validation<E, A>) => data is Passed<A>;
+        /**
+         * Type guard that checks if a Validation is failed.
+         */
+        const failed: <E, A>(data: Validation<E, A>) => data is Failed<E>;
+    }
+    namespace 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"])
+         * ```
+         */
+        const 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)
+         * ```
+         */
+        const 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)
+         * ```
+         */
+        const 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"])
+         * ```
+         */
+        const Result: <E, A>(data: Result<E, A>) => Validation<E, A>;
+    }
     /**
      * Transforms the success value inside a Validation.
      *
      * @example
      * ```ts
-     * pipe(Validation.passed(5), Validation.map(n => n * 2)); // Passed(10)
-     * pipe(Validation.failed("oops"), Validation.map(n => n * 2)); // Failed(["oops"])
+     * pipe(Validation.make.passed(5), Validation.map(n => n * 2)); // Passed(10)
+     * 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>;
@@ -1677,7 +1720,7 @@ declare namespace Validation {
      *
      * @example
      * ```ts
-     * pipe(Validation.failed("oops"), Validation.mapError(e => e.toUpperCase())); // Failed(["OOPS"])
+     * 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>;
@@ -1689,15 +1732,15 @@ declare namespace Validation {
      * ```ts
      * const add = (a: number) => (b: number) => a + b;
      * pipe(
-     *   Validation.passed(add),
-     *   Validation.ap(Validation.passed(5)),
-     *   Validation.ap(Validation.passed(3))
+     *   Validation.make.passed(add),
+     *   Validation.ap(Validation.make.passed(5)),
+     *   Validation.ap(Validation.make.passed(3))
      * ); // Passed(8)
      *
      * pipe(
-     *   Validation.passed(add),
-     *   Validation.ap(Validation.failed<string, number>("bad a")),
-     *   Validation.ap(Validation.failed<string, number>("bad b"))
+     *   Validation.make.passed(add),
+     *   Validation.ap(Validation.make.failed<string, number>("bad a")),
+     *   Validation.ap(Validation.make.failed<string, number>("bad b"))
      * ); // Failed(["bad a", "bad b"])
      * ```
      */
@@ -1708,7 +1751,7 @@ declare namespace Validation {
      * @example
      * ```ts
      * pipe(
-     *   Validation.passed(42),
+     *   Validation.make.passed(42),
      *   Validation.fold(
      *     errors => `Errors: ${errors.join(", ")}`,
      *     value => `Value: ${value}`
@@ -1741,9 +1784,9 @@ declare namespace Validation {
      *
      * @example
      * ```ts
-     * pipe(Validation.passed(5), Validation.getOrElse(() => 0)); // 5
-     * pipe(Validation.failed("oops"), Validation.getOrElse(() => 0)); // 0
-     * pipe(Validation.failed("oops"), Validation.getOrElse(() => null)); // null — typed as number | null
+     * 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
      * ```
      */
     const getOrElse: <E, A, B>(defaultValue: () => B) => (data: Validation<E, A>) => A | B;
@@ -1753,7 +1796,7 @@ declare namespace Validation {
      * @example
      * ```ts
      * pipe(
-     *   Validation.passed(5),
+     *   Validation.make.passed(5),
      *   Validation.tap(n => console.log("Value:", n)),
      *   Validation.map(n => n * 2)
      * );
@@ -1767,7 +1810,7 @@ declare namespace Validation {
      * @example
      * ```ts
      * pipe(
-     *   Validation.failed("Name required"),
+     *   Validation.make.failed("Name required"),
      *   Validation.tapError(errors => console.error("validation failed:", errors)),
      *   Validation.map(toUser)
      * );
@@ -1787,47 +1830,36 @@ declare namespace Validation {
      * @example
      * ```ts
      * pipe(
-     *   Validation.failed("field-error"),
-     *   Validation.recoverUnless(e => e === "fatal", () => Validation.passed(0))
+     *   Validation.make.failed("field-error"),
+     *   Validation.recoverUnless(e => e === "fatal", () => Validation.make.passed(0))
      * ); // Passed(0)
      * ```
      */
     const recoverUnless: <E, A, B>(isBlocked: (e: E) => boolean, fallback: () => Validation<E, B>) => (data: Validation<E, A>) => Validation<E, A | B>;
-    /**
-     * Converts a Validation to a Result.
-     * Passed becomes Ok, Failed becomes Err with the accumulated error list.
-     *
-     * @example
-     * ```ts
-     * Validation.toResult(Validation.passed(42));        // Ok(42)
-     * Validation.toResult(Validation.failed("oops"));  // Err(["oops"])
-     * ```
-     */
-    const toResult: <E, A>(data: Validation<E, A>) => Result<NonEmptyArr<E>, A>;
-    /**
-     * Converts a Validation to a Maybe. `Passed` becomes `Some`; `Failed` becomes `None`
-     * (errors are discarded).
-     *
-     * @example
-     * ```ts
-     * Validation.toMaybe(Validation.passed(42));       // Some(42)
-     * Validation.toMaybe(Validation.failed("bad"));  // None
-     * ```
-     */
-    const toMaybe: <E, A>(data: Validation<E, A>) => Maybe<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.fromResult(Result.ok(42));       // Passed(42)
-     * Validation.fromResult(Result.err("bad"));   // Failed(["bad"])
-     * ```
-     */
-    const fromResult: <E, A>(data: Result<E, A>) => Validation<E, A>;
+    namespace to {
+        /**
+         * Converts a Validation to a Result.
+         * Passed becomes Ok, Failed becomes Err with the accumulated error list.
+         *
+         * @example
+         * ```ts
+         * Validation.to.Result(Validation.make.passed(42));        // Ok(42)
+         * Validation.to.Result(Validation.make.failed("oops"));  // Err(["oops"])
+         * ```
+         */
+        const Result: <E, A>(data: Validation<E, A>) => Result<NonEmptyArr<E>, A>;
+        /**
+         * 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
+         * ```
+         */
+        const 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.
@@ -1836,13 +1868,13 @@ declare namespace Validation {
      * @example
      * ```ts
      * Validation.product(
-     *   Validation.passed("alice"),
-     *   Validation.passed(30)
+     *   Validation.make.passed("alice"),
+     *   Validation.make.passed(30)
      * ); // Passed(["alice", 30])
      *
      * Validation.product(
-     *   Validation.failed("Name required"),
-     *   Validation.failed("Age must be >= 0")
+     *   Validation.make.failed("Name required"),
+     *   Validation.make.failed("Age must be >= 0")
      * ); // Failed(["Name required", "Age must be >= 0"])
      * ```
      */
@@ -1870,13 +1902,13 @@ declare namespace Validation {
      * @example
      * ```ts
      * Validation.struct({
-     *   name: Validation.passed("Alice"),
-     *   age: Validation.passed(30)
+     *   name: Validation.make.passed("Alice"),
+     *   age: Validation.make.passed(30)
      * }); // Passed({ name: "Alice", age: 30 })
      *
      * Validation.struct({
-     *   name: Validation.failed("Name required"),
-     *   age: Validation.failed("Age must be >= 0")
+     *   name: Validation.make.failed("Name required"),
+     *   age: Validation.make.failed("Age must be >= 0")
      * }); // Failed(["Name required", "Age must be >= 0"])
      * ```
      */