@nlozgachev/pipelined 0.43.0 → 0.45.0

package/dist/utils.d.mts

@@ -1,6 +1,6 @@
-import { N as NonEmptyArr } from './InternalTypes-DsCqxWZm.mjs';
-import { M as Maybe, R as Result, E as Equality, b as Ordering, T as Task } from './Validation-Do6uWLLZ.mjs';
-import './types.mjs';
+import { a as NonEmptyArr, N as NonEmpty } from './InternalTypes-CLE7qlOc.mjs';
+import { M as Maybe, R as Result, E as Equality, b as Ordering, T as Task } from './Validation-v38R0qH-.mjs';
+import { Brand } from './types.mjs';
 
 declare namespace ArrMaybe {
     /**
@@ -11,7 +11,7 @@ declare namespace ArrMaybe {
      * ```ts
      * const parseNum = (s: string): Maybe<number> => {
      *   const n = Number(s);
-     *   return isNaN(n) ? Maybe.none() : Maybe.some(n);
+     *   return isNaN(n) ? Maybe.make.none() : Maybe.make.some(n);
      * };
      *
      * pipe(["1", "2", "3"], Arr.Maybe.traverse(parseNum)); // Some([1, 2, 3])
@@ -25,8 +25,8 @@ declare namespace ArrMaybe {
      *
      * @example
      * ```ts
-     * Arr.Maybe.sequence([Maybe.some(1), Maybe.some(2)]); // Some([1, 2])
-     * Arr.Maybe.sequence([Maybe.some(1), Maybe.none()]); // None
+     * Arr.Maybe.sequence([Maybe.make.some(1), Maybe.make.some(2)]); // Some([1, 2])
+     * Arr.Maybe.sequence([Maybe.make.some(1), Maybe.make.none()]); // None
      * ```
      */
     const sequence: <A>(data: readonly Maybe<A>[]) => Maybe<readonly A[]>;
@@ -40,7 +40,7 @@ declare namespace ArrResult {
      * ```ts
      * pipe(
      *   [1, 2, 3],
-     *   Arr.Result.traverse(n => n > 0 ? Result.ok(n) : Result.err("negative"))
+     *   Arr.Result.traverse(n => n > 0 ? Result.make.ok(n) : Result.make.err("negative"))
      * ); // Ok([1, 2, 3])
      * ```
      */
@@ -53,7 +53,7 @@ declare namespace ArrResult {
 }
 declare namespace ArrTaskResult {
     /**
-     * Maps each element to a TaskResult and runs them sequentially.
+     * Maps each element to a Task.Result and runs them sequentially.
      * Returns the first Err encountered, or Ok of all results if all succeed.
      *
      * @example
@@ -74,7 +74,7 @@ declare namespace ArrTaskResult {
      */
     const traverse: <E, A, B>(f: (a: A) => Task<Result<E, B>>) => (data: readonly A[]) => Task<Result<E, readonly B[]>>;
     /**
-     * Collects an array of TaskResults into a TaskResult of array.
+     * Collects an array of Task.Results into a Task.Result of array.
      * Returns the first Err if any element is Err, runs sequentially.
      */
     const sequence: <E, A>(data: readonly Task<Result<E, A>>[]) => Task<Result<E, readonly A[]>>;
@@ -108,16 +108,18 @@ declare namespace ArrNonEmpty {
      * ```
      */
     const singleton: <A>(value: A) => NonEmptyArr<A>;
-    /**
-     * Returns Some if the array is non-empty, None otherwise.
-     *
-     * @example
-     * ```ts
-     * Arr.NonEmpty.fromArray([1, 2]); // Some([1, 2])
-     * Arr.NonEmpty.fromArray([]); // None
-     * ```
-     */
-    const fromArray: <A>(data: readonly A[]) => Maybe<NonEmptyArr<A>>;
+    namespace from {
+        /**
+         * Returns Some if the array is non-empty, None otherwise.
+         *
+         * @example
+         * ```ts
+         * Arr.NonEmpty.from.Array([1, 2]); // Some([1, 2])
+         * Arr.NonEmpty.from.Array([]); // None
+         * ```
+         */
+        const Array: <A>(data: readonly A[]) => Maybe<NonEmptyArr<A>>;
+    }
     /**
      * Returns the first element of a NonEmptyArr.
      *
@@ -154,6 +156,51 @@ declare namespace ArrNonEmpty {
      * ```
      */
     const reduce: <A>(f: (acc: A, a: A) => A) => (data: NonEmptyArr<A>) => A;
+    /**
+     * Transforms each element of a NonEmptyArr.
+     *
+     * @example
+     * ```ts
+     * pipe(Arr.NonEmpty.singleton(1), Arr.NonEmpty.map(n => n * 2)); // [2]
+     * ```
+     */
+    const map: <A, B>(f: (a: A) => B) => (data: NonEmptyArr<A>) => NonEmptyArr<B>;
+    /**
+     * Transforms each element of a NonEmptyArr, also receiving the index.
+     *
+     * @example
+     * ```ts
+     * pipe(Arr.NonEmpty.singleton("a"), Arr.NonEmpty.mapWithIndex((i, s) => `${i}:${s}`)); // ["0:a"]
+     * ```
+     */
+    const mapWithIndex: <A, B>(f: (i: number, a: A) => B) => (data: NonEmptyArr<A>) => NonEmptyArr<B>;
+    /**
+     * Inserts a separator between every element of a NonEmptyArr.
+     *
+     * @example
+     * ```ts
+     * pipe([1, 2] as Arr.NonEmpty<number>, Arr.NonEmpty.intersperse(0)); // [1, 0, 2]
+     * ```
+     */
+    const intersperse: <A>(sep: A) => (data: NonEmptyArr<A>) => NonEmptyArr<A>;
+    /**
+     * Concatenates a NonEmptyArr with a standard array.
+     *
+     * @example
+     * ```ts
+     * pipe(Arr.NonEmpty.singleton(1), Arr.NonEmpty.concat([2, 3])); // [1, 2, 3]
+     * ```
+     */
+    const concat: <A>(other: readonly A[]) => (data: NonEmptyArr<A>) => NonEmptyArr<A>;
+    /**
+     * Reverses a NonEmptyArr.
+     *
+     * @example
+     * ```ts
+     * pipe(Arr.NonEmpty.singleton(1), Arr.NonEmpty.reverse); // [1]
+     * ```
+     */
+    const reverse: <A>(data: NonEmptyArr<A>) => NonEmptyArr<A>;
 }
 /**
  * Functional array utilities that compose well with pipe.
@@ -256,10 +303,7 @@ declare namespace Arr {
      * pipe([1, 2, 3], Arr.map(n => n * 2)); // [2, 4, 6]
      * ```
      */
-    const map: <A, B>(f: (a: A) => B) => {
-        (data: NonEmpty<A>): NonEmpty<B>;
-        (data: readonly A[]): readonly B[];
-    };
+    const map: <A, B>(f: (a: A) => B) => (data: readonly A[]) => readonly B[];
     /**
      * Transforms each element using both its value and its zero-based index.
      *
@@ -271,10 +315,7 @@ declare namespace Arr {
      * ); // [{ position: 1, value: "a" }, { position: 2, value: "b" }, { position: 3, value: "c" }]
      * ```
      */
-    const mapWithIndex: <A, B>(f: (i: number, a: A) => B) => {
-        (data: NonEmpty<A>): NonEmpty<B>;
-        (data: readonly A[]): readonly B[];
-    };
+    const mapWithIndex: <A, B>(f: (i: number, a: A) => B) => (data: readonly A[]) => readonly B[];
     /**
      * Filters elements that satisfy the predicate.
      *
@@ -292,7 +333,7 @@ declare namespace Arr {
      * ```ts
      * const parseNum = (s: string): Maybe<number> => {
      *   const n = Number(s);
-     *   return isNaN(n) ? Maybe.none() : Maybe.some(n);
+     *   return isNaN(n) ? Maybe.make.none() : Maybe.make.some(n);
      * };
      *
      * pipe(["1", "abc", "3"], Arr.filterMap(parseNum)); // [1, 3]
@@ -316,7 +357,7 @@ declare namespace Arr {
      *
      * @example
      * ```ts
-     * Arr.compact([Maybe.some(1), Maybe.none(), Maybe.some(3)]); // [1, 3]
+     * Arr.compact([Maybe.make.some(1), Maybe.make.none(), Maybe.make.some(3)]); // [1, 3]
      * ```
      */
     const compact: <A>(data: readonly Maybe<A>[]) => readonly A[];
@@ -326,7 +367,7 @@ declare namespace Arr {
      *
      * @example
      * ```ts
-     * Arr.separate([Result.ok(1), Result.err("bad"), Result.ok(3)]); // [["bad"], [1, 3]]
+     * Arr.separate([Result.make.ok(1), Result.make.err("bad"), Result.make.ok(3)]); // [["bad"], [1, 3]]
      * ```
      */
     const separate: <E, A>(data: readonly Result<E, A>[]) => readonly [readonly E[], readonly A[]];
@@ -337,7 +378,7 @@ declare namespace Arr {
      * ```ts
      * pipe(
      *   [1, 2, 3, 4],
-     *   Arr.partitionMap(n => n % 2 === 0 ? Result.ok(n) : Result.err(`odd: ${n}`))
+     *   Arr.partitionMap(n => n % 2 === 0 ? Result.make.ok(n) : Result.make.err(`odd: ${n}`))
      * ); // [["odd: 1", "odd: 3"], [2, 4]]
      * ```
      */
@@ -441,23 +482,16 @@ declare namespace Arr {
      * pipe([1, 2, 3], Arr.intersperse(0)); // [1, 0, 2, 0, 3]
      * ```
      */
-    const intersperse: <A>(sep: A) => {
-        (data: NonEmpty<A>): NonEmpty<A>;
-        (data: readonly A[]): readonly A[];
-    };
+    const intersperse: <A>(sep: A) => (data: readonly A[]) => readonly A[];
     /**
-     * Concatenates a standard array or NonEmptyArr with another array.
-     * If the first array is a NonEmptyArr, the result is guaranteed to be a NonEmptyArr.
+     * Concatenates a standard array with another array.
      *
      * @example
      * ```ts
      * pipe([1, 2], Arr.concat([3, 4])); // [1, 2, 3, 4]
      * ```
      */
-    const concat: <A>(other: readonly A[]) => {
-        (data: NonEmpty<A>): NonEmpty<A>;
-        (data: readonly A[]): readonly A[];
-    };
+    const concat: <A>(other: readonly A[]) => (data: readonly A[]) => readonly A[];
     /**
      * Splits an array into chunks of the given size.
      *
@@ -497,10 +531,16 @@ declare namespace Arr {
     const Maybe: typeof ArrMaybe;
     const Result: typeof ArrResult;
     const Task: typeof ArrTask;
-    /**
-     * Returns true if the array is non-empty (type guard).
-     */
-    const isNonEmpty: <A>(data: readonly A[]) => data is NonEmpty<A>;
+    namespace is {
+        /**
+         * Returns true if the array is empty.
+         */
+        const empty: <A>(data: readonly A[]) => data is readonly [];
+        /**
+         * Returns true if the array is non-empty (type guard).
+         */
+        const nonEmpty: <A>(data: readonly A[]) => data is NonEmpty<A>;
+    }
     /**
      * Prepends a value to the beginning of an array, returning a NonEmptyArr.
      *
@@ -549,10 +589,7 @@ declare namespace Arr {
      * Arr.reverse([1, 2, 3]); // [3, 2, 1]
      * ```
      */
-    const reverse: {
-        <A>(data: NonEmpty<A>): NonEmpty<A>;
-        <A>(data: readonly A[]): readonly A[];
-    };
+    const reverse: <A>(data: readonly A[]) => readonly A[];
     /**
      * Returns a new array with `item` inserted before the element at `index`.
      * Negative indices are clamped to 0; indices beyond the array length append to the end.
@@ -638,6 +675,10 @@ declare namespace Arr {
     const NonEmpty: typeof ArrNonEmpty;
 }
 
+/**
+ * A branded type representing a key-value dictionary with at least one entry.
+ */
+type NonEmptyMap<K, V> = Brand<NonEmpty<"Dict">, ReadonlyMap<K, V>>;
 /**
  * Functional utilities for key-value dictionaries (`ReadonlyMap<K, V>`). All functions are pure
  * and data-last — they compose naturally with `pipe`.
@@ -651,50 +692,150 @@ declare namespace Arr {
  * import { pipe } from "@nlozgachev/pipelined/composition";
  *
  * const scores = pipe(
- *   Dict.fromEntries([["alice", 10], ["bob", 8], ["carol", 10]] as const),
+ *   Dict.from.entries([["alice", 10], ["bob", 8], ["carol", 10]] as const),
  *   Dict.filter(n => n >= 10),
  *   Dict.map(n => `${n} points`),
  * );
  * // ReadonlyMap { "alice" => "10 points", "carol" => "10 points" }
  * ```
  */
-declare namespace Dict {
+declare namespace DictNonEmpty {
     /**
-     * Creates an empty dictionary.
+     * Creates a NonEmptyMap containing a single key-value entry.
      *
      * @example
      * ```ts
-     * Dict.empty<string, number>(); // ReadonlyMap {}
+     * Dict.NonEmpty.singleton("name", "Alice"); // ReadonlyMap { "name" => "Alice" }
      * ```
      */
-    const empty: <K, V>() => ReadonlyMap<K, V>;
+    const singleton: <K, V>(key: K, value: V) => NonEmptyMap<K, V>;
+    namespace from {
+        /**
+         * Returns Some containing NonEmptyMap if the map is not empty, None otherwise.
+         *
+         * @example
+         * ```ts
+         * Dict.NonEmpty.from.Map(Dict.from.entries([["a", 1]])); // Some(ReadonlyMap { "a" => 1 })
+         * Dict.NonEmpty.from.Map(Dict.empty());                 // None
+         * ```
+         */
+        const Map: <K, V>(m: ReadonlyMap<K, V>) => Maybe<NonEmptyMap<K, V>>;
+    }
     /**
-     * Creates a dictionary with a single entry.
+     * Returns a non-empty array of keys, in insertion order.
      *
      * @example
      * ```ts
-     * Dict.singleton("name", "Alice"); // ReadonlyMap { "name" => "Alice" }
+     * Dict.NonEmpty.keys(Dict.NonEmpty.singleton("a", 1)); // ["a"]
      * ```
      */
-    const singleton: <K, V>(key: K, value: V) => ReadonlyMap<K, V>;
+    const keys: <K, V>(m: NonEmptyMap<K, V>) => NonEmptyArr<K>;
+    /**
+     * Returns a non-empty array of values, in insertion order.
+     *
+     * @example
+     * ```ts
+     * Dict.NonEmpty.values(Dict.NonEmpty.singleton("a", 1)); // [1]
+     * ```
+     */
+    const values: <K, V>(m: NonEmptyMap<K, V>) => NonEmptyArr<V>;
+    /**
+     * Returns a non-empty array of entry tuples, in insertion order.
+     *
+     * @example
+     * ```ts
+     * Dict.NonEmpty.entries(Dict.NonEmpty.singleton("a", 1)); // [["a", 1]]
+     * ```
+     */
+    const entries: <K, V>(m: NonEmptyMap<K, V>) => NonEmptyArr<readonly [K, V]>;
+    /**
+     * Reduces a NonEmptyMap's values from the left without an initial seed value.
+     *
+     * @example
+     * ```ts
+     * pipe(Dict.NonEmpty.singleton("a", 1), Dict.NonEmpty.reduce((a, b) => a + b)); // 1
+     * ```
+     */
+    const reduce: <V>(f: (acc: V, value: V) => V) => <K>(m: NonEmptyMap<K, V>) => V;
+    /**
+     * Transforms each value in the non-empty dictionary.
+     *
+     * @example
+     * ```ts
+     * pipe(Dict.NonEmpty.singleton("a", 1), Dict.NonEmpty.map(n => n * 2));
+     * // ReadonlyMap { "a" => 2 }
+     * ```
+     */
+    const map: <A, B>(f: (a: A) => B) => <K>(m: NonEmptyMap<K, A>) => NonEmptyMap<K, B>;
+    /**
+     * Transforms each value in the non-empty dictionary, also receiving the key.
+     *
+     * @example
+     * ```ts
+     * pipe(Dict.NonEmpty.singleton("a", 1), Dict.NonEmpty.mapWithKey((k, v) => `${k}:${v}`));
+     * // ReadonlyMap { "a" => "a:1" }
+     * ```
+     */
+    const mapWithKey: <K, A, B>(f: (key: K, a: A) => B) => (m: NonEmptyMap<K, A>) => NonEmptyMap<K, B>;
+}
+declare namespace Dict {
+    /**
+     * A branded type representing a key-value dictionary with at least one entry.
+     */
+    type NonEmpty<K, V> = NonEmptyMap<K, V>;
+    namespace is {
+        /**
+         * Returns `true` if the dictionary has no entries.
+         *
+         * @example
+         * ```ts
+         * Dict.is.empty(Dict.empty()); // true
+         * ```
+         */
+        const empty: <K, V>(m: ReadonlyMap<K, V>) => boolean;
+        /**
+         * Type guard to check if a dictionary is non-empty.
+         */
+        const nonEmpty: <K, V>(m: ReadonlyMap<K, V>) => m is NonEmpty<K, V>;
+    }
     /**
-     * Creates a dictionary from an array of key-value pairs.
+     * Creates an empty dictionary.
      *
      * @example
      * ```ts
-     * Dict.fromEntries([["a", 1], ["b", 2]]); // ReadonlyMap { "a" => 1, "b" => 2 }
+     * Dict.empty<string, number>(); // ReadonlyMap {}
      * ```
      */
-    const fromEntries: <K, V>(entries: readonly (readonly [K, V])[]) => ReadonlyMap<K, V>;
+    const empty: <K, V>() => ReadonlyMap<K, V>;
     /**
-     * Creates a dictionary from a plain object. Keys are always strings.
+     * Creates a dictionary with a single entry.
      *
      * @example
      * ```ts
-     * Dict.fromRecord({ a: 1, b: 2 }); // ReadonlyMap { "a" => 1, "b" => 2 }
+     * Dict.singleton("name", "Alice"); // ReadonlyMap { "name" => "Alice" }
      * ```
      */
-    const fromRecord: <V>(rec: Readonly<Record<string, V>>) => ReadonlyMap<string, V>;
+    const singleton: <K, V>(key: K, value: V) => ReadonlyMap<K, V>;
+    namespace from {
+        /**
+         * Creates a dictionary from an array of key-value pairs.
+         *
+         * @example
+         * ```ts
+         * Dict.from.entries([["a", 1], ["b", 2]]); // ReadonlyMap { "a" => 1, "b" => 2 }
+         * ```
+         */
+        const entries: <K, V>(entries: readonly (readonly [K, V])[]) => ReadonlyMap<K, V>;
+        /**
+         * Creates a dictionary from a plain object. Keys are always strings.
+         *
+         * @example
+         * ```ts
+         * Dict.from.Record({ a: 1, b: 2 }); // ReadonlyMap { "a" => 1, "b" => 2 }
+         * ```
+         */
+        const Record: <V>(rec: Readonly<Record<string, V>>) => ReadonlyMap<string, V>;
+    }
     /**
      * Groups elements of an array into a dictionary keyed by the result of `keyFn`. Each key maps
      * to the array of elements that produced it, in insertion order. Uses the native `Map.groupBy`
@@ -715,8 +856,8 @@ declare namespace Dict {
      *
      * @example
      * ```ts
-     * pipe(Dict.fromEntries([["a", 1]]), Dict.has("a")); // true
-     * pipe(Dict.fromEntries([["a", 1]]), Dict.has("b")); // false
+     * pipe(Dict.from.Entries([["a", 1]]), Dict.has("a")); // true
+     * pipe(Dict.from.Entries([["a", 1]]), Dict.has("b")); // false
      * ```
      */
     const has: <K>(key: K) => <V>(m: ReadonlyMap<K, V>) => boolean;
@@ -725,8 +866,8 @@ declare namespace Dict {
      *
      * @example
      * ```ts
-     * pipe(Dict.fromEntries([["a", 1]]), Dict.lookup("a")); // Some(1)
-     * pipe(Dict.fromEntries([["a", 1]]), Dict.lookup("b")); // None
+     * pipe(Dict.from.Entries([["a", 1]]), Dict.lookup("a")); // Some(1)
+     * pipe(Dict.from.Entries([["a", 1]]), Dict.lookup("b")); // None
      * ```
      */
     const lookup: <K>(key: K) => <V>(m: ReadonlyMap<K, V>) => Maybe<V>;
@@ -735,25 +876,16 @@ declare namespace Dict {
      *
      * @example
      * ```ts
-     * Dict.size(Dict.fromEntries([["a", 1], ["b", 2]])); // 2
+     * Dict.size(Dict.from.Entries([["a", 1], ["b", 2]])); // 2
      * ```
      */
     const size: <K, V>(m: ReadonlyMap<K, V>) => number;
-    /**
-     * Returns `true` if the dictionary has no entries.
-     *
-     * @example
-     * ```ts
-     * Dict.isEmpty(Dict.empty()); // true
-     * ```
-     */
-    const isEmpty: <K, V>(m: ReadonlyMap<K, V>) => boolean;
     /**
      * Returns all keys as a readonly array, in insertion order.
      *
      * @example
      * ```ts
-     * Dict.keys(Dict.fromEntries([["a", 1], ["b", 2]])); // ["a", "b"]
+     * Dict.keys(Dict.from.Entries([["a", 1], ["b", 2]])); // ["a", "b"]
      * ```
      */
     const keys: <K, V>(m: ReadonlyMap<K, V>) => readonly K[];
@@ -762,7 +894,7 @@ declare namespace Dict {
      *
      * @example
      * ```ts
-     * Dict.values(Dict.fromEntries([["a", 1], ["b", 2]])); // [1, 2]
+     * Dict.values(Dict.from.Entries([["a", 1], ["b", 2]])); // [1, 2]
      * ```
      */
     const values: <K, V>(m: ReadonlyMap<K, V>) => readonly V[];
@@ -771,7 +903,7 @@ declare namespace Dict {
      *
      * @example
      * ```ts
-     * Dict.entries(Dict.fromEntries([["a", 1], ["b", 2]])); // [["a", 1], ["b", 2]]
+     * Dict.entries(Dict.from.Entries([["a", 1], ["b", 2]])); // [["a", 1], ["b", 2]]
      * ```
      */
     const entries: <K, V>(m: ReadonlyMap<K, V>) => readonly (readonly [K, V])[];
@@ -781,7 +913,7 @@ declare namespace Dict {
      *
      * @example
      * ```ts
-     * pipe(Dict.fromEntries([["a", 1]]), Dict.insert("b", 2));
+     * pipe(Dict.from.Entries([["a", 1]]), Dict.insert("b", 2));
      * // ReadonlyMap { "a" => 1, "b" => 2 }
      * ```
      */
@@ -792,7 +924,7 @@ declare namespace Dict {
      *
      * @example
      * ```ts
-     * pipe(Dict.fromEntries([["a", 1], ["b", 2]]), Dict.remove("a"));
+     * pipe(Dict.from.Entries([["a", 1], ["b", 2]]), Dict.remove("a"));
      * // ReadonlyMap { "b" => 2 }
      * ```
      */
@@ -808,8 +940,8 @@ declare namespace Dict {
      * import { Maybe } from "@nlozgachev/pipelined/core";
      *
      * const increment = (opt: Maybe<number>) => Maybe.getOrElse(() => 0)(opt) + 1;
-     * pipe(Dict.fromEntries([["views", 5]]), Dict.upsert("views", increment)); // { views: 6 }
-     * pipe(Dict.fromEntries([["views", 5]]), Dict.upsert("likes", increment)); // { views: 5, likes: 1 }
+     * pipe(Dict.from.Entries([["views", 5]]), Dict.upsert("views", increment)); // { views: 6 }
+     * pipe(Dict.from.Entries([["views", 5]]), Dict.upsert("likes", increment)); // { views: 5, likes: 1 }
      * ```
      */
     const upsert: <K, V>(key: K, f: (existing: Maybe<V>) => V) => (m: ReadonlyMap<K, V>) => ReadonlyMap<K, V>;
@@ -818,7 +950,7 @@ declare namespace Dict {
      *
      * @example
      * ```ts
-     * pipe(Dict.fromEntries([["a", 1], ["b", 2]]), Dict.map(n => n * 2));
+     * pipe(Dict.from.Entries([["a", 1], ["b", 2]]), Dict.map(n => n * 2));
      * // ReadonlyMap { "a" => 2, "b" => 4 }
      * ```
      */
@@ -828,7 +960,7 @@ declare namespace Dict {
      *
      * @example
      * ```ts
-     * pipe(Dict.fromEntries([["a", 1], ["b", 2]]), Dict.mapWithKey((k, v) => `${k}:${v}`));
+     * pipe(Dict.from.Entries([["a", 1], ["b", 2]]), Dict.mapWithKey((k, v) => `${k}:${v}`));
      * // ReadonlyMap { "a" => "a:1", "b" => "b:2" }
      * ```
      */
@@ -838,7 +970,7 @@ declare namespace Dict {
      *
      * @example
      * ```ts
-     * pipe(Dict.fromEntries([["a", 1], ["b", 3], ["c", 0]]), Dict.filter(n => n > 0));
+     * pipe(Dict.from.Entries([["a", 1], ["b", 3], ["c", 0]]), Dict.filter(n => n > 0));
      * // ReadonlyMap { "a" => 1, "b" => 3 }
      * ```
      */
@@ -849,7 +981,7 @@ declare namespace Dict {
      *
      * @example
      * ```ts
-     * pipe(Dict.fromEntries([["a", 1], ["b", 2]]), Dict.filterWithKey((k, v) => k !== "a" && v > 0));
+     * pipe(Dict.from.Entries([["a", 1], ["b", 2]]), Dict.filterWithKey((k, v) => k !== "a" && v > 0));
      * // ReadonlyMap { "b" => 2 }
      * ```
      */
@@ -862,10 +994,10 @@ declare namespace Dict {
      * ```ts
      * import { Maybe } from "@nlozgachev/pipelined/core";
      *
-     * Dict.compact(Dict.fromEntries([
-     *   ["a", Maybe.some(1)],
-     *   ["b", Maybe.none()],
-     *   ["c", Maybe.some(3)],
+     * Dict.compact(Dict.from.Entries([
+     *   ["a", Maybe.make.some(1)],
+     *   ["b", Maybe.make.none()],
+     *   ["c", Maybe.make.some(3)],
      * ]));
      * // ReadonlyMap { "a" => 1, "c" => 3 }
      * ```
@@ -879,9 +1011,9 @@ declare namespace Dict {
      * ```ts
      * const parse = (s: string): Maybe<number> => {
      *     const n = Number(s);
-     *     return isNaN(n) ? Maybe.none() : Maybe.some(n);
+     *     return isNaN(n) ? Maybe.make.none() : Maybe.make.some(n);
      * };
-     * Dict.filterMap(parse)(Dict.fromRecord({ a: "1", b: "two", c: "3" }));
+     * Dict.filterMap(parse)(Dict.from.Record({ a: "1", b: "two", c: "3" }));
      * // ReadonlyMap { "a" => 1, "c" => 3 }
      * ```
      */
@@ -893,8 +1025,8 @@ declare namespace Dict {
      * @example
      * ```ts
      * pipe(
-     *   Dict.fromEntries([["a", 1], ["b", 2]]),
-     *   Dict.union(Dict.fromEntries([["b", 3], ["c", 4]])),
+     *   Dict.from.Entries([["a", 1], ["b", 2]]),
+     *   Dict.union(Dict.from.Entries([["b", 3], ["c", 4]])),
      * );
      * // ReadonlyMap { "a" => 1, "b" => 3, "c" => 4 }
      * ```
@@ -907,8 +1039,8 @@ declare namespace Dict {
      * @example
      * ```ts
      * pipe(
-     *   Dict.fromEntries([["a", 1], ["b", 2], ["c", 3]]),
-     *   Dict.intersection(Dict.fromEntries([["b", 99], ["c", 0]])),
+     *   Dict.from.Entries([["a", 1], ["b", 2], ["c", 3]]),
+     *   Dict.intersection(Dict.from.Entries([["b", 99], ["c", 0]])),
      * );
      * // ReadonlyMap { "b" => 2, "c" => 3 }
      * ```
@@ -920,8 +1052,8 @@ declare namespace Dict {
      * @example
      * ```ts
      * pipe(
-     *   Dict.fromEntries([["a", 1], ["b", 2], ["c", 3]]),
-     *   Dict.difference(Dict.fromEntries([["b", 0]])),
+     *   Dict.from.Entries([["a", 1], ["b", 2], ["c", 3]]),
+     *   Dict.difference(Dict.from.Entries([["b", 0]])),
      * );
      * // ReadonlyMap { "a" => 1, "c" => 3 }
      * ```
@@ -934,7 +1066,7 @@ declare namespace Dict {
      * @example
      * ```ts
      * Dict.reduce(0, (acc, value) => acc + value)(
-     *   Dict.fromEntries([["a", 1], ["b", 2], ["c", 3]])
+     *   Dict.from.Entries([["a", 1], ["b", 2], ["c", 3]])
      * ); // 6
      * ```
      */
@@ -946,20 +1078,23 @@ declare namespace Dict {
      * @example
      * ```ts
      * Dict.reduceWithKey("", (acc, value, key) => acc + key + ":" + value + " ")(
-     *   Dict.fromEntries([["a", 1], ["b", 2]])
+     *   Dict.from.Entries([["a", 1], ["b", 2]])
      * ); // "a:1 b:2 "
      * ```
      */
     const reduceWithKey: <K, A, B>(init: B, f: (acc: B, value: A, key: K) => B) => (m: ReadonlyMap<K, A>) => B;
-    /**
-     * Converts a `ReadonlyMap<string, V>` to a plain object. Only meaningful when keys are strings.
-     *
-     * @example
-     * ```ts
-     * Dict.toRecord(Dict.fromEntries([["a", 1], ["b", 2]])); // { a: 1, b: 2 }
-     * ```
-     */
-    const toRecord: <V>(m: ReadonlyMap<string, V>) => Readonly<Record<string, V>>;
+    namespace to {
+        /**
+         * Converts a `ReadonlyMap<string, V>` to a plain object. Only meaningful when keys are strings.
+         *
+         * @example
+         * ```ts
+         * Dict.to.Record(Dict.from.Entries([["a", 1], ["b", 2]])); // { a: 1, b: 2 }
+         * ```
+         */
+        const Record: <V>(m: ReadonlyMap<string, V>) => Readonly<Record<string, V>>;
+    }
+    const NonEmpty: typeof DictNonEmpty;
 }
 
 /**
@@ -1185,13 +1320,10 @@ declare namespace Num {
     const max: (ns: readonly number[]) => Maybe<number>;
 }
 
-declare const _nonEmptyRecord: unique symbol;
 /**
  * A branded type representing a record with at least one key-value pair.
  */
-type NonEmptyRecord<A> = Readonly<Record<string, A>> & {
-    readonly [_nonEmptyRecord]: true;
-};
+type NonEmptyRecord<A, K extends string = string> = Brand<NonEmpty<"Rec">, Readonly<Record<K, A>>>;
 declare namespace RecMaybe {
     /**
      * Map a function that returns a `Maybe` over each value of a record,
@@ -1200,7 +1332,7 @@ declare namespace RecMaybe {
      *
      * @example
      * ```ts
-     * const parseNum = (s: string) => s === "NaN" ? Maybe.none() : Maybe.some(Number(s));
+     * const parseNum = (s: string) => s === "NaN" ? Maybe.make.none() : Maybe.make.some(Number(s));
      * pipe({ a: "1", b: "2" }, Rec.Maybe.traverse(parseNum)); // Some({ a: 1, b: 2 })
      * pipe({ a: "1", b: "NaN" }, Rec.Maybe.traverse(parseNum)); // None
      * ```
@@ -1212,8 +1344,8 @@ declare namespace RecMaybe {
      *
      * @example
      * ```ts
-     * Rec.Maybe.sequence({ a: Maybe.some(1), b: Maybe.some(2) }); // Some({ a: 1, b: 2 })
-     * Rec.Maybe.sequence({ a: Maybe.some(1), b: Maybe.none() }); // None
+     * Rec.Maybe.sequence({ a: Maybe.make.some(1), b: Maybe.make.some(2) }); // Some({ a: 1, b: 2 })
+     * Rec.Maybe.sequence({ a: Maybe.make.some(1), b: Maybe.make.none() }); // None
      * ```
      */
     const sequence: <A>(data: Readonly<Record<string, Maybe<A>>>) => Maybe<Readonly<Record<string, A>>>;
@@ -1226,7 +1358,7 @@ declare namespace RecResult {
      *
      * @example
      * ```ts
-     * const checkPositive = (n: number) => n < 0 ? Result.err("negative") : Result.ok(n);
+     * const checkPositive = (n: number) => n < 0 ? Result.make.err("negative") : Result.make.ok(n);
      * pipe({ a: 1, b: 2 }, Rec.Result.traverse(checkPositive)); // Ok({ a: 1, b: 2 })
      * pipe({ a: 1, b: -2 }, Rec.Result.traverse(checkPositive)); // Err("negative")
      * ```
@@ -1238,8 +1370,8 @@ declare namespace RecResult {
      *
      * @example
      * ```ts
-     * Rec.Result.sequence({ a: Result.ok(1), b: Result.ok(2) }); // Ok({ a: 1, b: 2 })
-     * Rec.Result.sequence({ a: Result.ok(1), b: Result.err("oops") }); // Err("oops")
+     * Rec.Result.sequence({ a: Result.make.ok(1), b: Result.make.ok(2) }); // Ok({ a: 1, b: 2 })
+     * Rec.Result.sequence({ a: Result.make.ok(1), b: Result.make.err("oops") }); // Err("oops")
      * ```
      */
     const sequence: <E, A>(data: Readonly<Record<string, Result<E, A>>>) => Result<E, Readonly<Record<string, A>>>;
@@ -1253,17 +1385,19 @@ declare namespace RecNonEmpty {
      * Rec.NonEmpty.singleton("a", 1); // { a: 1 }
      * ```
      */
-    const singleton: <A>(key: string, value: A) => NonEmptyRecord<A>;
-    /**
-     * Creates a NonEmpty record from a standard record if it is not empty.
-     *
-     * @example
-     * ```ts
-     * Rec.NonEmpty.fromRecord({ a: 1 }); // Some({ a: 1 })
-     * Rec.NonEmpty.fromRecord({});      // None
-     * ```
-     */
-    const fromRecord: <A>(data: Readonly<Record<string, A>>) => Maybe<NonEmptyRecord<A>>;
+    const singleton: <K extends string, A>(key: K, value: A) => NonEmptyRecord<A, K>;
+    namespace from {
+        /**
+         * Creates a NonEmpty record from a standard record if it is not empty.
+         *
+         * @example
+         * ```ts
+         * Rec.NonEmpty.from.Record({ a: 1 }); // Some({ a: 1 })
+         * Rec.NonEmpty.from.Record({});      // None
+         * ```
+         */
+        const Record: <K extends string, A>(data: Readonly<Record<K, A>>) => Maybe<NonEmptyRecord<A, K>>;
+    }
     /**
      * Returns a non-empty array of keys for a NonEmpty record.
      *
@@ -1272,7 +1406,7 @@ declare namespace RecNonEmpty {
      * Rec.NonEmpty.keys(Rec.NonEmpty.singleton("a", 1)); // ["a"]
      * ```
      */
-    const keys: <A>(data: NonEmptyRecord<A>) => NonEmptyArr<string>;
+    const keys: <K extends string, A>(data: NonEmptyRecord<A, K>) => NonEmptyArr<K>;
     /**
      * Returns a non-empty array of values for a NonEmpty record.
      *
@@ -1281,7 +1415,7 @@ declare namespace RecNonEmpty {
      * Rec.NonEmpty.values(Rec.NonEmpty.singleton("a", 1)); // [1]
      * ```
      */
-    const values: <A>(data: NonEmptyRecord<A>) => NonEmptyArr<A>;
+    const values: <K extends string, A>(data: NonEmptyRecord<A, K>) => NonEmptyArr<A>;
     /**
      * Returns a non-empty array of entry tuples for a NonEmpty record.
      *
@@ -1290,7 +1424,7 @@ declare namespace RecNonEmpty {
      * Rec.NonEmpty.entries(Rec.NonEmpty.singleton("a", 1)); // [["a", 1]]
      * ```
      */
-    const entries: <A>(data: NonEmptyRecord<A>) => NonEmptyArr<readonly [string, A]>;
+    const entries: <K extends string, A>(data: NonEmptyRecord<A, K>) => NonEmptyArr<readonly [K, A]>;
     /**
      * Reduces a NonEmpty record's values from the left without an initial value.
      *
@@ -1299,7 +1433,25 @@ declare namespace RecNonEmpty {
      * pipe(Rec.NonEmpty.singleton("a", 1), Rec.NonEmpty.reduce((a, b) => a + b)); // 1
      * ```
      */
-    const reduce: <A>(f: (acc: A, a: A) => A) => (data: NonEmptyRecord<A>) => A;
+    const reduce: <A>(f: (acc: A, a: A) => A) => <K extends string>(data: NonEmptyRecord<A, K>) => A;
+    /**
+     * Transforms each value of a NonEmpty record.
+     *
+     * @example
+     * ```ts
+     * pipe(Rec.NonEmpty.singleton("a", 1), Rec.NonEmpty.map(n => n * 2)); // { a: 2 }
+     * ```
+     */
+    const map: <A, B>(f: (a: A) => B) => <K extends string>(data: NonEmptyRecord<A, K>) => NonEmptyRecord<B, K>;
+    /**
+     * Transforms each value of a NonEmpty record, also receiving the key.
+     *
+     * @example
+     * ```ts
+     * pipe(Rec.NonEmpty.singleton("a", 1), Rec.NonEmpty.mapWithKey((k, v) => `${k}:${v}`)); // { a: "a:1" }
+     * ```
+     */
+    const mapWithKey: <A, B>(f: (key: string, a: A) => B) => <K extends string>(data: NonEmptyRecord<A, K>) => NonEmptyRecord<B, K>;
 }
 /**
  * Functional record/object utilities that compose well with pipe.
@@ -1318,11 +1470,17 @@ declare namespace Rec {
     /**
      * A branded type representing a record with at least one key-value pair.
      */
-    type NonEmpty<A> = NonEmptyRecord<A>;
-    /**
-     * Type guard to check if a record is non-empty.
-     */
-    const isNonEmpty: <A>(data: Readonly<Record<string, A>>) => data is NonEmptyRecord<A>;
+    type NonEmpty<A, K extends string = string> = NonEmptyRecord<A, K>;
+    namespace is {
+        /**
+         * Returns true if the record has no keys.
+         */
+        const empty: <A>(data: Readonly<Record<string, A>>) => boolean;
+        /**
+         * Type guard to check if a record is non-empty.
+         */
+        const nonEmpty: <A, K extends string>(data: Readonly<Record<K, A>>) => data is NonEmptyRecord<A, K>;
+    }
     /**
      * Transforms each value in a record.
      *
@@ -1331,10 +1489,7 @@ declare namespace Rec {
      * pipe({ a: 1, b: 2 }, Rec.map(n => n * 2)); // { a: 2, b: 4 }
      * ```
      */
-    const map: <A, B>(f: (a: A) => B) => {
-        (data: NonEmpty<A>): NonEmpty<B>;
-        (data: Readonly<Record<string, A>>): Readonly<Record<string, B>>;
-    };
+    const map: <A, B>(f: (a: A) => B) => <K extends string>(data: Readonly<Record<K, A>>) => Readonly<Record<K, B>>;
     const filterMap: <A, B>(f: (a: A) => Maybe<B>) => (data: Readonly<Record<string, A>>) => Readonly<Record<string, B>>;
     /**
      * Transforms each value in a record, also receiving the key.
@@ -1345,10 +1500,7 @@ declare namespace Rec {
      * // { a: "a:1", b: "b:2" }
      * ```
      */
-    const mapWithKey: <A, B>(f: (key: string, a: A) => B) => {
-        (data: NonEmpty<A>): NonEmpty<B>;
-        (data: Readonly<Record<string, A>>): Readonly<Record<string, B>>;
-    };
+    const mapWithKey: <A, B>(f: (key: string, a: A) => B) => <K extends string>(data: Readonly<Record<K, A>>) => Readonly<Record<K, B>>;
     /**
      * Filters values in a record by a predicate.
      *
@@ -1390,15 +1542,17 @@ declare namespace Rec {
      * Returns all key-value pairs of a record.
      */
     const entries: <T extends Record<string, unknown>>(data: T) => readonly (readonly [keyof T, T[keyof T]])[];
-    /**
-     * Creates a record from key-value pairs.
-     *
-     * @example
-     * ```ts
-     * Rec.fromEntries([["a", 1], ["b", 2]]); // { a: 1, b: 2 }
-     * ```
-     */
-    const fromEntries: <A>(data: readonly (readonly [string, A])[]) => Readonly<Record<string, A>>;
+    namespace from {
+        /**
+         * Creates a record from key-value pairs.
+         *
+         * @example
+         * ```ts
+         * Rec.from.entries([["a", 1], ["b", 2]]); // { a: 1, b: 2 }
+         * ```
+         */
+        const entries: <A>(data: readonly (readonly [string, A])[]) => Readonly<Record<string, A>>;
+    }
     /**
      * Groups elements of an array into a record keyed by the result of `keyFn`. Each key maps to
      * the array of elements that produced it, in insertion order.
@@ -1442,10 +1596,6 @@ declare namespace Rec {
      * ```
      */
     const merge: <A>(other: Readonly<Record<string, A>>) => (data: Readonly<Record<string, A>>) => Readonly<Record<string, A>>;
-    /**
-     * Returns true if the record has no keys.
-     */
-    const isEmpty: <A>(data: Readonly<Record<string, A>>) => boolean;
     /**
      * Returns the number of keys in a record.
      */
@@ -1467,7 +1617,7 @@ declare namespace Rec {
      *
      * @example
      * ```ts
-     * Rec.compact({ a: Maybe.some(1), b: Maybe.none(), c: Maybe.some(3) });
+     * Rec.compact({ a: Maybe.make.some(1), b: Maybe.make.none(), c: Maybe.make.some(3) });
      * // { a: 1, c: 3 }
      * ```
      */
@@ -1477,6 +1627,10 @@ declare namespace Rec {
     const NonEmpty: typeof RecNonEmpty;
 }
 
+/**
+ * A branded type representing a string with at least one character.
+ */
+type NonEmptyString = Brand<NonEmpty<"Str">, string>;
 /**
  * String utilities. All transformation functions are data-last and curried so they
  * compose naturally with `pipe`. Safe parsers return `Maybe` instead of `NaN`.
@@ -1489,7 +1643,41 @@ declare namespace Rec {
  * pipe("  Hello, World!  ", Str.trim, Str.toLowerCase); // "hello, world!"
  * ```
  */
+declare namespace StrNonEmpty {
+    namespace from {
+        /**
+         * Returns Some containing NonEmptyString if the string is not empty, None otherwise.
+         *
+         * @example
+         * ```ts
+         * Str.NonEmpty.from.String("hello"); // Some("hello")
+         * Str.NonEmpty.from.String("");      // None
+         * ```
+         */
+        const String: (s: string) => Maybe<NonEmptyString>;
+    }
+}
 declare namespace Str {
+    /**
+     * A branded type representing a string with at least one character.
+     */
+    type NonEmpty = NonEmptyString;
+    namespace is {
+        /**
+         * Returns `true` when the string is empty.
+         *
+         * @example
+         * ```ts
+         * pipe("", Str.is.empty);   // true
+         * pipe("hi", Str.is.empty); // false
+         * ```
+         */
+        const empty: (s: string) => boolean;
+        /**
+         * Type guard to check if a string is non-empty.
+         */
+        const nonEmpty: (s: string) => s is NonEmpty;
+    }
     /**
      * Splits a string by a separator. Data-last: use in `pipe`.
      *
@@ -1604,16 +1792,6 @@ declare namespace Str {
      * ```
      */
     const words: (s: string) => readonly string[];
-    /**
-     * Returns `true` when the string is empty.
-     *
-     * @example
-     * ```ts
-     * pipe("", Str.isEmpty);   // true
-     * pipe("hi", Str.isEmpty); // false
-     * ```
-     */
-    const isEmpty: (s: string) => boolean;
     /**
      * Returns `true` when the string is empty or contains only whitespace.
      *
@@ -1701,8 +1879,13 @@ declare namespace Str {
      * ```
      */
     const parseJson: (s: string) => Result<SyntaxError, unknown>;
+    const NonEmpty: typeof StrNonEmpty;
 }
 
+/**
+ * A branded type representing a unique collection with at least one element.
+ */
+type NonEmptySet<A> = Brand<NonEmpty<"Uniq">, ReadonlySet<A>>;
 /**
  * Functional utilities for unique-value collections (`ReadonlySet<A>`). All functions are pure
  * and data-last — they compose naturally with `pipe`.
@@ -1715,78 +1898,142 @@ declare namespace Str {
  * import { pipe } from "@nlozgachev/pipelined/composition";
  *
  * const active = pipe(
- *   Uniq.fromArray(["alice", "bob", "alice", "carol"]),
+ *   Uniq.from.Array(["alice", "bob", "alice", "carol"]),
  *   Uniq.remove("bob"),
  *   Uniq.map(name => name.toUpperCase()),
  * );
  * // ReadonlySet { "ALICE", "CAROL" }
  * ```
  */
-declare namespace Uniq {
+declare namespace UniqNonEmpty {
     /**
-     * Creates an empty unique collection.
+     * Creates a single-element unique collection.
      *
      * @example
      * ```ts
-     * Uniq.empty<number>(); // ReadonlySet {}
+     * Uniq.NonEmpty.singleton(42); // ReadonlySet { 42 }
      * ```
      */
-    const empty: <A>() => ReadonlySet<A>;
+    const singleton: <A>(item: A) => NonEmptySet<A>;
+    namespace from {
+        /**
+         * Returns Some containing NonEmptySet if the set is not empty, None otherwise.
+         *
+         * @example
+         * ```ts
+         * Uniq.NonEmpty.from.Set(Uniq.from.Array([1, 2])); // Some(ReadonlySet { 1, 2 })
+         * Uniq.NonEmpty.from.Set(Uniq.empty());           // None
+         * ```
+         */
+        const Set: <A>(s: ReadonlySet<A>) => Maybe<NonEmptySet<A>>;
+    }
     /**
-     * Creates a unique collection containing a single item.
+     * Folds the collection into a single value without an initial seed value.
      *
      * @example
      * ```ts
-     * Uniq.singleton(42); // ReadonlySet { 42 }
+     * pipe(Uniq.NonEmpty.singleton(42), Uniq.NonEmpty.reduce((a, b) => a + b)); // 42
      * ```
      */
-    const singleton: <A>(item: A) => ReadonlySet<A>;
+    const reduce: <A>(f: (acc: A, a: A) => A) => (s: NonEmptySet<A>) => A;
     /**
-     * Creates a unique collection from an array, automatically discarding duplicates.
+     * Transforms each item in the non-empty unique collection.
      *
      * @example
      * ```ts
-     * Uniq.fromArray([1, 2, 2, 3, 3, 3]); // ReadonlySet { 1, 2, 3 }
-     * Uniq.fromArray([]);                  // ReadonlySet {}
+     * pipe(Uniq.NonEmpty.singleton(1), Uniq.NonEmpty.map(n => n * 2)); // ReadonlySet { 2 }
      * ```
      */
-    const fromArray: <A>(arr: readonly A[]) => ReadonlySet<A>;
+    const map: <A, B>(f: (a: A) => B) => (s: NonEmptySet<A>) => NonEmptySet<B>;
+    namespace to {
+        /**
+         * Converts the collection to a non-empty readonly array in insertion order.
+         *
+         * @example
+         * ```ts
+         * Uniq.NonEmpty.to.Array(Uniq.NonEmpty.singleton(42)); // [42]
+         * ```
+         */
+        const Array: <A>(s: NonEmptySet<A>) => NonEmptyArr<A>;
+    }
+}
+declare namespace Uniq {
+    /**
+     * A branded type representing a unique collection with at least one element.
+     */
+    type NonEmpty<A> = NonEmptySet<A>;
+    namespace is {
+        /**
+         * Returns `true` if the collection has no items.
+         *
+         * @example
+         * ```ts
+         * Uniq.is.empty(Uniq.empty()); // true
+         * ```
+         */
+        const empty: <A>(s: ReadonlySet<A>) => boolean;
+        /**
+         * Type guard to check if a unique collection is non-empty.
+         */
+        const nonEmpty: <A>(s: ReadonlySet<A>) => s is NonEmpty<A>;
+    }
     /**
-     * Returns `true` if the collection contains the given item.
+     * Creates an empty unique collection.
      *
      * @example
      * ```ts
-     * pipe(Uniq.fromArray([1, 2, 3]), Uniq.has(2)); // true
-     * pipe(Uniq.fromArray([1, 2, 3]), Uniq.has(4)); // false
+     * Uniq.empty<number>(); // ReadonlySet {}
      * ```
      */
-    const has: <A>(item: A) => (s: ReadonlySet<A>) => boolean;
+    const empty: <A>() => ReadonlySet<A>;
     /**
-     * Returns the number of items in the collection.
+     * Creates a unique collection containing a single item.
      *
      * @example
      * ```ts
-     * Uniq.size(Uniq.fromArray([1, 2, 3])); // 3
+     * Uniq.singleton(42); // ReadonlySet { 42 }
      * ```
      */
-    const size: <A>(s: ReadonlySet<A>) => number;
+    const singleton: <A>(item: A) => ReadonlySet<A>;
+    namespace from {
+        /**
+         * Creates a unique collection from an array, automatically discarding duplicates.
+         *
+         * @example
+         * ```ts
+         * Uniq.from.Array([1, 2, 2, 3, 3, 3]); // ReadonlySet { 1, 2, 3 }
+         * Uniq.from.Array([]);                  // ReadonlySet {}
+         * ```
+         */
+        const Array: <A>(arr: readonly A[]) => ReadonlySet<A>;
+    }
+    /**
+     * Returns `true` if the collection contains the given item.
+     *
+     * @example
+     * ```ts
+     * pipe(Uniq.from.Array([1, 2, 3]), Uniq.has(2)); // true
+     * pipe(Uniq.from.Array([1, 2, 3]), Uniq.has(4)); // false
+     * ```
+     */
+    const has: <A>(item: A) => (s: ReadonlySet<A>) => boolean;
     /**
-     * Returns `true` if the collection has no items.
+     * Returns the number of items in the collection.
      *
      * @example
      * ```ts
-     * Uniq.isEmpty(Uniq.empty()); // true
+     * Uniq.size(Uniq.from.Array([1, 2, 3])); // 3
      * ```
      */
-    const isEmpty: <A>(s: ReadonlySet<A>) => boolean;
+    const size: <A>(s: ReadonlySet<A>) => number;
     /**
      * Returns `true` if every item in `set` also exists in `other`.
      *
      * @example
      * ```ts
-     * pipe(Uniq.fromArray([1, 2]), Uniq.isSubsetOf(Uniq.fromArray([1, 2, 3]))); // true
-     * pipe(Uniq.fromArray([1, 4]), Uniq.isSubsetOf(Uniq.fromArray([1, 2, 3]))); // false
-     * pipe(Uniq.empty<number>(), Uniq.isSubsetOf(Uniq.fromArray([1, 2, 3])));   // true
+     * pipe(Uniq.from.Array([1, 2]), Uniq.isSubsetOf(Uniq.from.Array([1, 2, 3]))); // true
+     * pipe(Uniq.from.Array([1, 4]), Uniq.isSubsetOf(Uniq.from.Array([1, 2, 3]))); // false
+     * pipe(Uniq.empty<number>(), Uniq.isSubsetOf(Uniq.from.Array([1, 2, 3])));   // true
      * ```
      */
     const isSubsetOf: <A>(other: ReadonlySet<A>) => (s: ReadonlySet<A>) => boolean;
@@ -1796,8 +2043,8 @@ declare namespace Uniq {
      *
      * @example
      * ```ts
-     * pipe(Uniq.fromArray([1, 2]), Uniq.insert(3)); // ReadonlySet { 1, 2, 3 }
-     * pipe(Uniq.fromArray([1, 2]), Uniq.insert(2)); // ReadonlySet { 1, 2 } — unchanged
+     * pipe(Uniq.from.Array([1, 2]), Uniq.insert(3)); // ReadonlySet { 1, 2, 3 }
+     * pipe(Uniq.from.Array([1, 2]), Uniq.insert(2)); // ReadonlySet { 1, 2 } — unchanged
      * ```
      */
     const insert: <A>(item: A) => (s: ReadonlySet<A>) => ReadonlySet<A>;
@@ -1807,8 +2054,8 @@ declare namespace Uniq {
      *
      * @example
      * ```ts
-     * pipe(Uniq.fromArray([1, 2, 3]), Uniq.remove(2)); // ReadonlySet { 1, 3 }
-     * pipe(Uniq.fromArray([1, 2, 3]), Uniq.remove(4)); // ReadonlySet { 1, 2, 3 } — unchanged
+     * pipe(Uniq.from.Array([1, 2, 3]), Uniq.remove(2)); // ReadonlySet { 1, 3 }
+     * pipe(Uniq.from.Array([1, 2, 3]), Uniq.remove(4)); // ReadonlySet { 1, 2, 3 } — unchanged
      * ```
      */
     const remove: <A>(item: A) => (s: ReadonlySet<A>) => ReadonlySet<A>;
@@ -1818,7 +2065,7 @@ declare namespace Uniq {
      *
      * @example
      * ```ts
-     * pipe(Uniq.fromArray([1, 2, 3, 4]), Uniq.map(n => n % 3)); // ReadonlySet { 1, 2, 0 }
+     * pipe(Uniq.from.Array([1, 2, 3, 4]), Uniq.map(n => n % 3)); // ReadonlySet { 1, 2, 0 }
      * ```
      */
     const map: <A, B>(f: (a: A) => B) => (s: ReadonlySet<A>) => ReadonlySet<B>;
@@ -1827,7 +2074,7 @@ declare namespace Uniq {
      *
      * @example
      * ```ts
-     * pipe(Uniq.fromArray([1, 2, 3, 4, 5]), Uniq.filter(n => n % 2 === 0));
+     * pipe(Uniq.from.Array([1, 2, 3, 4, 5]), Uniq.filter(n => n % 2 === 0));
      * // ReadonlySet { 2, 4 }
      * ```
      */
@@ -1837,7 +2084,7 @@ declare namespace Uniq {
      *
      * @example
      * ```ts
-     * pipe(Uniq.fromArray([1, 2, 3]), Uniq.union(Uniq.fromArray([2, 3, 4])));
+     * pipe(Uniq.from.Array([1, 2, 3]), Uniq.union(Uniq.from.Array([2, 3, 4])));
      * // ReadonlySet { 1, 2, 3, 4 }
      * ```
      */
@@ -1847,7 +2094,7 @@ declare namespace Uniq {
      *
      * @example
      * ```ts
-     * pipe(Uniq.fromArray([1, 2, 3]), Uniq.intersection(Uniq.fromArray([2, 3, 4])));
+     * pipe(Uniq.from.Array([1, 2, 3]), Uniq.intersection(Uniq.from.Array([2, 3, 4])));
      * // ReadonlySet { 2, 3 }
      * ```
      */
@@ -1857,7 +2104,7 @@ declare namespace Uniq {
      *
      * @example
      * ```ts
-     * pipe(Uniq.fromArray([1, 2, 3, 4]), Uniq.difference(Uniq.fromArray([2, 4])));
+     * pipe(Uniq.from.Array([1, 2, 3, 4]), Uniq.difference(Uniq.from.Array([2, 4])));
      * // ReadonlySet { 1, 3 }
      * ```
      */
@@ -1867,19 +2114,22 @@ declare namespace Uniq {
      *
      * @example
      * ```ts
-     * Uniq.reduce(0, (acc, n) => acc + n)(Uniq.fromArray([1, 2, 3])); // 6
+     * Uniq.reduce(0, (acc, n) => acc + n)(Uniq.from.Array([1, 2, 3])); // 6
      * ```
      */
     const reduce: <A, B>(init: B, f: (acc: B, a: A) => B) => (s: ReadonlySet<A>) => B;
-    /**
-     * Converts the collection to a readonly array in insertion order.
-     *
-     * @example
-     * ```ts
-     * Uniq.toArray(Uniq.fromArray([3, 1, 2])); // [3, 1, 2]
-     * ```
-     */
-    const toArray: <A>(s: ReadonlySet<A>) => readonly A[];
+    namespace to {
+        /**
+         * Converts the collection to a readonly array in insertion order.
+         *
+         * @example
+         * ```ts
+         * Uniq.to.Array(Uniq.from.Array([3, 1, 2])); // [3, 1, 2]
+         * ```
+         */
+        const Array: <A>(s: ReadonlySet<A>) => readonly A[];
+    }
+    const NonEmpty: typeof UniqNonEmpty;
 }
 
-export { Arr, Dict, type NonEmptyRecord, Num, Rec, Str, Uniq };
+export { Arr, Dict, type NonEmptyMap, type NonEmptyRecord, type NonEmptySet, type NonEmptyString, Num, Rec, Str, Uniq };