@nlozgachev/pipelined 0.44.0 → 0.46.0

package/dist/core.d.ts

@@ -1,6 +1,6 @@
-import { M as Maybe, R as Result, T as Task } from './Validation-DM2eh6wj.js';
-export { E as Equality, a as Err, F as Failed, N as None, O as Ok, b as Ordering, P as Passed, S as Some, c as TaskMaybe, d as TaskResult, e as TaskValidation, V as Validation } from './Validation-DM2eh6wj.js';
-import { n as WithValue, h as WithLog, D as Deferred, g as WithKind, d as WithError, R as RetryOptions, a as TimeoutOptions, m as WithTimeout, i as WithMinInterval, b as WithCooldown, W as WithConcurrency, l as WithSize, c as WithDuration, j as WithN, f as WithFirst, k as WithSecond } from './InternalTypes-7o9-yrHq.js';
+import { M as Maybe, R as Result, T as Task } from './Validation-BMsvixWH.js';
+export { E as Equality, a as Err, F as Failed, N as None, O as Ok, b as Ordering, P as Passed, S as Some, c as TaskMaybe, d as TaskResult, e as TaskValidation, V as Validation } from './Validation-BMsvixWH.js';
+import { o as WithValue, i as WithLog, D as Deferred, h as WithKind, e as WithError, R as RetryOptions, b as TimeoutOptions, n as WithTimeout, j as WithMinInterval, c as WithCooldown, W as WithConcurrency, m as WithSize, d as WithDuration, k as WithN, g as WithFirst, l as WithSecond } from './InternalTypes-Mssktd7z.js';
 import { Duration } from './types.js';
 
 /**
@@ -81,8 +81,8 @@ declare namespace Combinable {
      * @example
      * ```ts
      * const c = Combinable.maybe(Combinable.sum);
-     * c.combine(Maybe.some(3))(Maybe.some(2)); // Some(5)
-     * c.combine(Maybe.none())(Maybe.some(5));  // Some(5)
+     * c.combine(Maybe.make.some(3))(Maybe.make.some(2)); // Some(5)
+     * c.combine(Maybe.make.none())(Maybe.make.some(5));  // Some(5)
      * ```
      */
     const maybe: <A>(inner: Combinable<A>) => Combinable<Maybe<A>>;
