ts-fortress 2.6.2 → 2.8.0

package/src/branded/brand.mts

@@ -1,10 +1,6 @@
 import { pipe, Result } from 'ts-data-forge';
 import { type Type } from '../type.mjs';
-import {
-  createType,
-  type ValidationError,
-  type ValidationErrorWithMessage,
-} from '../utils/index.mjs';
+import { createType, type ValidationError } from '../utils/index.mjs';
 
 type ArrayToUnion<A extends readonly unknown[]> = A extends readonly []
   ? never
@@ -17,31 +13,35 @@ export const brand = <
 >({
   codec,
   is,
+  defaultValue,
+  typeName,
   brandKeys,
   brandFalseKeys,
-  defaultValue,
 }: Readonly<{
   codec: Type<A>;
   is: (
     a: A,
   ) => a is Brand<A, ArrayToUnion<BrandTrueKeys>, ArrayToUnion<BrandFalseKeys>>;
-  brandKeys: BrandTrueKeys;
-  brandFalseKeys?: BrandFalseKeys;
   defaultValue: Brand<
     A,
     ArrayToUnion<BrandTrueKeys>,
     ArrayToUnion<BrandFalseKeys>
   >;
+  typeName?: string;
+  brandKeys: BrandTrueKeys;
+  brandFalseKeys?: BrandFalseKeys;
 }>): Type<
   Brand<A, ArrayToUnion<BrandTrueKeys>, ArrayToUnion<BrandFalseKeys>>
 > => {
   type T = Brand<A, ArrayToUnion<BrandTrueKeys>, ArrayToUnion<BrandFalseKeys>>;
 
   const brandKeysStr = [
-    ...brandKeys,
-    ...(brandFalseKeys?.map((s) => `not(${s})`) ?? []),
+    ...brandKeys.map((s) => `"${s}"`),
+    ...(brandFalseKeys?.map((s) => `not("${s}")`) ?? []),
   ].join(' & ');
 
+  const typeNameFilled = typeName ?? brandKeysStr;
+
   const validate: Type<T>['validate'] = (a) =>
     pipe(a)
       .map(codec.validate)
@@ -55,23 +55,19 @@ export const brand = <
                   {
                     path: [],
                     actualValue: v.value,
-                    expectedType: brandKeysStr,
+                    expectedType: typeNameFilled,
                     typeName: brandKeysStr,
-                    message: `The value must satisfy the constraint corresponding to the brand keys: <${brandKeysStr}>`,
-                  } satisfies ValidationErrorWithMessage,
+                    message:
+                      typeName === undefined
+                        ? `The value must satisfy the constraint corresponding to the brand keys: <${brandKeysStr}>`
+                        : undefined,
+                  } satisfies ValidationError,
                 ]),
       ).value;
 
-  const fill: Type<T>['fill'] = (a) =>
-    Result.unwrapOkOr(
-      validate(a) satisfies Result<T, unknown>,
-      defaultValue satisfies T,
-    ) satisfies T;
-
   return createType({
     typeName: brandKeysStr,
     defaultValue,
     validate,
-    fill,
   });
 };

package/src/branded/number/finite-number.mts

@@ -12,4 +12,5 @@ export const finiteNumber = (
     defaultValue,
     brandKeys: ['Finite'],
     brandFalseKeys: ['NaNValue'],
+    typeName: 'FiniteNumber',
   });

package/src/branded/number/finite-number.test.mts

@@ -90,10 +90,9 @@ describe('finiteNumber', () => {
           {
             path: [],
             actualValue: Number.POSITIVE_INFINITY,
-            expectedType: 'Finite & not(NaNValue)',
-            typeName: 'Finite & not(NaNValue)',
-            message:
-              'The value must satisfy the constraint corresponding to the brand keys: <Finite & not(NaNValue)>',
+            expectedType: 'FiniteNumber',
+            typeName: '"Finite" & not("NaNValue")',
+            message: undefined,
           },
         ]);
       }
@@ -115,7 +114,7 @@ describe('finiteNumber', () => {
         ]);
 
         expect(validationErrorsToMessages(result.value)).toStrictEqual([
-          'Expected number, got string',
+          'Expected <number>, got <string> type value "not a number".',
         ]);
       }
     });
