@nlozgachev/pipelined 0.66.0 → 0.67.0

package/dist/data.d.ts

@@ -1,12 +1,14 @@
-import { r as Brand } from "./index-Bs8En5LJ.js";
-import { n as NonEmpty, r as NonEmptyArr } from "./InternalTypes-DzDey5Do.js";
-import { C as Ordering, E as Maybe, N as Equality, a as Task, f as Result } from "./index-CY4ZLbjM.js";
+import { r as Brand } from "./index-CTe9CCHY.js";
+import { n as NonEmpty, r as NonEmptyArr } from "./InternalTypes-C0F5jyVQ.js";
+import { C as Ordering, E as Maybe, N as Equality, a as Task, c as Validation, f as Result } from "./index-CdzHrj62.js";
 //#region src/Data/Arr.d.ts
 declare namespace ArrTaskResult {
   /**
    * Maps each element to a Task.Result and runs them sequentially.
    * Returns the first Err encountered, or Ok of all results if all succeed.
    *
+   * @see {@link sequence} for collecting an existing array of Task.Result values.
+   *
    * @example
    * ```ts
    * const validate = (n: number): Task.Result<string, number> =>
@@ -23,13 +25,15 @@ declare namespace ArrTaskResult {
    * )(); // Deferred<Err("non-positive")>
    * ```
    */
-  const traverse: <E, A, B>(f: (a: A) => Task.Result<E, B>, options?: {
+  const traverse: <E, A, B>(transform: (item: A) => Task.Result<E, B>, options?: {
     concurrency?: number;
-  }) => (data: readonly A[]) => Task.Result<E, readonly B[]>;
+  }) => (items: readonly A[]) => Task.Result<E, readonly B[]>;
   /**
    * Collects an array of Task.Results into a Task.Result of array.
    * Returns the first Err if any element is Err, runs sequentially.
    *
+   * @see {@link traverse} for mapping elements to Task.Result instances and collecting them.
+   *
    * @example
    * ```ts
    * pipe(
@@ -38,7 +42,7 @@ declare namespace ArrTaskResult {
    * )(); // Deferred<Ok([1, 2])>
    * ```
    */
-  const sequence: <E, A>(data: readonly Task.Result<E, A>[]) => Task.Result<E, readonly A[]>;
+  const sequence: <E, A>(items: readonly Task.Result<E, A>[]) => Task.Result<E, readonly A[]>;
 }
 interface TaskTraverse {
   <A, B>(f: (a: A) => Task<B>, options?: {
@@ -51,91 +55,101 @@ interface TaskSequence {
   Result: typeof ArrTaskResult.sequence;
 }
 export declare const Arr: {
-  head: <A>(data: readonly A[]) => Maybe<A>;
-  last: <A>(data: readonly A[]) => Maybe<A>;
-  tail: <A>(data: readonly A[]) => Maybe<readonly A[]>;
-  init: <A>(data: readonly A[]) => Maybe<readonly A[]>;
-  findFirst: <A>(predicate: (a: A) => boolean) => (data: readonly A[]) => Maybe<A>;
-  findLast: <A>(predicate: (a: A) => boolean) => (data: readonly A[]) => Maybe<A>;
-  findIndex: <A>(predicate: (a: A) => boolean) => (data: readonly A[]) => Maybe<number>;
-  map: <A, B>(f: (a: A) => B) => (data: readonly A[]) => readonly B[];
-  mapWithIndex: <A, B>(f: (i: number, a: A) => B) => (data: readonly A[]) => readonly B[];
-  filter: <A>(predicate: (a: A) => boolean) => (data: readonly A[]) => readonly A[];
-  filterMap: <A, B>(f: (a: A) => Maybe<B>) => (data: readonly A[]) => readonly B[];
-  partition: <A>(predicate: (a: A) => boolean) => (data: readonly A[]) => readonly [readonly A[], readonly A[]];
-  compact: <A>(data: readonly Maybe<A>[]) => readonly A[];
-  separate: <E, A>(data: readonly Result<E, A>[]) => readonly [readonly E[], readonly A[]];
-  partitionMap: <A, E, B>(f: (a: A) => Result<E, B>) => (data: readonly A[]) => readonly [readonly E[], readonly B[]];
-  groupBy: <A>(f: (a: A) => string) => (data: readonly A[]) => Record<string, NonEmptyArr<A>>;
-  uniq: <A>(data: readonly A[]) => readonly A[];
-  uniqBy: <A, B>(f: (a: A) => B) => (data: readonly A[]) => readonly A[];
-  uniqWith: <A>(eq: Equality<A>) => (data: readonly A[]) => readonly A[];
-  sortBy: <A>(compare: (a: A, b: A) => number) => (data: readonly A[]) => readonly A[];
-  sortWith: <A>(ord: Ordering<A>) => (data: readonly A[]) => readonly A[];
-  zip: <B>(other: readonly B[]) => <A>(data: readonly A[]) => readonly (readonly [A, B])[];
-  zipWith: <A, B, C>(f: (a: A, b: B) => C) => (other: readonly B[]) => (data: readonly A[]) => readonly C[];
-  intersperse: <A>(sep: A) => (data: readonly A[]) => readonly A[];
-  concat: <A>(other: readonly A[]) => (data: readonly A[]) => readonly A[];
-  chunksOf: (n: number) => <A>(data: readonly A[]) => readonly (readonly A[])[];
-  flatten: <A>(data: readonly (readonly A[])[]) => readonly A[];
-  flatMap: <A, B>(f: (a: A) => readonly B[]) => (data: readonly A[]) => readonly B[];
-  reduce: <A, B>(initial: B, f: (acc: B, a: A) => B) => (data: readonly A[]) => B;
-  prepend: <A>(value: A) => (data: readonly A[]) => NonEmptyArr<A>;
-  append: <A>(value: A) => (data: readonly A[]) => NonEmptyArr<A>;
-  size: <A>(data: readonly A[]) => number;
-  some: <A>(predicate: (a: A) => boolean) => (data: readonly A[]) => boolean;
-  every: <A>(predicate: (a: A) => boolean) => (data: readonly A[]) => boolean;
-  reverse: <A>(data: readonly A[]) => readonly A[];
-  insertAt: <A>(index: number, item: A) => (data: readonly A[]) => readonly A[];
-  removeAt: (index: number) => <A>(data: readonly A[]) => readonly A[];
-  take: (n: number) => <A>(data: readonly A[]) => readonly A[];
-  drop: (n: number) => <A>(data: readonly A[]) => readonly A[];
-  takeWhile: <A>(predicate: (a: A) => boolean) => (data: readonly A[]) => readonly A[];
-  dropWhile: <A>(predicate: (a: A) => boolean) => (data: readonly A[]) => readonly A[];
-  scan: <A, B>(initial: B, f: (acc: B, a: A) => B) => (data: readonly A[]) => readonly B[];
-  splitAt: (index: number) => <A>(data: readonly A[]) => readonly [readonly A[], readonly A[]];
-  partitionMaybe: <A, B>(f: (a: A) => Maybe<B>) => (data: readonly A[]) => readonly [failures: readonly A[], successes: readonly B[]];
-  at: (index: number) => <A>(data: readonly A[]) => Maybe<A>;
-  findMap: <A, B>(f: (a: A) => Maybe<B>) => (data: readonly A[]) => Maybe<B>;
-  indexBy: <A, K>(keyFn: (a: A) => K) => (data: readonly A[]) => ReadonlyMap<K, A>;
-  frequencies: <A>(data: readonly A[]) => ReadonlyMap<A, number>;
-  chunkBy: <A, K>(keyFn: (a: A) => K) => (data: readonly A[]) => readonly (readonly A[])[];
-  dedupeAdjacent: <A>(eq?: Equality<A>) => (data: readonly A[]) => readonly A[];
+  head: <A>(items: readonly A[]) => Maybe<A>;
+  last: <A>(items: readonly A[]) => Maybe<A>;
+  tail: <A>(items: readonly A[]) => Maybe<readonly A[]>;
+  init: <A>(items: readonly A[]) => Maybe<readonly A[]>;
+  findFirst: <A>(predicate: (item: A) => boolean) => (items: readonly A[]) => Maybe<A>;
+  findLast: <A>(predicate: (item: A) => boolean) => (items: readonly A[]) => Maybe<A>;
+  findIndex: <A>(predicate: (item: A) => boolean) => (items: readonly A[]) => Maybe<number>;
+  map: <A, B>(transform: (item: A) => B) => (items: readonly A[]) => readonly B[];
+  mapWithIndex: <A, B>(transform: (index: number, item: A) => B) => (items: readonly A[]) => readonly B[];
+  filter: <A>(predicate: (item: A) => boolean) => (items: readonly A[]) => readonly A[];
+  filterMap: <A, B>(transform: (item: A) => Maybe<B>) => (items: readonly A[]) => readonly B[];
+  partition: <A>(predicate: (item: A) => boolean) => (items: readonly A[]) => readonly [readonly A[], readonly A[]];
+  compact: <A>(items: readonly Maybe<A>[]) => readonly A[];
+  separate: <E, A>(items: readonly Result<E, A>[]) => readonly [readonly E[], readonly A[]];
+  partitionMap: <A, E, B>(transform: (item: A) => Result<E, B>) => (items: readonly A[]) => readonly [readonly E[], readonly B[]];
+  groupBy: <A>(keySelector: (item: A) => string) => (items: readonly A[]) => Record<string, NonEmptyArr<A>>;
+  uniq: <A>(items: readonly A[]) => readonly A[];
+  uniqBy: <A, B>(keySelector: (item: A) => B) => (items: readonly A[]) => readonly A[];
+  uniqWith: <A>(areEqual: Equality<A>) => (items: readonly A[]) => readonly A[];
+  sortBy: <A>(compare: (first: A, second: A) => number) => (items: readonly A[]) => readonly A[];
+  sortWith: <A>(ordering: Ordering<A>) => (items: readonly A[]) => readonly A[];
+  zip: <B>(other: readonly B[]) => <A>(items: readonly A[]) => readonly (readonly [A, B])[];
+  zipWith: <A, B, C>(combine: (first: A, second: B) => C) => (other: readonly B[]) => (items: readonly A[]) => readonly C[];
+  intersperse: <A>(separator: A) => (items: readonly A[]) => readonly A[];
+  concat: <A>(other: readonly A[]) => (items: readonly A[]) => readonly A[];
+  chunksOf: (size: number) => <A>(items: readonly A[]) => readonly (readonly A[])[];
+  flatten: <A>(items: readonly (readonly A[])[]) => readonly A[];
+  flatMap: <A, B>(transform: (item: A) => readonly B[]) => (items: readonly A[]) => readonly B[];
+  reduce: <A, B>(initial: B, reducer: (accumulator: B, item: A) => B) => (items: readonly A[]) => B;
+  prepend: <A>(item: A) => (items: readonly A[]) => NonEmptyArr<A>;
+  append: <A>(item: A) => (items: readonly A[]) => NonEmptyArr<A>;
+  size: <A>(items: readonly A[]) => number;
+  length: <A>(items: readonly A[]) => number;
+  some: <A>(predicate: (item: A) => boolean) => (items: readonly A[]) => boolean;
+  every: <A>(predicate: (item: A) => boolean) => (items: readonly A[]) => boolean;
+  reverse: <A>(items: readonly A[]) => readonly A[];
+  insertAt: <A>(index: number, item: A) => (items: readonly A[]) => readonly A[];
+  removeAt: (index: number) => <A>(items: readonly A[]) => readonly A[];
+  take: (count: number) => <A>(items: readonly A[]) => readonly A[];
+  drop: (count: number) => <A>(items: readonly A[]) => readonly A[];
+  takeWhile: <A>(predicate: (item: A) => boolean) => (items: readonly A[]) => readonly A[];
+  dropWhile: <A>(predicate: (item: A) => boolean) => (items: readonly A[]) => readonly A[];
+  scan: <A, B>(initial: B, reducer: (accumulator: B, item: A) => B) => (items: readonly A[]) => readonly B[];
+  splitAt: (index: number) => <A>(items: readonly A[]) => readonly [readonly A[], readonly A[]];
+  partitionMaybe: <A, B>(transform: (item: A) => Maybe<B>) => (items: readonly A[]) => readonly [failures: readonly A[], successes: readonly B[]];
+  at: (index: number) => <A>(items: readonly A[]) => Maybe<A>;
+  findMap: <A, B>(transform: (item: A) => Maybe<B>) => (items: readonly A[]) => Maybe<B>;
+  indexBy: <A, K>(keySelector: (item: A) => K) => (items: readonly A[]) => ReadonlyMap<K, A>;
+  frequencies: <A>(items: readonly A[]) => ReadonlyMap<A, number>;
+  chunkBy: <A, K>(keySelector: (item: A) => K) => (items: readonly A[]) => readonly (readonly A[])[];
+  dedupeAdjacent: <A>(areEqual?: Equality<A>) => (items: readonly A[]) => readonly A[];
   windowed: (windowSize: number, options?: {
     step?: number;
-  }) => <A>(data: readonly A[]) => readonly (readonly A[])[];
-  unfold: <A, S>(initial: S, f: (state: S) => Maybe<readonly [A, S]>) => readonly A[];
-  from: {
-    Array: <A>(data: readonly A[]) => Maybe<NonEmptyArr<A>>;
-  };
+  }) => <A>(items: readonly A[]) => readonly (readonly A[])[];
+  unfold: <A, S>(initial: S, step: (state: S) => Maybe<readonly [A, S]>) => readonly A[];
   is: {
-    empty: <A>(data: readonly A[]) => data is readonly [];
-    nonEmpty: <A>(data: readonly A[]) => data is NonEmptyArr<A>;
+    /**
+     * Returns `true` when the array is empty.
+     *
+     * @see {@link nonEmpty} for checking if an array contains elements.
+     */
+    empty: <A>(items: readonly A[]) => items is readonly [];
+    /**
+     * Returns `true` when the array contains at least one element.
+     *
+     * @see {@link empty} for checking if an array is empty.
+     */
+    nonEmpty: <A>(items: readonly A[]) => items is NonEmptyArr<A>;
   };
   traverse: {
-    Maybe: <A, B>(f: (a: A) => Maybe<B>) => (data: readonly A[]) => Maybe<readonly B[]>;
-    Result: <E, A, B>(f: (a: A) => Result<E, B>) => (data: readonly A[]) => Result<E, readonly B[]>;
+    Maybe: <A, B>(transform: (item: A) => Maybe<B>) => (items: readonly A[]) => Maybe<readonly B[]>;
+    Result: <E, A, B>(transform: (item: A) => Result<E, B>) => (items: readonly A[]) => Result<E, readonly B[]>;
     Task: TaskTraverse;
+    Validation: <E, A, B>(transform: (item: A) => Validation<E, B>) => (items: readonly A[]) => Validation<E, readonly B[]>;
   };
   sequence: {
-    Maybe: <A>(data: readonly Maybe<A>[]) => Maybe<readonly A[]>;
-    Result: <E, A>(data: readonly Result<E, A>[]) => Result<E, readonly A[]>;
+    Maybe: <A>(items: readonly Maybe<A>[]) => Maybe<readonly A[]>;
+    Result: <E, A>(items: readonly Result<E, A>[]) => Result<E, readonly A[]>;
     Task: TaskSequence;
+    Validation: <E, A>(items: readonly Validation<E, A>[]) => Validation<E, readonly A[]>;
   };
   NonEmpty: {
-    singleton: <A>(value: A) => NonEmptyArr<A>;
+    singleton: <A>(item: A) => NonEmptyArr<A>;
     from: {
-      Array: <A>(data: readonly A[]) => Maybe<NonEmptyArr<A>>;
+      array: <A>(items: readonly A[]) => Maybe<NonEmptyArr<A>>;
     };
-    head: <A>(data: NonEmptyArr<A>) => A;
-    last: <A>(data: NonEmptyArr<A>) => A;
-    tail: <A>(data: NonEmptyArr<A>) => readonly A[];
-    reduce: <A>(f: (acc: A, a: A) => A) => (data: NonEmptyArr<A>) => A;
-    map: <A, B>(f: (a: A) => B) => (data: NonEmptyArr<A>) => NonEmptyArr<B>;
-    mapWithIndex: <A, B>(f: (i: number, a: A) => B) => (data: NonEmptyArr<A>) => NonEmptyArr<B>;
-    intersperse: <A>(sep: A) => (data: NonEmptyArr<A>) => NonEmptyArr<A>;
-    concat: <A>(other: readonly A[]) => (data: NonEmptyArr<A>) => NonEmptyArr<A>;
-    reverse: <A>(data: NonEmptyArr<A>) => NonEmptyArr<A>;
+    head: <A>(items: NonEmptyArr<A>) => A;
+    last: <A>(items: NonEmptyArr<A>) => A;
+    tail: <A>(items: NonEmptyArr<A>) => readonly A[];
+    reduce: <A>(reducer: (accumulator: A, item: A) => A) => (items: NonEmptyArr<A>) => A;
+    map: <A, B>(transform: (item: A) => B) => (items: NonEmptyArr<A>) => NonEmptyArr<B>;
+    mapWithIndex: <A, B>(transform: (index: number, item: A) => B) => (items: NonEmptyArr<A>) => NonEmptyArr<B>;
+    intersperse: <A>(separator: A) => (items: NonEmptyArr<A>) => NonEmptyArr<A>;
+    concat: <A>(other: readonly A[]) => (items: NonEmptyArr<A>) => NonEmptyArr<A>;
+    reverse: <A>(items: NonEmptyArr<A>) => NonEmptyArr<A>;
   };
 };
 export declare namespace Arr {
@@ -169,30 +183,36 @@ export declare const BigNum: {
      * BigNum.is.zero(5n); // false
      * ```
      */
-    zero: (b: bigint) => boolean;
+    zero: (value: bigint) => boolean;
     /**
      * Returns `true` when the bigint is an even integer.
      *
+     * @see {@link BigNum.is.odd} to check if a bigint is odd.
+     *
      * @example
      * ```ts
      * BigNum.is.even(4n); // true
      * BigNum.is.even(3n); // false
      * ```
      */
-    even: (b: bigint) => boolean;
+    even: (value: bigint) => boolean;
     /**
      * Returns `true` when the bigint is an odd integer.
      *
+     * @see {@link BigNum.is.even} to check if a bigint is even.
+     *
      * @example
      * ```ts
      * BigNum.is.odd(3n); // true
      * BigNum.is.odd(4n); // false
      * ```
      */
-    odd: (b: bigint) => boolean;
+    odd: (value: bigint) => boolean;
     /**
      * Returns `true` when the bigint is strictly greater than zero (`0n`).
      *
+     * @see {@link BigNum.is.negative} to check if a bigint is less than zero.
+     *
      * @example
      * ```ts
      * BigNum.is.positive(5n);  // true
@@ -200,10 +220,12 @@ export declare const BigNum: {
      * BigNum.is.positive(-5n); // false
      * ```
      */
-    positive: (b: bigint) => boolean;
+    positive: (value: bigint) => boolean;
     /**
      * Returns `true` when the bigint is strictly less than zero (`0n`).
      *
+     * @see {@link BigNum.is.positive} to check if a bigint is greater than zero.
+     *
      * @example
      * ```ts
      * BigNum.is.negative(-5n); // true
@@ -211,7 +233,7 @@ export declare const BigNum: {
      * BigNum.is.negative(5n);  // false
      * ```
      */
-    negative: (b: bigint) => boolean;
+    negative: (value: bigint) => boolean;
   };
   from: {
     /**
@@ -223,7 +245,7 @@ export declare const BigNum: {
      * BigNum.from.string("abc"); // None
      * ```
      */
-    string: (s: string) => Maybe<bigint>;
+    string: (text: string) => Maybe<bigint>;
     /**
      * Safely converts a number into a `bigint`. Returns `None` for floats, `NaN`, or non-safe integers.
      *
@@ -233,7 +255,7 @@ export declare const BigNum: {
      * BigNum.from.number(3.14); // None
      * ```
      */
-    number: (n: number) => Maybe<bigint>;
+    number: (value: number) => Maybe<bigint>;
   };
   to: {
     /**
@@ -245,73 +267,98 @@ export declare const BigNum: {
      * BigNum.to.number(9007199254740993n);      // None
      * ```
      */
-    number: (b: bigint) => Maybe<number>;
+    number: (value: bigint) => Maybe<number>;
   };
   /**
-   * Adds `b` to `a`. Data-last curried signature: `add(b)(a)` = `a + b`.
+   * Adds `amount` to `value`. Data-last curried signature: `add(amount)(value)` = `value + amount`.
+   *
+   * @see {@link BigNum.subtract} to subtract an amount from a bigint.
    *
    * @example
    * ```ts
    * pipe(10n, BigNum.add(5n)); // 15n
    * ```
    */
-  add: (b: bigint) => (a: bigint) => bigint;
+  add: (amount: bigint) => (value: bigint) => bigint;
   /**
-   * Subtracts `b` from `a`. Data-last curried signature: `sub(b)(a)` = `a - b`.
+   * Subtracts `amount` from `from`. Data-last curried signature: `subtract(amount)(from)` = `from - amount`.
+   *
+   * @see {@link BigNum.add} to add an amount to a bigint.
    *
    * @example
    * ```ts
-   * pipe(10n, BigNum.sub(3n)); // 7n
+   * pipe(10n, BigNum.subtract(3n)); // 7n
    * ```
    */
-  sub: (b: bigint) => (a: bigint) => bigint;
+  subtract: (amount: bigint) => (from: bigint) => bigint;
   /**
-   * Multiplies `a` by `b`. Data-last curried signature: `mul(b)(a)` = `a * b`.
+   * Multiplies `value` by `factor`. Data-last curried signature: `multiply(factor)(value)` = `value * factor`.
+   *
+   * @see {@link BigNum.divide} to divide a bigint by a divisor.
    *
    * @example
    * ```ts
-   * pipe(6n, BigNum.mul(7n)); // 42n
+   * pipe(6n, BigNum.multiply(7n)); // 42n
    * ```
    */
-  mul: (b: bigint) => (a: bigint) => bigint;
+  multiply: (factor: bigint) => (value: bigint) => bigint;
   /**
-   * Divides `a` by `b`. Returns `None` if `b` is `0n`.
+   * Divides `dividend` by `divisor`. Returns `None` if `divisor` is `0n`.
+   *
+   * @see {@link BigNum.multiply} to multiply a bigint by a factor.
+   * @see {@link BigNum.remainder} to compute the division remainder.
    *
    * @example
    * ```ts
-   * pipe(20n, BigNum.div(4n)); // Some(5n)
-   * pipe(5n, BigNum.div(0n));  // None
+   * pipe(20n, BigNum.divide(4n)); // Some(5n)
+   * pipe(5n, BigNum.divide(0n));  // None
    * ```
    */
-  div: (b: bigint) => (a: bigint) => Maybe<bigint>;
+  divide: (divisor: bigint) => (dividend: bigint) => Maybe<bigint>;
   /**
-   * Computes remainder of `a / b`. Returns `None` if `b` is `0n`.
+   * Computes remainder of `dividend / divisor`. Returns `None` if `divisor` is `0n`.
+   *
+   * @see {@link BigNum.divide} for full division.
    *
    * @example
    * ```ts
-   * pipe(10n, BigNum.mod(3n)); // Some(1n)
-   * pipe(5n, BigNum.mod(0n));  // None
+   * pipe(10n, BigNum.remainder(3n)); // Some(1n)
+   * pipe(5n, BigNum.remainder(0n));  // None
    * ```
    */
-  mod: (b: bigint) => (a: bigint) => Maybe<bigint>;
+  remainder: (divisor: bigint) => (dividend: bigint) => Maybe<bigint>;
   /**
-   * Clamps `a` between `min` and `max` (inclusive).
+   * Clamps `value` between `min` and `max` (inclusive).
    *
    * @example
    * ```ts
    * pipe(150n, BigNum.clamp(0n, 100n)); // 100n
    * ```
    */
-  clamp: (min: bigint, max: bigint) => (a: bigint) => bigint;
+  clamp: (min: bigint, max: bigint) => (value: bigint) => bigint;
+  /**
+   * Returns `true` when the bigint is between `min` and `max` (both inclusive).
+   *
+   * @see {@link BigNum.inRange} for half-open range checking [start, end).
+   *
+   * @example
+   * ```ts
+   * pipe(5n, BigNum.between(1n, 10n)); // true
+   * pipe(0n, BigNum.between(1n, 10n)); // false
+   * ```
+   */
+  between: (min: bigint, max: bigint) => (value: bigint) => boolean;
   /**
-   * Returns `true` if `a` is in the range `[start, end)` (inclusive start, exclusive end).
+   * Returns `true` if `value` is in the range `[start, end)` (inclusive start, exclusive end).
+   *
+   * @see {@link BigNum.between} for fully closed range checking [min, max].
    *
    * @example
    * ```ts
    * pipe(5n, BigNum.inRange(1n, 10n)); // true
    * ```
    */
-  inRange: (start: bigint, end: bigint) => (a: bigint) => boolean;
+  inRange: (start: bigint, end: bigint) => (value: bigint) => boolean;
   /**
    * Returns absolute value of a `bigint`.
    *
@@ -320,25 +367,29 @@ export declare const BigNum: {
    * BigNum.abs(-42n); // 42n
    * ```
    */
-  abs: (a: bigint) => bigint;
+  abs: (value: bigint) => bigint;
   /**
-   * Returns the minimum of `a` and `b`.
+   * Returns the minimum of `value` and `other`.
+   *
+   * @see {@link BigNum.max} to determine the maximum value.
    *
    * @example
    * ```ts
    * pipe(10n, BigNum.min(5n)); // 5n
    * ```
    */
-  min: (b: bigint) => (a: bigint) => bigint;
+  min: (other: bigint) => (value: bigint) => bigint;
   /**
-   * Returns the maximum of `a` and `b`.
+   * Returns the maximum of `value` and `other`.
+   *
+   * @see {@link BigNum.min} to determine the minimum value.
    *
    * @example
    * ```ts
    * pipe(10n, BigNum.max(5n)); // 10n
    * ```
    */
-  max: (b: bigint) => (a: bigint) => bigint;
+  max: (other: bigint) => (value: bigint) => bigint;
 };
 //#endregion
 //#region src/Data/Bool.d.ts
@@ -359,30 +410,36 @@ export declare const Bool: {
      * Bool.is.boolean(null);      // false
      * ```
      */
-    boolean: (u: unknown) => u is boolean;
+    boolean: (value: unknown) => value is boolean;
     /**
      * Narrowing guard — checks if a value is strictly `true`.
      *
+     * @see {@link Bool.is.false} to check if a value is strictly false.
+     *
      * @example
      * ```ts
      * Bool.is.true(true);  // true
      * Bool.is.true(false); // false
      * ```
      */
-    true: (u: unknown) => u is true;
+    true: (value: unknown) => value is true;
     /**
      * Narrowing guard — checks if a value is strictly `false`.
      *
+     * @see {@link Bool.is.true} to check if a value is strictly true.
+     *
      * @example
      * ```ts
      * Bool.is.false(false); // true
      * Bool.is.false(true);  // false
      * ```
      */
-    false: (u: unknown) => u is false;
+    false: (value: unknown) => value is false;
     /**
      * Type guard — checks if a value is truthy (not `false`, `0`, `0n`, `""`, `null`, `undefined`, or `NaN`).
      *
+     * @see {@link Bool.is.falsy} to check if a value is falsy.
+     *
      * @example
      * ```ts
      * Bool.is.truthy("hello"); // true
@@ -391,10 +448,12 @@ export declare const Bool: {
      * Bool.is.truthy(null);    // false
      * ```
      */
-    truthy: <T>(u: T) => u is Exclude<T, false | 0 | 0n | "" | null | undefined>;
+    truthy: <T>(value: T) => value is Exclude<T, false | 0 | 0n | "" | null | undefined>;
     /**
      * Type guard — checks if a value is falsy (`false`, `0`, `0n`, `""`, `null`, `undefined`, or `NaN`).
      *
+     * @see {@link Bool.is.truthy} to check if a value is truthy.
+     *
      * @example
      * ```ts
      * Bool.is.falsy("");        // true
@@ -402,7 +461,7 @@ export declare const Bool: {
      * Bool.is.falsy("content"); // false
      * ```
      */
-    falsy: (u: unknown) => u is false | 0 | 0n | "" | null | undefined;
+    falsy: (value: unknown) => value is false | 0 | 0n | "" | null | undefined;
   };
   /**
    * Unary boolean negation: inverts the given boolean value.
@@ -413,11 +472,14 @@ export declare const Bool: {
    * Bool.not(false); // true
    * ```
    */
-  not: (b: boolean) => boolean;
+  not: (condition: boolean) => boolean;
   /**
-   * Logical AND combinator. Returns `true` only if both `self` and `that` are `true`.
+   * Logical AND combinator. Returns `true` only if both `condition` and `that` are `true`.
+   *
+   * Data-last: `pipe(condition, Bool.and(that))`.
    *
-   * Data-last: `pipe(self, Bool.and(that))`.
+   * @see {@link Bool.or} for logical OR combinator.
+   * @see {@link Bool.andLazy} for short-circuiting lazy evaluation.
    *
    * @example
    * ```ts
@@ -425,11 +487,14 @@ export declare const Bool: {
    * pipe(true, Bool.and(false)); // false
    * ```
    */
-  and: (that: boolean) => (self: boolean) => boolean;
+  and: (that: boolean) => (condition: boolean) => boolean;
   /**
-   * Logical OR combinator. Returns `true` if either `self` or `that` is `true`.
+   * Logical OR combinator. Returns `true` if either `condition` or `that` is `true`.
+   *
+   * Data-last: `pipe(condition, Bool.or(that))`.
    *
-   * Data-last: `pipe(self, Bool.or(that))`.
+   * @see {@link Bool.and} for logical AND combinator.
+   * @see {@link Bool.orLazy} for short-circuiting lazy evaluation.
    *
    * @example
    * ```ts
@@ -437,11 +502,11 @@ export declare const Bool: {
    * pipe(false, Bool.or(false)); // false
    * ```
    */
-  or: (that: boolean) => (self: boolean) => boolean;
+  or: (that: boolean) => (condition: boolean) => boolean;
   /**
-   * Logical XOR (exclusive OR) combinator. Returns `true` if exactly one of `self` and `that` is `true`.
+   * Logical XOR (exclusive OR) combinator. Returns `true` if exactly one of `condition` and `that` is `true`.
    *
-   * Data-last: `pipe(self, Bool.xor(that))`.
+   * Data-last: `pipe(condition, Bool.xor(that))`.
    *
    * @example
    * ```ts
@@ -449,12 +514,15 @@ export declare const Bool: {
    * pipe(true, Bool.xor(true));  // false
    * ```
    */
-  xor: (that: boolean) => (self: boolean) => boolean;
+  xor: (that: boolean) => (condition: boolean) => boolean;
   /**
    * Lazy logical AND combinator.
-   * If `self` is `false`, the `that` computation is never evaluated.
+   * If `condition` is `false`, the `that` computation is never evaluated.
    *
-   * Data-last: `pipe(self, Bool.andLazy(that))`.
+   * Data-last: `pipe(condition, Bool.andLazy(that))`.
+   *
+   * @see {@link Bool.orLazy} for lazy logical OR combinator.
+   * @see {@link Bool.and} for strict logical AND evaluation.
    *
    * @example
    * ```ts
@@ -464,12 +532,15 @@ export declare const Bool: {
    * );
    * ```
    */
-  andLazy: (that: () => boolean) => (self: boolean) => boolean;
+  andLazy: (that: () => boolean) => (condition: boolean) => boolean;
   /**
    * Lazy logical OR combinator.
-   * If `self` is `true`, the `that` computation is never evaluated.
+   * If `condition` is `true`, the `that` computation is never evaluated.
+   *
+   * Data-last: `pipe(condition, Bool.orLazy(that))`.
    *
-   * Data-last: `pipe(self, Bool.orLazy(that))`.
+   * @see {@link Bool.andLazy} for lazy logical AND combinator.
+   * @see {@link Bool.or} for strict logical OR evaluation.
    *
    * @example
    * ```ts
@@ -479,12 +550,14 @@ export declare const Bool: {
    * );
    * ```
    */
-  orLazy: (that: () => boolean) => (self: boolean) => boolean;
+  orLazy: (that: () => boolean) => (condition: boolean) => boolean;
   /**
    * N-ary AND aggregation across an array of booleans.
    * Returns `true` if every boolean is `true`, or for an empty array (vacuous truth).
    * Short-circuits on the first `false`.
    *
+   * @see {@link Bool.any} to check if at least one boolean is true.
+   *
    * @example
    * ```ts
    * Bool.all([true, true, true]);  // true
@@ -492,12 +565,14 @@ export declare const Bool: {
    * Bool.all([]);                  // true
    * ```
    */
-  all: (booleans: readonly boolean[]) => boolean;
+  all: (conditions: readonly boolean[]) => boolean;
   /**
    * N-ary OR aggregation across an array of booleans.
    * Returns `true` if at least one boolean is `true`. Returns `false` for an empty array.
    * Short-circuits on the first `true`.
    *
+   * @see {@link Bool.all} to check if all booleans are true.
+   *
    * @example
    * ```ts
    * Bool.any([false, true, false]); // true
@@ -505,13 +580,15 @@ export declare const Bool: {
    * Bool.any([]);                   // false
    * ```
    */
-  any: (booleans: readonly boolean[]) => boolean;
+  any: (conditions: readonly boolean[]) => boolean;
   /**
    * Catamorphism for boolean: evaluates `onFalse()` when `false` and `onTrue()` when `true`.
    *
    * Positional ordering: `onFalse` first, `onTrue` second.
    * Aligned with `Result.fold(onErr, onOk)` and `Maybe.fold(onNone, onSome)`.
    *
+   * @see {@link Bool.match} for named-case pattern matching with an object literal.
+   *
    * @example
    * ```ts
    * pipe(
@@ -523,10 +600,12 @@ export declare const Bool: {
    * );
    * ```
    */
-  fold: <A, B>(onFalse: () => A, onTrue: () => B) => (b: boolean) => A | B;
+  fold: <A, B>(onFalse: () => A, onTrue: () => B) => (condition: boolean) => A | B;
   /**
    * Pattern matching on boolean using named cases `{ true, false }`.
    *
+   * @see {@link Bool.fold} for positional argument pattern matching.
+   *
    * @example
    * ```ts
    * pipe(
@@ -538,7 +617,7 @@ export declare const Bool: {
    * );
    * ```
    */
-  match: <A, B>(cases: BoolMatchCases<A, B>) => (b: boolean) => A | B;
+  match: <A, B>(cases: BoolMatchCases<A, B>) => (condition: boolean) => A | B;
   from: {
     /**
      * Parses a string into a `Maybe<boolean>`.
@@ -552,7 +631,7 @@ export declare const Bool: {
      * Bool.from.string("yes");   // None
      * ```
      */
-    string: (s: string) => Maybe<boolean>;
+    string: (text: string) => Maybe<boolean>;
     /**
      * Converts a number into a `Maybe<boolean>`.
      * Returns `Some(true)` for `1`, `Some(false)` for `0`, and `None` for any other number.
@@ -564,7 +643,7 @@ export declare const Bool: {
      * Bool.from.number(42); // None
      * ```
      */
-    number: (n: number) => Maybe<boolean>;
+    number: (value: number) => Maybe<boolean>;
     /**
      * Coerces any unknown value into a boolean via standard JS `Boolean(value)`.
      *
@@ -589,7 +668,7 @@ export declare const Bool: {
      * ); // Some(profile) or None
      * ```
      */
-    Maybe: <A>(onTrue: () => A) => (b: boolean) => Maybe<A>;
+    Maybe: <A>(onTrue: () => A) => (condition: boolean) => Maybe<A>;
     /**
      * Lifts a boolean condition into a `Result`.
      * Returns `Ok(onOk())` when `true`, and `Err(onErr())` when `false`.
@@ -605,7 +684,7 @@ export declare const Bool: {
      * ); // Ok(sessionData) or Err("Permission denied")
      * ```
      */
-    Result: <E, A>(onErr: () => E, onOk: () => A) => (b: boolean) => Result<E, A>;
+    Result: <E, A>(onErr: () => E, onOk: () => A) => (condition: boolean) => Result<E, A>;
     /**
      * Converts a boolean to numeric `1` or `0`.
      *
@@ -615,7 +694,7 @@ export declare const Bool: {
      * Bool.to.number(false); // 0
      * ```
      */
-    number: (b: boolean) => 1 | 0;
+    number: (condition: boolean) => 1 | 0;
     /**
      * Converts a boolean to literal string `"true"` or `"false"`.
      *
@@ -625,7 +704,7 @@ export declare const Bool: {
      * Bool.to.string(false); // "false"
      * ```
      */
-    string: (b: boolean) => "true" | "false";
+    string: (condition: boolean) => "true" | "false";
   };
 };
 //#endregion
@@ -634,61 +713,73 @@ export declare const Bool: {
  * A branded type representing a key-value dictionary with at least one entry.
  */
 export type NonEmptyMap<K, V> = Brand<NonEmpty<"Dict">, ReadonlyMap<K, V>>;
-declare function mergeWith$1<V>(combine: (a: V, b: V) => V): {
+/**
+ * Merges two dictionaries using a combination function on collisions.
+ */
+declare function mergeWith$1<V>(combine: (first: V, second: V) => V): {
   <K>(first: ReadonlyMap<K, V>, second: ReadonlyMap<K, V>): ReadonlyMap<K, V>;
   <K>(second: ReadonlyMap<K, V>): (first: ReadonlyMap<K, V>) => ReadonlyMap<K, V>;
 };
 export declare const Dict: {
   is: {
-    empty: <K, V>(m: ReadonlyMap<K, V>) => boolean;
-    nonEmpty: <K, V>(m: ReadonlyMap<K, V>) => m is NonEmptyMap<K, V>;
+    /**
+     * Returns `true` when the dictionary contains zero entries.
+     *
+     * @see {@link nonEmpty} for checking if a dictionary contains entries.
+     */
+    empty: <K, V>(dict: ReadonlyMap<K, V>) => boolean;
+    /**
+     * Returns `true` when the dictionary contains at least one entry.
+     *
+     * @see {@link empty} for checking if a dictionary is empty.
+     */
+    nonEmpty: <K, V>(dict: ReadonlyMap<K, V>) => dict is NonEmptyMap<K, V>;
   };
   empty: <K, V>() => ReadonlyMap<K, V>;
   singleton: <K, V>(key: K, value: V) => ReadonlyMap<K, V>;
   from: {
     entries: <K, V>(entries: readonly (readonly [K, V])[]) => ReadonlyMap<K, V>;
-    Record: <K extends string, V>(record: Readonly<Record<K, V>>) => ReadonlyMap<K, V>;
-    Array: <K, V>(data: readonly (readonly [K, V])[]) => ReadonlyMap<K, V>;
-    nullable: <K, V>(data: ReadonlyMap<K, V> | null | undefined) => Maybe<ReadonlyMap<K, V>>;
+    record: <K extends string, V>(record: Readonly<Record<K, V>>) => ReadonlyMap<K, V>;
+    nullable: <K, V>(dict: ReadonlyMap<K, V> | null | undefined) => Maybe<ReadonlyMap<K, V>>;
   };
   to: {
-    Record: <K extends string, V>(map: ReadonlyMap<K, V>) => Readonly<Record<K, V>>;
+    record: <K extends string, V>(dict: ReadonlyMap<K, V>) => Readonly<Record<K, V>>;
   };
-  groupBy: <A, K>(f: (a: A) => K) => (as: readonly A[]) => ReadonlyMap<K, NonEmptyArr<A>>;
-  has: <K, V>(key: K) => (data: ReadonlyMap<K, V>) => boolean;
-  lookup: <K, V>(key: K) => (data: ReadonlyMap<K, V>) => Maybe<V>;
-  size: <K, V>(data: ReadonlyMap<K, V>) => number;
-  keys: <K, V>(data: ReadonlyMap<K, V>) => readonly K[];
-  values: <K, V>(data: ReadonlyMap<K, V>) => readonly V[];
-  entries: <K, V>(data: ReadonlyMap<K, V>) => readonly (readonly [K, V])[];
-  insert: <K, V>(key: K, value: V) => (data: ReadonlyMap<K, V>) => ReadonlyMap<K, V>;
-  remove: <K, V>(key: K) => (data: ReadonlyMap<K, V>) => ReadonlyMap<K, V>;
-  upsert: <K, V>(key: K, f: (existing: Maybe<V>) => V) => (data: ReadonlyMap<K, V>) => ReadonlyMap<K, V>;
-  map: <A, B>(f: (a: A) => B) => <K>(data: ReadonlyMap<K, A>) => ReadonlyMap<K, B>;
-  mapWithKey: <K, A, B>(f: (key: K, value: A) => B) => (data: ReadonlyMap<K, A>) => ReadonlyMap<K, B>;
-  filter: <A>(predicate: (a: A) => boolean) => <K>(data: ReadonlyMap<K, A>) => ReadonlyMap<K, A>;
-  filterWithKey: <K, A>(predicate: (key: K, value: A) => boolean) => (data: ReadonlyMap<K, A>) => ReadonlyMap<K, A>;
-  compact: <K, A>(data: ReadonlyMap<K, Maybe<A>>) => ReadonlyMap<K, A>;
-  filterMap: <A, B>(f: (a: A) => Maybe<B>) => <K>(data: ReadonlyMap<K, A>) => ReadonlyMap<K, B>;
-  union: <K, V>(other: ReadonlyMap<K, V>) => (data: ReadonlyMap<K, V>) => ReadonlyMap<K, V>;
-  intersection: <K, V>(other: ReadonlyMap<K, V>) => (data: ReadonlyMap<K, V>) => ReadonlyMap<K, V>;
-  difference: <K, V>(other: ReadonlyMap<K, V>) => (data: ReadonlyMap<K, V>) => ReadonlyMap<K, V>;
-  reduce: <B, V>(init: B, f: (acc: B, value: V) => B) => <K>(data: ReadonlyMap<K, V>) => B;
-  reduceWithKey: <B, K, V>(init: B, f: (acc: B, value: V, key: K) => B) => (data: ReadonlyMap<K, V>) => B;
+  groupBy: <A, K>(keySelector: (item: A) => K) => (items: readonly A[]) => ReadonlyMap<K, NonEmptyArr<A>>;
+  has: <K, V>(key: K) => (dict: ReadonlyMap<K, V>) => boolean;
+  lookup: <K, V>(key: K) => (dict: ReadonlyMap<K, V>) => Maybe<V>;
+  size: <K, V>(dict: ReadonlyMap<K, V>) => number;
+  keys: <K, V>(dict: ReadonlyMap<K, V>) => readonly K[];
+  values: <K, V>(dict: ReadonlyMap<K, V>) => readonly V[];
+  entries: <K, V>(dict: ReadonlyMap<K, V>) => readonly (readonly [K, V])[];
+  insert: <K, V>(key: K, value: V) => (dict: ReadonlyMap<K, V>) => ReadonlyMap<K, V>;
+  remove: <K, V>(key: K) => (dict: ReadonlyMap<K, V>) => ReadonlyMap<K, V>;
+  upsert: <K, V>(key: K, update: (existing: Maybe<V>) => V) => (dict: ReadonlyMap<K, V>) => ReadonlyMap<K, V>;
+  map: <A, B>(transform: (value: A) => B) => <K>(dict: ReadonlyMap<K, A>) => ReadonlyMap<K, B>;
+  mapWithKey: <K, A, B>(transform: (key: K, value: A) => B) => (dict: ReadonlyMap<K, A>) => ReadonlyMap<K, B>;
+  filter: <A>(predicate: (value: A) => boolean) => <K>(dict: ReadonlyMap<K, A>) => ReadonlyMap<K, A>;
+  filterWithKey: <K, A>(predicate: (key: K, value: A) => boolean) => (dict: ReadonlyMap<K, A>) => ReadonlyMap<K, A>;
+  compact: <K, A>(dict: ReadonlyMap<K, Maybe<A>>) => ReadonlyMap<K, A>;
+  filterMap: <A, B>(transform: (value: A) => Maybe<B>) => <K>(dict: ReadonlyMap<K, A>) => ReadonlyMap<K, B>;
+  union: <K, V>(other: ReadonlyMap<K, V>) => (dict: ReadonlyMap<K, V>) => ReadonlyMap<K, V>;
+  intersection: <K, V>(other: ReadonlyMap<K, V>) => (dict: ReadonlyMap<K, V>) => ReadonlyMap<K, V>;
+  difference: <K, V>(other: ReadonlyMap<K, V>) => (dict: ReadonlyMap<K, V>) => ReadonlyMap<K, V>;
+  reduce: <B, V>(initial: B, reducer: (accumulator: B, value: V) => B) => <K>(dict: ReadonlyMap<K, V>) => B;
+  reduceWithKey: <B, K, V>(initial: B, reducer: (accumulator: B, value: V, key: K) => B) => (dict: ReadonlyMap<K, V>) => B;
   mergeWith: typeof mergeWith$1;
-  mapEntries: <K1, V1, K2, V2>(f: (key: K1, value: V1) => readonly [K2, V2]) => (data: ReadonlyMap<K1, V1>) => ReadonlyMap<K2, V2>;
-  mapKeys: <K1, K2, V>(f: (key: K1) => K2) => (data: ReadonlyMap<K1, V>) => ReadonlyMap<K2, V>;
+  mapEntries: <K1, V1, K2, V2>(transform: (key: K1, value: V1) => readonly [K2, V2]) => (dict: ReadonlyMap<K1, V1>) => ReadonlyMap<K2, V2>;
+  mapKeys: <K1, K2, V>(transform: (key: K1) => K2) => (dict: ReadonlyMap<K1, V>) => ReadonlyMap<K2, V>;
   NonEmpty: {
     singleton: <K, V>(key: K, value: V) => NonEmptyMap<K, V>;
     from: {
-      Map: <K, V>(m: ReadonlyMap<K, V>) => Maybe<NonEmptyMap<K, V>>;
+      map: <K, V>(dict: ReadonlyMap<K, V>) => Maybe<NonEmptyMap<K, V>>;
     };
-    keys: <K, V>(m: NonEmptyMap<K, V>) => NonEmptyArr<K>;
-    values: <K, V>(m: NonEmptyMap<K, V>) => NonEmptyArr<V>;
-    entries: <K, V>(m: NonEmptyMap<K, V>) => NonEmptyArr<readonly [K, V]>;
-    reduce: <V>(f: (acc: V, value: V) => V) => <K>(m: NonEmptyMap<K, V>) => V;
-    map: <A, B>(f: (a: A) => B) => <K>(m: NonEmptyMap<K, A>) => NonEmptyMap<K, B>;
-    mapWithKey: <K, A, B>(f: (key: K, a: A) => B) => (m: NonEmptyMap<K, A>) => NonEmptyMap<K, B>;
+    keys: <K, V>(dict: NonEmptyMap<K, V>) => NonEmptyArr<K>;
+    values: <K, V>(dict: NonEmptyMap<K, V>) => NonEmptyArr<V>;
+    entries: <K, V>(dict: NonEmptyMap<K, V>) => NonEmptyArr<readonly [K, V]>;
+    reduce: <V>(reducer: (accumulator: V, value: V) => V) => <K>(dict: NonEmptyMap<K, V>) => V;
+    map: <A, B>(transform: (value: A) => B) => <K>(dict: NonEmptyMap<K, A>) => NonEmptyMap<K, B>;
+    mapWithKey: <K, A, B>(transform: (key: K, value: A) => B) => (dict: NonEmptyMap<K, A>) => NonEmptyMap<K, B>;
   };
 };
 export declare namespace Dict {
@@ -750,27 +841,31 @@ export declare const Num: {
      * Num.is.zero(5); // false
      * ```
      */
-    zero: (n: number) => boolean;
+    zero: (value: number) => boolean;
     /**
      * Returns `true` when the number is a whole integer.
      *
+     * @see {@link Num.is.float} to check for fractional numbers.
+     *
      * @example
      * ```ts
      * Num.is.integer(5);    // true
      * Num.is.integer(3.14); // false
      * ```
      */
-    integer: (n: number) => boolean;
+    integer: (value: number) => boolean;
     /**
      * Returns `true` when the number is a finite float (fractional number).
      *
+     * @see {@link Num.is.integer} to check for whole numbers.
+     *
      * @example
      * ```ts
      * Num.is.float(3.14); // true
      * Num.is.float(5);    // false
      * ```
      */
-    float: (n: number) => boolean;
+    float: (value: number) => boolean;
     /**
      * Returns `true` when the number is finite (not `Infinity`, `-Infinity`, or `NaN`).
      *
@@ -780,7 +875,7 @@ export declare const Num: {
      * Num.is.finite(Infinity); // false
      * ```
      */
-    finite: (n: number) => boolean;
+    finite: (value: number) => boolean;
     /**
      * Returns `true` when the value is `NaN`.
      *
@@ -790,10 +885,12 @@ export declare const Num: {
      * Num.is.nan(42);  // false
      * ```
      */
-    nan: (n: number) => boolean;
+    nan: (value: number) => boolean;
     /**
      * Returns `true` when the number is an even integer.
      *
+     * @see {@link Num.is.odd} to check if a number is odd.
+     *
      * @example
      * ```ts
      * Num.is.even(4);   // true
@@ -801,10 +898,12 @@ export declare const Num: {
      * Num.is.even(2.5); // false
      * ```
      */
-    even: (n: number) => boolean;
+    even: (value: number) => boolean;
     /**
      * Returns `true` when the number is an odd integer.
      *
+     * @see {@link Num.is.even} to check if a number is even.
+     *
      * @example
      * ```ts
      * Num.is.odd(3);   // true
@@ -812,10 +911,12 @@ export declare const Num: {
      * Num.is.odd(2.5); // false
      * ```
      */
-    odd: (n: number) => boolean;
+    odd: (value: number) => boolean;
     /**
      * Returns `true` when the number is strictly greater than zero.
      *
+     * @see {@link Num.is.negative} to check if a number is less than zero.
+     *
      * @example
      * ```ts
      * Num.is.positive(5);  // true
@@ -823,10 +924,12 @@ export declare const Num: {
      * Num.is.positive(-5); // false
      * ```
      */
-    positive: (n: number) => boolean;
+    positive: (value: number) => boolean;
     /**
      * Returns `true` when the number is strictly less than zero.
      *
+     * @see {@link Num.is.positive} to check if a number is greater than zero.
+     *
      * @example
      * ```ts
      * Num.is.negative(-5); // true
@@ -834,7 +937,7 @@ export declare const Num: {
      * Num.is.negative(5);  // false
      * ```
      */
-    negative: (n: number) => boolean;
+    negative: (value: number) => boolean;
   };
   /**
    * Generates an array of numbers from `from` to `to` (both inclusive),
@@ -862,10 +965,12 @@ export declare const Num: {
    * pipe(42, Num.clamp(0, 100));  // 42
    * ```
    */
-  clamp: (min: number, max: number) => (n: number) => number;
+  clamp: (min: number, max: number) => (value: number) => number;
   /**
    * Returns `true` when the number is between `min` and `max` (both inclusive).
    *
+   * @see {@link Num.inRange} for half-open range checking [start, end).
+   *
    * @example
    * ```ts
    * pipe(5, Num.between(1, 10));  // true
@@ -873,10 +978,12 @@ export declare const Num: {
    * pipe(10, Num.between(1, 10)); // true
    * ```
    */
-  between: (min: number, max: number) => (n: number) => boolean;
+  between: (min: number, max: number) => (value: number) => boolean;
   /**
    * Returns `true` when the number is in the range `[start, end)` (inclusive of `start`, exclusive of `end`).
    *
+   * @see {@link Num.between} for fully closed range checking [min, max].
+   *
    * @example
    * ```ts
    * pipe(5, Num.inRange(1, 10));  // true
@@ -884,7 +991,7 @@ export declare const Num: {
    * pipe(10, Num.inRange(1, 10)); // false
    * ```
    */
-  inRange: (start: number, end: number) => (n: number) => boolean;
+  inRange: (start: number, end: number) => (value: number) => boolean;
   /**
    * Parses a string as a number. Returns `None` when the result is `NaN`.
    *
@@ -896,9 +1003,11 @@ export declare const Num: {
    * Num.parse("");     // None
    * ```
    */
-  parse: (s: string) => Maybe<number>;
+  parse: (text: string) => Maybe<number>;
   /**
-   * Adds `b` to a number. Data-last: use in `pipe` or `Arr.map`.
+   * Adds `amount` to a number. Data-last: use in `pipe` or `Arr.map`.
+   *
+   * @see {@link Num.subtract} to subtract an amount from a number.
    *
    * @example
    * ```ts
@@ -906,9 +1015,11 @@ export declare const Num: {
    * pipe([1, 2, 3], Arr.map(Num.add(10))); // [11, 12, 13]
    * ```
    */
-  add: (b: number) => (a: number) => number;
+  add: (amount: number) => (value: number) => number;
   /**
-   * Subtracts `b` from a number. Data-last: `subtract(b)(a)` = `a - b`.
+   * Subtracts `amount` from a number. Data-last: `subtract(amount)(from)` = `from - amount`.
+   *
+   * @see {@link Num.add} to add an amount to a number.
    *
    * @example
    * ```ts
@@ -916,9 +1027,11 @@ export declare const Num: {
    * pipe([5, 10, 15], Arr.map(Num.subtract(2))); // [3, 8, 13]
    * ```
    */
-  subtract: (b: number) => (a: number) => number;
+  subtract: (amount: number) => (from: number) => number;
   /**
-   * Multiplies a number by `b`. Data-last: use in `pipe` or `Arr.map`.
+   * Multiplies a number by `factor`. Data-last: use in `pipe` or `Arr.map`.
+   *
+   * @see {@link Num.divide} to divide a number by a divisor.
    *
    * @example
    * ```ts
@@ -926,9 +1039,12 @@ export declare const Num: {
    * pipe([1, 2, 3], Arr.map(Num.multiply(100))); // [100, 200, 300]
    * ```
    */
-  multiply: (b: number) => (a: number) => number;
+  multiply: (factor: number) => (value: number) => number;
   /**
-   * Divides a number by `b`. Returns `None` when `b` is zero. Data-last: `divide(b)(a)` = `a / b`.
+   * Divides a number by `divisor`. Returns `None` when `divisor` is zero. Data-last: `divide(divisor)(dividend)` = `dividend / divisor`.
+   *
+   * @see {@link Num.multiply} to multiply a number by a factor.
+   * @see {@link Num.remainder} to compute the division remainder.
    *
    * @example
    * ```ts
@@ -937,7 +1053,7 @@ export declare const Num: {
    * pipe([10, 20, 30], Arr.filterMap(Num.divide(10))); // [1, 2, 3]
    * ```
    */
-  divide: (b: number) => (a: number) => Maybe<number>;
+  divide: (divisor: number) => (dividend: number) => Maybe<number>;
   /**
    * Returns the absolute value of a number.
    *
@@ -947,7 +1063,7 @@ export declare const Num: {
    * pipe(5, Num.abs);  // 5
    * ```
    */
-  abs: (n: number) => number;
+  abs: (value: number) => number;
   /**
    * Negates a number (arithmetic negation).
    *
@@ -957,40 +1073,51 @@ export declare const Num: {
    * pipe(-5, Num.negate); // 5
    * ```
    */
-  negate: (n: number) => number;
+  negate: (value: number) => number;
   /**
    * Rounds a number to the nearest integer.
    *
+   * @see {@link Num.floor} to round down.
+   * @see {@link Num.ceil} to round up.
+   *
    * @example
    * ```ts
    * pipe(3.5, Num.round); // 4
    * pipe(3.4, Num.round); // 3
    * ```
    */
-  round: (n: number) => number;
+  round: (value: number) => number;
   /**
    * Rounds a number down to the nearest integer.
    *
+   * @see {@link Num.round} to round to nearest integer.
+   * @see {@link Num.ceil} to round up.
+   *
    * @example
    * ```ts
    * pipe(3.9, Num.floor); // 3
    * pipe(-3.2, Num.floor); // -4
    * ```
    */
-  floor: (n: number) => number;
+  floor: (value: number) => number;
   /**
    * Rounds a number up to the nearest integer.
    *
+   * @see {@link Num.round} to round to nearest integer.
+   * @see {@link Num.floor} to round down.
+   *
    * @example
    * ```ts
    * pipe(3.1, Num.ceil); // 4
    * pipe(-3.9, Num.ceil); // -3
    * ```
    */
-  ceil: (n: number) => number;
+  ceil: (value: number) => number;
   /**
    * Returns the remainder of dividing a number by `divisor`. Returns `None` when `divisor` is zero.
-   * Data-last: `remainder(divisor)(a)` = `a % divisor`.
+   * Data-last: `remainder(divisor)(dividend)` = `dividend % divisor`.
+   *
+   * @see {@link Num.divide} for full division.
    *
    * @example
    * ```ts
@@ -999,7 +1126,7 @@ export declare const Num: {
    * pipe([10, 11, 12], Arr.filterMap(Num.remainder(3))); // [1, 2, 0]
    * ```
    */
-  remainder: (divisor: number) => (n: number) => Maybe<number>;
+  remainder: (divisor: number) => (dividend: number) => Maybe<number>;
   /**
    * Computes the sum of a list of numbers. Returns `0` if the list is empty.
    *
@@ -1009,7 +1136,7 @@ export declare const Num: {
    * Num.sum([]);        // 0
    * ```
    */
-  sum: (ns: readonly number[]) => number;
+  sum: (numbers: readonly number[]) => number;
   /**
    * Computes the mean of a list of numbers. Returns `None` if the list is empty.
    *
@@ -1019,29 +1146,33 @@ export declare const Num: {
    * Num.mean([]);        // None
    * ```
    */
-  mean: (ns: readonly number[]) => Maybe<number>;
+  mean: (numbers: readonly number[]) => Maybe<number>;
   /**
    * Computes the minimum of a list of numbers. Returns `None` if the list is empty.
    *
+   * @see {@link Num.max} to compute the maximum value.
+   *
    * @example
    * ```ts
    * Num.min([5, 1, 3]); // Some(1)
    * Num.min([]);        // None
    * ```
    */
-  min: (ns: readonly number[]) => Maybe<number>;
+  min: (numbers: readonly number[]) => Maybe<number>;
   /**
    * Computes the maximum of a list of numbers. Returns `None` if the list is empty.
    *
+   * @see {@link Num.min} to compute the minimum value.
+   *
    * @example
    * ```ts
    * Num.max([1, 5, 3]); // Some(5)
    * Num.max([]);        // None
    * ```
    */
-  max: (ns: readonly number[]) => Maybe<number>;
+  max: (numbers: readonly number[]) => Maybe<number>;
   /**
-   * Formats a number using `Intl.NumberFormat`. Returns `None` when `n` is `NaN` or non-finite.
+   * Formats a number using `Intl.NumberFormat`. Returns `None` when `value` is `NaN` or non-finite.
    * Data-last curried signature.
    *
    * @example
@@ -1051,7 +1182,7 @@ export declare const Num: {
    * pipe(NaN, formatCurrency);    // None
    * ```
    */
-  format: (options?: Intl.NumberFormatOptions, locales?: string | string[]) => (n: number) => Maybe<string>;
+  format: (options?: Intl.NumberFormatOptions, locales?: string | string[]) => (value: number) => Maybe<string>;
 };
 //#endregion
 //#region src/Data/Rec.d.ts
@@ -1063,6 +1194,8 @@ export type NonEmptyRecord<A, K extends string = string> = Brand<NonEmpty<"Rec">
  * Merges two records using a custom combination function on key collisions.
  * Supports both uncurried `Rec.mergeWith(combine)(first, second)` and curried `pipe(first, Rec.mergeWith(combine)(second))`.
  *
+ * @see {@link merge} for shallow merging with right-precedence.
+ *
  * @example
  * ```ts
  * const combineStats = Rec.mergeWith((a: number, b: number) => a + b);
@@ -1070,7 +1203,7 @@ export type NonEmptyRecord<A, K extends string = string> = Brand<NonEmpty<"Rec">
  * pipe({ a: 1, b: 2 }, combineStats({ b: 3, c: 4 })); // { a: 1, b: 5, c: 4 }
  * ```
  */
-declare function mergeWith<A>(combine: (a: A, b: A) => A): {
+declare function mergeWith<A>(combine: (first: A, second: A) => A): {
   (second: Readonly<Record<string, A>>): (first: Readonly<Record<string, A>>) => Readonly<Record<string, A>>;
   (first: Readonly<Record<string, A>>, second: Readonly<Record<string, A>>): Readonly<Record<string, A>>;
 };
@@ -1079,23 +1212,27 @@ export declare const Rec: {
     /**
      * Returns true if the record has no keys.
      *
+     * @see {@link nonEmpty} for checking if a record has keys.
+     *
      * @example
      * ```ts
      * Rec.is.empty({});       // true
      * Rec.is.empty({ a: 1 }); // false
      * ```
      */
-    empty: <A>(data: Readonly<Record<string, A>>) => boolean;
+    empty: <A>(record: Readonly<Record<string, A>>) => boolean;
     /**
      * Type guard to check if a record is non-empty.
      *
+     * @see {@link empty} for checking if a record has no keys.
+     *
      * @example
      * ```ts
      * Rec.is.nonEmpty({ a: 1 }); // true
      * Rec.is.nonEmpty({});       // false
      * ```
      */
-    nonEmpty: <A, K extends string>(data: Readonly<Record<K, A>>) => data is NonEmptyRecord<A, K>;
+    nonEmpty: <A, K extends string>(record: Readonly<Record<K, A>>) => record is NonEmptyRecord<A, K>;
   };
   from: {
     /**
@@ -1106,49 +1243,49 @@ export declare const Rec: {
      * Rec.from.entries([["a", 1], ["b", 2]]); // { a: 1, b: 2 }
      * ```
      */
-    entries: <A>(data: readonly (readonly [string, A])[]) => Readonly<Record<string, A>>;
+    entries: <A>(pairs: readonly (readonly [string, A])[]) => Readonly<Record<string, A>>;
   };
   to: {
-    Dict: <A, K extends string = string>(data: Readonly<Record<K, A>>) => ReadonlyMap<K, A>;
+    Dict: <A, K extends string = string>(record: Readonly<Record<K, A>>) => ReadonlyMap<K, A>;
   };
-  map: <A, B>(f: (a: A) => B) => <K extends string>(data: Readonly<Record<K, A>>) => Readonly<Record<K, B>>;
-  filterMap: <A, B>(f: (a: A) => Maybe<B>) => (data: Readonly<Record<string, A>>) => Readonly<Record<string, B>>;
-  mapWithKey: <A, B>(f: (key: string, a: A) => B) => <K extends string>(data: Readonly<Record<K, A>>) => Readonly<Record<K, B>>;
-  filter: <A>(predicate: (a: A) => boolean) => (data: Readonly<Record<string, A>>) => Readonly<Record<string, A>>;
-  filterWithKey: <A>(predicate: (key: string, a: A) => boolean) => (data: Readonly<Record<string, A>>) => Readonly<Record<string, A>>;
-  lookup: <K extends string>(key: K) => <V>(data: Record<string, V>) => Maybe<V>;
-  keys: <T extends Record<string, unknown>>(data: T) => readonly (keyof T & string)[];
-  values: <T extends Record<string, unknown>>(data: T) => readonly T[keyof T & string][];
-  entries: <T extends Record<string, unknown>>(data: T) => readonly (readonly [keyof T, T[keyof T]])[];
-  groupBy: <A>(keyFn: (a: A) => string) => (items: readonly A[]) => Readonly<Record<string, readonly A[]>>;
-  pick: <K extends string>(...pickedKeys: K[]) => <A extends Record<K, unknown>>(data: A) => Pick<A, K>;
-  omit: <K extends string>(...omittedKeys: K[]) => <A extends Record<K, unknown>>(data: A) => Omit<A, K>;
-  merge: <A>(other: Readonly<Record<string, A>>) => (data: Readonly<Record<string, A>>) => Readonly<Record<string, A>>;
+  map: <A, B>(transform: (value: A) => B) => <K extends string>(record: Readonly<Record<K, A>>) => Readonly<Record<K, B>>;
+  filterMap: <A, B>(transform: (value: A) => Maybe<B>) => (record: Readonly<Record<string, A>>) => Readonly<Record<string, B>>;
+  mapWithKey: <A, B>(transform: (key: string, value: A) => B) => <K extends string>(record: Readonly<Record<K, A>>) => Readonly<Record<K, B>>;
+  filter: <A>(predicate: (value: A) => boolean) => (record: Readonly<Record<string, A>>) => Readonly<Record<string, A>>;
+  filterWithKey: <A>(predicate: (key: string, value: A) => boolean) => (record: Readonly<Record<string, A>>) => Readonly<Record<string, A>>;
+  lookup: <K extends string>(key: K) => <V>(record: Record<string, V>) => Maybe<V>;
+  keys: <T extends Record<string, unknown>>(record: T) => readonly (keyof T & string)[];
+  values: <T extends Record<string, unknown>>(record: T) => readonly T[keyof T & string][];
+  entries: <T extends Record<string, unknown>>(record: T) => readonly (readonly [keyof T, T[keyof T]])[];
+  groupBy: <A>(keySelector: (item: A) => string) => (items: readonly A[]) => Readonly<Record<string, readonly A[]>>;
+  pick: <K extends string>(...pickedKeys: K[]) => <A extends Record<K, unknown>>(record: A) => Pick<A, K>;
+  omit: <K extends string>(...omittedKeys: K[]) => <A extends Record<K, unknown>>(record: A) => Omit<A, K>;
+  merge: <A>(other: Readonly<Record<string, A>>) => (record: Readonly<Record<string, A>>) => Readonly<Record<string, A>>;
   mergeWith: typeof mergeWith;
-  size: <A>(data: Readonly<Record<string, A>>) => number;
-  mapKeys: (f: (key: string) => string) => <A>(data: Readonly<Record<string, A>>) => Readonly<Record<string, A>>;
-  compact: <A>(data: Readonly<Record<string, Maybe<A>>>) => Readonly<Record<string, A>>;
-  mapEntries: <A, K2 extends string, B>(f: (key: string, value: A) => readonly [K2, B]) => (data: Readonly<Record<string, A>>) => Readonly<Record<K2, B>>;
-  updateIn: <T>(path: readonly [string, ...string[]], f: (val: T) => T) => (data: Readonly<Record<string, unknown>>) => Readonly<Record<string, unknown>>;
+  size: <A>(record: Readonly<Record<string, A>>) => number;
+  mapKeys: (transform: (key: string) => string) => <A>(record: Readonly<Record<string, A>>) => Readonly<Record<string, A>>;
+  compact: <A>(record: Readonly<Record<string, Maybe<A>>>) => Readonly<Record<string, A>>;
+  mapEntries: <A, K2 extends string, B>(transform: (key: string, value: A) => readonly [K2, B]) => (record: Readonly<Record<string, A>>) => Readonly<Record<K2, B>>;
+  updateIn: <T>(path: readonly [string, ...string[]], transform: (value: T) => T) => (record: Readonly<Record<string, unknown>>) => Readonly<Record<string, unknown>>;
   traverse: {
-    Maybe: <A, B>(f: (a: A) => Maybe<B>) => (data: Readonly<Record<string, A>>) => Maybe<Readonly<Record<string, B>>>;
-    Result: <E, A, B>(f: (a: A) => Result<E, B>) => (data: Readonly<Record<string, A>>) => Result<E, Readonly<Record<string, B>>>;
+    Maybe: <A, B>(transform: (value: A) => Maybe<B>) => (record: Readonly<Record<string, A>>) => Maybe<Readonly<Record<string, B>>>;
+    Result: <E, A, B>(transform: (value: A) => Result<E, B>) => (record: Readonly<Record<string, A>>) => Result<E, Readonly<Record<string, B>>>;
   };
   sequence: {
-    Maybe: <A>(data: Readonly<Record<string, Maybe<A>>>) => Maybe<Readonly<Record<string, A>>>;
-    Result: <E, A>(data: Readonly<Record<string, Result<E, A>>>) => Result<E, Readonly<Record<string, A>>>;
+    Maybe: <A>(record: Readonly<Record<string, Maybe<A>>>) => Maybe<Readonly<Record<string, A>>>;
+    Result: <E, A>(record: Readonly<Record<string, Result<E, A>>>) => Result<E, Readonly<Record<string, A>>>;
   };
   NonEmpty: {
     singleton: <K extends string, A>(key: K, value: A) => NonEmptyRecord<A, K>;
     from: {
-      Record: <K extends string, A>(data: Readonly<Record<K, A>>) => Maybe<NonEmptyRecord<A, K>>;
+      record: <K extends string, A>(record: Readonly<Record<K, A>>) => Maybe<NonEmptyRecord<A, K>>;
     };
-    keys: <K extends string, A>(data: NonEmptyRecord<A, K>) => NonEmptyArr<K>;
-    values: <K extends string, A>(data: NonEmptyRecord<A, K>) => NonEmptyArr<A>;
-    entries: <K extends string, A>(data: NonEmptyRecord<A, K>) => NonEmptyArr<readonly [K, A]>;
-    reduce: <A>(f: (acc: A, a: A) => A) => <K extends string>(data: NonEmptyRecord<A, K>) => A;
-    map: <A, B>(f: (a: A) => B) => <K extends string>(data: NonEmptyRecord<A, K>) => NonEmptyRecord<B, K>;
-    mapWithKey: <A, B>(f: (key: string, a: A) => B) => <K extends string>(data: NonEmptyRecord<A, K>) => NonEmptyRecord<B, K>;
+    keys: <K extends string, A>(record: NonEmptyRecord<A, K>) => NonEmptyArr<K>;
+    values: <K extends string, A>(record: NonEmptyRecord<A, K>) => NonEmptyArr<A>;
+    entries: <K extends string, A>(record: NonEmptyRecord<A, K>) => NonEmptyArr<readonly [K, A]>;
+    reduce: <A>(reducer: (accumulator: A, value: A) => A) => <K extends string>(record: NonEmptyRecord<A, K>) => A;
+    map: <A, B>(transform: (value: A) => B) => <K extends string>(record: NonEmptyRecord<A, K>) => NonEmptyRecord<B, K>;
+    mapWithKey: <A, B>(transform: (key: string, value: A) => B) => <K extends string>(record: NonEmptyRecord<A, K>) => NonEmptyRecord<B, K>;
   };
 };
 export declare namespace Rec {
@@ -1165,17 +1302,33 @@ export declare const Str: {
     /**
      * Returns `true` when the string is empty.
      *
+     * @see {@link nonEmpty} for checking if a string contains at least one character.
+     *
      * @example
      * ```ts
      * pipe("", Str.is.empty);   // true
      * pipe("hi", Str.is.empty); // false
      * ```
      */
-    empty: (s: string) => boolean;
+    empty: (text: string) => boolean;
     /**
      * Type guard to check if a string is non-empty.
+     *
+     * @see {@link empty} for checking if a string has zero length.
      */
-    nonEmpty: (s: string) => s is NonEmptyString;
+    nonEmpty: (text: string) => text is NonEmptyString;
+    /**
+     * Returns `true` when the string is empty or contains only whitespace.
+     *
+     * @see {@link empty} for checking zero length without trimming whitespace.
+     *
+     * @example
+     * ```ts
+     * pipe("   ", Str.is.blank); // true
+     * pipe("hi", Str.is.blank);  // false
+     * ```
+     */
+    blank: (text: string) => boolean;
   };
   /**
    * Splits a string by a separator. Data-last: use in `pipe`.
@@ -1185,7 +1338,7 @@ export declare const Str: {
    * pipe("a,b,c", Str.split(",")); // ["a", "b", "c"]
    * ```
    */
-  split: (separator: string | RegExp) => (s: string) => readonly string[];
+  split: (separator: string | RegExp) => (text: string) => readonly string[];
   /**
    * Removes leading and trailing whitespace from a string.
    *
@@ -1194,7 +1347,7 @@ export declare const Str: {
    * pipe("  hello  ", Str.trim); // "hello"
    * ```
    */
-  trim: (s: string) => string;
+  trim: (text: string) => string;
   /**
    * Returns `true` when the string contains the given substring.
    *
@@ -1204,74 +1357,88 @@ export declare const Str: {
    * pipe("hello world", Str.includes("xyz"));   // false
    * ```
    */
-  includes: (substring: string) => (s: string) => boolean;
+  includes: (substring: string) => (text: string) => boolean;
   /**
    * Replaces the first occurrence of a pattern in a string. Data-last: use in `pipe`.
    *
+   * @see {@link replaceAll} for substituting every occurrence instead of only the first.
+   *
    * @example
    * ```ts
    * pipe("foo foo foo", Str.replace("foo", "bar")); // "bar foo foo"
    * pipe("Hello World", Str.replace(/world/i, "Earth")); // "Hello Earth"
    * ```
    */
-  replace: (pattern: string | RegExp, replacement: string) => (s: string) => string;
+  replace: (pattern: string | RegExp, replacement: string) => (text: string) => string;
   /**
    * Replaces all occurrences of a pattern in a string. Data-last: use in `pipe`.
    *
+   * @see {@link replace} for substituting only the first occurrence.
+   *
    * @example
    * ```ts
    * pipe("foo foo foo", Str.replaceAll("foo", "bar")); // "bar bar bar"
    * pipe("aAbBaA", Str.replaceAll(/a/gi, "x")); // "xxBBxx"
    * ```
    */
-  replaceAll: (pattern: string | RegExp, replacement: string) => (s: string) => string;
+  replaceAll: (pattern: string | RegExp, replacement: string) => (text: string) => string;
   /**
    * Returns `true` when the string starts with the given prefix.
    *
+   * @see {@link endsWith} for checking suffix matches.
+   *
    * @example
    * ```ts
    * pipe("hello world", Str.startsWith("hello")); // true
    * pipe("hello world", Str.startsWith("world")); // false
    * ```
    */
-  startsWith: (prefix: string) => (s: string) => boolean;
+  startsWith: (prefix: string) => (text: string) => boolean;
   /**
    * Returns `true` when the string ends with the given suffix.
    *
+   * @see {@link startsWith} for checking prefix matches.
+   *
    * @example
    * ```ts
    * pipe("hello world", Str.endsWith("world")); // true
    * pipe("hello world", Str.endsWith("hello")); // false
    * ```
    */
-  endsWith: (suffix: string) => (s: string) => boolean;
+  endsWith: (suffix: string) => (text: string) => boolean;
   /**
    * Converts a string to uppercase.
    *
+   * @see {@link toLowerCase} for lowercasing characters.
+   *
    * @example
    * ```ts
    * pipe("hello", Str.toUpperCase); // "HELLO"
    * ```
    */
-  toUpperCase: (s: string) => string;
+  toUpperCase: (text: string) => string;
   /**
    * Converts a string to lowercase.
    *
+   * @see {@link toUpperCase} for uppercasing characters.
+   *
    * @example
    * ```ts
    * pipe("HELLO", Str.toLowerCase); // "hello"
    * ```
    */
-  toLowerCase: (s: string) => string;
+  toLowerCase: (text: string) => string;
   /**
    * Converts the first character of a string to uppercase.
    *
+   * @see {@link uncapitalize} for converting the first character to lowercase.
+   *
    * @example
    * ```ts
    * pipe("hello", Str.capitalize); // "Hello"
    * ```
    */
-  capitalize: (s: string) => string;
+  capitalize: (text: string) => string;
   /**
    * Splits a string into lines, normalising `\r\n` and `\r` line endings.
    *
@@ -1281,7 +1448,7 @@ export declare const Str: {
    * Str.lines("a\r\nb");         // ["a", "b"]
    * ```
    */
-  lines: (s: string) => readonly string[];
+  lines: (text: string) => readonly string[];
   /**
    * Splits a string into words on any whitespace boundary, filtering out empty strings.
    *
@@ -1290,17 +1457,7 @@ export declare const Str: {
    * Str.words("  hello   world  "); // ["hello", "world"]
    * ```
    */
-  words: (s: string) => readonly string[];
-  /**
-   * Returns `true` when the string is empty or contains only whitespace.
-   *
-   * @example
-   * ```ts
-   * pipe("   ", Str.isBlank); // true
-   * pipe("hi", Str.isBlank);  // false
-   * ```
-   */
-  isBlank: (s: string) => boolean;
+  words: (text: string) => readonly string[];
   /**
    * Returns the length of the string.
    *
@@ -1310,7 +1467,7 @@ export declare const Str: {
    * pipe("", Str.length);      // 0
    * ```
    */
-  length: (s: string) => number;
+  length: (text: string) => number;
   /**
    * Extracts a substring between two indices. Data-last: use in `pipe`.
    *
@@ -1320,27 +1477,31 @@ export declare const Str: {
    * pipe("hello", Str.slice(2));    // "llo"
    * ```
    */
-  slice: (start: number, end?: number) => (s: string) => string;
+  slice: (start: number, end?: number) => (text: string) => string;
   /**
    * Pads the start of a string to a specified length. Data-last: use in `pipe`.
    *
+   * @see {@link padEnd} for padding the right side of a string.
+   *
    * @example
    * ```ts
    * pipe("5", Str.padStart(3, "0")); // "005"
    * pipe("hi", Str.padStart(5));     // "   hi"
    * ```
    */
-  padStart: (maxLength: number, fillString?: string) => (s: string) => string;
+  padStart: (maxLength: number, fillString?: string) => (text: string) => string;
   /**
    * Pads the end of a string to a specified length. Data-last: use in `pipe`.
    *
+   * @see {@link padStart} for padding the left side of a string.
+   *
    * @example
    * ```ts
    * pipe("hi", Str.padEnd(5, "."));  // "hi..."
    * pipe("hi", Str.padEnd(5));       // "hi   "
    * ```
    */
-  padEnd: (maxLength: number, fillString?: string) => (s: string) => string;
+  padEnd: (maxLength: number, fillString?: string) => (text: string) => string;
   /**
    * Safe number parsers that return `Maybe` instead of `NaN`.
    */
@@ -1348,6 +1509,8 @@ export declare const Str: {
     /**
      * Parses a string as an integer (base 10). Returns `None` if the result is `NaN`.
      *
+     * @see {@link float} for parsing floating-point numbers.
+     *
      * @example
      * ```ts
      * Str.parse.int("42");   // Some(42)
@@ -1355,10 +1518,12 @@ export declare const Str: {
      * Str.parse.int("abc");  // None
      * ```
      */
-    int: (s: string) => Maybe<number>;
+    int: (text: string) => Maybe<number>;
     /**
      * Parses a string as a floating-point number. Returns `None` if the result is `NaN`.
      *
+     * @see {@link int} for parsing base-10 integers.
+     *
      * @example
      * ```ts
      * Str.parse.float("3.14"); // Some(3.14)
@@ -1366,40 +1531,46 @@ export declare const Str: {
      * Str.parse.float("abc");  // None
      * ```
      */
-    float: (s: string) => Maybe<number>;
+    float: (text: string) => Maybe<number>;
   };
   /**
    * Matches a string against a regular expression.
    * Pure and safe: resets `pattern.lastIndex = 0` to prevent bugs with stateful `/g` and `/y` regexes.
    *
+   * @see {@link test} for boolean validation without extracting capture groups.
+   *
    * @example
    * ```ts
    * pipe("hello 42", Str.match(/\d+/)); // Some(["42"])
    * pipe("hello", Str.match(/\d+/));    // None
    * ```
    */
-  match: (pattern: RegExp) => (s: string) => Maybe<RegExpMatchArray>;
+  match: (pattern: RegExp) => (text: string) => Maybe<RegExpMatchArray>;
   /**
    * Tests whether a string matches a regular expression.
    * Pure and safe: resets `pattern.lastIndex = 0` to prevent bugs with stateful `/g` and `/y` regexes.
    *
+   * @see {@link match} for extracting capture groups into a Maybe.
+   *
    * @example
    * ```ts
    * pipe("user@example.com", Str.test(/^[^@]+@[^@]+$/)); // true
    * pipe("invalid-email", Str.test(/^[^@]+@[^@]+$/));    // false
    * ```
    */
-  test: (pattern: RegExp) => (s: string) => boolean;
+  test: (pattern: RegExp) => (text: string) => boolean;
   /**
    * Converts the first character of a string to lower case.
    *
+   * @see {@link capitalize} for converting the first character to uppercase.
+   *
    * @example
    * ```ts
-   * Str.uncapitalize("Hello"); // "hello"
-   * Str.uncapitalize("");      // ""
+   * pipe("Hello", Str.uncapitalize); // "hello"
+   * pipe("", Str.uncapitalize);      // ""
    * ```
    */
-  uncapitalize: (s: string) => string;
+  uncapitalize: (text: string) => string;
   /**
    * Truncates a string to a maximum length, appending an optional suffix (default `"..."`).
    * Data-last curried signature.
@@ -1414,7 +1585,7 @@ export declare const Str: {
   truncate: (options: {
     length: number;
     suffix?: string;
-  }) => (s: string) => string;
+  }) => (text: string) => string;
   NonEmpty: {
     from: {
       /**
@@ -1422,11 +1593,11 @@ export declare const Str: {
        *
        * @example
        * ```ts
-       * Str.NonEmpty.from.String("hello"); // Some("hello")
-       * Str.NonEmpty.from.String("");      // None
+       * Str.NonEmpty.from.string("hello"); // Some("hello")
+       * Str.NonEmpty.from.string("");      // None
        * ```
        */
-      String: (s: string) => Maybe<NonEmptyString>;
+      string: (text: string) => Maybe<NonEmptyString>;
     };
   };
 };
@@ -1444,40 +1615,40 @@ export declare namespace Str {
 export type NonEmptySet<A> = Brand<NonEmpty<"Uniq">, ReadonlySet<A>>;
 export declare const Uniq: {
   is: {
-    empty: <A>(s: ReadonlySet<A>) => boolean;
-    nonEmpty: <A>(s: ReadonlySet<A>) => s is NonEmptySet<A>;
+    empty: <A>(set: ReadonlySet<A>) => boolean;
+    nonEmpty: <A>(set: ReadonlySet<A>) => set is NonEmptySet<A>;
+    subsetOf: <A>(other: ReadonlySet<A>) => (set: ReadonlySet<A>) => boolean;
   };
   empty: <A>() => ReadonlySet<A>;
   singleton: <A>(item: A) => ReadonlySet<A>;
   from: {
-    Array: <A>(arr: readonly A[]) => ReadonlySet<A>;
+    array: <A>(items: readonly A[]) => ReadonlySet<A>;
   };
-  has: <A>(item: A) => (s: ReadonlySet<A>) => boolean;
-  size: <A>(s: ReadonlySet<A>) => number;
-  add: <A>(item: A) => (s: ReadonlySet<A>) => ReadonlySet<A>;
-  insert: <A>(item: A) => (s: ReadonlySet<A>) => ReadonlySet<A>;
-  remove: <A>(item: A) => (s: ReadonlySet<A>) => ReadonlySet<A>;
-  toggle: <A>(item: A) => (s: ReadonlySet<A>) => ReadonlySet<A>;
-  map: <A, B>(f: (a: A) => B) => (s: ReadonlySet<A>) => ReadonlySet<B>;
-  filter: <A>(predicate: (a: A) => boolean) => (s: ReadonlySet<A>) => ReadonlySet<A>;
-  filterMap: <A, B>(f: (a: A) => Maybe<B>) => (s: ReadonlySet<A>) => ReadonlySet<B>;
-  union: <A>(other: ReadonlySet<A>) => (s: ReadonlySet<A>) => ReadonlySet<A>;
-  intersection: <A>(other: ReadonlySet<A>) => (s: ReadonlySet<A>) => ReadonlySet<A>;
-  difference: <A>(other: ReadonlySet<A>) => (s: ReadonlySet<A>) => ReadonlySet<A>;
-  isSubsetOf: <A>(other: ReadonlySet<A>) => (s: ReadonlySet<A>) => boolean;
-  reduce: <A, B>(init: B, f: (acc: B, a: A) => B) => (s: ReadonlySet<A>) => B;
+  has: <A>(item: A) => (set: ReadonlySet<A>) => boolean;
+  size: <A>(set: ReadonlySet<A>) => number;
+  add: <A>(item: A) => (set: ReadonlySet<A>) => ReadonlySet<A>;
+  insert: <A>(item: A) => (set: ReadonlySet<A>) => ReadonlySet<A>;
+  remove: <A>(item: A) => (set: ReadonlySet<A>) => ReadonlySet<A>;
+  toggle: <A>(item: A) => (set: ReadonlySet<A>) => ReadonlySet<A>;
+  map: <A, B>(transform: (item: A) => B) => (set: ReadonlySet<A>) => ReadonlySet<B>;
+  filter: <A>(predicate: (item: A) => boolean) => (set: ReadonlySet<A>) => ReadonlySet<A>;
+  filterMap: <A, B>(transform: (item: A) => Maybe<B>) => (set: ReadonlySet<A>) => ReadonlySet<B>;
+  union: <A>(other: ReadonlySet<A>) => (set: ReadonlySet<A>) => ReadonlySet<A>;
+  intersection: <A>(other: ReadonlySet<A>) => (set: ReadonlySet<A>) => ReadonlySet<A>;
+  difference: <A>(other: ReadonlySet<A>) => (set: ReadonlySet<A>) => ReadonlySet<A>;
+  reduce: <A, B>(initial: B, reducer: (accumulator: B, item: A) => B) => (set: ReadonlySet<A>) => B;
   to: {
-    Array: <A>(s: ReadonlySet<A>) => readonly A[];
+    array: <A>(set: ReadonlySet<A>) => readonly A[];
   };
   NonEmpty: {
     singleton: <A>(item: A) => NonEmptySet<A>;
     from: {
-      Set: <A>(s: ReadonlySet<A>) => Maybe<NonEmptySet<A>>;
+      set: <A>(set: ReadonlySet<A>) => Maybe<NonEmptySet<A>>;
     };
-    reduce: <A>(f: (acc: A, a: A) => A) => (s: NonEmptySet<A>) => A;
-    map: <A, B>(f: (a: A) => B) => (s: NonEmptySet<A>) => NonEmptySet<B>;
+    reduce: <A>(reducer: (accumulator: A, item: A) => A) => (set: NonEmptySet<A>) => A;
+    map: <A, B>(transform: (item: A) => B) => (set: NonEmptySet<A>) => NonEmptySet<B>;
     to: {
-      Array: <A>(s: NonEmptySet<A>) => NonEmptyArr<A>;
+      array: <A>(set: NonEmptySet<A>) => NonEmptyArr<A>;
     };
   };
 };