ts-fortress 3.0.1 → 3.2.0

package/README.md

@@ -7,11 +7,12 @@ TypeScript-first schema validation library with static type inference.
 [![License](https://img.shields.io/npm/l/ts-fortress.svg)](./LICENSE)
 [![codecov](https://codecov.io/gh/noshiro-pf/ts-fortress/graph/badge.svg?token=Y522SWQTPB)](https://codecov.io/gh/noshiro-pf/ts-fortress)
 
-**ts-fortress** is a runtime validation library similar to [io-ts](https://github.com/gcanti/io-ts) and [zod](https://github.com/colinhacks/zod), designed to provide type-safe schema validation with excellent TypeScript integration and static type inference.
+**ts-fortress** is a runtime validation library similar to [io-ts](https://github.com/gcanti/io-ts) and [zod/mini](https://zod.dev/packages/mini), designed to provide type-safe schema validation with excellent TypeScript integration and static type inference.
 
 ## Features
 
 - 🔒 **Type-safe validation** - Full TypeScript support with static type inference
+- 📖 **Readonly by default** - All constructed types are fully readonly, preventing accidental mutations and promoting immutability
 - 🏗️ **Composable schemas** - Build complex validation schemas from simple building blocks
 - 🔄 **Result-based error handling** - Structured error reporting with `Result<T, readonly ValidationError[]>`
 - 🏷️ **Branded types** - Rich collection of branded number types (Int, SafeInt, PositiveInt, etc.)
@@ -210,7 +211,7 @@ export const SomeObject = t.record({
 
 // ✅ Correct ts-fortress usage - enforced by TypeScript
 export const SomeObject = t.record({
-    key1: t.numberLiteral(1), // or t.number(1) with default
+    key1: t.literal(1), // or t.number(1) with default
     key2: t.string(''),
 });
 ```
@@ -633,8 +634,8 @@ const nullType = t.nullType;
 const undefinedType = t.undefinedType;
 
 // Literal types
-const statusType = t.stringLiteral('active');
-const versionType = t.number(1);
+const statusType = t.literal('active');
+const versionType = t.literal(1);
 
 // Arrays
 const stringArrayType = t.array(t.string(''));
@@ -647,6 +648,8 @@ const coordinateType = t.tuple([t.number(0), t.number(0)]);
 ### Record Types
 
 ```typescript
+import * as t from 'ts-fortress';
+
 // Define object schemas
 const PersonType = t.record({
     firstName: t.string(''),
@@ -732,9 +735,11 @@ UserSchema.is({
 ts-fortress provides extensive support for branded types to create domain-specific validation:
 
 ```typescript
+import * as t from 'ts-fortress';
+
 // Simple branded types
-const UserId = t.simpleBrandedString('UserId', '');
-const Weight = t.simpleBrandedNumber('Weight', 0);
+const UserId = t.simpleBrandedString({ typeName: 'UserId', defaultValue: '' });
+const Weight = t.simpleBrandedNumber({ typeName: 'Weight', defaultValue: 0 });
 
 type UserId = t.TypeOf<typeof UserId>; // Brand<string, 'UserId'>
 type Weight = t.TypeOf<typeof Weight>; // Brand<number, 'Weight'>
@@ -754,14 +759,9 @@ if (t.Result.isOk(userIdResult)) {
 ### Union and Intersection Types
 
 ```typescript
-// Union types
-const StatusType = t.union([
-    t.stringLiteral('pending'),
-    t.stringLiteral('completed'),
-    t.stringLiteral('failed'),
-]);
+import * as t from 'ts-fortress';
 
-// Complex unions
+// Union types
 const IdType = t.union([t.string(''), t.number(0)]);
 
 // Intersection types
@@ -786,6 +786,8 @@ const ExtendedUserType = t.mergeRecords([
 ### Enums
 
 ```typescript
+import * as t from 'ts-fortress';
+
 // String enums
 const ColorEnum = t.enumType(['red', 'green', 'blue']);
 type Color = t.TypeOf<typeof ColorEnum>; // 'red' | 'green' | 'blue'
@@ -804,6 +806,8 @@ type DiceRoll = t.TypeOf<typeof DiceRoll>; // 1 | 2 | 3 | 4 | 5 | 6
 ts-fortress uses `Result<T, readonly ValidationError[]>` for structured error handling with detailed error information:
 
 ```typescript
+import * as t from 'ts-fortress';
+
 const UserType = t.record({
     name: t.string(''),
     age: t.number(0),
@@ -882,7 +886,7 @@ type ValidationError = Readonly<{
 - `t.number(defaultValue)` - Number validation
 - `t.boolean(defaultValue)` - Boolean validation
 - `t.nullType` / `t.undefinedType` - Null/undefined validation
-- `t.stringLiteral(value)` - Literal string types
+- `t.literal(value)` - Literal types (string, number, or boolean)
 
 ### Collections
 
@@ -909,18 +913,27 @@ type ValidationError = Readonly<{
 - `t.intersection(types, defaultType)` - Intersection type validation
 - `t.mergeRecords(recordTypes)` - Merge multiple record types
 
-### Branded Types
+### Refinement
 
-- `t.simpleBrandedString(brandName, defaultValue)` - Simple string branding
-- `t.simpleBrandedNumber(brandName, defaultValue)` - Simple number branding
+- `t.refine({ baseType, is, defaultValue })` - Refine `baseType` by `is` function
+- `t.simpleBrandedString({ typeName, defaultValue, is? })` - Simple string branding
+- `t.simpleBrandedNumber({ typeName, defaultValue, is? })` - Simple number branding
 - Number types: `t.int()`, `t.safeInt()`, `t.positiveInt()`, `t.uint16()`, etc.
 
 ### Utilities
 
 - `t.TypeOf<T>` - Extract TypeScript type from validator
 - `t.enumType(values)` - Enum validation
-- `t.uintRange({ start, end, defaultValue? })` - Integer range validation
+- `t.uintRange({ start, end, defaultValue? })` - Non-negative integer range validation
+- `t.intRange({ start, end, defaultValue? })` - Integer range validation
 - `t.unknown` - Unknown Type
+- `t.recursion(typeName, definition)` - Define recursive type
+
+### Pre-defined types
+
+- `t.int8` / `t.uint8` - Int8 / Uint8
+- `t.JsonValue` / `t.JsonPrimitive` / `t.JsonObject`
+- `t.nullable(T)` - An alias of `t.union([T, t.undefinedType])`
 
 ## Contributing
 

package/dist/entry-point.mjs

@@ -30,10 +30,13 @@ export { enumType } from './enum/enum.mjs';
 export { intRange } from './enum/int-range.mjs';
 export { uintRange } from './enum/uint-range.mjs';
 export { literal } from './other-types/literal.mjs';
+export { MapType } from './other-types/map.mjs';
 export { refine } from './other-types/refine.mjs';
+export { SetType } from './other-types/set.mjs';
 export { unknown } from './other-types/unknown.mjs';
 export { int8 } from './predefined/int8.mjs';
 export { JsonObject, JsonPrimitive, JsonValue } from './predefined/json.mjs';
+export { nullable } from './predefined/nullable.mjs';
 export { uint8 } from './predefined/uint8.mjs';
 export { bigint, bigintLiteral } from './primitives/bigint.mjs';
 export { boolean, booleanLiteral } from './primitives/boolean.mjs';

package/dist/entry-point.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"entry-point.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"entry-point.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/index.mjs

@@ -29,10 +29,13 @@ export { enumType } from './enum/enum.mjs';
 export { intRange } from './enum/int-range.mjs';
 export { uintRange } from './enum/uint-range.mjs';
 export { literal } from './other-types/literal.mjs';
+export { MapType } from './other-types/map.mjs';
 export { refine } from './other-types/refine.mjs';
+export { SetType } from './other-types/set.mjs';
 export { unknown } from './other-types/unknown.mjs';
 export { int8 } from './predefined/int8.mjs';
 export { JsonObject, JsonPrimitive, JsonValue } from './predefined/json.mjs';
+export { nullable } from './predefined/nullable.mjs';
 export { uint8 } from './predefined/uint8.mjs';
 export { bigint, bigintLiteral } from './primitives/bigint.mjs';
 export { boolean, booleanLiteral } from './primitives/boolean.mjs';

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/other-types/index.d.mts

@@ -1,4 +1,6 @@
 export * from './literal.mjs';
+export * from './map.mjs';
 export * from './refine.mjs';
+export * from './set.mjs';
 export * from './unknown.mjs';
 //# sourceMappingURL=index.d.mts.map

package/dist/other-types/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../src/other-types/index.mts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC;AAC9B,cAAc,cAAc,CAAC;AAC7B,cAAc,eAAe,CAAC"}
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../src/other-types/index.mts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC;AAC9B,cAAc,WAAW,CAAC;AAC1B,cAAc,cAAc,CAAC;AAC7B,cAAc,WAAW,CAAC;AAC1B,cAAc,eAAe,CAAC"}

package/dist/other-types/index.mjs

@@ -1,4 +1,6 @@
 export { literal } from './literal.mjs';
+export { MapType } from './map.mjs';
 export { refine } from './refine.mjs';
+export { SetType } from './set.mjs';
 export { unknown } from './unknown.mjs';
 //# sourceMappingURL=index.mjs.map

package/dist/other-types/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;"}
+{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;"}

package/dist/other-types/map.d.mts

@@ -0,0 +1,7 @@
+import { type Type, type TypeOf } from '../type.mjs';
+type MapResultType<K extends Type<unknown>, V extends Type<unknown>> = ReadonlyMap<TypeOf<K>, TypeOf<V>>;
+export declare const MapType: <K extends Type<unknown>, V extends Type<unknown>>(keyType: K, valueType: V, options?: Readonly<{
+    typeName?: string;
+}>) => Type<MapResultType<K, V>>;
+export {};
+//# sourceMappingURL=map.d.mts.map

package/dist/other-types/map.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"map.d.mts","sourceRoot":"","sources":["../../src/other-types/map.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,IAAI,EAAE,KAAK,MAAM,EAAE,MAAM,aAAa,CAAC;AAWrD,KAAK,aAAa,CAChB,CAAC,SAAS,IAAI,CAAC,OAAO,CAAC,EACvB,CAAC,SAAS,IAAI,CAAC,OAAO,CAAC,IACrB,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;AAEtC,eAAO,MAAM,OAAO,GAAI,CAAC,SAAS,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,SAAS,IAAI,CAAC,OAAO,CAAC,EACtE,SAAS,CAAC,EACV,WAAW,CAAC,EACZ,UAAU,QAAQ,CAAC;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,KACxC,IAAI,CAAC,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,CA6E1B,CAAC"}

package/dist/other-types/map.mjs

@@ -0,0 +1,70 @@
+import { Result, Arr, unknownToString } from 'ts-data-forge';
+import { createAssertFn } from '../utils/create-assert-fn.mjs';
+import { createCastFn } from '../utils/create-cast-fn.mjs';
+import { createIsFn } from '../utils/create-is-fn.mjs';
+import { createPrimitiveValidationError, prependPathToValidationErrors } from '../utils/validation-error.mjs';
+
+const MapType = (keyType, valueType, options) => {
+    const typeName = options?.typeName ?? 'Map';
+    const defaultValue = new Map();
+    const validate = (a) => {
+        if (!(a instanceof Map)) {
+            return Result.err([
+                createPrimitiveValidationError({
+                    actualValue: a,
+                    expectedType: 'Map',
+                    typeName,
+                }),
+            ]);
+        }
+        const errors = Arr.generate(function* () {
+            for (const [k, v] of a.entries()) {
+                {
+                    const res = keyType.validate(k);
+                    if (Result.isErr(res)) {
+                        yield {
+                            path: [],
+                            actualValue: k,
+                            expectedType: typeName,
+                            message: `The key of the Map is expected to be <${keyType.typeName}>, but got <${typeof k}> type value \`${unknownToString(k)}\``,
+                            typeName,
+                        };
+                        yield* res.value;
+                    }
+                }
+                {
+                    const res = valueType.validate(v);
+                    if (Result.isErr(res)) {
+                        yield {
+                            path: [],
+                            actualValue: v,
+                            expectedType: typeName,
+                            message: `The value of the Map is expected to be <${valueType.typeName}>, but got <${typeof v}> type value \`${unknownToString(v)}\``,
+                            typeName,
+                        };
+                        yield* prependPathToValidationErrors(res.value, unknownToString(k));
+                    }
+                }
+            }
+        });
+        if (errors.length > 0) {
+            return Result.err(errors);
+        }
+        return Result.ok(a);
+    };
+    const fill = (a) => a instanceof Map
+        ? new Map(Array.from(a.entries()).filter(([k, v]) => keyType.is(k) && valueType.is(v)))
+        : defaultValue;
+    return {
+        typeName,
+        defaultValue,
+        fill,
+        validate,
+        is: createIsFn(validate),
+        assertIs: createAssertFn(validate),
+        cast: createCastFn(validate),
+    };
+};
+
+export { MapType };
+//# sourceMappingURL=map.mjs.map

package/dist/other-types/map.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"map.mjs","sources":["../../src/other-types/map.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;AAiBO,MAAM,OAAO,GAAG,CACrB,OAAU,EACV,SAAY,EACZ,OAAyC,KACZ;AAG7B,IAAA,MAAM,QAAQ,GAAG,OAAO,EAAE,QAAQ,IAAI,KAAK;AAE3C,IAAA,MAAM,YAAY,GAAM,IAAI,GAAG,EAAE;AAEjC,IAAA,MAAM,QAAQ,GAAwB,CAAC,CAAC,KAAI;AAC1C,QAAA,IAAI,EAAE,CAAC,YAAY,GAAG,CAAC,EAAE;YACvB,OAAO,MAAM,CAAC,GAAG,CAAC;AAChB,gBAAA,8BAA8B,CAAC;AAC7B,oBAAA,WAAW,EAAE,CAAC;AACd,oBAAA,YAAY,EAAE,KAAK;oBACnB,QAAQ;iBACT,CAAC;AACH,aAAA,CAAC;QACJ;AAEA,QAAA,MAAM,MAAM,GAA+B,GAAG,CAAC,QAAQ,CAAC,aAAS;AAC/D,YAAA,KAAK,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,IAAK,CAAmC,CAAC,OAAO,EAAE,EAAE;gBACnE;oBACE,MAAM,GAAG,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC;AAE/B,oBAAA,IAAI,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE;wBACrB,MAAM;AACJ,4BAAA,IAAI,EAAE,EAAE;AACR,4BAAA,WAAW,EAAE,CAAC;AACd,4BAAA,YAAY,EAAE,QAAQ;AACtB,4BAAA,OAAO,EAAE,CAAA,sCAAA,EAAyC,OAAO,CAAC,QAAQ,CAAA,YAAA,EAAe,OAAO,CAAC,CAAA,eAAA,EAAkB,eAAe,CAAC,CAAC,CAAC,CAAA,EAAA,CAAI;4BACjI,QAAQ;yBAC4B;AAEtC,wBAAA,OAAO,GAAG,CAAC,KAAK;oBAClB;gBACF;gBACA;oBACE,MAAM,GAAG,GAAG,SAAS,CAAC,QAAQ,CAAC,CAAC,CAAC;AACjC,oBAAA,IAAI,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE;wBACrB,MAAM;AACJ,4BAAA,IAAI,EAAE,EAAE;AACR,4BAAA,WAAW,EAAE,CAAC;AACd,4BAAA,YAAY,EAAE,QAAQ;AACtB,4BAAA,OAAO,EAAE,CAAA,wCAAA,EAA2C,SAAS,CAAC,QAAQ,CAAA,YAAA,EAAe,OAAO,CAAC,CAAA,eAAA,EAAkB,eAAe,CAAC,CAAC,CAAC,CAAA,EAAA,CAAI;4BACrI,QAAQ;yBAC4B;AAEtC,wBAAA,OAAO,6BAA6B,CAAC,GAAG,CAAC,KAAK,EAAE,eAAe,CAAC,CAAC,CAAC,CAAC;oBACrE;gBACF;YACF;AACF,QAAA,CAAC,CAAC;AAEF,QAAA,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE;AACrB,YAAA,OAAO,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC;QAC3B;AAEA,QAAA,OAAO,MAAM,CAAC,EAAE,CAAC,CAAM,CAAC;AAC1B,IAAA,CAAC;IAED,MAAM,IAAI,GAAoB,CAAC,CAAC,KAC9B,CAAC,YAAY;AACX,UAAG,IAAI,GAAG,CACN,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC,MAAM,CAC5B,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,OAAO,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,SAAS,CAAC,EAAE,CAAC,CAAC,CAAC,CAC7C;UAEH,YAAY;IAElB,OAAO;QACL,QAAQ;QACR,YAAY;QACZ,IAAI;QACJ,QAAQ;AACR,QAAA,EAAE,EAAE,UAAU,CAAC,QAAQ,CAAC;AACxB,QAAA,QAAQ,EAAE,cAAc,CAAC,QAAQ,CAAC;AAClC,QAAA,IAAI,EAAE,YAAY,CAAC,QAAQ,CAAC;KAC7B;AACH;;;;"}

package/dist/other-types/set.d.mts

@@ -0,0 +1,7 @@
+import { type Type, type TypeOf } from '../type.mjs';
+type SetResultType<T extends Type<unknown>> = ReadonlySet<TypeOf<T>>;
+export declare const SetType: <T extends Type<unknown>>(elementType: T, options?: Readonly<{
+    typeName?: string;
+}>) => Type<SetResultType<T>>;
+export {};
+//# sourceMappingURL=set.d.mts.map

package/dist/other-types/set.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"set.d.mts","sourceRoot":"","sources":["../../src/other-types/set.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,IAAI,EAAE,KAAK,MAAM,EAAE,MAAM,aAAa,CAAC;AAUrD,KAAK,aAAa,CAAC,CAAC,SAAS,IAAI,CAAC,OAAO,CAAC,IAAI,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;AAErE,eAAO,MAAM,OAAO,GAAI,CAAC,SAAS,IAAI,CAAC,OAAO,CAAC,EAC7C,aAAa,CAAC,EACd,UAAU,QAAQ,CAAC;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,KACxC,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,CAyDvB,CAAC"}

package/dist/other-types/set.mjs

@@ -0,0 +1,55 @@
+import { Result, Arr, unknownToString } from 'ts-data-forge';
+import { createAssertFn } from '../utils/create-assert-fn.mjs';
+import { createCastFn } from '../utils/create-cast-fn.mjs';
+import { createIsFn } from '../utils/create-is-fn.mjs';
+import { createPrimitiveValidationError } from '../utils/validation-error.mjs';
+
+const SetType = (elementType, options) => {
+    const typeName = options?.typeName ?? 'Set';
+    const defaultValue = new Set();
+    const validate = (a) => {
+        if (!(a instanceof Set)) {
+            return Result.err([
+                createPrimitiveValidationError({
+                    actualValue: a,
+                    expectedType: 'Set',
+                    typeName,
+                }),
+            ]);
+        }
+        const errors = Arr.generate(function* () {
+            for (const element of a.values()) {
+                const res = elementType.validate(element);
+                if (Result.isErr(res)) {
+                    yield {
+                        path: [],
+                        actualValue: element,
+                        expectedType: typeName,
+                        message: `The element of the Set is expected to be <${elementType.typeName}>, but got <${typeof element}> type value \`${unknownToString(element)}\``,
+                        typeName,
+                    };
+                    yield* res.value;
+                }
+            }
+        });
+        if (errors.length > 0) {
+            return Result.err(errors);
+        }
+        return Result.ok(a);
+    };
+    const fill = (a) => a instanceof Set
+        ? new Set(Array.from(a.values()).filter((v) => elementType.is(v)))
+        : defaultValue;
+    return {
+        typeName,
+        defaultValue,
+        fill,
+        validate,
+        is: createIsFn(validate),
+        assertIs: createAssertFn(validate),
+        cast: createCastFn(validate),
+    };
+};
+
+export { SetType };
+//# sourceMappingURL=set.mjs.map

package/dist/other-types/set.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"set.mjs","sources":["../../src/other-types/set.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;MAaa,OAAO,GAAG,CACrB,WAAc,EACd,OAAyC,KACf;AAG1B,IAAA,MAAM,QAAQ,GAAG,OAAO,EAAE,QAAQ,IAAI,KAAK;AAE3C,IAAA,MAAM,YAAY,GAAM,IAAI,GAAG,EAAE;AAEjC,IAAA,MAAM,QAAQ,GAAwB,CAAC,CAAC,KAAI;AAC1C,QAAA,IAAI,EAAE,CAAC,YAAY,GAAG,CAAC,EAAE;YACvB,OAAO,MAAM,CAAC,GAAG,CAAC;AAChB,gBAAA,8BAA8B,CAAC;AAC7B,oBAAA,WAAW,EAAE,CAAC;AACd,oBAAA,YAAY,EAAE,KAAK;oBACnB,QAAQ;iBACT,CAAC;AACH,aAAA,CAAC;QACJ;AAEA,QAAA,MAAM,MAAM,GAA+B,GAAG,CAAC,QAAQ,CAAC,aAAS;YAC/D,KAAK,MAAM,OAAO,IAAK,CAA0B,CAAC,MAAM,EAAE,EAAE;gBAC1D,MAAM,GAAG,GAAG,WAAW,CAAC,QAAQ,CAAC,OAAO,CAAC;AAEzC,gBAAA,IAAI,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE;oBACrB,MAAM;AACJ,wBAAA,IAAI,EAAE,EAAE;AACR,wBAAA,WAAW,EAAE,OAAO;AACpB,wBAAA,YAAY,EAAE,QAAQ;AACtB,wBAAA,OAAO,EAAE,CAAA,0CAAA,EAA6C,WAAW,CAAC,QAAQ,CAAA,YAAA,EAAe,OAAO,OAAO,CAAA,eAAA,EAAkB,eAAe,CAAC,OAAO,CAAC,CAAA,EAAA,CAAI;wBACrJ,QAAQ;qBAC4B;AAEtC,oBAAA,OAAO,GAAG,CAAC,KAAK;gBAClB;YACF;AACF,QAAA,CAAC,CAAC;AAEF,QAAA,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE;AACrB,YAAA,OAAO,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC;QAC3B;AAEA,QAAA,OAAO,MAAM,CAAC,EAAE,CAAC,CAAM,CAAC;AAC1B,IAAA,CAAC;IAED,MAAM,IAAI,GAAoB,CAAC,CAAC,KAC9B,CAAC,YAAY;AACX,UAAG,IAAI,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,WAAW,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;UAChE,YAAY;IAElB,OAAO;QACL,QAAQ;QACR,YAAY;QACZ,IAAI;QACJ,QAAQ;AACR,QAAA,EAAE,EAAE,UAAU,CAAC,QAAQ,CAAC;AACxB,QAAA,QAAQ,EAAE,cAAc,CAAC,QAAQ,CAAC;AAClC,QAAA,IAAI,EAAE,YAAY,CAAC,QAAQ,CAAC;KAC7B;AACH;;;;"}

package/dist/predefined/index.d.mts

@@ -1,4 +1,5 @@
 export * from './int8.mjs';
 export * from './json.mjs';
+export * from './nullable.mjs';
 export * from './uint8.mjs';
 //# sourceMappingURL=index.d.mts.map

package/dist/predefined/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../src/predefined/index.mts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC"}
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../src/predefined/index.mts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,aAAa,CAAC"}

package/dist/predefined/index.mjs

@@ -1,4 +1,5 @@
 export { int8 } from './int8.mjs';
 export { JsonObject, JsonPrimitive, JsonValue } from './json.mjs';
+export { nullable } from './nullable.mjs';
 export { uint8 } from './uint8.mjs';
 //# sourceMappingURL=index.mjs.map

package/dist/predefined/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;"}
+{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;"}

package/dist/predefined/nullable.d.mts

@@ -0,0 +1,3 @@
+import { type Type } from '../type.mjs';
+export declare const nullable: <T>(type: Type<T>) => Type<T | undefined>;
+//# sourceMappingURL=nullable.d.mts.map

package/dist/predefined/nullable.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nullable.d.mts","sourceRoot":"","sources":["../../src/predefined/nullable.mts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,IAAI,EAAE,MAAM,aAAa,CAAC;AAExC,eAAO,MAAM,QAAQ,GAAI,CAAC,EAAG,MAAM,IAAI,CAAC,CAAC,CAAC,KAAG,IAAI,CAAC,CAAC,GAAG,SAAS,CACjC,CAAC"}

package/dist/predefined/nullable.mjs

@@ -0,0 +1,8 @@
+import 'ts-data-forge';
+import { union } from '../compose/union.mjs';
+import { undefinedType } from '../primitives/undefined.mjs';
+
+const nullable = (type) => union([type, undefinedType]);
+
+export { nullable };
+//# sourceMappingURL=nullable.mjs.map

package/dist/predefined/nullable.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"nullable.mjs","sources":["../../src/predefined/nullable.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIO,MAAM,QAAQ,GAAG,CAAK,IAAa,KACxC,KAAK,CAAC,CAAC,IAAI,EAAE,aAAa,CAAC;;;;"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-fortress",
-  "version": "3.0.1",
+  "version": "3.2.0",
   "private": false,
   "keywords": [
     "typescript"
@@ -65,14 +65,14 @@
     "@semantic-release/commit-analyzer": "^13.0.1",
     "@semantic-release/exec": "^7.1.0",
     "@semantic-release/git": "^10.0.1",
-    "@semantic-release/github": "^11.0.4",
+    "@semantic-release/github": "^11.0.5",
     "@semantic-release/npm": "^12.0.2",
     "@semantic-release/release-notes-generator": "^14.0.3",
-    "@types/node": "^24.3.0",
+    "@types/node": "^24.3.1",
     "@vitest/coverage-v8": "^3.2.4",
     "@vitest/ui": "^3.2.4",
     "conventional-changelog-conventionalcommits": "^9.1.0",
-    "cspell": "^9.2.0",
+    "cspell": "^9.2.1",
     "eslint": "^9.34.0",
     "eslint-import-resolver-typescript": "4.4.4",
     "eslint-plugin-array-func": "5.0.2",
@@ -89,12 +89,12 @@
     "prettier": "^3.6.2",
     "prettier-plugin-organize-imports": "^4.2.0",
     "prettier-plugin-packagejson": "^2.5.19",
-    "rollup": "^4.49.0",
+    "rollup": "^4.50.0",
     "semantic-release": "^24.2.7",
     "ts-repo-utils": "^7.0.4",
     "tslib": "^2.8.1",
     "tsx": "^4.20.4",
-    "typedoc": "^0.28.11",
+    "typedoc": "^0.28.12",
     "typedoc-plugin-markdown": "^4.8.1",
     "typescript": "^5.9.2",
     "typescript-eslint": "^8.41.0",

package/src/other-types/index.mts

@@ -1,3 +1,5 @@
 export * from './literal.mjs';
+export * from './map.mjs';
 export * from './refine.mjs';
+export * from './set.mjs';
 export * from './unknown.mjs';

package/src/other-types/map.mts

@@ -0,0 +1,99 @@
+import { Arr, Result, unknownToString } from 'ts-data-forge';
+import { type Type, type TypeOf } from '../type.mjs';
+import {
+  createAssertFn,
+  createCastFn,
+  createIsFn,
+  createPrimitiveValidationError,
+  prependPathToValidationErrors,
+  type ValidationError,
+  type ValidationErrorWithMessage,
+} from '../utils/index.mjs';
+
+type MapResultType<
+  K extends Type<unknown>,
+  V extends Type<unknown>,
+> = ReadonlyMap<TypeOf<K>, TypeOf<V>>;
+
+export const MapType = <K extends Type<unknown>, V extends Type<unknown>>(
+  keyType: K,
+  valueType: V,
+  options?: Readonly<{ typeName?: string }>,
+): Type<MapResultType<K, V>> => {
+  type M = MapResultType<K, V>;
+
+  const typeName = options?.typeName ?? 'Map';
+
+  const defaultValue: M = new Map();
+
+  const validate: Type<M>['validate'] = (a) => {
+    if (!(a instanceof Map)) {
+      return Result.err([
+        createPrimitiveValidationError({
+          actualValue: a,
+          expectedType: 'Map',
+          typeName,
+        }),
+      ]);
+    }
+
+    const errors: readonly ValidationError[] = Arr.generate(function* () {
+      for (const [k, v] of (a as ReadonlyMap<unknown, unknown>).entries()) {
+        {
+          const res = keyType.validate(k);
+
+          if (Result.isErr(res)) {
+            yield {
+              path: [],
+              actualValue: k,
+              expectedType: typeName,
+              message: `The key of the Map is expected to be <${keyType.typeName}>, but got <${typeof k}> type value \`${unknownToString(k)}\``,
+              typeName,
+            } satisfies ValidationErrorWithMessage;
+
+            yield* res.value;
+          }
+        }
+        {
+          const res = valueType.validate(v);
+          if (Result.isErr(res)) {
+            yield {
+              path: [],
+              actualValue: v,
+              expectedType: typeName,
+              message: `The value of the Map is expected to be <${valueType.typeName}>, but got <${typeof v}> type value \`${unknownToString(v)}\``,
+              typeName,
+            } satisfies ValidationErrorWithMessage;
+
+            yield* prependPathToValidationErrors(res.value, unknownToString(k));
+          }
+        }
+      }
+    });
+
+    if (errors.length > 0) {
+      return Result.err(errors);
+    }
+
+    return Result.ok(a as M);
+  };
+
+  const fill: Type<M>['fill'] = (a) =>
+    a instanceof Map
+      ? (new Map(
+          Array.from(a.entries()).filter(
+            ([k, v]) => keyType.is(k) && valueType.is(v),
+          ),
+        ) as M)
+      : defaultValue;
+
+  return {
+    typeName,
+    defaultValue,
+    fill,
+    validate,
+    is: createIsFn(validate),
+    assertIs: createAssertFn(validate),
+    cast: createCastFn(validate),
+  };
+};

package/src/other-types/map.test.mts

@@ -0,0 +1,181 @@
+import { expectType, Result } from 'ts-data-forge';
+import { number, string } from '../primitives/index.mjs';
+import { type TypeOf } from '../type.mjs';
+import { MapType } from './map.mjs';
+
+test('MapType with string keys and number values', () => {
+  const StringNumberMap = MapType(string(''), number(0));
+  type StringNumberMap = TypeOf<typeof StringNumberMap>;
+
+  // Type test
+  expectType<StringNumberMap, ReadonlyMap<string, number>>('=');
+
+  // Valid map
+  const validMap = new Map([
+    ['a', 1],
+    ['b', 2],
+    ['c', 3],
+  ]);
+
+  // is() test
+  expect(StringNumberMap.is(validMap)).toBe(true);
+  expect(StringNumberMap.is(new Map())).toBe(true);
+  expect(StringNumberMap.is({})).toBe(false);
+  expect(StringNumberMap.is([])).toBe(false);
+  expect(StringNumberMap.is(null)).toBe(false);
+  expect(StringNumberMap.is(undefined)).toBe(false);
+
+  // validate() test
+  const result = StringNumberMap.validate(validMap);
+  expect(Result.isOk(result)).toBe(true);
+  if (Result.isOk(result)) {
+    expect(result.value).toBe(validMap); // Same reference
+  }
+});
+
+test('MapType with invalid key types', () => {
+  const StringNumberMap = MapType(string(''), number(0));
+
+  const invalidMap = new Map<unknown, unknown>([
+    ['valid', 1],
+    [123, 2], // Invalid key type
+    ['another', 3],
+  ]);
+
+  // is() test
+  expect(StringNumberMap.is(invalidMap)).toBe(false);
+
+  // validate() test
+  const result = StringNumberMap.validate(invalidMap);
+  expect(Result.isErr(result)).toBe(true);
+  if (Result.isErr(result)) {
+    expect(result.value.length).toBeGreaterThan(0);
+    expect(result.value[0]?.message).toContain('key of the Map');
+  }
+});
+
+test('MapType with invalid value types', () => {
+  const StringNumberMap = MapType(string(''), number(0));
+
+  const invalidMap = new Map<unknown, unknown>([
+    ['a', 1],
+    ['b', 'not a number'], // Invalid value type
+    ['c', 3],
+  ]);
+
+  // is() test
+  expect(StringNumberMap.is(invalidMap)).toBe(false);
+
+  // validate() test
+  const result = StringNumberMap.validate(invalidMap);
+  expect(Result.isErr(result)).toBe(true);
+  if (Result.isErr(result)) {
+    expect(result.value.length).toBeGreaterThan(0);
+    expect(result.value[0]?.message).toContain('value of the Map');
+  }
+});
+
+test('MapType fill() method', () => {
+  const StringNumberMap = MapType(string(''), number(0));
+
+  // Valid map - should preserve valid entries
+  const validMap = new Map([
+    ['a', 1],
+    ['b', 2],
+  ]);
+  const filled1 = StringNumberMap.fill(validMap);
+  expect(filled1.size).toBe(2);
+  expect(filled1.get('a')).toBe(1);
+  expect(filled1.get('b')).toBe(2);
+
+  // Mixed valid/invalid entries - should filter out invalid ones
+  const mixedMap = new Map<unknown, unknown>([
+    ['valid', 1],
+    [123, 2], // Invalid key
+    ['another', 'not a number'], // Invalid value
+    ['good', 3],
+  ]);
+  const filled2 = StringNumberMap.fill(mixedMap);
+  expect(filled2.size).toBe(2);
+  expect(filled2.get('valid')).toBe(1);
+  expect(filled2.get('good')).toBe(3);
+
+  // Non-map input - should return default (empty map)
+  const filled3 = StringNumberMap.fill({});
+  expect(filled3.size).toBe(0);
+  expect(filled3).toStrictEqual(new Map());
+});
+
+test('MapType cast() method', () => {
+  const StringNumberMap = MapType(string(''), number(0));
+
+  // Valid map
+  const validMap = new Map([['key', 42]]);
+  const casted = StringNumberMap.cast(validMap);
+  expect(casted).toBe(validMap);
+
+  // Invalid input - should throw
+  expect(() => StringNumberMap.cast('not a map')).toThrow(
+    'Expected <Map>, got <string> type value',
+  );
+});
+
+test('MapType assertIs() method', () => {
+  const StringNumberMap = MapType(string(''), number(0));
+
+  const assertIsStringNumberMap: (
+    a: unknown,
+  ) => asserts a is ReadonlyMap<string, number> = StringNumberMap.assertIs;
+
+  // Valid map - should not throw
+  const validMap = new Map([['key', 42]]);
+  expect(() => {
+    assertIsStringNumberMap(validMap);
+  }).not.toThrow();
+
+  // Invalid input - should throw
+  expect(() => {
+    assertIsStringNumberMap('not a map');
+  }).toThrow('Expected <Map>, got <string> type value');
+});
+
+test('MapType with custom typeName', () => {
+  const CustomMap = MapType(string(''), number(0), {
+    typeName: 'CustomStringNumberMap',
+  });
+
+  expect(CustomMap.typeName).toBe('CustomStringNumberMap');
+
+  // Error message should include custom type name
+  const result = CustomMap.validate('not a map');
+  expect(Result.isErr(result)).toBe(true);
+  if (Result.isErr(result)) {
+    expect(result.value[0]?.typeName).toBe('CustomStringNumberMap');
+  }
+});
+
+test('MapType with number keys and string values', () => {
+  const NumberStringMap = MapType(number(0), string(''));
+  type NumberStringMap = TypeOf<typeof NumberStringMap>;
+
+  // Type test
+  expectType<NumberStringMap, ReadonlyMap<number, string>>('=');
+
+  const validMap = new Map([
+    [1, 'one'],
+    [2, 'two'],
+    [3, 'three'],
+  ]);
+
+  expect(NumberStringMap.is(validMap)).toBe(true);
+
+  const result = NumberStringMap.validate(validMap);
+  expect(Result.isOk(result)).toBe(true);
+});
+
+test('MapType defaultValue', () => {
+  const StringNumberMap = MapType(string(''), number(0));
+
+  expect(StringNumberMap.defaultValue).toStrictEqual(new Map());
+  expect(StringNumberMap.defaultValue.size).toBe(0);
+});

package/src/other-types/set.mts

@@ -0,0 +1,74 @@
+import { Arr, Result, unknownToString } from 'ts-data-forge';
+import { type Type, type TypeOf } from '../type.mjs';
+import {
+  createAssertFn,
+  createCastFn,
+  createIsFn,
+  createPrimitiveValidationError,
+  type ValidationError,
+  type ValidationErrorWithMessage,
+} from '../utils/index.mjs';
+
+type SetResultType<T extends Type<unknown>> = ReadonlySet<TypeOf<T>>;
+
+export const SetType = <T extends Type<unknown>>(
+  elementType: T,
+  options?: Readonly<{ typeName?: string }>,
+): Type<SetResultType<T>> => {
+  type S = SetResultType<T>;
+
+  const typeName = options?.typeName ?? 'Set';
+
+  const defaultValue: S = new Set();
+
+  const validate: Type<S>['validate'] = (a) => {
+    if (!(a instanceof Set)) {
+      return Result.err([
+        createPrimitiveValidationError({
+          actualValue: a,
+          expectedType: 'Set',
+          typeName,
+        }),
+      ]);
+    }
+
+    const errors: readonly ValidationError[] = Arr.generate(function* () {
+      for (const element of (a as ReadonlySet<unknown>).values()) {
+        const res = elementType.validate(element);
+
+        if (Result.isErr(res)) {
+          yield {
+            path: [],
+            actualValue: element,
+            expectedType: typeName,
+            message: `The element of the Set is expected to be <${elementType.typeName}>, but got <${typeof element}> type value \`${unknownToString(element)}\``,
+            typeName,
+          } satisfies ValidationErrorWithMessage;
+
+          yield* res.value;
+        }
+      }
+    });
+
+    if (errors.length > 0) {
+      return Result.err(errors);
+    }
+
+    return Result.ok(a as S);
+  };
+
+  const fill: Type<S>['fill'] = (a) =>
+    a instanceof Set
+      ? (new Set(Array.from(a.values()).filter((v) => elementType.is(v))) as S)
+      : defaultValue;
+
+  return {
+    typeName,
+    defaultValue,
+    fill,
+    validate,
+    is: createIsFn(validate),
+    assertIs: createAssertFn(validate),
+    cast: createCastFn(validate),
+  };
+};

package/src/other-types/set.test.mts

@@ -0,0 +1,199 @@
+import { expectType, Result } from 'ts-data-forge';
+import { test } from 'vitest';
+import { number, string } from '../primitives/index.mjs';
+import { record } from '../record/index.mjs';
+import { type TypeOf } from '../type.mjs';
+import { SetType } from './set.mjs';
+
+test('SetType with string elements', () => {
+  const StringSet = SetType(string(''));
+  type StringSet = TypeOf<typeof StringSet>;
+
+  // Type test
+  expectType<StringSet, ReadonlySet<string>>('=');
+
+  // Valid set
+  const validSet = new Set(['a', 'b', 'c']);
+
+  // is() test
+  expect(StringSet.is(validSet)).toBe(true);
+  expect(StringSet.is(new Set())).toBe(true);
+  expect(StringSet.is({})).toBe(false);
+  expect(StringSet.is([])).toBe(false);
+  expect(StringSet.is(null)).toBe(false);
+  expect(StringSet.is(undefined)).toBe(false);
+
+  // validate() test
+  const result = StringSet.validate(validSet);
+  expect(Result.isOk(result)).toBe(true);
+  if (Result.isOk(result)) {
+    expect(result.value).toBe(validSet); // Same reference
+  }
+});
+
+test('SetType with number elements', () => {
+  const NumberSet = SetType(number(0));
+  type NumberSet = TypeOf<typeof NumberSet>;
+
+  // Type test
+  expectType<NumberSet, ReadonlySet<number>>('=');
+
+  const validSet = new Set([1, 2, 3, 4, 5]);
+
+  // is() test
+  expect(NumberSet.is(validSet)).toBe(true);
+
+  // validate() test
+  const result = NumberSet.validate(validSet);
+  expect(Result.isOk(result)).toBe(true);
+  if (Result.isOk(result)) {
+    expect(result.value).toBe(validSet);
+  }
+});
+
+test('SetType with invalid element types', () => {
+  const StringSet = SetType(string(''));
+
+  const invalidSet = new Set<unknown>(['valid', 123, 'another', true]);
+
+  // is() test
+  expect(StringSet.is(invalidSet)).toBe(false);
+
+  // validate() test
+  const result = StringSet.validate(invalidSet);
+  expect(Result.isErr(result)).toBe(true);
+  if (Result.isErr(result)) {
+    expect(result.value.length).toBeGreaterThan(0);
+    expect(result.value[0]?.message).toContain('element of the Set');
+  }
+});
+
+test('SetType fill() method', () => {
+  const NumberSet = SetType(number(0));
+
+  // Valid set - should preserve all elements
+  const validSet = new Set([1, 2, 3]);
+  const filled1 = NumberSet.fill(validSet);
+  expect(filled1.size).toBe(3);
+  expect(filled1.has(1)).toBe(true);
+  expect(filled1.has(2)).toBe(true);
+  expect(filled1.has(3)).toBe(true);
+
+  // Mixed valid/invalid elements - should filter out invalid ones
+  const mixedSet = new Set<unknown>([1, 'not a number', 2, true, 3]);
+  const filled2 = NumberSet.fill(mixedSet);
+  expect(filled2.size).toBe(3);
+  expect(filled2.has(1)).toBe(true);
+  expect(filled2.has(2)).toBe(true);
+  expect(filled2.has(3)).toBe(true);
+
+  // Non-set input - should return default (empty set)
+  const filled3 = NumberSet.fill({});
+  expect(filled3.size).toBe(0);
+  expect(filled3).toStrictEqual(new Set());
+});
+
+test('SetType cast() method', () => {
+  const StringSet = SetType(string(''));
+
+  // Valid set
+  const validSet = new Set(['hello', 'world']);
+  const casted = StringSet.cast(validSet);
+  expect(casted).toBe(validSet);
+
+  // Invalid input - should throw
+  expect(() => StringSet.cast('not a set')).toThrow(
+    'Expected <Set>, got <string> type value',
+  );
+  expect(() => StringSet.cast([])).toThrow(
+    'Expected <Set>, got <object> type value',
+  );
+});
+
+test('SetType assertIs() method', () => {
+  const NumberSet = SetType(number(0));
+
+  const assertIsNumberSet: (a: unknown) => asserts a is ReadonlySet<number> =
+    NumberSet.assertIs;
+
+  // Valid set - should not throw
+  const validSet = new Set([1, 2, 3]);
+  expect(() => {
+    assertIsNumberSet(validSet);
+  }).not.toThrow();
+
+  // Invalid input - should throw
+  expect(() => {
+    assertIsNumberSet('not a set');
+  }).toThrow('Expected <Set>, got <string> type value');
+  expect(() => {
+    assertIsNumberSet([1, 2, 3]);
+  }).toThrow('Expected <Set>, got <object> type value');
+});
+
+test('SetType with custom typeName', () => {
+  const CustomSet = SetType(string(''), {
+    typeName: 'CustomStringSet',
+  });
+
+  expect(CustomSet.typeName).toBe('CustomStringSet');
+
+  // Error message should include custom type name
+  const result = CustomSet.validate('not a set');
+  expect(Result.isErr(result)).toBe(true);
+  if (Result.isErr(result)) {
+    expect(result.value[0]?.typeName).toBe('CustomStringSet');
+  }
+});
+
+test('SetType with complex element types', () => {
+  const UserType = record({
+    id: number(0),
+    name: string(''),
+  });
+
+  const UserSet = SetType(UserType);
+  type UserSet = TypeOf<typeof UserSet>;
+
+  // Type test
+  expectType<UserSet, ReadonlySet<Readonly<{ id: number; name: string }>>>('=');
+
+  const user1 = { id: 1, name: 'Alice' };
+  const user2 = { id: 2, name: 'Bob' };
+  const validSet = new Set([user1, user2]);
+
+  // is() test
+  expect(UserSet.is(validSet)).toBe(true);
+
+  // validate() test
+  const result = UserSet.validate(validSet);
+  expect(Result.isOk(result)).toBe(true);
+
+  // Invalid element
+  const invalidSet = new Set([
+    user1,
+    { id: 'invalid', name: 'Charlie' }, // Invalid id type
+  ]);
+
+  expect(UserSet.is(invalidSet)).toBe(false);
+});
+
+test('SetType defaultValue', () => {
+  const StringSet = SetType(string(''));
+
+  expect(StringSet.defaultValue).toStrictEqual(new Set());
+  expect(StringSet.defaultValue.size).toBe(0);
+});
+
+test('SetType ensures uniqueness', () => {
+  const NumberSet = SetType(number(0));
+
+  // Set with duplicate values (Set automatically handles uniqueness)
+  const setWithDuplicates = new Set([1, 2, 2, 3, 3, 3]);
+
+  expect(setWithDuplicates.size).toBe(3); // Only unique values
+  expect(NumberSet.is(setWithDuplicates)).toBe(true);
+
+  const result = NumberSet.validate(setWithDuplicates);
+  expect(Result.isOk(result)).toBe(true);
+});

package/src/predefined/index.mts

@@ -1,3 +1,4 @@
 export * from './int8.mjs';
 export * from './json.mjs';
+export * from './nullable.mjs';
 export * from './uint8.mjs';

package/src/predefined/nullable.mts

@@ -0,0 +1,6 @@
+import { union } from '../compose/index.mjs';
+import { undefinedType } from '../primitives/index.mjs';
+import { type Type } from '../type.mjs';
+
+export const nullable = <T,>(type: Type<T>): Type<T | undefined> =>
+  union([type, undefinedType]);