@@ -139,7 +138,7 @@ describe('finiteNumber', () => {
         targetType.assertIs;
       expect(() => {
         assertIs(x);
-      }).toThrow('The value must satisfy the constraint');
+      }).toThrow('Expected <FiniteNumber>');
     });
   });
 

package/src/branded/number/int.mts

@@ -10,4 +10,5 @@ export const int = (defaultValue: Int = asInt(0)): Type<Int> =>
     defaultValue,
     brandKeys: ['Finite', 'Int'],
     brandFalseKeys: ['NaNValue'],
+    typeName: 'Int',
   });

package/src/branded/number/int.test.mts

@@ -69,15 +69,14 @@ describe('int', () => {
           {
             path: [],
             actualValue: 42.5,
-            expectedType: 'Finite & Int & not(NaNValue)',
-            typeName: 'Finite & Int & not(NaNValue)',
-            message:
-              'The value must satisfy the constraint corresponding to the brand keys: <Finite & Int & not(NaNValue)>',
+            expectedType: 'Int',
+            typeName: '"Finite" & "Int" & not("NaNValue")',
+            message: undefined,
           },
         ]);
 
         expect(validationErrorsToMessages(result.value)).toStrictEqual([
-          'The value must satisfy the constraint corresponding to the brand keys: <Finite & Int & not(NaNValue)>',
+          'Expected <Int>, got <number> type value `42.5`.',
         ]);
       }
     });
@@ -98,7 +97,7 @@ describe('int', () => {
         ]);
 
         expect(validationErrorsToMessages(result.value)).toStrictEqual([
-          'Expected number, got string',
+          'Expected <number>, got <string> type value "not a number".',
         ]);
       }
     });
@@ -131,7 +130,7 @@ describe('int', () => {
         targetType.assertIs;
       expect(() => {
         assertIs(x);
-      }).toThrow('The value must satisfy the constraint');
+      }).toThrow('Expected <Int>');
     });
   });
 

package/src/branded/number/int16.mts

@@ -22,4 +22,5 @@ export const int16 = (defaultValue: Int16 = asInt16(0)): Type<Int16> =>
       '>= -2^15',
     ],
     brandFalseKeys: ['NaNValue'],
+    typeName: 'Int16',
   });

package/src/branded/number/int16.test.mts

@@ -79,16 +79,14 @@ describe('int16', () => {
           {
             path: [],
             actualValue: 50000,
-            expectedType:
-              'Finite & Int & SafeInt & > -2^32 & >= -2^31 & < 2^32 & < 2^31 & < 2^15 & < 2^16 & > -2^16 & >= -2^15 & not(NaNValue)',
+            expectedType: 'Int16',
             typeName:
-              'Finite & Int & SafeInt & > -2^32 & >= -2^31 & < 2^32 & < 2^31 & < 2^15 & < 2^16 & > -2^16 & >= -2^15 & not(NaNValue)',
-            message:
-              'The value must satisfy the constraint corresponding to the brand keys: <Finite & Int & SafeInt & > -2^32 & >= -2^31 & < 2^32 & < 2^31 & < 2^15 & < 2^16 & > -2^16 & >= -2^15 & not(NaNValue)>',
+              '"Finite" & "Int" & "SafeInt" & "> -2^32" & ">= -2^31" & "< 2^32" & "< 2^31" & "< 2^15" & "< 2^16" & "> -2^16" & ">= -2^15" & not("NaNValue")',
+            message: undefined,
           },
         ]);
         expect(validationErrorsToMessages(result.value)).toStrictEqual([
-          'The value must satisfy the constraint corresponding to the brand keys: <Finite & Int & SafeInt & > -2^32 & >= -2^31 & < 2^32 & < 2^31 & < 2^15 & < 2^16 & > -2^16 & >= -2^15 & not(NaNValue)>',
+          'Expected <Int16>, got <number> type value `50000`.',
         ]);
       }
     });

package/src/branded/number/int32.mts

@@ -18,4 +18,5 @@ export const int32 = (defaultValue: Int32 = asInt32(0)): Type<Int32> =>
       '< 2^31',
     ],
     brandFalseKeys: ['NaNValue'],
+    typeName: 'Int32',
   });

package/src/branded/number/int32.test.mts