@@ -179,8 +179,8 @@ declare namespace Lazy {
  * type Address = { city: string; zip: string };
  * type User = { name: string; address: Address };
  *
- * const addressLens = Lens.prop<User>()("address");
- * const cityLens    = Lens.prop<Address>()("city");
+ * const addressLens = Lens.from.property<User>()("address");
+ * const cityLens    = Lens.from.property<Address>()("city");
  * const userCityLens = pipe(addressLens, Lens.andThen(cityLens));
  *
  * pipe(user, Lens.get(userCityLens));             // "Berlin"
@@ -193,28 +193,30 @@ type Lens<S, A> = {
     readonly set: (a: A) => (s: S) => S;
 };
 declare namespace Lens {
-    /**
-     * Constructs a Lens from a getter and a setter.
-     *
-     * @example
-     * ```ts
-     * const nameLens = Lens.make(
-     *   (user: User) => user.name,
-     *   (name) => (user) => ({ ...user, name }),
-     * );
-     * ```
-     */
-    const make: <S, A>(get: (s: S) => A, set: (a: A) => (s: S) => S) => Lens<S, A>;
-    /**
-     * Creates a Lens that focuses on a property of an object.
-     * Call with the structure type first, then the key.
-     *
-     * @example
-     * ```ts
-     * const nameLens = Lens.prop<User>()("name");
-     * ```
-     */
-    const prop: <S>() => <K extends keyof S>(key: K) => Lens<S, S[K]>;
+    namespace from {
+        /**
+         * Constructs a Lens from a getter and a setter.
+         *
+         * @example
+         * ```ts
+         * const nameLens = Lens.from.accessors(
+         *   (user: User) => user.name,
+         *   (name) => (user) => ({ ...user, name }),
+         * );
+         * ```
+         */
+        const accessors: <S, A>(get: (s: S) => A, set: (a: A) => (s: S) => S) => Lens<S, A>;
+        /**
+         * Creates a Lens that focuses on a property of an object.
+         * Call with the structure type first, then the key.
+         *
+         * @example
+         * ```ts
+         * const nameLens = Lens.from.property<User>()("name");
+         * ```
+         */
+        const property: <S>() => <K extends keyof S>(key: K) => Lens<S, S[K]>;
+    }
     /**
      * Reads the focused value from a structure.
      *
@@ -249,8 +251,8 @@ declare namespace Lens {
      * @example
      * ```ts
      * const userCityLens = pipe(
-     *   Lens.prop<User>()("address"),
-     *   Lens.andThen(Lens.prop<Address>()("city")),
+     *   Lens.from.property<User>()("address"),
+     *   Lens.andThen(Lens.from.property<Address>()("city")),
      * );
      * ```
      */
@@ -262,8 +264,8 @@ declare namespace Lens {
      * @example
      * ```ts
      * const userBioOpt = pipe(
-     *   Lens.prop<User>()("profile"),
-     *   Lens.andThenOptional(Optional.prop<Profile>()("bio")),
+     *   Lens.from.property<User>()("profile"),
+     *   Lens.andThenOptional(Optional.from.property<Profile>()("bio")),
      * );
      * ```
      */
@@ -275,9 +277,9 @@ declare namespace Lens {
      * @example
      * ```ts
      * pipe(
-     *   Lens.prop<User>()("address"),
+     *   Lens.from.property<User>()("address"),
      *   Lens.toOptional,
-     *   Optional.andThen(Optional.prop<Address>()("landmark")),
+     *   Optional.andThen(Optional.from.property<Address>()("landmark")),
      * );
      * ```
      */
@@ -295,13 +297,13 @@ declare namespace Lens {
  * @example
  * ```ts
  * const program = pipe(
- *   Logged.make<string, number>(0),
+ *   Logged.from.value<string, number>(0),
  *   Logged.chain(n => pipe(
- *     Logged.tell("start"),
+ *     Logged.from.entry("start"),
  *     Logged.map(() => n + 1),
  *   )),
  *   Logged.chain(n => pipe(
- *     Logged.tell("done"),
+ *     Logged.from.entry("done"),
  *     Logged.map(() => n * 10),
  *   )),
  * );
@@ -311,32 +313,34 @@ declare namespace Lens {
  */
 type Logged<L, A> = WithValue<A> & WithLog<L>;
 declare namespace Logged {
-    /**
-     * Wraps a pure value into a `Logged` with an empty log.
-     *
-     * @example
-     * ```ts
-     * Logged.make<string, number>(42); // { value: 42, log: [] }
-     * ```
-     */
-    const make: <W, A>(value: A) => Logged<W, A>;
-    /**
-     * Creates a `Logged` that records a single log entry and produces no
-     * meaningful value. Use this to append to the log inside a `chain`.
-     *
-     * @example
-     * ```ts
-     * Logged.tell("operation completed"); // { value: undefined, log: ["operation completed"] }
-     * ```
-     */
-    const tell: <W>(entry: W) => Logged<W, undefined>;
+    namespace from {
+        /**
+         * Wraps a pure value into a `Logged` with an empty log.
+         *
+         * @example
+         * ```ts
+         * Logged.from.value<string, number>(42); // { value: 42, log: [] }
+         * ```
+         */
+        const value: <W, A>(val: A) => Logged<W, A>;
+        /**
+         * Creates a `Logged` that records a single log entry and produces no
+         * meaningful value. Use this to append to the log inside a `chain`.
+         *
+         * @example
+         * ```ts
+         * Logged.from.entry("operation completed"); // { value: undefined, log: ["operation completed"] }
+         * ```
+         */
+        const entry: <W>(logEntry: W) => Logged<W, undefined>;
+    }
     /**
      * Transforms the value inside a `Logged` without affecting the log.
      *
      * @example
      * ```ts
      * pipe(
-     *   Logged.make<string, number>(5),
+     *   Logged.from.value<string, number>(5),
      *   Logged.map(n => n * 2),
      * ); // { value: 10, log: [] }
      * ```
@@ -352,9 +356,9 @@ declare namespace Logged {
      * @example
      * ```ts
      * const result = pipe(
-     *   Logged.make<string, number>(1),
-     *   Logged.chain(n => pipe(Logged.tell("step"), Logged.map(() => n + 1))),
-     *   Logged.chain(n => pipe(Logged.tell("done"), Logged.map(() => n * 10))),
+     *   Logged.from.value<string, number>(1),
+     *   Logged.chain(n => pipe(Logged.from.entry("step"), Logged.map(() => n + 1))),
+     *   Logged.chain(n => pipe(Logged.from.entry("done"), Logged.map(() => n * 10))),
      * );
      *
      * Logged.run(result); // [20, ["step", "done"]]
@@ -385,7 +389,7 @@ declare namespace Logged {
      * @example
      * ```ts
      * pipe(
-     *   Logged.make<string, number>(42),
+     *   Logged.from.value<string, number>(42),
      *   Logged.tap(n => console.log("value:", n)),
      * );
      * ```
@@ -398,8 +402,8 @@ declare namespace Logged {
      * @example
      * ```ts
      * const result = pipe(
-     *   Logged.make<string, number>(1),
-     *   Logged.chain(n => pipe(Logged.tell("incremented"), Logged.map(() => n + 1))),
+     *   Logged.from.value<string, number>(1),
+     *   Logged.chain(n => pipe(Logged.from.entry("incremented"), Logged.map(() => n + 1))),
      * );
      *
      * const [value, log] = Logged.run(result);
@@ -412,7 +416,7 @@ declare namespace Logged {
      *
      * @example
      * ```ts
-     * pipe(Logged.make<string, number>(42), Logged.bindTo("value")); // Logged({ value: 42 })
+     * pipe(Logged.from.value<string, number>(42), Logged.bindTo("value")); // Logged({ value: 42 })
      * ```
      */
     const bindTo: <K extends string>(key: K) => <W, A>(data: Logged<W, A>) => Logged<W, { [P in K]: A; }>;
@@ -422,8 +426,8 @@ declare namespace Logged {
      * @example
      * ```ts
      * pipe(
-     *   Logged.make<string, { a: number }>({ a: 1 }),
-     *   Logged.bind("b", ({ a }) => Logged.make<string, number>(a + 1))
+     *   Logged.from.value<string, { a: number }>({ a: 1 }),
+     *   Logged.bind("b", ({ a }) => Logged.from.value<string, number>(a + 1))
      * ); // Logged({ value: { a: 1, b: 2 } })
      * ```
      */
@@ -1035,19 +1039,29 @@ declare namespace Op {
      *
      * @example
      * ```ts
-     * Op.toResult(() => new ApiError("no result"))(outcome);
+     * Op.to.Result(() => new ApiError("no result"))(outcome);
      * ```
      */
-    const toResult: <E, A>(onNil: () => E) => (outcome: Outcome<E, A>) => Result<E, A>;
-    /**
-     * Converts an Outcome to a `Maybe`. `Ok` becomes `Some`; `Err` and `Nil` become `None`.
-     *
-     * @example
-     * ```ts
-     * Op.toMaybe(outcome); // Maybe<User>
-     * ```
-     */
-    const toMaybe: <E, A>(outcome: Outcome<E, A>) => Maybe<A>;
+    namespace to {
+        /**
+         * Converts an Outcome to a `Result`. `Nil` becomes `Err(onNil())`.
+         *
+         * @example
+         * ```ts
+         * Op.to.Result(() => new ApiError("no result"))(outcome);
+         * ```
+         */
+        const Result: <E, A>(onNil: () => E) => (outcome: Outcome<E, A>) => Result<E, A>;
+        /**
+         * Converts an Outcome to a `Maybe`. `Ok` becomes `Some`; `Err` and `Nil` become `None`.
+         *
+         * @example
+         * ```ts
+         * Op.to.Maybe(outcome); // Maybe<User>
+         * ```
+         */
+        const Maybe: <E, A>(outcome: Outcome<E, A>) => Maybe<A>;
+    }
     /**
      * Resolves when all invocations settle, returning their outcomes in order.
      * An alternative to `Promise.all` that stays within the `Op` type system.
@@ -1147,7 +1161,7 @@ type OptionalKeys<T> = {
  * ```ts
  * type Profile = { username: string; bio?: string };
  *
- * const bioOpt = Optional.prop<Profile>()("bio");
+ * const bioOpt = Optional.from.property<Profile>()("bio");
  *
  * pipe(profile, Optional.get(bioOpt));               // Some("hello") or None
  * pipe(profile, Optional.set(bioOpt)("hello"));      // new Profile with bio set
@@ -1159,30 +1173,32 @@ type Optional<S, A> = {
     readonly set: (a: A) => (s: S) => S;
 };
 declare namespace Optional {
-    /**
-     * Constructs an Optional from a getter (returning Maybe<A>) and a setter.
-     *
-     * @example
-     * ```ts
-     * const firstChar = Optional.make(
-     *   (s: string) => s.length > 0 ? Maybe.some(s[0]) : Maybe.none(),
-     *   (c) => (s) => s.length > 0 ? c + s.slice(1) : s,
-     * );
-     * ```
-     */
-    const make: <S, A>(get: (s: S) => Maybe<A>, set: (a: A) => (s: S) => S) => Optional<S, A>;
-    /**
-     * Creates an Optional that focuses on an optional property of an object.
-     * Only keys whose type includes undefined (i.e. `field?: T`) are accepted.
-     * Call with the structure type first, then the key.
-     *
-     * @example
-     * ```ts
-     * type Profile = { username: string; bio?: string };
-     * const bioOpt = Optional.prop<Profile>()("bio");
-     * ```
-     */
-    const prop: <S>() => <K extends OptionalKeys<S>>(key: K) => Optional<S, NonNullable<S[K]>>;
+    namespace from {
+        /**
+         * Constructs an Optional from a getter (returning Maybe<A>) and a setter.
+         *
+         * @example
+         * ```ts
+         * const firstChar = Optional.from.accessors(
+         *   (s: string) => s.length > 0 ? Maybe.make.some(s[0]) : Maybe.make.none(),
+         *   (c) => (s) => s.length > 0 ? c + s.slice(1) : s,
+         * );
+         * ```
+         */
+        const accessors: <S, A>(get: (s: S) => Maybe<A>, set: (a: A) => (s: S) => S) => Optional<S, A>;
+        /**
+         * Creates an Optional that focuses on an optional property of an object.
+         * Only keys whose type includes undefined (i.e. `field?: T`) are accepted.
+         * Call with the structure type first, then the key.
+         *
+         * @example
+         * ```ts
+         * type Profile = { username: string; bio?: string };
+         * const bioOpt = Optional.from.property<Profile>()("bio");
+         * ```
+         */
+        const property: <S>() => <K extends OptionalKeys<S>>(key: K) => Optional<S, NonNullable<S[K]>>;
+    }
     /**
      * Creates an Optional that focuses on an element at a given index in an array.
      * Returns None when the index is out of bounds; set is a no-op when out of bounds.
@@ -1266,8 +1282,8 @@ declare namespace Optional {
      * @example
      * ```ts
      * const deepOpt = pipe(
-     *   Optional.prop<User>()("address"),
-     *   Optional.andThen(Optional.prop<Address>()("landmark")),
+     *   Optional.from.property<User>()("address"),
+     *   Optional.andThen(Optional.from.property<Address>()("landmark")),
      * );
      * ```
      */
@@ -1279,8 +1295,8 @@ declare namespace Optional {
      * @example
      * ```ts
      * const cityOpt = pipe(
-     *   Optional.prop<User>()("address"),
-     *   Optional.andThenLens(Lens.prop<Address>()("city")),
+     *   Optional.from.property<User>()("address"),
+     *   Optional.andThenLens(Lens.from.property<Address>()("city")),
      * );
      * ```
      */
@@ -1295,7 +1311,7 @@ declare namespace Optional {
  * Use it when you need to combine, negate, or adapt boolean checks as first-class values
  * and do not require the extra type information that a `Refinement` provides.
  *
- * Every `Refinement<A, B>` is a `Predicate<A>` — convert with `Predicate.fromRefinement`
+ * Every `Refinement<A, B>` is a `Predicate<A>` — convert with `Predicate.from.Refinement`
  * when you want to compose a narrowing check alongside plain predicates.
  *
  * @example
@@ -1424,27 +1440,31 @@ declare namespace Predicate {
      * ```
      */
     const any: <A>(predicates: ReadonlyArray<Predicate<A>>) => Predicate<A>;
-    /**
-     * Converts a `Refinement<A, B>` into a `Predicate<A>`, discarding the compile-time
-     * narrowing. Use this when you want to combine a type guard with plain predicates
-     * using `and`, `or`, or `all`.
-     *
-     * @example
-     * ```ts
-     * const isString: Refinement<unknown, string> =
-     *   Refinement.make(x => typeof x === "string");
-     *
-     * const isShortString: Predicate<unknown> = pipe(
-     *   Predicate.fromRefinement(isString),
-     *   Predicate.and(x => (x as string).length < 10)
-     * );
-     *
-     * isShortString("hi");            // true
-     * isShortString("a very long string that exceeds ten characters");  // false
-     * isShortString(42);              // false
-     * ```
-     */
-    const fromRefinement: <A, B extends A>(r: Refinement<A, B>) => Predicate<A>;
+    namespace from {
+        /**
+         * Converts a `Refinement<A, B>` into a `Predicate<A>`, discarding the compile-time
+         * narrowing. Use this when you want to combine a type guard with plain predicates
+         * using `and`, `or`, or `all`.
+         *
+         * This is a zero-cost runtime type cast.
+         *
+         * @example
+         * ```ts
+         * const isString: Refinement<unknown, string> =
+         *   Refinement.from.predicate(x => typeof x === "string");
+         *
+         * const isShortString: Predicate<unknown> = pipe(
+         *   Predicate.from.Refinement(isString),
+         *   Predicate.and(x => (x as string).length < 10)
+         * );
+         *
+         * isShortString("hi");            // true
+         * isShortString("a very long string that exceeds ten characters");  // false
+         * isShortString(42);              // false
+         * ```
+         */
+        const Refinement: <A, B extends A>(r: Refinement<A, B>) => Predicate<A>;
+    }
 }
 
 /**
@@ -1638,33 +1658,35 @@ declare namespace Reader {
  * type NonEmptyString = string & { readonly _tag: "NonEmptyString" };
  *
  * const isNonEmpty: Refinement<string, NonEmptyString> =
- *   Refinement.make(s => s.length > 0);
+ *   Refinement.from.predicate(s => s.length > 0);
  *
  * pipe(
  *   "hello",
- *   Refinement.toFilter(isNonEmpty)
+ *   Refinement.to.Maybe(isNonEmpty)
  * ); // Some("hello")
  * ```
  */
 type Refinement<A, B extends A> = (a: A) => a is B;
 declare namespace Refinement {
-    /**
-     * Creates a `Refinement<A, B>` from a plain boolean predicate.
-     *
-     * This is an unsafe cast — the caller is responsible for ensuring that the
-     * predicate truly characterises values of type `B`. Use this only when
-     * bootstrapping a new refinement; prefer `compose`, `and`, or `or` to build
-     * derived refinements from existing ones.
-     *
-     * @example
-     * ```ts
-     * type PositiveNumber = number & { readonly _tag: "PositiveNumber" };
-     *
-     * const isPositive: Refinement<number, PositiveNumber> =
-     *   Refinement.make(n => n > 0);
-     * ```
-     */
-    const make: <A, B extends A>(f: (a: A) => boolean) => Refinement<A, B>;
+    namespace from {
+        /**
+         * Creates a `Refinement<A, B>` from a plain boolean predicate.
+         *
+         * This is an unsafe cast — the caller is responsible for ensuring that the
+         * predicate truly characterises values of type `B`. Use this only when
+         * bootstrapping a new refinement; prefer `compose`, `and`, or `or` to build
+         * derived refinements from existing ones.
+         *
+         * @example
+         * ```ts
+         * type PositiveNumber = number & { readonly _tag: "PositiveNumber" };
+         *
+         * const isPositive: Refinement<number, PositiveNumber> =
+         *   Refinement.from.predicate(n => n > 0);
+         * ```
+         */
+        const predicate: <A, B extends A>(f: (a: A) => boolean) => Refinement<A, B>;
+    }
     /**
      * Chains two refinements: if `ab` narrows `A` to `B` and `bc` narrows `B` to `C`,
      * the result narrows `A` directly to `C`.
@@ -1677,9 +1699,9 @@ declare namespace Refinement {
      * type TrimmedString  = NonEmptyString & { readonly _tag: "Trimmed" };
      *
      * const isNonEmpty: Refinement<string, NonEmptyString> =
-     *   Refinement.make(s => s.length > 0);
+     *   Refinement.from.predicate(s => s.length > 0);
      * const isTrimmed: Refinement<NonEmptyString, TrimmedString> =
-     *   Refinement.make(s => s === s.trim());
+     *   Refinement.from.predicate(s => s === s.trim());
      *
      * const isNonEmptyTrimmed: Refinement<string, TrimmedString> = pipe(
      *   isNonEmpty,
@@ -1696,9 +1718,9 @@ declare namespace Refinement {
      *
      * @example
      * ```ts
-     * const isString: Refinement<unknown, string> = Refinement.make(x => typeof x === "string");
+     * const isString: Refinement<unknown, string> = Refinement.from.predicate(x => typeof x === "string");
      * const isNonEmpty: Refinement<unknown, { length: number }> =
-     *   Refinement.make(x => (x as any).length > 0);
+     *   Refinement.from.predicate(x => (x as any).length > 0);
      *
      * const isNonEmptyString = pipe(isString, Refinement.and(isNonEmpty));
      * isNonEmptyString("hi");  // true
@@ -1714,8 +1736,8 @@ declare namespace Refinement {
      *
      * @example
      * ```ts
-     * const isString:  Refinement<unknown, string>  = Refinement.make(x => typeof x === "string");
-     * const isNumber:  Refinement<unknown, number>  = Refinement.make(x => typeof x === "number");
+     * const isString:  Refinement<unknown, string>  = Refinement.from.predicate(x => typeof x === "string");
+     * const isNumber:  Refinement<unknown, number>  = Refinement.from.predicate(x => typeof x === "number");
      *
      * const isStringOrNumber = pipe(isString, Refinement.or(isNumber));
      * isStringOrNumber("hi"); // true
@@ -1724,40 +1746,42 @@ declare namespace Refinement {
      * ```
      */
     const or: <A, C extends A>(second: Refinement<A, C>) => <B extends A>(first: Refinement<A, B>) => Refinement<A, B | C>;
-    /**
-     * Converts a `Refinement<A, B>` into a function `(a: A) => Maybe<B>`.
-     *
-     * Returns `Some(a)` when the refinement holds, `None` otherwise. Useful for
-     * integrating runtime validation into a `Maybe`-based pipeline.
-     *
-     * @example
-     * ```ts
-     * type PositiveNumber = number & { readonly _tag: "Positive" };
-     * const isPositive: Refinement<number, PositiveNumber> =
-     *   Refinement.make(n => n > 0);
-     *
-     * pipe(-1, Refinement.toFilter(isPositive)); // None
-     * pipe(42, Refinement.toFilter(isPositive)); // Some(42)
-     * ```
-     */
-    const toFilter: <A, B extends A>(r: Refinement<A, B>) => (a: A) => Maybe<B>;
-    /**
-     * Converts a `Refinement<A, B>` into a function `(a: A) => Result<E, B>`.
-     *
-     * Returns `Ok(a)` when the refinement holds, `Err(onFail(a))` otherwise. Use
-     * this to surface validation failures as typed errors inside a `Result` pipeline.
-     *
-     * @example
-     * ```ts
-     * type NonEmptyString = string & { readonly _tag: "NonEmpty" };
-     * const isNonEmpty: Refinement<string, NonEmptyString> =
-     *   Refinement.make(s => s.length > 0);
-     *
-     * pipe("", Refinement.toResult(isNonEmpty, () => "must not be empty")); // Err(...)
-     * pipe("hi", Refinement.toResult(isNonEmpty, () => "must not be empty")); // Ok("hi")
-     * ```
-     */
-    const toResult: <A, B extends A, E>(r: Refinement<A, B>, onFail: (a: A) => E) => (a: A) => Result<E, B>;
+    namespace to {
+        /**
+         * Converts a `Refinement<A, B>` into a function `(a: A) => Maybe<B>`.
+         *
+         * Returns `Some(a)` when the refinement holds, `None` otherwise. Useful for
+         * integrating runtime validation into a `Maybe`-based pipeline.
+         *
+         * @example
+         * ```ts
+         * type PositiveNumber = number & { readonly _tag: "Positive" };
+         * const isPositive: Refinement<number, PositiveNumber> =
+         *   Refinement.from.predicate(n => n > 0);
+         *
+         * pipe(-1, Refinement.to.Maybe(isPositive)); // None
+         * pipe(42, Refinement.to.Maybe(isPositive)); // Some(42)
+         * ```
+         */
+        const Maybe: <A, B extends A>(r: Refinement<A, B>) => (a: A) => Maybe<B>;
+        /**
+         * Converts a `Refinement<A, B>` into a function `(a: A) => Result<E, B>`.
+         *
+         * Returns `Ok(a)` when the refinement holds, `Err(onFail(a))` otherwise. Use
+         * this to surface validation failures as typed errors inside a `Result` pipeline.
+         *
+         * @example
+         * ```ts
+         * type NonEmptyString = string & { readonly _tag: "NonEmpty" };
+         * const isNonEmpty: Refinement<string, NonEmptyString> =
+         *   Refinement.from.predicate(s => s.length > 0);
+         *
+         * pipe("", Refinement.to.Result(isNonEmpty, () => "must not be empty")); // Err(...)
+         * pipe("hi", Refinement.to.Result(isNonEmpty, () => "must not be empty")); // Ok("hi")
+         * ```
+         */
+        const Result: <A, B extends A, E>(r: Refinement<A, B>, onFail: (a: A) => E) => (a: A) => Result<E, B>;
+    }
 }
 
 type NotAsked = WithKind<"NotAsked">;
@@ -1786,45 +1810,49 @@ type Success<A> = WithKind<"Success"> & WithValue<A>;
  */
 type RemoteData<E, A> = NotAsked | Loading | Failure<E> | Success<A>;
 declare namespace RemoteData {
-    /**
-     * Creates a NotAsked RemoteData.
-     */
-    const notAsked: () => NotAsked;
-    /**
-     * Creates a Loading RemoteData.
-     */
-    const loading: () => Loading;
-    /**
-     * Creates a Failure RemoteData with the given error.
-     */
-    const failure: <E>(error: E) => Failure<E>;
-    /**
-     * Creates a Success RemoteData with the given value.
-     */
-    const success: <A>(value: A) => Success<A>;
-    /**
-     * Type guard that checks if a RemoteData is NotAsked.
-     */
-    const isNotAsked: <E, A>(data: RemoteData<E, A>) => data is NotAsked;
-    /**
-     * Type guard that checks if a RemoteData is Loading.
-     */
-    const isLoading: <E, A>(data: RemoteData<E, A>) => data is Loading;
-    /**
-     * Type guard that checks if a RemoteData is Failure.
-     */
-    const isFailure: <E, A>(data: RemoteData<E, A>) => data is Failure<E>;
-    /**
-     * Type guard that checks if a RemoteData is Success.
-     */
-    const isSuccess: <E, A>(data: RemoteData<E, A>) => data is Success<A>;
+    namespace make {
+        /**
+         * Creates a NotAsked RemoteData.
+         */
+        const notAsked: () => NotAsked;
+        /**
+         * Creates a Loading RemoteData.
+         */
+        const loading: () => Loading;
+        /**
+         * Creates a Failure RemoteData with the given error.
+         */
+        const failure: <E>(error: E) => Failure<E>;
+        /**
+         * Creates a Success RemoteData with the given value.
+         */
+        const success: <A>(value: A) => Success<A>;
+    }
+    namespace is {
+        /**
+         * Type guard that checks if a RemoteData is NotAsked.
+         */
+        const notAsked: <E, A>(data: RemoteData<E, A>) => data is NotAsked;
+        /**
+         * Type guard that checks if a RemoteData is Loading.
+         */
+        const loading: <E, A>(data: RemoteData<E, A>) => data is Loading;
+        /**
+         * Type guard that checks if a RemoteData is Failure.
+         */
+        const failure: <E, A>(data: RemoteData<E, A>) => data is Failure<E>;
+        /**
+         * Type guard that checks if a RemoteData is Success.
+         */
+        const success: <E, A>(data: RemoteData<E, A>) => data is Success<A>;
+    }
     /**
      * Transforms the success value inside a RemoteData.
      *
      * @example
      * ```ts
-     * pipe(RemoteData.success(5), RemoteData.map(n => n * 2)); // Success(10)
-     * pipe(RemoteData.loading(), RemoteData.map(n => n * 2)); // Loading
+     * pipe(RemoteData.make.success(5), RemoteData.map(n => n * 2)); // Success(10)
+     * pipe(RemoteData.make.loading(), RemoteData.map(n => n * 2)); // Loading
      * ```
      */
     const map: <A, B>(f: (a: A) => B) => <E>(data: RemoteData<E, A>) => RemoteData<E, B>;
@@ -1833,7 +1861,7 @@ declare namespace RemoteData {
      *
      * @example
      * ```ts
-     * pipe(RemoteData.failure("oops"), RemoteData.mapError(e => e.toUpperCase())); // Failure("OOPS")
+     * pipe(RemoteData.make.failure("oops"), RemoteData.mapError(e => e.toUpperCase())); // Failure("OOPS")
      * ```
      */
     const mapError: <E, F>(f: (e: E) => F) => <A>(data: RemoteData<E, A>) => RemoteData<F, A>;
@@ -1844,8 +1872,8 @@ declare namespace RemoteData {
      * @example
      * ```ts
      * pipe(
-     *   RemoteData.success(5),
-     *   RemoteData.chain(n => n > 0 ? RemoteData.success(n) : RemoteData.failure("negative"))
+     *   RemoteData.make.success(5),
+     *   RemoteData.chain(n => n > 0 ? RemoteData.make.success(n) : RemoteData.make.failure("negative"))
      * );
      * ```
      */
@@ -1857,9 +1885,9 @@ declare namespace RemoteData {
      * ```ts
      * const add = (a: number) => (b: number) => a + b;
      * pipe(
-     *   RemoteData.success(add),
-     *   RemoteData.ap(RemoteData.success(5)),
-     *   RemoteData.ap(RemoteData.success(3))
+     *   RemoteData.make.success(add),
+     *   RemoteData.ap(RemoteData.make.success(5)),
+     *   RemoteData.ap(RemoteData.make.success(3))
      * ); // Success(8)
      * ```
      */
@@ -1909,9 +1937,9 @@ declare namespace RemoteData {
      *
      * @example
      * ```ts
-     * pipe(RemoteData.success(5), RemoteData.getOrElse(() => 0)); // 5
-     * pipe(RemoteData.loading(), RemoteData.getOrElse(() => 0)); // 0
-     * pipe(RemoteData.loading<string, number>(), RemoteData.getOrElse(() => null)); // null — typed as number | null
+     * pipe(RemoteData.make.success(5), RemoteData.getOrElse(() => 0)); // 5
+     * pipe(RemoteData.make.loading(), RemoteData.getOrElse(() => 0)); // 0
+     * pipe(RemoteData.make.loading<string, number>(), RemoteData.getOrElse(() => null)); // null — typed as number | null
      * ```
      */
     const getOrElse: <E, A, B>(defaultValue: () => B) => (data: RemoteData<E, A>) => A | B;
@@ -1921,7 +1949,7 @@ declare namespace RemoteData {
      * @example
      * ```ts
      * pipe(
-     *   RemoteData.success(5),
+     *   RemoteData.make.success(5),
      *   RemoteData.tap(n => console.log("Value:", n)),
      *   RemoteData.map(n => n * 2)
      * );
@@ -1935,7 +1963,7 @@ declare namespace RemoteData {
      * @example
      * ```ts
      * pipe(
-     *   RemoteData.failure("not found"),
+     *   RemoteData.make.failure("not found"),
      *   RemoteData.tapError(e => console.error("fetch failed:", e)),
      *   RemoteData.map(render)
      * );
@@ -1947,58 +1975,62 @@ declare namespace RemoteData {
      * The fallback can produce a different success type, widening the result to `RemoteData<E, A | B>`.
      */
     const recover: <E, A, B>(fallback: (e: E) => RemoteData<E, B>) => (data: RemoteData<E, A>) => RemoteData<E, A | B>;
-    /**
-     * Converts a RemoteData to a Maybe.
-     * Success becomes Some, all other states become None.
-     */
-    const toMaybe: <E, A>(data: RemoteData<E, A>) => Maybe<A>;
-    /**
-     * Converts a RemoteData to a Result.
-     * Success becomes Ok, Failure becomes Err.
-     * NotAsked and Loading become Err with the provided fallback error.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   RemoteData.success(42),
-     *   RemoteData.toResult(() => "not loaded")
-     * ); // Ok(42)
-     * ```
-     */
-    const toResult: <E>(onNotReady: () => E) => <A>(data: RemoteData<E, A>) => Result<E, A>;
-    /**
-     * Converts a Result to a RemoteData.
-     * Ok becomes Success, Err becomes Failure.
-     *
-     * @example
-     * ```ts
-     * const result = await Task.Result.tryCatch(fetchUser, String)();
-     * setState(RemoteData.fromResult(result)); // Success(user) or Failure(msg)
-     * ```
-     */
-    const fromResult: <E, A>(data: Result<E, A>) => RemoteData<E, A>;
-    /**
-     * Converts a Maybe to a RemoteData.
-     * Some becomes Success, None becomes Failure using the onNone error producer.
-     *
-     * @example
-     * ```ts
-     * pipe(Maybe.some(user), RemoteData.fromMaybe(() => "not found")); // Success(user)
-     * pipe(Maybe.none(), RemoteData.fromMaybe(() => "not found"));     // Failure("not found")
-     * ```
-     */
-    const fromMaybe: <E>(onNone: () => E) => <A>(data: Maybe<A>) => RemoteData<E, A>;
+    namespace to {
+        /**
+         * Converts a RemoteData to a Maybe.
+         * Success becomes Some, all other states become None.
+         */
+        const Maybe: <E, A>(data: RemoteData<E, A>) => Maybe<A>;
+        /**
+         * Converts a RemoteData to a Result.
+         * Success becomes Ok, Failure becomes Err.
+         * NotAsked and Loading become Err with the provided fallback error.
+         *
+         * @example
+         * ```ts
+         * pipe(
+         *   RemoteData.make.success(42),
+         *   RemoteData.to.Result(() => "not loaded")
+         * ); // Ok(42)
+         * ```
+         */
+        const Result: <E>(onNotReady: () => E) => <A>(data: RemoteData<E, A>) => Result<E, A>;
+    }
+    namespace from {
+        /**
+         * Converts a Result to a RemoteData.
+         * Ok becomes Success, Err becomes Failure.
+         *
+         * @example
+         * ```ts
+         * const result = await Task.Result.tryCatch(fetchUser, String)();
+         * setState(RemoteData.from.Result(result)); // Success(user) or Failure(msg)
+         * ```
+         */
+        const Result: <E, A>(data: Result<E, A>) => RemoteData<E, A>;
+        /**
+         * Converts a Maybe to a RemoteData.
+         * Some becomes Success, None becomes Failure using the onNone error producer.
+         *
+         * @example
+         * ```ts
+         * pipe(Maybe.make.some(user), RemoteData.from.Maybe(() => "not found")); // Success(user)
+         * pipe(Maybe.make.none(), RemoteData.from.Maybe(() => "not found"));     // Failure("not found")
+         * ```
+         */
+        const Maybe: <E>(onNone: () => E) => <A>(data: Maybe<A>) => RemoteData<E, A>;
+    }
     /**
      * Filters a `Success` value. When the predicate passes, the value is kept. When it fails,
      * `Success` becomes `Failure` using the error produced by `onFalse`. All other states pass through unchanged.
      *
      * @example
      * ```ts
-     * RemoteData.filter(n => n > 0, n => `${n} is not a valid price`)(RemoteData.success(9.99));
+     * RemoteData.filter(n => n > 0, n => `${n} is not a valid price`)(RemoteData.make.success(9.99));
      * // Success(9.99)
-     * RemoteData.filter(n => n > 0, n => `${n} is not a valid price`)(RemoteData.success(-1));
+     * RemoteData.filter(n => n > 0, n => `${n} is not a valid price`)(RemoteData.make.success(-1));
      * // Failure("-1 is not a valid price")
-     * RemoteData.filter(n => n > 0, () => "error")(RemoteData.loading()); // Loading
+     * RemoteData.filter(n => n > 0, () => "error")(RemoteData.make.loading()); // Loading
      * ```
      */
     const filter: <E, A>(pred: (a: A) => boolean, onFalse: (a: A) => E) => (data: RemoteData<E, A>) => RemoteData<E, A>;
@@ -2015,14 +2047,14 @@ declare namespace RemoteData {
  * the work function returns an error. If `acquire` itself fails, `release` is
  * skipped — there is nothing to clean up.
  *
- * Build a Resource with `Resource.make` or `Resource.fromTask`, then run it
+ * Build a Resource with `Resource.from.handlers` or `Resource.from.Task`, then run it
  * with `Resource.use`.
  *
  * @example
  * ```ts
- * const dbResource = Resource.make(
+ * const dbResource = Resource.from.handlers(
  *   Task.Result.tryCatch(() => openConnection(config), (e) => new DbError(e)),
- *   (conn) => Task.from(() => conn.close())
+ *   (conn) => Task.from.Promise(() => conn.close())
  * );
  *
  * const result = await pipe(
@@ -2037,32 +2069,34 @@ type Resource<E, A> = {
     readonly release: (a: A) => Task<void>;
 };
 declare namespace Resource {
-    /**
-     * Creates a Resource from an acquire operation that may fail and a release function.
-     *
-     * @example
-     * ```ts
-     * const fileResource = Resource.make(
-     *   Task.Result.tryCatch(() => fs.promises.open("data.csv", "r"), toFileError),
-     *   (handle) => Task.from(() => handle.close())
-     * );
-     * ```
-     */
-    const make: <E, A>(acquire: Task.Result<E, A>, release: (a: A) => Task<void>) => Resource<E, A>;
-    /**
-     * Creates a Resource from an acquire operation that cannot fail.
-     * Use this when opening the resource is guaranteed to succeed, such as
-     * in-memory locks, counters, or timers.
-     *
-     * @example
-     * ```ts
-     * const timerResource = Resource.fromTask<never, Timer>(
-     *   Task.from(() => Promise.resolve(startTimer())),
-     *   (timer) => Task.from(() => Promise.resolve(timer.stop()))
-     * );
-     * ```
-     */
-    const fromTask: <E, A>(acquire: Task<A>, release: (a: A) => Task<void>) => Resource<E, A>;
+    namespace from {
+        /**
+         * Creates a Resource from an acquire operation that may fail and a release function.
+         *
+         * @example
+         * ```ts
+         * const fileResource = Resource.from.handlers(
+         *   Task.Result.tryCatch(() => fs.promises.open("data.csv", "r"), toFileError),
+         *   (handle) => Task.from.Promise(() => handle.close())
+         * );
+         * ```
+         */
+        const handlers: <E, A>(acquire: Task.Result<E, A>, release: (a: A) => Task<void>) => Resource<E, A>;
+        /**
+         * Creates a Resource from an acquire operation that cannot fail.
+         * Use this when opening the resource is guaranteed to succeed, such as
+         * in-memory locks, counters, or timers.
+         *
+         * @example
+         * ```ts
+         * const timerResource = Resource.from.Task<never, Timer>(
+         *   Task.from.Promise(() => Promise.resolve(startTimer())),
+         *   (timer) => Task.from.Promise(() => Promise.resolve(timer.stop()))
+         * );
+         * ```
+         */
+        const Task: <E, A>(acquire: Task<A>, release: (a: A) => Task<void>) => Resource<E, A>;
+    }
     /**
      * Acquires the resource, runs `f` with it, then releases it.
      *
@@ -2332,53 +2366,57 @@ type TheseBoth<First, Second> = WithKind<"Both"> & WithFirst<First> & WithSecond
  * const parse = (s: string): These<number, string> => {
  *   const trimmed = s.trim();
  *   const n = parseFloat(trimmed);
- *   if (isNaN(n)) return These.second("Not a number");
- *   if (s !== trimmed) return These.both(n, "Leading/trailing whitespace trimmed");
- *   return These.first(n);
+ *   if (isNaN(n)) return These.make.second("Not a number");
+ *   if (s !== trimmed) return These.make.both(n, "Leading/trailing whitespace trimmed");
+ *   return These.make.first(n);
  * };
  * ```
  */
 type These<A, B> = TheseFirst<A> | TheseSecond<B> | TheseBoth<A, B>;
 declare namespace These {
-    /**
-     * Creates a These holding only a first value.
-     *
-     * @example
-     * ```ts
-     * These.first(42); // { kind: "First", first: 42 }
-     * ```
-     */
-    const first: <A>(value: A) => TheseFirst<A>;
-    /**
-     * Creates a These holding only a second value.
-     *
-     * @example
-     * ```ts
-     * These.second("warning"); // { kind: "Second", second: "warning" }
-     * ```
-     */
-    const second: <B>(value: B) => TheseSecond<B>;
-    /**
-     * Creates a These holding both a first and a second value simultaneously.
-     *
-     * @example
-     * ```ts
-     * These.both(42, "Deprecated API used"); // { kind: "Both", first: 42, second: "Deprecated API used" }
-     * ```
-     */
-    const both: <A, B>(f: A, s: B) => TheseBoth<A, B>;
-    /**
-     * Type guard — checks if a These holds only a first value.
-     */
-    const isFirst: <A, B>(data: These<A, B>) => data is TheseFirst<A>;
-    /**
-     * Type guard — checks if a These holds only a second value.
-     */
-    const isSecond: <A, B>(data: These<A, B>) => data is TheseSecond<B>;
-    /**
-     * Type guard — checks if a These holds both values simultaneously.
-     */
-    const isBoth: <A, B>(data: These<A, B>) => data is TheseBoth<A, B>;
+    namespace make {
+        /**
+         * Creates a These holding only a first value.
+         *
+         * @example
+         * ```ts
+         * These.make.first(42); // { kind: "First", first: 42 }
+         * ```
+         */
+        const first: <A>(value: A) => TheseFirst<A>;
+        /**
+         * Creates a These holding only a second value.
+         *
+         * @example
+         * ```ts
+         * These.make.second("warning"); // { kind: "Second", second: "warning" }
+         * ```
+         */
+        const second: <B>(value: B) => TheseSecond<B>;
+        /**
+         * Creates a These holding both a first and a second value simultaneously.
+         *
+         * @example
+         * ```ts
+         * These.make.both(42, "Deprecated API used"); // { kind: "Both", first: 42, second: "Deprecated API used" }
+         * ```
+         */
+        const both: <A, B>(f: A, s: B) => TheseBoth<A, B>;
+    }
+    namespace is {
+        /**
+         * Type guard — checks if a These holds only a first value.
+         */
+        const first: <A, B>(data: These<A, B>) => data is TheseFirst<A>;
+        /**
+         * Type guard — checks if a These holds only a second value.
+         */
+        const second: <A, B>(data: These<A, B>) => data is TheseSecond<B>;
+        /**
+         * Type guard — checks if a These holds both values simultaneously.
+         */
+        const both: <A, B>(data: These<A, B>) => data is TheseBoth<A, B>;
+    }
     /**
      * Returns true if the These contains a first value (First or Both).
      */
@@ -2392,9 +2430,9 @@ declare namespace These {
      *
      * @example
      * ```ts
-     * pipe(These.first(5), These.mapFirst(n => n * 2));           // First(10)
-     * pipe(These.both(5, "warn"), These.mapFirst(n => n * 2));    // Both(10, "warn")
-     * pipe(These.second("warn"), These.mapFirst(n => n * 2));     // Second("warn")
+     * pipe(These.make.first(5), These.mapFirst(n => n * 2));           // First(10)
+     * pipe(These.make.both(5, "warn"), These.mapFirst(n => n * 2));    // Both(10, "warn")
+     * pipe(These.make.second("warn"), These.mapFirst(n => n * 2));     // Second("warn")
      * ```
      */
     const mapFirst: <A, C>(f: (a: A) => C) => <B>(data: These<A, B>) => These<C, B>;
@@ -2403,8 +2441,8 @@ declare namespace These {
      *
      * @example
      * ```ts
-     * pipe(These.second("warn"), These.mapSecond(e => e.toUpperCase()));     // Second("WARN")
-     * pipe(These.both(5, "warn"), These.mapSecond(e => e.toUpperCase()));    // Both(5, "WARN")
+     * pipe(These.make.second("warn"), These.mapSecond(e => e.toUpperCase()));     // Second("WARN")
+     * pipe(These.make.both(5, "warn"), These.mapSecond(e => e.toUpperCase()));    // Both(5, "WARN")
      * ```
      */
     const mapSecond: <B, D>(f: (b: B) => D) => <A>(data: These<A, B>) => These<A, D>;
@@ -2414,7 +2452,7 @@ declare namespace These {
      * @example
      * ```ts
      * pipe(
-     *   These.both(5, "warn"),
+     *   These.make.both(5, "warn"),
      *   These.mapBoth(n => n * 2, e => e.toUpperCase())
      * ); // Both(10, "WARN")
      * ```
@@ -2426,11 +2464,11 @@ declare namespace These {
      *
      * @example
      * ```ts
-     * const double = (n: number): These<number, string> => These.first(n * 2);
+     * const double = (n: number): These<number, string> => These.make.first(n * 2);
      *
-     * pipe(These.first(5), These.chainFirst(double));            // First(10)
-     * pipe(These.both(5, "warn"), These.chainFirst(double));     // First(10)
-     * pipe(These.second("warn"), These.chainFirst(double));      // Second("warn")
+     * pipe(These.make.first(5), These.chainFirst(double));            // First(10)
+     * pipe(These.make.both(5, "warn"), These.chainFirst(double));     // First(10)
+     * pipe(These.make.second("warn"), These.chainFirst(double));      // Second("warn")
      * ```
      */
     const chainFirst: <A, B, C>(f: (a: A) => These<C, B>) => (data: These<A, B>) => These<C, B>;
@@ -2440,11 +2478,11 @@ declare namespace These {
      *
      * @example
      * ```ts
-     * const shout = (s: string): These<number, string> => These.second(s.toUpperCase());
+     * const shout = (s: string): These<number, string> => These.make.second(s.toUpperCase());
      *
-     * pipe(These.second("warn"), These.chainSecond(shout));      // Second("WARN")
-     * pipe(These.both(5, "warn"), These.chainSecond(shout));     // Second("WARN")
-     * pipe(These.first(5), These.chainSecond(shout));            // First(5)
+     * pipe(These.make.second("warn"), These.chainSecond(shout));      // Second("WARN")
+     * pipe(These.make.both(5, "warn"), These.chainSecond(shout));     // Second("WARN")
+     * pipe(These.make.first(5), These.chainSecond(shout));            // First(5)
      * ```
      */
     const chainSecond: <A, B, D>(f: (b: B) => These<A, D>) => (data: These<A, B>) => These<A, D>;
@@ -2490,10 +2528,10 @@ declare namespace These {
      *
      * @example
      * ```ts
-     * pipe(These.first(5), These.getFirstOrElse(() => 0));            // 5
-     * pipe(These.both(5, "warn"), These.getFirstOrElse(() => 0));     // 5
-     * pipe(These.second("warn"), These.getFirstOrElse(() => 0));      // 0
-     * pipe(These.second("warn"), These.getFirstOrElse(() => null));   // null — typed as number | null
+     * pipe(These.make.first(5), These.getFirstOrElse(() => 0));            // 5
+     * pipe(These.make.both(5, "warn"), These.getFirstOrElse(() => 0));     // 5
+     * pipe(These.make.second("warn"), These.getFirstOrElse(() => 0));      // 0
+     * pipe(These.make.second("warn"), These.getFirstOrElse(() => null));   // null — typed as number | null
      * ```
      */
     const getFirstOrElse: <A, C>(defaultValue: () => C) => <B>(data: These<A, B>) => A | C;
@@ -2503,20 +2541,20 @@ declare namespace These {
      *
      * @example
      * ```ts
-     * pipe(These.second("warn"), These.getSecondOrElse(() => "none")); // "warn"
-     * pipe(These.both(5, "warn"), These.getSecondOrElse(() => "none")); // "warn"
-     * pipe(These.first(5), These.getSecondOrElse(() => "none"));       // "none"
-     * pipe(These.first(5), These.getSecondOrElse(() => null));         // null — typed as string | null
+     * pipe(These.make.second("warn"), These.getSecondOrElse(() => "none")); // "warn"
+     * pipe(These.make.both(5, "warn"), These.getSecondOrElse(() => "none")); // "warn"
+     * pipe(These.make.first(5), These.getSecondOrElse(() => "none"));       // "none"
+     * pipe(These.make.first(5), These.getSecondOrElse(() => null));         // null — typed as string | null
      * ```
      */
     const getSecondOrElse: <B, D>(defaultValue: () => D) => <A>(data: These<A, B>) => B | D;
     /**
-     * Executes a side effect on the first value without changing the These.
+     * Runs a side effect on the first value without changing the These.
      * Useful for logging or debugging.
      *
      * @example
      * ```ts
-     * pipe(These.first(5), These.tap(console.log)); // logs 5, returns First(5)
+     * pipe(These.make.first(5), These.tap(console.log)); // logs 5, returns First(5)
      * ```
      */
     const tap: <A>(f: (a: A) => void) => <B>(data: These<A, B>) => These<A, B>;
@@ -2528,9 +2566,9 @@ declare namespace These {
      *
      * @example
      * ```ts
-     * These.swap(These.first(5));            // Second(5)
-     * These.swap(These.second("warn"));      // First("warn")
-     * These.swap(These.both(5, "warn"));     // Both("warn", 5)
+     * These.swap(These.make.first(5));            // Second(5)
+     * These.swap(These.make.second("warn"));      // First("warn")
+     * These.swap(These.make.both(5, "warn"));     // Both("warn", 5)
      * ```
      */
     const swap: <A, B>(data: These<A, B>) => These<B, A>;
@@ -2548,7 +2586,7 @@ declare namespace These {
  * import { Tuple } from "@nlozgachev/pipelined/core";
  * import { pipe } from "@nlozgachev/pipelined/composition";
  *
- * const entry = Tuple.make("alice", 42);
+ * const entry = Tuple.from.pair("alice", 42);
  *
  * pipe(
  *   entry,
@@ -2560,21 +2598,32 @@ declare namespace These {
  */
 type Tuple<A, B> = readonly [A, B];
 declare namespace Tuple {
-    /**
-     * Creates a pair from two values.
-     *
-     * @example
-     * ```ts
-     * Tuple.make("Paris", 2_161_000); // ["Paris", 2161000]
-     * ```
-     */
-    const make: <A, B>(first: A, second: B) => Tuple<A, B>;
+    namespace from {
+        /**
+         * Creates a pair from two values.
+         *
+         * @example
+         * ```ts
+         * Tuple.from.pair("Paris", 2_161_000); // ["Paris", 2161000]
+         * ```
+         */
+        const pair: <A, B>(first: A, second: B) => Tuple<A, B>;
+        /**
+         * Creates a Tuple from a two-element array.
+         *
+         * @example
+         * ```ts
+         * Tuple.from.array(["Paris", 2_161_000] as const); // ["Paris", 2161000]
+         * ```
+         */
+        const array: <A, B>(arr: readonly [A, B]) => Tuple<A, B>;
+    }
     /**
      * Returns the first value from the pair.
      *
      * @example
      * ```ts
-     * Tuple.first(Tuple.make("Paris", 2_161_000)); // "Paris"
+     * Tuple.first(Tuple.from.pair("Paris", 2_161_000)); // "Paris"
      * ```
      */
     const first: <A, B>(tuple: Tuple<A, B>) => A;
@@ -2583,7 +2632,7 @@ declare namespace Tuple {
      *
      * @example
      * ```ts
-     * Tuple.second(Tuple.make("Paris", 2_161_000)); // 2161000
+     * Tuple.second(Tuple.from.pair("Paris", 2_161_000)); // 2161000
      * ```
      */
     const second: <A, B>(tuple: Tuple<A, B>) => B;
@@ -2592,7 +2641,7 @@ declare namespace Tuple {
      *
      * @example
      * ```ts
-     * pipe(Tuple.make("alice", 42), Tuple.mapFirst((s) => s.toUpperCase())); // ["ALICE", 42]
+     * pipe(Tuple.from.pair("alice", 42), Tuple.mapFirst((s) => s.toUpperCase())); // ["ALICE", 42]
      * ```
      */
     const mapFirst: <A, C>(f: (a: A) => C) => <B>(tuple: Tuple<A, B>) => Tuple<C, B>;
@@ -2601,7 +2650,7 @@ declare namespace Tuple {
      *
      * @example
      * ```ts
-     * pipe(Tuple.make("alice", 42), Tuple.mapSecond((n) => n * 2)); // ["alice", 84]
+     * pipe(Tuple.from.pair("alice", 42), Tuple.mapSecond((n) => n * 2)); // ["alice", 84]
      * ```
      */
     const mapSecond: <B, D>(f: (b: B) => D) => <A>(tuple: Tuple<A, B>) => Tuple<A, D>;
@@ -2611,7 +2660,7 @@ declare namespace Tuple {
      * @example
      * ```ts
      * pipe(
-     *   Tuple.make("alice", 42),
+     *   Tuple.from.pair("alice", 42),
      *   Tuple.mapBoth(
      *     (name) => name.toUpperCase(),
      *     (score) => score * 2,
@@ -2626,7 +2675,7 @@ declare namespace Tuple {
      *
      * @example
      * ```ts
-     * pipe(Tuple.make("Alice", 100), Tuple.fold((name, score) => `${name}: ${score}`));
+     * pipe(Tuple.from.pair("Alice", 100), Tuple.fold((name, score) => `${name}: ${score}`));
      * // "Alice: 100"
      * ```
      */
@@ -2636,19 +2685,21 @@ declare namespace Tuple {
      *
      * @example
      * ```ts
-     * Tuple.swap(Tuple.make("key", 1)); // [1, "key"]
+     * Tuple.swap(Tuple.from.pair("key", 1)); // [1, "key"]
      * ```
      */
     const swap: <A, B>(tuple: Tuple<A, B>) => Tuple<B, A>;
-    /**
-     * Converts the pair to a heterogeneous readonly array `readonly (A | B)[]`.
-     *
-     * @example
-     * ```ts
-     * Tuple.toArray(Tuple.make("hello", 42)); // ["hello", 42]
-     * ```
-     */
-    const toArray: <A, B>(tuple: Tuple<A, B>) => readonly (A | B)[];
+    namespace to {
+        /**
+         * Converts the pair to a heterogeneous readonly array `readonly (A | B)[]`.
+         *
+         * @example
+         * ```ts
+         * Tuple.to.Array(Tuple.from.pair("hello", 42)); // ["hello", 42]
+         * ```
+         */
+        const Array: <A, B>(tuple: Tuple<A, B>) => readonly (A | B)[];
+    }
     /**
      * Runs a side effect with both values without changing the pair.
      * Useful for logging or debugging in the middle of a pipeline.
@@ -2656,7 +2707,7 @@ declare namespace Tuple {
      * @example
      * ```ts
      * pipe(
-     *   Tuple.make("Paris", 2_161_000),
+     *   Tuple.from.pair("Paris", 2_161_000),
      *   Tuple.tap((city, pop) => console.log(`${city}: ${pop}`)),
      *   Tuple.mapSecond((n) => n / 1_000_000),
      * ); // logs "Paris: 2161000", returns ["Paris", 2.161]