@@ -73,16 +73,14 @@ describe('int32', () => {
           {
             path: [],
             actualValue: 3000000000,
-            expectedType:
-              'Finite & Int & SafeInt & > -2^32 & >= -2^31 & < 2^32 & < 2^31 & not(NaNValue)',
+            expectedType: 'Int32',
             typeName:
-              'Finite & Int & SafeInt & > -2^32 & >= -2^31 & < 2^32 & < 2^31 & not(NaNValue)',
-            message:
-              'The value must satisfy the constraint corresponding to the brand keys: <Finite & Int & SafeInt & > -2^32 & >= -2^31 & < 2^32 & < 2^31 & not(NaNValue)>',
+              '"Finite" & "Int" & "SafeInt" & "> -2^32" & ">= -2^31" & "< 2^32" & "< 2^31" & not("NaNValue")',
+            message: undefined,
           },
         ]);
         expect(validationErrorsToMessages(result.value)).toStrictEqual([
-          'The value must satisfy the constraint corresponding to the brand keys: <Finite & Int & SafeInt & > -2^32 & >= -2^31 & < 2^32 & < 2^31 & not(NaNValue)>',
+          'Expected <Int32>, got <number> type value `3000000000`.',
         ]);
       }
     });

package/src/branded/number/non-negative-finite-number.mts

@@ -15,4 +15,5 @@ export const nonNegativeFiniteNumber = (
     defaultValue,
     brandKeys: ['>=0', '> -2^16', '> -2^32', '>= -2^15', '>= -2^31', 'Finite'],
     brandFalseKeys: ['NaNValue'],
+    typeName: 'NonNegativeFiniteNumber',
   });

package/src/branded/number/non-negative-finite-number.test.mts

@@ -90,16 +90,14 @@ describe('nonNegativeFiniteNumber', () => {
           {
             path: [],
             actualValue: -5.5,
-            expectedType:
-              '>=0 & > -2^16 & > -2^32 & >= -2^15 & >= -2^31 & Finite & not(NaNValue)',
+            expectedType: 'NonNegativeFiniteNumber',
             typeName:
-              '>=0 & > -2^16 & > -2^32 & >= -2^15 & >= -2^31 & Finite & not(NaNValue)',
-            message:
-              'The value must satisfy the constraint corresponding to the brand keys: <>=0 & > -2^16 & > -2^32 & >= -2^15 & >= -2^31 & Finite & not(NaNValue)>',
+              '">=0" & "> -2^16" & "> -2^32" & ">= -2^15" & ">= -2^31" & "Finite" & not("NaNValue")',
+            message: undefined,
           },
         ]);
         expect(validationErrorsToMessages(result.value)).toStrictEqual([
-          'The value must satisfy the constraint corresponding to the brand keys: <>=0 & > -2^16 & > -2^32 & >= -2^15 & >= -2^31 & Finite & not(NaNValue)>',
+          'Expected <NonNegativeFiniteNumber>, got <number> type value `-5.5`.',
         ]);
       }
     });

package/src/branded/number/non-zero-finite-number.mts

@@ -12,4 +12,5 @@ export const nonZeroFiniteNumber = (
     defaultValue,
     brandKeys: ['!=0', 'Finite'],
     brandFalseKeys: ['NaNValue'],
+    typeName: 'NonZeroFiniteNumber',
   });

package/src/branded/number/non-zero-finite-number.test.mts

@@ -86,14 +86,13 @@ describe('nonZeroFiniteNumber', () => {
           {
             path: [],
             actualValue: 0,
-            expectedType: '!=0 & Finite & not(NaNValue)',
-            typeName: '!=0 & Finite & not(NaNValue)',
-            message:
-              'The value must satisfy the constraint corresponding to the brand keys: <!=0 & Finite & not(NaNValue)>',
+            expectedType: 'NonZeroFiniteNumber',
+            typeName: '"!=0" & "Finite" & not("NaNValue")',
+            message: undefined,
           },
         ]);
         expect(validationErrorsToMessages(result.value)).toStrictEqual([
-          'The value must satisfy the constraint corresponding to the brand keys: <!=0 & Finite & not(NaNValue)>',
+          'Expected <NonZeroFiniteNumber>, got <number> type value `0`.',
         ]);
       }
     });

package/src/branded/number/non-zero-int.mts

@@ -12,4 +12,5 @@ export const nonZeroInt = (
     defaultValue,
     brandKeys: ['Finite', 'Int', '!=0'],
     brandFalseKeys: ['NaNValue'],
+    typeName: 'NonZeroInt',
   });

package/src/branded/number/non-zero-int.test.mts

@@ -79,14 +79,13 @@ describe('nonZeroInt', () => {
           {
             path: [],
             actualValue: 0,
-            expectedType: 'Finite & Int & !=0 & not(NaNValue)',
-            typeName: 'Finite & Int & !=0 & not(NaNValue)',
-            message:
-              'The value must satisfy the constraint corresponding to the brand keys: <Finite & Int & !=0 & not(NaNValue)>',
+            expectedType: 'NonZeroInt',
+            typeName: '"Finite" & "Int" & "!=0" & not("NaNValue")',
+            message: undefined,
           },
         ]);
         expect(validationErrorsToMessages(result.value)).toStrictEqual([
-          'The value must satisfy the constraint corresponding to the brand keys: <Finite & Int & !=0 & not(NaNValue)>',
+          'Expected <NonZeroInt>, got <number> type value `0`.',
         ]);
       }
     });

package/src/branded/number/non-zero-safe-int.mts

@@ -12,4 +12,5 @@ export const nonZeroSafeInt = (
     defaultValue,
     brandKeys: ['Finite', 'Int', 'SafeInt', '!=0'],
     brandFalseKeys: ['NaNValue'],
+    typeName: 'NonZeroSafeInt',
   });

package/src/branded/number/non-zero-safe-int.test.mts

@@ -86,14 +86,13 @@ describe('nonZeroSafeInt', () => {
           {
             path: [],
             actualValue: 0,
-            expectedType: 'Finite & Int & SafeInt & !=0 & not(NaNValue)',
-            typeName: 'Finite & Int & SafeInt & !=0 & not(NaNValue)',
-            message:
-              'The value must satisfy the constraint corresponding to the brand keys: <Finite & Int & SafeInt & !=0 & not(NaNValue)>',
+            expectedType: 'NonZeroSafeInt',
+            typeName: '"Finite" & "Int" & "SafeInt" & "!=0" & not("NaNValue")',
+            message: undefined,
           },
         ]);
         expect(validationErrorsToMessages(result.value)).toStrictEqual([
-          'The value must satisfy the constraint corresponding to the brand keys: <Finite & Int & SafeInt & !=0 & not(NaNValue)>',
+          'Expected <NonZeroSafeInt>, got <number> type value `0`.',
         ]);
       }
     });

package/src/branded/number/positive-finite-number.mts

@@ -20,4 +20,5 @@ export const positiveFiniteNumber = (
       '!=0',
     ],
     brandFalseKeys: ['NaNValue'],
+    typeName: 'PositiveFiniteNumber',
   });

package/src/branded/number/positive-finite-number.test.mts

@@ -86,16 +86,14 @@ describe('positiveFiniteNumber', () => {
           {
             path: [],
             actualValue: 0,
-            expectedType:
-              '>=0 & > -2^16 & > -2^32 & >= -2^15 & >= -2^31 & Finite & !=0 & not(NaNValue)',
+            expectedType: 'PositiveFiniteNumber',
             typeName:
-              '>=0 & > -2^16 & > -2^32 & >= -2^15 & >= -2^31 & Finite & !=0 & not(NaNValue)',
-            message:
-              'The value must satisfy the constraint corresponding to the brand keys: <>=0 & > -2^16 & > -2^32 & >= -2^15 & >= -2^31 & Finite & !=0 & not(NaNValue)>',
+              '">=0" & "> -2^16" & "> -2^32" & ">= -2^15" & ">= -2^31" & "Finite" & "!=0" & not("NaNValue")',
+            message: undefined,
           },
         ]);
         expect(validationErrorsToMessages(result.value)).toStrictEqual([
-          'The value must satisfy the constraint corresponding to the brand keys: <>=0 & > -2^16 & > -2^32 & >= -2^15 & >= -2^31 & Finite & !=0 & not(NaNValue)>',
+          'Expected <PositiveFiniteNumber>, got <number> type value `0`.',
         ]);
       }
     });

package/src/branded/number/positive-int.mts

@@ -21,4 +21,5 @@ export const positiveInt = (
       '!=0',
     ],
     brandFalseKeys: ['NaNValue'],
+    typeName: 'PositiveInt',
   });

package/src/branded/number/positive-int.test.mts

@@ -96,16 +96,14 @@ describe('positiveInt', () => {
           {
             path: [],
             actualValue: -5,
-            expectedType:
-              'Finite & Int & > -2^32 & >= -2^31 & > -2^16 & >= -2^15 & >=0 & !=0 & not(NaNValue)',
+            expectedType: 'PositiveInt',
             typeName:
-              'Finite & Int & > -2^32 & >= -2^31 & > -2^16 & >= -2^15 & >=0 & !=0 & not(NaNValue)',
-            message:
-              'The value must satisfy the constraint corresponding to the brand keys: <Finite & Int & > -2^32 & >= -2^31 & > -2^16 & >= -2^15 & >=0 & !=0 & not(NaNValue)>',
+              '"Finite" & "Int" & "> -2^32" & ">= -2^31" & "> -2^16" & ">= -2^15" & ">=0" & "!=0" & not("NaNValue")',
+            message: undefined,
           },
         ]);
         expect(validationErrorsToMessages(result.value)).toStrictEqual([
-          'The value must satisfy the constraint corresponding to the brand keys: <Finite & Int & > -2^32 & >= -2^31 & > -2^16 & >= -2^15 & >=0 & !=0 & not(NaNValue)>',
+          'Expected <PositiveInt>, got <number> type value `-5`.',
         ]);
       }
     });
@@ -125,7 +123,7 @@ describe('positiveInt', () => {
           },
         ]);
         expect(validationErrorsToMessages(result.value)).toStrictEqual([
-          'Expected number, got string',
+          'Expected <number>, got <string> type value "not a number".',
         ]);
       }
     });
@@ -149,7 +147,7 @@ describe('positiveInt', () => {
         targetType.assertIs;
       expect(() => {
         assertIs(x);
-      }).toThrow('The value must satisfy the constraint');
+      }).toThrow('Expected <PositiveInt>');
     });
   });
 

package/src/branded/number/positive-safe-int.mts

@@ -22,4 +22,5 @@ export const positiveSafeInt = (
       '!=0',
     ],
     brandFalseKeys: ['NaNValue'],
+    typeName: 'PositiveSafeInt',
   });

package/src/branded/number/positive-safe-int.test.mts

@@ -90,16 +90,14 @@ describe('positiveSafeInt', () => {
           {
             path: [],
             actualValue: 0,
-            expectedType:
-              'Finite & Int & SafeInt & > -2^32 & >= -2^31 & > -2^16 & >= -2^15 & >=0 & !=0 & not(NaNValue)',
+            expectedType: 'PositiveSafeInt',
             typeName:
-              'Finite & Int & SafeInt & > -2^32 & >= -2^31 & > -2^16 & >= -2^15 & >=0 & !=0 & not(NaNValue)',
-            message:
-              'The value must satisfy the constraint corresponding to the brand keys: <Finite & Int & SafeInt & > -2^32 & >= -2^31 & > -2^16 & >= -2^15 & >=0 & !=0 & not(NaNValue)>',
+              '"Finite" & "Int" & "SafeInt" & "> -2^32" & ">= -2^31" & "> -2^16" & ">= -2^15" & ">=0" & "!=0" & not("NaNValue")',
+            message: undefined,
           },
         ]);
         expect(validationErrorsToMessages(result.value)).toStrictEqual([
-          'The value must satisfy the constraint corresponding to the brand keys: <Finite & Int & SafeInt & > -2^32 & >= -2^31 & > -2^16 & >= -2^15 & >=0 & !=0 & not(NaNValue)>',
+          'Expected <PositiveSafeInt>, got <number> type value `0`.',
         ]);
       }
     });

package/src/branded/number/safe-int.mts

@@ -10,4 +10,5 @@ export const safeInt = (defaultValue: SafeInt = asSafeInt(0)): Type<SafeInt> =>
     defaultValue,
     brandKeys: ['Finite', 'Int', 'SafeInt'],
     brandFalseKeys: ['NaNValue'],
+    typeName: 'SafeInt',
   });

package/src/branded/number/safe-int.test.mts

@@ -78,15 +78,14 @@ describe('safeInt', () => {
           {
             path: [],
             actualValue: Number.MAX_SAFE_INTEGER + 1,
-            expectedType: 'Finite & Int & SafeInt & not(NaNValue)',
-            typeName: 'Finite & Int & SafeInt & not(NaNValue)',
-            message:
-              'The value must satisfy the constraint corresponding to the brand keys: <Finite & Int & SafeInt & not(NaNValue)>',
+            expectedType: 'SafeInt',
+            typeName: '"Finite" & "Int" & "SafeInt" & not("NaNValue")',
+            message: undefined,
           },
         ]);
 
         expect(validationErrorsToMessages(result.value)).toStrictEqual([
-          'The value must satisfy the constraint corresponding to the brand keys: <Finite & Int & SafeInt & not(NaNValue)>',
+          'Expected <SafeInt>, got <number> type value `9007199254740992`.',
         ]);
       }
     });

package/src/branded/number/safe-uint.mts

@@ -21,4 +21,5 @@ export const safeUint = (
       '>=0',
     ],
     brandFalseKeys: ['NaNValue'],
+    typeName: 'SafeUint',
   });

package/src/branded/number/safe-uint.test.mts

@@ -85,16 +85,14 @@ describe('safeUint', () => {
           {
             path: [],
             actualValue: -5,
-            expectedType:
-              'Finite & Int & SafeInt & > -2^16 & > -2^32 & >= -2^15 & >= -2^31 & >=0 & not(NaNValue)',
+            expectedType: 'SafeUint',
             typeName:
-              'Finite & Int & SafeInt & > -2^16 & > -2^32 & >= -2^15 & >= -2^31 & >=0 & not(NaNValue)',
-            message:
-              'The value must satisfy the constraint corresponding to the brand keys: <Finite & Int & SafeInt & > -2^16 & > -2^32 & >= -2^15 & >= -2^31 & >=0 & not(NaNValue)>',
+              '"Finite" & "Int" & "SafeInt" & "> -2^16" & "> -2^32" & ">= -2^15" & ">= -2^31" & ">=0" & not("NaNValue")',
+            message: undefined,
           },
         ]);
         expect(validationErrorsToMessages(result.value)).toStrictEqual([
-          'The value must satisfy the constraint corresponding to the brand keys: <Finite & Int & SafeInt & > -2^16 & > -2^32 & >= -2^15 & >= -2^31 & >=0 & not(NaNValue)>',
+          'Expected <SafeUint>, got <number> type value `-5`.',
         ]);
       }
     });

package/src/branded/number/uint.mts

@@ -18,4 +18,5 @@ export const uint = (defaultValue: Uint = asUint(0)): Type<Uint> =>
       '>=0',
     ],
     brandFalseKeys: ['NaNValue'],
+    typeName: 'Uint',
   });

package/src/branded/number/uint.test.mts

@@ -91,16 +91,14 @@ describe('uint', () => {
           {
             path: [],
             actualValue: -5,
-            expectedType:
-              'Finite & Int & > -2^32 & >= -2^31 & > -2^16 & >= -2^15 & >=0 & not(NaNValue)',
+            expectedType: 'Uint',
             typeName:
-              'Finite & Int & > -2^32 & >= -2^31 & > -2^16 & >= -2^15 & >=0 & not(NaNValue)',
-            message:
-              'The value must satisfy the constraint corresponding to the brand keys: <Finite & Int & > -2^32 & >= -2^31 & > -2^16 & >= -2^15 & >=0 & not(NaNValue)>',
+              '"Finite" & "Int" & "> -2^32" & ">= -2^31" & "> -2^16" & ">= -2^15" & ">=0" & not("NaNValue")',
+            message: undefined,
           },
         ]);
         expect(validationErrorsToMessages(result.value)).toStrictEqual([
-          'The value must satisfy the constraint corresponding to the brand keys: <Finite & Int & > -2^32 & >= -2^31 & > -2^16 & >= -2^15 & >=0 & not(NaNValue)>',
+          'Expected <Uint>, got <number> type value `-5`.',
         ]);
       }
     });
@@ -120,7 +118,7 @@ describe('uint', () => {
           },
         ]);
         expect(validationErrorsToMessages(result.value)).toStrictEqual([
-          'Expected number, got string',
+          'Expected <number>, got <string> type value "not a number".',
         ]);
       }
     });
@@ -144,7 +142,7 @@ describe('uint', () => {
         targetType.assertIs;
       expect(() => {
         assertIs(x);
-      }).toThrow('The value must satisfy the constraint');
+      }).toThrow('Expected <Uint>');
     });
   });
 

package/src/branded/number/uint16.mts

@@ -22,4 +22,5 @@ export const uint16 = (defaultValue: Uint16 = asUint16(0)): Type<Uint16> =>
       '< 2^31',
     ],
     brandFalseKeys: ['NaNValue'],
+    typeName: 'Uint16',
   });

package/src/branded/number/uint16.test.mts

@@ -85,16 +85,14 @@ describe('uint16', () => {
           {
             path: [],
             actualValue: -5,
-            expectedType:
-              'Finite & Int & SafeInt & > -2^16 & > -2^32 & >= -2^15 & >= -2^31 & >=0 & < 2^32 & < 2^16 & < 2^31 & not(NaNValue)',
+            expectedType: 'Uint16',
             typeName:
-              'Finite & Int & SafeInt & > -2^16 & > -2^32 & >= -2^15 & >= -2^31 & >=0 & < 2^32 & < 2^16 & < 2^31 & not(NaNValue)',
-            message:
-              'The value must satisfy the constraint corresponding to the brand keys: <Finite & Int & SafeInt & > -2^16 & > -2^32 & >= -2^15 & >= -2^31 & >=0 & < 2^32 & < 2^16 & < 2^31 & not(NaNValue)>',
+              '"Finite" & "Int" & "SafeInt" & "> -2^16" & "> -2^32" & ">= -2^15" & ">= -2^31" & ">=0" & "< 2^32" & "< 2^16" & "< 2^31" & not("NaNValue")',
+            message: undefined,
           },
         ]);
         expect(validationErrorsToMessages(result.value)).toStrictEqual([
-          'The value must satisfy the constraint corresponding to the brand keys: <Finite & Int & SafeInt & > -2^16 & > -2^32 & >= -2^15 & >= -2^31 & >=0 & < 2^32 & < 2^16 & < 2^31 & not(NaNValue)>',
+          'Expected <Uint16>, got <number> type value `-5`.',
         ]);
       }
     });

package/src/branded/number/uint32.mts

@@ -20,4 +20,5 @@ export const uint32 = (defaultValue: Uint32 = asUint32(0)): Type<Uint32> =>
       '< 2^32',
     ],
     brandFalseKeys: ['NaNValue'],
+    typeName: 'Uint32',
   });

package/src/branded/number/uint32.test.mts

@@ -85,16 +85,14 @@ describe('uint32', () => {
           {
             path: [],
             actualValue: -5,
-            expectedType:
-              'Finite & Int & SafeInt & > -2^16 & > -2^32 & >= -2^15 & >= -2^31 & >=0 & < 2^32 & not(NaNValue)',
+            expectedType: 'Uint32',
             typeName:
-              'Finite & Int & SafeInt & > -2^16 & > -2^32 & >= -2^15 & >= -2^31 & >=0 & < 2^32 & not(NaNValue)',
-            message:
-              'The value must satisfy the constraint corresponding to the brand keys: <Finite & Int & SafeInt & > -2^16 & > -2^32 & >= -2^15 & >= -2^31 & >=0 & < 2^32 & not(NaNValue)>',
+              '"Finite" & "Int" & "SafeInt" & "> -2^16" & "> -2^32" & ">= -2^15" & ">= -2^31" & ">=0" & "< 2^32" & not("NaNValue")',
+            message: undefined,
           },
         ]);
         expect(validationErrorsToMessages(result.value)).toStrictEqual([
-          'The value must satisfy the constraint corresponding to the brand keys: <Finite & Int & SafeInt & > -2^16 & > -2^32 & >= -2^15 & >= -2^31 & >=0 & < 2^32 & not(NaNValue)>',
+          'Expected <Uint32>, got <number> type value `-5`.',
         ]);
       }
     });